PsySc0rpi0n Posted October 11, 2016 at 02:24 PM Report #599537 Posted October 11, 2016 at 02:24 PM (edited) Boas. Ando a ver se consigo arranjar maneira de criar movimento num LCD de forma suave sem ser simplesmente saltar de uma posição para outra. Vou tentar explicar com alguns "desenhos". O LCD é composto por linhas e colunas, sendo que no meu caso, tenho um LCD de 20 colunas * 4 linhas Quote Linha 0 __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ Linha 1 __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ Linha 2 __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ Linha 3 __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ O mais comum é fazer saltar um caractére de uma coluna para a coluna seguinte mas isto cria um movimento pouco suave e parece que estamos a jogar um jogo a 3 fps ou menos. Agora a parte mais técnica é a seguinte: cada posição do LCD é constituída por uma matriz de 5 colunas e por 8 linhas de pixeis e cada '__' é constituído por: Quote 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 Isto permite-nos criar caractéres personalizados colocando cada pixel a 0 ou a 1. Exemplo: Quote 0 0 0 1 1 0 0 0 0 0 1 0 0 1 0 0 0 1 0 0 0 0 1 0 1 0 0 0 0 0 0 1 0 1 0 0 0 0 1 0 0 0 1 0 0 1 0 0 0 0 0 1 1 0 0 0 1 1 1 1 1 1 1 1 Ou seja, a ideia é criar uma matriz: int matrix [8] = { 0b00011000, 0b00100100, 0b01000010, 0b10000001, 0b01000010, 0b00100100, 0b00011000, 0b11111111 } E para criar movimento suave, tentar usar as operações de bitshift para ir avançando ou atrasando os 1's daquela posição para os ir colocando na posição seguinte: Ou seja, os 1's vão acançando bit a bit para a direita, e vão abandonando a posição actual para irem aparecendo também bit a bit na posição seguinte. Algo como isto: Quote 0 0 0 1 1 0 0 0 | 0 0 0 0 0 0 0 0 |||||||| 0 0 0 0 1 1 0 0 | 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 | 0 0 0 0 0 0 0 0 |||||||| 0 0 0 1 0 0 1 0 | 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 | 0 0 0 0 0 0 0 0 |||||||| 0 0 1 0 0 0 0 1 | 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 | 0 0 0 0 0 0 0 0 |||||||| 0 1 0 0 0 0 0 0 | 1 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 | 0 0 0 0 0 0 0 0 |||||||| 0 0 1 0 0 0 0 1 | 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 | 0 0 0 0 0 0 0 0 |||||||| 0 0 0 1 0 0 1 0 | 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 | 0 0 0 0 0 0 0 0 |||||||| 0 0 0 0 1 1 0 0 | 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 | 0 0 0 0 0 0 0 0 |||||||| 0 1 1 1 1 1 1 1 | 1 0 0 0 0 0 0 0 depois passa a isto Quote 0 0 0 0 0 1 1 0 | 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 | 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 | 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 | 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 | 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 | 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 | 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 | 1 1 0 0 0 0 0 0 pronto e depois o losango vai passando para a posição seguinte, bit a bit... Já não me apetece desenhar mais!!! Fonix! PS: Eu disse que cada caractére é composto por 5 colunas e 8 linhas mas desenhei como se fosse 8 * 8. Não vou emendar porque o que importa é perceber como funciona e perceber o que pretendo fazer! Edited October 11, 2016 at 02:56 PM by PsySc0rpi0n Kurt Cobain - Grunge misses you Nissan GT-R - beast killer
HappyHippyHippo Posted October 11, 2016 at 03:02 PM Report #599542 Posted October 11, 2016 at 03:02 PM executa o seguinte teste: - para todas as linhas - para todas as colunas - cria um caracter aleatório - envia o caracter para a memória do LCD - escreve o caracter no final, verifica o tempo de preenchimento das 24*4 posições do LCd IRC : sim, é algo que ainda existe >> #p@p Portugol Plus
PsySc0rpi0n Posted October 11, 2016 at 03:34 PM Author Report #599544 Posted October 11, 2016 at 03:34 PM (edited) #include <stdio.h> void createCustomChar(byte* customChar, uint8_t quant){ uint8_t pos = 0; for(uint8_t i = 0; i < quant; i++){ pos = rand() % 41; !customChar[pos] ? customChar[pos] = 1 : continue; } lcd.createChar(0, customChar); } int main(void) { byte customChar[8] = {0}; lcd.setCursor(0, 0); for(uint8_t i = 0; i < 4, i++) for(uint8_t j = 0; j < 20; j++){ createCustomChar(customChar, 10); lcd.write(byte(0)); } return 0; } Será isto que querias, HappyHippyHippo? Edited October 11, 2016 at 03:35 PM by PsySc0rpi0n Kurt Cobain - Grunge misses you Nissan GT-R - beast killer
HappyHippyHippo Posted October 11, 2016 at 03:38 PM Report #599545 Posted October 11, 2016 at 03:38 PM não percebo essa construção de caracter, mas ok ... o objectivo é agora saber quanto tempo leva a preencher o LCD 1 Report IRC : sim, é algo que ainda existe >> #p@p Portugol Plus
seuqram Posted October 11, 2016 at 06:01 PM Report #599552 Posted October 11, 2016 at 06:01 PM (edited) Em vez de um buffer de 0's e 1's, podias ter de numeros inteiros que representavam a luminosidade que cada pixel deve ter. Tbuffer = [ 25, 75, 0, 0, 25, 75, 20, 80, (T)] O minT é o tempo minimo de o pixel desligar e voltar a acender. O maxT é o tempo limite que o olho humano consegue perceber que o pixel se desliga. Ex: T: | 0 | 1 | 2 | minT | 4 | 5 | 6 | 7 | 8 | maxT | ->Depois é só desligares, invidualmente cada pixel pelo seu tempo T, a cada MaxT. ->E Ires passando os numeros, no buffer, para a direita, de forma gradual. No momento de decidir se o pixel deve estar ligado ou desligado vai analizar primeiro esta exceção: se (T < minT) -> ligado completamente durante todo o tempo do ciclo (maxT). Edited October 11, 2016 at 06:54 PM by seuqram
PsySc0rpi0n Posted October 11, 2016 at 08:01 PM Author Report #599555 Posted October 11, 2016 at 08:01 PM (edited) seuqram, amanhã respondo-te. Para já deixo aqui outra versão para o que eu acho que o HappyHippyHippo me pediu. #include <stdio.h> #include <time.h> //<-- inserted line void CreatePrintCustomChar(uint8_t memOffset, byte* customChar){ //<-- changed line for(uint8_t i = 0; i < 8; i++) customChar[i] = rand() % 32; lcd.createChar(memOffset, customChar); lcd.write(memOffset, customChar); } int main(void){ uint8_t memOffset = 0, dir = 1; byte customChar[8] = {0}; srand(time(NULL)); lcd.setCursor(0, 0); for(uint8_t i = 0; i < 80; i++){ CreatePrintCustomChar(memOffset, customChar0); if(memOffset < 7 && dir) memOffset++; else if(memOffset > 1 && !dir) memOffset--; else dir ^= 1; } return 0; } Isto apenas impreime um customChar, mas depois é só repetir 80 vezes para encher o LCD e deixar o apontador interno avançar naturalmente Edit; Entretanto corrigi o código e penso que assim já teremos o LCD todo preenchido com caractéres aleatórios para testar quanto tempo leva o LCD a criar e a imprimir os 80 caractéres! Edited October 12, 2016 at 11:28 AM by PsySc0rpi0n Kurt Cobain - Grunge misses you Nissan GT-R - beast killer
PsySc0rpi0n Posted October 12, 2016 at 10:16 AM Author Report #599568 Posted October 12, 2016 at 10:16 AM 15 hours ago, seuqram said: Em vez de um buffer de 0's e 1's, podias ter de numeros inteiros que representavam a luminosidade que cada pixel deve ter. Tbuffer = [ 25, 75, 0, 0, 25, 75, 20, 80, (T)] O minT é o tempo minimo de o pixel desligar e voltar a acender. O maxT é o tempo limite que o olho humano consegue perceber que o pixel se desliga. Ex: T: | 0 | 1 | 2 | minT | 4 | 5 | 6 | 7 | 8 | maxT | ->Depois é só desligares, invidualmente cada pixel pelo seu tempo T, a cada MaxT. ->E Ires passando os numeros, no buffer, para a direita, de forma gradual. No momento de decidir se o pixel deve estar ligado ou desligado vai analizar primeiro esta exceção: se (T < minT) -> ligado completamente durante todo o tempo do ciclo (maxT). Boas... Pessoalmente não sei se isso pode ser feito assim, porque pelo conhecimento que tenho nós apenas temos acesso a ligar/activar e/ou desligar/desactivar pixeis e não controlar a luminosidade deles! O primeiro código que fiz não ia surtir qualquer efeito porque eu estava a pensar mal! Estava a gerar os bits individualmente para cada linha do caractére mas não dá para ser assim. Cada posição do LCD é um vector/array/matriz/whatever de apenas 8 elementos e cada elemento é um número de 5 bit. Portanto o que eu tenho que gerar são 8 valores de 5 bit. E cada valor gerado, no seu formato binário é que vai dizer quais os pixeis, por assim dizer, acesos e apagados! Portanto ainda tenho que corrigir o código que fiz ontem porque estou a gerar números de 8 bits. Kurt Cobain - Grunge misses you Nissan GT-R - beast killer
seuqram Posted October 12, 2016 at 08:41 PM Report #599578 Posted October 12, 2016 at 08:41 PM (edited) Citação porque pelo conhecimento que tenho nós apenas temos acesso a ligar/activar e/ou desligar/desactivar pixeis e não controlar a luminosidade deles! Sim. Mas se apagares o pixel por x tempo antes de "olho humano" perceber que se desligou, e voltares a ligar, consegues criar um efeito qualquer fisico que faz parecer que o pixel tem menos "luminosidade". Eu nunca tive a chance de experimentar isso embora... É só uma ideia. Podias ainda usar aquela tecnica das televisões de ir atualizando colunas de pixeis enterlaçadamente. Mas como é um lcd com poucos pixeis, não sei se iria gerar um efeito de "suavidade" tão grande. Outra ideia, é mandares um array "0", ou sejam, que deia informação ao LCD para que desligue todos os pixeis, por um curto intervalo tempo, antes de continuar o movimento. Apesar de ser mais facil de meter a funcionar, não é um efeito tão bom em relação á primeira ideia. Mas vale a pena começares por aqui. Edited October 12, 2016 at 08:59 PM by seuqram
PsySc0rpi0n Posted October 13, 2016 at 07:44 AM Author Report #599580 Posted October 13, 2016 at 07:44 AM (edited) 11 hours ago, seuqram said: Sim. Mas se apagares o pixel por x tempo antes de "olho humano" perceber que se desligou, e voltares a ligar, consegues criar um efeito qualquer fisico que faz parecer que o pixel tem menos "luminosidade". Eu nunca tive a chance de experimentar isso embora... É só uma ideia. Podias ainda usar aquela tecnica das televisões de ir atualizando colunas de pixeis enterlaçadamente. Mas como é um lcd com poucos pixeis, não sei se iria gerar um efeito de "suavidade" tão grande. Outra ideia, é mandares um array "0", ou sejam, que deia informação ao LCD para que desligue todos os pixeis, por um curto intervalo tempo, antes de continuar o movimento. Apesar de ser mais facil de meter a funcionar, não é um efeito tão bom em relação á primeira ideia. Mas vale a pena começares por aqui. Ok, estou a perceber a tua ideia. Mas não é bem esse o objectivo. O objectivo é criar o efeito de que um pixel se está a deslocar para a direita/esquerda. Ou seja, sabendo que cada posição do LCD é uma matriz de 8 linhas por 5 colunas, eu quero mover, pixel a pixel, todas as 8 linhas da matriz de forma a que os pixeis da posição 'x' passem para a posição 'x + 1' mas pixel a pixel. E isso acho que se consegue usando bitshift operators. Edited; Reparei agora que o código que fiz lá em cima para imprimir os caractéres ainda precisa de um ajuste pois a built-in function que define a posição onde vai ser escrito o próximo caratére, recebe essa informação na forma lcd.setCursor(<linha>, <coluna>); o que significa que se não definir a posição onde escrever o próximo caractére, sabe-se lá onde vai ser escrito o caractére a seguir a ter sido escrito o último caractére da primeira linha! Edited October 13, 2016 at 08:01 AM by PsySc0rpi0n Kurt Cobain - Grunge misses you Nissan GT-R - beast killer
Flinger Posted October 13, 2016 at 08:06 AM Report #599581 Posted October 13, 2016 at 08:06 AM (edited) Consegues, tens é que guardar o resto, e alimentar à esquerda do da posição seguinte. void actualiza_char(int *carry, int *currchar) { int novo_carry; for (int i=0;i<8;i++) { /*Guardar o bit mais à direita para passar ao próximo char*/ novo_carry = currchar[i] & 0x01; /*retirar o bit mais à direita e colocar o bit mais à esquerda (que vem do caracter anterior)*/ currchar[i] =( carry[i] << 7) & (currchar[i] >> 1); /*Passar o novo carry para o próximo char*/ carry[i]=novo_carry; } } Dependendo das estruturas e da API do lcd, pode ser possivel optimizar isto um bocado, usando os 32 bits, por exemplo, para fazeres o switch de 4 caracteres de cada vez. Outra possível optimização é usares tabelas de chars já pré definidas, isto é, para cada char que uses já tens as várias posições do mesmo, desde que entra pela esquerda até desaparecer pela direita. Creio que só será útil se tiveres "mensagens" fixas. PS: Nos displays com que já trabalhei, cada instrução demora o seu tempo. Estares a definir cada caracter dos 20 * 4, provavelmente vai-te demorar demasiado tempo, deitando por terra a fluidez que poderias ganhar com isso. Edited October 13, 2016 at 08:12 AM by Flinger
HappyHippyHippo Posted October 13, 2016 at 08:11 AM Report #599582 Posted October 13, 2016 at 08:11 AM isso continua a ser tudo especulação até teres o resultado do teste que te pedi : a velocidade do teu sistema ser suficiente para implementar qualquer uma das estratégias apresentadas IRC : sim, é algo que ainda existe >> #p@p Portugol Plus
PsySc0rpi0n Posted October 13, 2016 at 08:18 AM Author Report #599583 Posted October 13, 2016 at 08:18 AM Flinger, assim de cor não consigo perceber o que está aí a acontecer no teu code. Assim que tiver oportunidade já passo isso para o papel para ver o que acontece! HappyHippyHippo, sim, eu sei. Ainda não tive tempo para fazer o teste! Mas quanto mais escrutinar o código agora, mas rápido é de fazer o teste depois porque já terei o código certo para correr! O código que fiz lá em cima não ia funcionar e quando desse conta tinha que estar a perder tempo a tentar corrigir. Se o for corrigindo à medida que dou conta dos possíveis problemas, quando o for testar (em princípio amanhã) se calhar ele corre direitinho e fica o teste feito. Senão ainda vou ter que estar amanhã a ajustar o code! E eu estou apenas a falar no code que me pediste para encher o LCD de caractéres aleatórios! Kurt Cobain - Grunge misses you Nissan GT-R - beast killer
seuqram Posted October 13, 2016 at 12:35 PM Report #599588 Posted October 13, 2016 at 12:35 PM (edited) //currchar[i] = (carry[i] << 7) & (currchar[i] >> 1); BUGS //Deve ser juntar e não interceptar resultados: | //Também, no lugar de 7 tem de estar 4, visto que o LCD tem 5 colunas: currchar[i] = (carry[i] << 4) | (currchar[i] >> 1); Citação assim de cor não consigo perceber o que está aí a acontecer no teu code novo_carry = currchar[i] & 0x01; //Intercepta todas as variaveis do array com 1. Por exemplo: //01011 com 00001 que dá 00001 //A outra situação: 01010 com 00001 que dá 00000 //Isto para descubrir se há o valor "1" no ultimo bit para ser levado para o segundo LCD. currchar[i] = (carry[i] << 4) | (currchar[i] >> 1); //O carry provem da analise do array do LCD anterior /*Por exemplo 00001, 00000, 00001, 00001, 00000, 00000, 00001, 00001 */ //(carry[i] << 4) //Ocorre a deslocação de todos os bits para a esquerda 4 vezes: /* 10000, 00000, 10000, 10000, 00000, 00000, 10000, 10000 */ //... | (currchar[i] >> 1) //O | Junta os bits, ou seja, se houver o bit 1 em alguma das variaveis, o produto final será 1 nesse mesmo bit. //Neste caso junta o carry da linha atual (tirado do array do LCD anterior), com a informação dos pixeis do LCD atual, que é deslocada 1 coluna para a direita (... >> 1) //Ex: /* 10000 (carry) | (10011)>>1 = 10000 | 01001 (o novo bit é 0 e o ultimo (neste caso o 1) é excluido) = 11001 (isto em cada variavel do array) ... */ carry[i]=novo_carry; //Depois Atualiza o carry (0 ou 1) no array... para depois o adicionar como o primeiro bit do proximo LCD Edited October 13, 2016 at 01:08 PM by seuqram
Flinger Posted October 13, 2016 at 12:50 PM Report #599589 Posted October 13, 2016 at 12:50 PM tens razão... Fiz isso em cima do joelho estava a pensar numa coisa, saiu outra.
PsySc0rpi0n Posted October 13, 2016 at 11:02 PM Author Report #599605 Posted October 13, 2016 at 11:02 PM (edited) Boas... Ainda não consegui pôr os caractéres todos a dar no LCD. Já tive que reformular o código mas ainda não está a funcionar: #include <time.h> #include <LiquidCrystal.h> LiquidCrystal lcd(12, 11, 10, 9, 8, 7); void CreatePrintCustomChar(uint8_t memOffset, byte* customChar){ //<-- changed line for(uint8_t i = 0; i < 8; i++) customChar[i] = rand() % 32; lcd.createChar(memOffset, customChar); } void setup(){ Serial.begin(9600); lcd.begin(20, 4); } void loop(){ uint8_t memOffset = 0, dir = 1, col = 0, lin = 0; byte customChar[8] = {0}; srand(time(NULL)); lcd.setCursor(lin, col); for(uint8_t i = 0; i < 80; i++){ if( !(col % 19) && lin == 3){ col = 0; lin = 0; }else if( !(col % 19) ){ col = 0; lin++; }else col++; lcd.setCursor(lin, col); Serial.println("Linha:"); Serial.println(lin); Serial.println("Coluna:"); Serial.println(col); Serial.println("----------"); CreatePrintCustomChar(memOffset, customChar); if(memOffset < 7 && dir) memOffset++; else if(memOffset > 1 && !dir) memOffset--; else dir ^= 1; Serial.println("memOffset:"); Serial.println(memOffset); } } As variáveis de controlo dos limites do LCD e das 8 posições de memória não estão a funcionar bem. Preciso de as corrigir. 'lin' e 'col' têm que estar entre '0 e 3' e entre '0 e 19', respectivamente mas o que está a contecer é o seguinte: Spoiler Linha: 1 Coluna: 0 ---------- Linha: 2 Coluna: 0 ---------- Linha: 3 Coluna: 0 ---------- Linha: 0 Coluna: 0 ---------- Linha: 1 Coluna: 0 ---------- Linha: 2 Coluna: 0 ---------- Linha: 3 Coluna: 0 ---------- Linha: 0 Coluna: 0 ---------- Linha: 1 Coluna: 0 ---------- Linha: 2 Coluna: 0 ---------- Linha: 3 Coluna: 0 ---------- Linha: 0 Coluna: 0 ---------- Linha: 1 Coluna: 0 ---------- Linha: 2 Coluna: 0 ---------- Linha: 3 Coluna: 0 ---------- Linha: 0 Coluna: 0 ---------- Linha: 1 Coluna: 0 ---------- Linha: 2 Coluna: 0 ---------- Linha: 3 Coluna: 0 ---------- Linha: 0 Coluna: 0 ---------- Linha: 1 Coluna: 0 ---------- Linha: 2 Coluna: 0 ---------- Linha: 3 Coluna: 0 ---------- Linha: 0 Coluna: 0 ---------- Linha: 1 Coluna: 0 ---------- Linha: 2 Coluna: 0 ---------- Linha: 3 Coluna: 0 ---------- Linha: 0 Coluna: 0 ---------- Linha: 1 Coluna: 0 ---------- Linha: 2 Coluna: 0 ---------- Linha: 3 Coluna: 0 ---------- Linha: 0 Coluna: 0 ---------- Linha: 1 Coluna: 0 ---------- Linha: 2 Coluna: 0 ---------- Linha: 3 Coluna: 0 ---------- Linha: 0 Coluna: 0 ---------- Linha: 1 Coluna: 0 ---------- Linha: 2 Coluna: 0 ---------- Linha: 3 Coluna: 0 ---------- Linha: 0 Coluna: 0 ---------- Linha: 1 Coluna: 0 ---------- Linha: 2 Coluna: 0 ---------- Linha: 3 Coluna: 0 ---------- Linha: 0 Coluna: 0 ---------- Linha: 1 Coluna: 0 ---------- Linha: 2 Coluna: 0 ---------- Linha: 3 Coluna: 0 ---------- Linha: 0 Coluna: 0 ---------- Linha: 1 Coluna: 0 ---------- Linha: 2 Coluna: 0 ---------- Linha: 3 Coluna: 0 ---------- Linha: 0 Coluna: 0 ---------- Linha: 1 Coluna: 0 ---------- Linha: 2 Coluna: 0 ---------- Linha: 3 Coluna: 0 ---------- A variável 'memOffset' devia variar entre 0 e 7 mas está a acontecer o seguinte: Spoiler emOffset: 1 memOffset: 2 memOffset: 3 memOffset: 4 memOffset: 5 memOffset: 6 memOffset: 7 memOffset: 7 memOffset: 6 memOffset: 5 memOffset: 4 memOffset: 3 memOffset: 2 memOffset: 1 memOffset: 1 memOffset: 2 Tenho que corrigir isto e depois ver o que ainda está mais mal! Edited October 13, 2016 at 11:03 PM by PsySc0rpi0n Kurt Cobain - Grunge misses you Nissan GT-R - beast killer
PsySc0rpi0n Posted October 14, 2016 at 08:05 AM Author Report #599609 Posted October 14, 2016 at 08:05 AM (edited) Bom dia. Hoje de manhã ainda estive uns minutos a pensar no que estaria mal e dei conta que pelo menos, as declarações das variáveis que tinha dentro da função void loop(), não podiam lá estar, pois esta função é executada "eternamente", portanto as variáveis estavam a voltar a zero por cada vez que esta função é excutada! Alterei também a ordem do código dentro da função void loop() para ver se evitava alguns problemas. Tenho que testar o código novamente no LCD para ver se já dá alguma coisa! #include <time.h> #include <LiquidCrystal.h> LiquidCrystal lcd(12, 11, 10, 9, 8, 7); uint8_t memOffset = 0, dir = 1, col = 0, lin = 0; byte customChar[8] = {0}; void CreatePrintCustomChar(uint8_t memOffset, byte* customChar){ for(uint8_t i = 0; i < 8; i++) customChar[i] = rand() % 32; lcd.createChar(memOffset, customChar); } void setup(){ srand(time(NULL)); Serial.begin(9600); lcd.begin(20, 4); lcd.setCursor(lin, col); } void loop(){ for(uint8_t i = 0; i < 80; i++){ lcd.setCursor(lin, col); Serial.println("Linha:"); Serial.println(lin); Serial.println("Coluna:"); Serial.println(col); Serial.println("----------"); Serial.println("memOffset:"); Serial.println(memOffset); CreatePrintCustomChar(memOffset, customChar); if( !(col % 19) && lin == 3){ col = 0; lin = 0; }else if(col == 19){ col = 0; lin++; }else col++; if(memOffset < 7 && dir) memOffset++; else if(memOffset > 1 && !dir) memOffset--; else dir ^= 1; } } Edited October 14, 2016 at 01:47 PM by PsySc0rpi0n Kurt Cobain - Grunge misses you Nissan GT-R - beast killer
PsySc0rpi0n Posted October 14, 2016 at 05:59 PM Author Report #599633 Posted October 14, 2016 at 05:59 PM (edited) Bom, após algumas tentativas e alterações ao código, a coisa ainda não está a funcionar. O código está assim: #include <time.h> #include <LiquidCrystal.h> LiquidCrystal lcd(12, 11, 10, 9, 8, 7); uint8_t memOffset = 0, dir = 1, col = 0, lin = 0; byte customChar[8] = {0}; void CreatePrintCustomChar(uint8_t memOffset, byte* customChar){ //<-- changed line for(uint8_t i = 0; i < 8; i++) customChar[i] = rand() % 32; lcd.createChar(memOffset, customChar); Serial.println("memOffset:"); Serial.println(memOffset); lcd.write(byte(memOffset)); } void setup(){ srand(time(NULL)); Serial.begin(9600); lcd.begin(20, 4); lcd.setCursor(lin, col); } void loop(){ for(uint8_t i = 0; i < 80; i++){ // lcd.setCursor(lin, col); // Serial.println("Linha:"); // Serial.println(lin); // Serial.println("Coluna:"); // Serial.println(col); // Serial.println("----------\n"); CreatePrintCustomChar(memOffset, customChar); if( !(col % 19) && lin == 3){ col = 0; lin = 0; }else if( col == 19 ){ col = 0; lin++; }else col++; if(dir) memOffset += 1; else memOffset -= 1; if (memOffset < 0) { dir ^= 1; memOffset = 1; }else if (memOffset > 7) { dir ^= 1; memOffset = 6; } delay(500); } } E a variável memOffset está assim: Quote memOffset: 0 memOffset: 1 memOffset: 2 memOffset: 3 memOffset: 4 memOffset: 5 memOffset: 6 memOffset: 7 memOffset: 6 memOffset: 5 memOffset: 4 memOffset: 3 memOffset: 2 memOffset: 1 memOffset: 0 memOffset: 6 memOffset: 7 memOffset: 6 memOffset: 5 memOffset: 4 memOffset: 3 memOffset: 2 memOffset: 1 memOffset: 0 Edited October 14, 2016 at 06:08 PM by PsySc0rpi0n Kurt Cobain - Grunge misses you Nissan GT-R - beast killer
PsySc0rpi0n Posted October 15, 2016 at 03:32 PM Author Report #599650 Posted October 15, 2016 at 03:32 PM (edited) Bom, cheguei a um código que faz mais ou menos o que o HappyHippiHippo pediu. A questão é que parece não ser possível criar mais que 8 caractéres personalizados pois, por limitação do controlador e da próprima memória interna do LCD, apenas 8 é possível. Então o que fiz foi criar os tais 8 caractéres aleatórios e guardá-los na memória interna do LCD e depois imprimi-los nas 80 posições do LCD. Para fazer o que o HappyHippiHippo pediu temos outra limitação. É a rapidez com que o LCD consegue imprimir os caractéres. Se não fizer qualquer delay entre cada print de cada caractér, e se o que fiz com o osciloscópio está certo, demora cerca de 70ms a preencher o LCD todo! Edited October 15, 2016 at 04:00 PM by PsySc0rpi0n Kurt Cobain - Grunge misses you Nissan GT-R - beast killer
Recommended Posts
Create an account or sign in to comment
You need to be a member in order to leave a comment
Create an account
Sign up for a new account in our community. It's easy!
Register a new accountSign in
Already have an account? Sign in here.
Sign In Now