Algumas alterações feitas na biblioteca LedControl.
Quando usamos repetidamente o método setLed da biblioteca LedControl, percebemos um atraso na atualização dos displays (como pode ser visto no vídeo abaixo). Isso acontece, pois a cada chamada de setLed, é feito o envio do status de todos os leds do display, inclusive, os que não tiveram alterações, o que compromete muito a eficiência do código.
Para melhorar a performance da biblioteca foi incluída uma nova funcionalidade, a qual permite atualizar os status dos leds sem enviar os dados para os registradores de deslocamento (Max7219), ou seja, as alterações são mantidas na memória, e depois do processamento terminado, os dados são, então, enviados todos de uma única vez aos registradores. Essa funcionalidade se chama "Auto Send".
Por default a biblioteca funciona da mesma forma que é originalmente, com o auto send igual a true, ou seja, cada chamada a clear(), setLed(), setRow() ou setColumn() continua enviando os dados aos registradores. Mas caso o programador queira fazer um conjunto de alterações nos leds e só enviar as informações para os registradores após todas as alterações estarem prontas, deve-se então, usar o método startWrite().
Depois de chamado startWrite(), os dados serão alterados mas apenas na memória e só serão enviados aos registradores através de um outro método que foi criado. O método send().
No código-fonte a baixo, vemos o uso desses dois métodos, na função update_display. Como pode ser visto, antes de iniciar o processamento dos dados, é feita uma chamada a startWrite(), e ao final uma chamada a send().
void update_displays() {
lc.startWrite();
for (int lin=0; lin<8; lin++) {
for (int col=0; col<16; col++) {
for (int i=0; i<2; i++) {
int l = lin;
int c = col - (i*8);
if (l>=0 && l<=7 && c>=0 && c<=7) {
lc.setLed(i, l, c, (l+c+cont)%2 );
}
}
}
}
cont++;
lc.send();
}
Observações: No código abaixo, foram removidas as funcionalidades voltadas ao uso de displays de 7 segmentos, pois não serão utilizados nos meu projetos futuros, mas nada impede que sejam inclusos novamente.
Código-fonte:
/*************************************************************************************************************
*******************************LEDCONTROL ALTERADA************************************************************
**************************************************************************************************************/
//the opcodes for the MAX7221 and MAX7219
#define OP_DECODEMODE 9
#define OP_INTENSITY 10
#define OP_SCANLIMIT 11
#define OP_SHUTDOWN 12
#define OP_DISPLAYTEST 15
class LedControl {
private :
byte spidata[16];
byte * status;
int SPI_MOSI;
int SPI_CLK;
int SPI_CS;
int maxDevices;
int _auto_send;
void spiTransfer(int addr, volatile byte opcode, volatile byte data) {
int offset = addr*2;
int maxbytes = maxDevices*2;
for(int i=0;i<maxbytes;i++) { spidata[i]=(byte)0; }
spidata[offset+1] = opcode;
spidata[offset] = data;
digitalWrite(SPI_CS,LOW);
for(int i=maxbytes;i>0;i--) { shiftOut(SPI_MOSI,SPI_CLK,MSBFIRST,spidata[i-1]); }
digitalWrite(SPI_CS,HIGH);
}
public:
LedControl(int dataPin, int clkPin, int csPin, int numDevices) {
_auto_send = true;
SPI_MOSI = dataPin;
SPI_CLK = clkPin;
SPI_CS = csPin;
maxDevices = numDevices;
pinMode(SPI_MOSI, OUTPUT);
pinMode(SPI_CLK, OUTPUT);
pinMode(SPI_CS, OUTPUT);
digitalWrite(SPI_CS, HIGH);
status = new byte[maxDevices * 8]; //instancia o array de acordo com a quantia de displays usados
for(int i=0;i<maxDevices * 8 ;i++) { status[i]=0x00; }
for(int i=0;i<maxDevices;i++) {
spiTransfer(i, OP_DISPLAYTEST,0);
setScanLimit(i, 7); //scanlimit is set to max on startup
spiTransfer(i, OP_DECODEMODE,0); //decode is done in source
clearDisplay(i);
shutdown(i,true); //we go into shutdown-mode on startup
}
}
void startWrite() { _auto_send = false; };
void send() {
for (int j=0; j<maxDevices; j++) {
int offset = j*8;
for(int i=0;i<8;i++) { spiTransfer(j, i+1, status[offset+i]); }
}
_auto_send = true;
}
int getDeviceCount(){ return maxDevices; }
void shutdown(int addr, bool b){
if(addr<0 || addr>=maxDevices) return;
spiTransfer(addr, OP_SHUTDOWN, b ? 0 : 1);
}
void setScanLimit(int addr, int limit){
if(addr<0 || addr>=maxDevices) return;
if(limit>=0 && limit<8) spiTransfer(addr, OP_SCANLIMIT,limit);
}
void setIntensity(int addr, int intensity) {
if(addr<0 || addr>=maxDevices) { return; }
if(intensity>=0 && intensity<16) { spiTransfer(addr, OP_INTENSITY, intensity); }
}
void clearDisplay(int addr){
if(addr<0 || addr>=maxDevices) return;
int offset = addr*8;
for(int i=0;i<8;i++) {
status[offset+i] = 0;
if (_auto_send) { spiTransfer(addr, i+1, status[offset+i]); }
}
}
void setLed(int addr, int row, int column, boolean state) {
if(addr<0 || addr>=maxDevices) { return; }
if(row<0 || row>7 || column<0 || column>7) { return; }
int offset = addr*8;
byte val = B10000000 >> column;
if(state) { status[offset+row] = status[offset+row] | val; }
else {
val=~val;
status[offset+row] = status[offset+row]&val;
}
if (_auto_send) { spiTransfer(addr, row+1, status[offset+row]); }
}
void setRow(int addr, int row, byte value) {
if(addr<0 || addr>=maxDevices) return;
if(row<0 || row>7) return;
int offset = addr*8;
status[offset+row] = value;
if (_auto_send) {
spiTransfer(addr, row+1, status[offset+row]);
}
}
void setColumn(int addr, int col, byte value) {
if(addr<0 || addr>=maxDevices) return;
if(col<0 || col>7) return;
byte val;
for(int row=0; row<8; row++) {
val=value >> (7-row);
val=val & 0x01;
setLed(addr,row,col,val);
}
}
};
/*************************************************************************************************************
*******************************FIM LEDCONTROL ALTERADA********************************************************
**************************************************************************************************************/
/*
pin 4 is connected to the DataIn
pin 6 is connected to the CLK
pin 5 is connected to LOAD
*/
LedControl lc=LedControl(4,6,5,2);
const int LINHAS = 8;
const int COLUNAS = 16;
int cont=0;
void update_displays() {
lc.startWrite();
for (int lin=0; lin<8; lin++) {
for (int col=0; col<16; col++) {
for (int i=0; i<2; i++) {
int l = lin;
int c = col - (i*8);
if (l>=0 && l<=7 && c>=0 && c<=7) {
lc.setLed(i, l, c, (l+c+cont)%2 );
}
}
}
}
cont++;
lc.send();
}
void setup() {
lc.shutdown(0,false);
lc.setIntensity(0,8);
lc.clearDisplay(0);
lc.shutdown(1,false);
lc.setIntensity(1,8);
lc.clearDisplay(1);
Serial.begin(9600);
}
void loop() {
update_displays();
for(int i=0;i<LINHAS;i++){
for(int j=0;j<COLUNAS;j++){
Serial.print( (i+j)%2 );
Serial.print(" ");
}
Serial.println(" ");
}
Serial.println(" ");
delay(2000);
}
Arduino é uma plataforma de prototipação que fez sucesso devido a facilidade com que junta eletrônica e programação e apresenta aos interessados nessas áreas. Tanto pessoas com experiência como sem experiências podem começar a implementar seus projetos sem ter que se preocupar muito com os fundamentos dessas duas áreas de conhecimento. Claro que isso é bom, pois democratiza o conhecimento e permite com que ideias saiam do papel e se tornem projetos, sejam simples ou mais complexos, mas isso não significa que não devemos nos aprofundar nos conhecimentos dessas duas áreas de conhecimento.
A IDE padrão do Arduino, utiliza C/C++, e o que eu quero mostrar aqui são algumas pegadinhas em que as vezes programadores menos experientes podem cair.
C/C++ é uma linguagem Fortemente Tipada. Isso significa que sempre que formos declarar uma variável, precisamos definir a que tipo de dados ela pertence.
Os principais tipos de variáveis são:
void
boolean
char
unsigned char
byte
int
unsigned int
word
long
unsigned long
short
float
double
string - char array
String - object
array
Minha intenção não é apresentar e explicar os tipos de dados utilizados para programar o Arduino, mas mostrar alguns detalhes que devemos prestar atenção na hora de programar.
Se olharmos os tipos acimas, veremos que alguns deles, como int, char e long, possuem o tipo unsigned, por exemplo, tem int, e tem unsigned int.
Mas qual a diferença entre esses dois tipos? Para exemplificar vamos pegar os tipos int e unsigned int. Tanto um como outro irá reservar 16 bits de memória para cada variável declarada. A diferença é que int armazena números que vão de -32.768 a 32.767, ou seja, aceita números negativos. Enquanto que unsigned int, armazena números de 0 a 65.535.
Agora vamos imaginar o seguinte, iremos declarar duas variáveis, uma variável i do tipo int, e uma variável u do tipo unsigned int e inicializamos cada uma com o valor 0.
Se agora fizermos um if verificando se i é igual a u, obviamente o if será verdadeiro, pois ambas possuem valor 0.
Agora supomos que o valor das duas variáveis sejam decrementadas em 1 (i-- e u--). Vamos analisar então o que acontece com cada uma das variáveis.
Se i era igual a 0, agora ela será igual a -1. Já no caso de u, é diferente, pois u não pode armazenar valores negativos. Nesse caso, u-- var resultar no seguinte valor: 65.535. Isso mesmo. O valor assumido é o último valor dos possíveis valores para o tipo unsigned int. Isso sempre acontece quando extrapolamos os valores aceitos por esses tipos de dados, seja no início ou no fim.
Pois bem, considerando então que i é igual a -1 e u igual a 65.535, o que aconteceria se novamente verificássemos se i é igual a u. Apesar de não ser tão óbvio agora, a comparação continuaria resultado verdadeiro. Sim. -1 seria igual a 65.535.
O que acontece aqui é o seguinte: Quando uma comparação entre dois tipos é feita, é preciso que o compilador converta os tipos de dados para um mesmo tipo, e nessa conversão, os dados resultantes da conversão dos tipos de dados vão ser os mesmos, ou seja iguais. O que, dependendo da lógica que está sendo programada, pode levar a erros. E o programador menos experiente pode ficar doidinho tentando entender o que está acontecendo e não conseguir achar o problema.
Sketch com o exemplo acima
int i = 0; /* -32.768 .. 32.767 */
unsigned int u = 0; /* 0 .. 65.535 */
void setup() {
Serial.begin(9600);
}
void loop() {
Serial.print("i = ");
Serial.print(i);
Serial.println("");
Serial.print("u = ");
Serial.print(u);
Serial.println("");
if (i == u) {
Serial.println("iguais");
} else {
Serial.println("diferentes");
}
i--;
u--;
delay(5000);
Serial.println("");
Serial.println("");
}
Vamos imaginar agora um exemplo parecido, mas ao invés de decrementarmos as duas variaveis, vamos decrementar apenas i e iremos verificar se i é maior, menor ou igual a u.
int i = 0; /* -32.768 .. 32.767 */
unsigned int u = 0; /* 0 .. 65.535 */
void setup() {
Serial.begin(9600);
}
void loop() {
Serial.print("i = ");
Serial.print(i);
Serial.println("");
Serial.print("u = ");
Serial.print(u);
Serial.println("");
if (i == u) {
Serial.println("iguais");
} else {
if (i > u) {
Serial.println("i maior que u");
} else {
Serial.println("u maior que i");
}
}
i--; //apenas i é decrementado
delay(5000);
Serial.println("");
Serial.println("");
}
Veja que mesmo i sendo negativo, o programa entende que i é maior que zero. Isso acontece pelo mesmo motivo mostrado anteriormente. O compilador precisa converteri, que é int, em unsigned int. pois só pode comparar variáveis do mesmo tipo, e nessa conversão de um tipo para outro, o valor que era -1, passa a ser 65.535, ou seja, após a conversão, i de fato passa a ser maior que u.
Conclusão
Sempre que for declarar o tipo de dado, pense exatamente o que aquele dado vai representar, se de fato pode ou não haver valores negativos. E se haver, pense nos problemas que podem ocorrer. E procure não misturar os tipos de dados na hora de fazer comparações ou outras operações entre eles. E o principal: Sempre teste seu código com todas as possibilidades de valores.
Pra quem estiver interessado, vou deixar o código-fonte, mas já aviso, que foi algo rápido, sem muito planejamento, e que com certeza dá pra ser melhorado.
Uma das melhorias que poderiam ser feitas, é substituir os delays, pelos millis. Tenho um artigo falando sobre como fazer isso. veja aqui.
Outro detalhe é que utilizo uma classe que criei pra gerar números aleatórios não repetidos. Quem quiser saber mais detalhes sobre essa classe, veja o artigo, clicando aqui.
valeu!
código-fonte:
#include "LedControl.h"
/**********************************************************************************
************************************CLASSE UNIQUE RANDOM***************************
**********************************************************************************/
class UniqueRandom{
private:
int _index;
int _min;
int _max;
int _tam;
int* _list;
void _init(int min, int max) {
_list = 0;
if (min < max) { _min = min; _max = max; } else { _min = max; _max = min; }
_tam = _max - _min;
_index = 0;
}
public:
UniqueRandom(int max) { _init(0, max); randomize(); } //construtor com 1 parametro
UniqueRandom(int min, int max) { _init(min, max); randomize(); } //construtor com 2 parametros
void randomize() {
if (_list == 0) { _list = (int*) malloc(_tam * sizeof(int)); }
for (int i=0; i<_tam; i++) { _list[i] = _min+i; } //preenche a lista do menor ao maior valor
//embaralha a lista
for (int i=0; i<_tam; i++) {
int r = random(0, _tam); //sorteia uma posição qualquer
int aux = _list[i];
_list[i] = _list[r];
_list[r] = aux;
}
}
int next() { //retorna o proximo numero da lista
int n = _list[_index++];
if (_index >= _tam ) { _index = 0;} //após recuper o ultimo numero, recomeça na posicao 0
return n;
}
~UniqueRandom(){ free ( _list ); } //destrutor
};
/**********************************************************************************
************************************FIM CLASSE UNIQUE RANDOM***********************
**********************************************************************************/
/*
pin 4 is connected to the DataIn
pin 6 is connected to the CLK
pin 5 is connected to LOAD
*/
LedControl lc(4,6,5, 2); //2 max7219
UniqueRandom ur(64); //declaracao do objeto unique random
/* we always wait a bit between updates of the display */
unsigned long delaytime=500;
void setup() {
int seed = 0;
for (int i=0; i<10; i++) {
seed += ( analogRead(A0) + analogRead(A1) + analogRead(A2) + analogRead(A3) + analogRead(A4) + analogRead(A5) ) ;
delay(10);
}
randomSeed(seed);
lc.shutdown(0,false);
lc.setIntensity(0,1);
lc.clearDisplay(0);
lc.shutdown(1,false);
lc.setIntensity(1,1);
lc.clearDisplay(1);
int lin = 0;
lc.setColumn(1, lin++, B11111111);
lc.setColumn(1, lin++, B11111111);
lc.setColumn(1, lin++, B01110000);
lc.setColumn(1, lin++, B00111000);
lc.setColumn(1, lin++, B00011100);
lc.setColumn(1, lin++, B00001110);
lc.setColumn(1, lin++, B11111111);
lc.setColumn(1, lin++, B11111111);
delay(500);
}
byte leds_0[8] = {
B00111000,
B00111000,
B00011000,
B00011000,
B00011000,
B00011000,
B01111110,
B01111110
};
byte leds_1[8] = {
B11000011,
B11100011,
B11110011,
B11111011,
B11011111,
B11001111,
B11000111,
B11000011
};
void loop() {
int aleatorio = random(0, 9);
//aleatorio = 8;
Serial.println(aleatorio);
if (aleatorio == 0) {
//linhas de cima para baixo
lc.clearDisplay(0);
delay(delaytime/2);
for(int row=0;row<8;row++) { lc.setRow(0,row, leds_0[row]);delay(50); }
delay(delaytime*5);
}
if (aleatorio == 1) {
//linhas de baixo para cima
lc.clearDisplay(0);
delay(delaytime/2);
for(int row=7;row>=0;row--) { lc.setRow(0,row, leds_0[row]);delay(50); }
delay(delaytime*5);
}
if (aleatorio == 2) {
//direita para a esquerda
lc.clearDisplay(0);
delay(delaytime/2);
for (int col=0;col<8;col++){
for(int row=0;row<8;row++) { lc.setLed(0, row, col, (leds_0[row] & (1 << (7-col) )) != 0 ); }
delay(50);
}
delay(delaytime*5);
}
if (aleatorio == 3) {
//esquerda para a direita
lc.clearDisplay(0);
delay(delaytime/2);
for (int col=7;col>=0;col--){
for(int row=0;row<8;row++) { lc.setLed(0, row, col, (leds_0[row] & (1 << (7-col) )) != 0 ); }
delay(50);
}
delay(delaytime*5);
}
if (aleatorio == 4) {
//direita para a esquerda
lc.clearDisplay(0);
delay(delaytime/2);
for(int row=0;row<8;row++) {
for (int col=0;col<8;col++){
lc.setLed(0, row, col, (leds_0[row] & (1 << (7-col) )) != 0 );
if ( (leds_0[row] & (1 << (7-col) )) != 0 ) {
delay(100);
}
}
}
delay(delaytime*5);
}
if (aleatorio == 5) {
//direita para a esquerda
lc.clearDisplay(0);
delay(delaytime/2);
for(int row=0;row<8;row++) {
for (int col=7;col>=0;col--){
lc.setLed(0, row, col, (leds_0[row] & (1 << (7-col) )) != 0 );
if ( (leds_0[row] & (1 << (7-col) )) != 0 ) {
delay(100);
}
}
}
delay(delaytime*5);
}
if (aleatorio == 6) {
//------------------------
lc.clearDisplay(0);
delay(delaytime/2);
for (int col=0;col<8;col++){
for(int row=0;row<8;row++) {
lc.setLed(0, row, col, (leds_0[row] & (1 << (7-col) )) != 0 );
if ( (leds_0[row] & (1 << (7-col) )) != 0 ) {
delay(100);
}
}
}
delay(delaytime*5);
}
if (aleatorio == 7) {
//--------------------------
lc.clearDisplay(0);
delay(delaytime/2);
for (int col=7;col>=0;col--){
for(int row=0;row<8;row++) {
lc.setLed(0, row, col, (leds_0[row] & (1 << (7-col) )) != 0 );
if ( (leds_0[row] & (1 << (7-col) )) != 0 ) {
delay(100);
}
}
}
delay(delaytime*5);
}
if (aleatorio == 8) {
//--------------------------
lc.clearDisplay(0);
delay(delaytime/2);
for(int i=0;i<64;i++) {
int r = ur.next();
int l = r / 8;
int c = r % 8;
int val = (leds_0[l] & (1 << (7-c) )) != 0 ;
if ( val ) { delay(100); }
lc.setLed(0, l, c, val );
}
ur.randomize();
delay(delaytime*5);
}
aleatorio = random(0, 9);
if (aleatorio == 0) {
//linhas de cima para baixo
lc.clearDisplay(1);
delay(delaytime/2);
for(int row=0;row<8;row++) { lc.setRow(1,row, leds_1[row]);delay(50); }
delay(delaytime*5);
}
if (aleatorio == 1) {
//linhas de baixo para cima
lc.clearDisplay(1);
delay(delaytime/2);
for(int row=7;row>=0;row--) { lc.setRow(1,row, leds_1[row]);delay(50); }
delay(delaytime*5);
}
if (aleatorio == 2) {
//direita para a esquerda
lc.clearDisplay(1);
delay(delaytime/2);
for (int col=0;col<8;col++){
for(int row=0;row<8;row++) { lc.setLed(1, row, col, (leds_1[row] & (1 << (7-col) )) != 0 ); }
delay(50);
}
delay(delaytime*5);
}
if (aleatorio == 3) {
//esquerda para a direita
lc.clearDisplay(1);
delay(delaytime/2);
for (int col=7;col>=0;col--){
for(int row=0;row<8;row++) { lc.setLed(1, row, col, (leds_1[row] & (1 << (7-col) )) != 0 ); }
delay(50);
}
delay(delaytime*5);
}
if (aleatorio == 4) {
//direita para a esquerda
lc.clearDisplay(1);
delay(delaytime/2);
for(int row=0;row<8;row++) {
for (int col=0;col<8;col++){
lc.setLed(1, row, col, (leds_1[row] & (1 << (7-col) )) != 0 );
if ( (leds_1[row] & (1 << (7-col) )) != 0 ) {
delay(100);
}
}
}
delay(delaytime*5);
}
if (aleatorio == 5) {
//direita para a esquerda
lc.clearDisplay(1);
delay(delaytime/2);
for(int row=0;row<8;row++) {
for (int col=7;col>=0;col--){
lc.setLed(1, row, col, (leds_1[row] & (1 << (7-col) )) != 0 );
if ( (leds_1[row] & (1 << (7-col) )) != 0 ) {
delay(100);
}
}
}
delay(delaytime*5);
}
if (aleatorio == 6) {
//------------------------
lc.clearDisplay(1);
delay(delaytime/2);
for (int col=0;col<8;col++){
for(int row=0;row<8;row++) {
lc.setLed(1, row, col, (leds_1[row] & (1 << (7-col) )) != 0 );
if ( (leds_1[row] & (1 << (7-col) )) != 0 ) {
delay(100);
}
}
}
delay(delaytime*5);
}
if (aleatorio == 7) {
//--------------------------
lc.clearDisplay(1);
delay(delaytime/2);
for (int col=7;col>=0;col--){
for(int row=0;row<8;row++) {
lc.setLed(1, row, col, (leds_1[row] & (1 << (7-col) )) != 0 );
if ( (leds_1[row] & (1 << (7-col) )) != 0 ) {
delay(100);
}
}
}
delay(delaytime*5);
}
if (aleatorio == 8) {
//--------------------------
lc.clearDisplay(1);
delay(delaytime/2);
for(int i=0;i<64;i++) {
int r = ur.next();
int l = r / 8;
int c = r % 8;
int val = (leds_1[l] & (1 << (7-c) )) != 0 ;
if ( val ) { delay(100); }
lc.setLed(1, l, c, val );
}
ur.randomize();
delay(delaytime*5);
}
}
No Artigo anterior mostrei como gerar números aleatórios, tantos repetidos quanto não repetidos. Pra isso criei uma classe e fiz um vídeo demonstrando o uso da mesma. Para quem quiser o ver o artigo, clique aqui. Como exemplo, fiz um programa bem simples, que ligava aleatoriamente led por led de uma matriz de 8X8 e depois desligava-os um por um. Pra controlar o tempo que cada led era ligado, utilizei a função delay, ou seja, ligava um led, espera alguns milissegundos e depois ligava o próximo led.
Funcionou perfeitamente. Consegui demonstrar o que eu queria. Mas um dos problemas é que o delay utilizado dentro do laço for, me impedia de conseguir incluir uma segunda matriz de leds para fazer outra coisa. Até daria para incluir, mas seria bem trabalhoso, e se eu quisesse incluir um terceiro, quarto ou qualquer outra coisa no arduino, como um teclado, por exemplo, eu teria problemas.
for(int i=0; i<64; i++) {
int r = ur.next();
int l = r / 8;
int c = r % 8;
delay(100); //delay para cada led da matriz.
lc.setLed(0, l, c, HIGH );
}
Para solucionar esse problema, resolvi eliminar as chamadas para delay, e para isso criei uma função chamada time:
int time(long timeHigh, long timeLow, long atraso, long mref = 0) {
long ajuste = mref % (timeHigh + timeLow);
long resto = (millis() + timeHigh + timeLow - ajuste - atraso) % (timeHigh + timeLow);
return (resto < timeHigh ? HIGH : LOW);
}
Os dois primeiros parâmetros são timeHigh e timeLow. Que significa que, se por exemplo, timeHigh for 1000 e timeLow também for 1000, a função irá retornar HIGH nos primeiros 1000 milissegundos e LOW nos últimos 1000 milissegundos. Supondo que eu quisesse piscar um led no Arduino com essa função, poderia ser feito da seguinte maneira:
void loop() {
digitalWrite(13, time(1000, 1000, 0, 0) ); //pisca o led do pino 13
//colocar aqui o código para fazer outras coisas durante o pisca led
}
O terceiro parâmetro (long atraso) é usado para iniciar a contagem com um atraso de tempo, em milissegundos, enquanto que o quarto é o millis de referencia. Por exemplo, se eu quiser iniciar a contagem no momento que o usuário apertar um botão, eu passo como referência o valor lido no momento que pressionou o botão.
Para piscar 3 leds ao mesmo, mas cada um com um atraso de 300 milissegundos em relação ao anterior, poderia ser feito da seguinte maneira:
void loop() {
digitalWrite(13, time(1000, 1000, 0, 0) ); //pisca o led do pino 13
digitalWrite(12, time(1000, 1000, 300, 0) ); //pisca o led do pino 12
digitalWrite(11, time(1000, 1000, 600, 0) ); //pisca o led do pino 11
}
E ainda se eu quisesse piscar os leds apenas enquanto um botão fosse mantido pressionado, poderia ser feito da seguinte maneira:
unsigned long mref = 0;
void loop() {
if ( digitalRead(4) ) {
if (mref == 0) { mref = millis(); }
} else {
mref = 0;
}
if (mref > 0) {
digitalWrite(13, time(1000, 1000, 0, mref) ); //pisca o led do pino 13
digitalWrite(12, time(1000, 1000, 300, mref) ); //pisca o led do pino 13
digitalWrite(11, time(1000, 1000, 600, mref) ); //pisca o led do pino 13
} else {
digitalWrite(13, LOW ); //pisca o led do pino 13
digitalWrite(12, LOW ); //pisca o led do pino 13
digitalWrite(11, LOW ); //pisca o led do pino 13
}
}
Veja no vídeo abaixo a demonstração de como usar a função acima, para mostrar diferentes animações em uma matriz de leds 8x8.
Código-fonte:
#include "LedControl.h"
/**********************************************************************************
************************************CLASSE UNIQUE RANDOM***************************
**********************************************************************************/
class UniqueRandom{
private:
int _index;
int _min;
int _max;
int _size;
int* _list;
void _init(int min, int max) {
_list = 0;
if (min < max) { _min = min; _max = max; } else { _min = max; _max = min; }
_size = _max - _min;
_index = 0;
}
public:
UniqueRandom(int max) { _init(0, max); randomize(); } //construtor com 1 parametro
UniqueRandom(int min, int max) { _init(min, max); randomize(); } //construtor com 2 parametros
void randomize() {
if (_list == 0) { _list = (int*) malloc(size() * sizeof(int)); }
for (int i=0; i<size(); i++) { _list[i] = _min+i; } //preenche a lista do menor ao maior valor
//embaralha a lista
for (int i=0; i<size(); i++) {
int r = random(0, size()); //sorteia uma posição qualquer
int aux = _list[i];
_list[i] = _list[r];
_list[r] = aux;
}
}
int next() { //retorna o proximo numero da lista
int n = _list[_index++];
if (_index >= size() ) { _index = 0;} //após recuper o ultimo numero, recomeça na posicao 0
return n;
}
int size() { return _size; }
~UniqueRandom(){ free ( _list ); } //destrutor
};
/**********************************************************************************
************************************FIM CLASSE UNIQUE RANDOM***********************
**********************************************************************************/
/**********************************************************************************
************************************FUNÇÃO TIME************************************
**********************************************************************************/
int time(long timeHigh, long timeLow, long atraso, long mref = 0){
long ajuste = mref % (timeHigh + timeLow);
long resto = (millis() + timeHigh + timeLow - ajuste - atraso) % (timeHigh + timeLow);
return (resto < timeHigh ? HIGH : LOW);
}
/**********************************************************************************
************************************FIM FUNÇÃO TIME********************************
**********************************************************************************/
/*
pin 4 is connected to the DataIn
pin 6 is connected to the CLK
pin 5 is connected to LOAD
*/
LedControl lc(4,6,5, 2); //2 max7219
UniqueRandom ur(64); //declaracao do objeto unique random
unsigned long delaytime=500;
unsigned long mref0, mref1;
void setup() {
int seed = 0;
for (int i=0; i<10; i++) {
seed += ( analogRead(A0) + analogRead(A1) + analogRead(A2) + analogRead(A3) + analogRead(A4) + analogRead(A5) ) ;
delay(10);
}
randomSeed(seed);
lc.shutdown(0,false);
lc.setIntensity(0,1);
lc.clearDisplay(0);
lc.shutdown(1,false);
lc.setIntensity(1,1);
lc.clearDisplay(1);
pinMode(13, OUTPUT);
}
void loop() {
digitalWrite(13, time(1000, 1000, 0, 0) ); //pisca o led do pino 13
//display 01
long t1 = 250; //tempo entre ligar um led e outro
if ( time(1000, 64*t1*2, 0, 0) ) {
lc.clearDisplay(0);
ur.randomize();
mref0 = millis();
} else {
for(int i=0; i<64; i++) {
int r = ur.next();
int lin = r / 8;
int col = r % 8;
lc.setLed(0, lin, col, time(64*t1, 64*t1, i*t1, mref0) );
}
}
//display 02
long t2 = 700; //tempo entre ligar um led e outro
if ( time(2000, 64*t2, 0) ) {
lc.clearDisplay(1);
mref1 = millis();
} else {
for(int i=0; i<64; i++) {
int r = i;
int lin = r / 8;
int col = r % 8;
lc.setLed(1, lin, col, time(64*t2, 64*t2, i*t2, mref1) );
}
}
}
segundo-exemplo:
unsigned long mref1=-10000;
unsigned long mref2=-10000;
int t1 = 1000; //tempo 1
int t2 = 4000; //tempo 2
/*
A FUNÇÃO TIME ESTÁ ESPLICADA NESSE LINK:
http://fabianoallex.blogspot.com.br/2015/09/arduino-como-substituir-delay-pelo.html
*/
int time(long timeHigh, long timeLow, long atraso, long mref = 0) {
long ajuste = mref % (timeHigh + timeLow);
long resto = (millis() + timeHigh + timeLow - ajuste - atraso) % (timeHigh + timeLow);
return (resto < timeHigh ? HIGH : LOW);
}
void setup() {
pinMode(3, OUTPUT); //led
pinMode(4, OUTPUT); //led
pinMode(8, INPUT); //botao
pinMode(9, INPUT); //botao
}
// the loop routine runs over and over again forever:
void loop() {
if (digitalRead(8) && (millis()-mref1) > t1 ){ mref1 = millis(); }
if (digitalRead(9) && (millis()-mref2) > t2 ){ mref2 = millis(); }
if ( (millis()-mref1) <= t1 && (mref1 > 0) ) { digitalWrite(3, time(200,200,0,mref1) ); } else { digitalWrite(3, LOW); }
if ( (millis()-mref2) <= t2 && (mref2 > 0) ) { digitalWrite(4, time(200,200,0,mref2) ); } else { digitalWrite(4, LOW); }
delay(10);
}
Atualização - 21/10/2015
O Vídeo abaixo mostra alguns outros detalhes a ser considerado na hora de trabalhar com temporização no Arduino, pra isso criei uma classe chamada MyTimer, que detecta tanto se tá em timeHigh, timeLow, borda de subida e borda de descida, o que dá mais possibilidades na hora de trabalhar com temporização.
A classe mostrada acima (MyTimer) foi modificada para executar funções de callback. Pra isso fiz um vídeo falando sobre o assunto (ponteiro pra funções e funções de callback). Mais abaixo está o código alterado.
Mais uma atualização no artigo, agora iremos controlar uma quantidade indefinida de eventos que devem ser executados cada um por um determinado intervalo de tempo. Pra isso criei uma nova versão da classe MyTimer.
vídeo:
/*********************************************************************************************************
************************************CLASSE MYTIMER********************************************************
**********************************************************************************************************/
class MyTimer{
private:
unsigned long _mref;
unsigned long *_times;
long _lag;
unsigned int _quantidade;
int _index_time;
int _last_index_time;
void (*_onChanging)( int index_time ); //ponteiro para funcao do evento
public:
MyTimer(unsigned long times[], int quantidade, long lag, unsigned long mref){
_lag = lag;
_mref = mref;
_times = times;
_quantidade = quantidade;
_undetermine();
}
void _undetermine(){
_index_time = -1;
_last_index_time = -1;
update();
}
void setTimes(unsigned long times[], int quantidade){
_times = times;
_quantidade = quantidade;
_undetermine();
update();
};
void setMillisRef(unsigned long mref) { _mref = mref; _undetermine(); }
void setLag(long lag) { _lag = lag; _undetermine(); }
boolean isChanging() { return ( _index_time != _last_index_time); }
boolean isIndexTime(int index) { return ( _index_time == index); }
void setOnChanging( void (*onChanging)(int) ) { _onChanging = onChanging; }
void update();
};
void MyTimer::update(){
unsigned long s = 0;
for (int i=0; i<_quantidade;i++){ s += _times[i]; }
long adjustment = _mref % s;
long rest = (millis() + s - adjustment - _lag) % s;
_last_index_time = _index_time;
s = 0;
for (int i=0; i<_quantidade;i++){
s += _times[i];
if (rest < s) { _index_time = i; break; }
}
if ( isChanging() && _onChanging ) { (*_onChanging)( _index_time ); }
}
/*********************************************************************************************************
************************************FIM CLASSE MYTIMER****************************************************
**********************************************************************************************************/
//vermelho 800 milissegundos
//amarelo 200 milissegundos
//azul 500 milissegundos
//amarelo 200 milissegundos
//verde 300 milissegundos
//amarelo 200 milissegundos
unsigned long times[] = {800, 200, 500, 200, 300, 200};
MyTimer t1(times, sizeof(times)/sizeof(unsigned long), 100, 0); //tem um atraso de 100 milissegundos em relação a referencia 0
MyTimer t2(times, sizeof(times)/sizeof(unsigned long), 300, 0); //tem um atraso de 300 milissegundos em relação a referencia 0
void setup() {
Serial.begin(9600);
t1.setOnChanging( onChanging_t1 );
t2.setOnChanging( onChanging_t2 );
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
pinMode(10, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
}
void loop() {
t1.update();
t2.update();
}
void onChanging_t1(int index ) {
if (index == 0 ){ digitalWrite(8, HIGH); digitalWrite(9, LOW); digitalWrite(10, LOW); }
if (index == 2) { digitalWrite(8, LOW); digitalWrite(9, HIGH); digitalWrite(10, LOW); }
if (index == 4) { digitalWrite(8, LOW); digitalWrite(9, LOW); digitalWrite(10, HIGH); }
if (index == 1 || index == 3 || index == 5){ digitalWrite(8, HIGH); digitalWrite(9, LOW); digitalWrite(10, HIGH); }
}
void onChanging_t2(int index ) {
if (index == 0 ){ digitalWrite(5, HIGH); digitalWrite(6, LOW); digitalWrite(7, LOW); }
if (index == 2) { digitalWrite(5, LOW); digitalWrite(6, HIGH); digitalWrite(7, LOW); }
if (index == 4) { digitalWrite(5, LOW); digitalWrite(6, LOW); digitalWrite(7, HIGH); }
if (index == 1 || index == 3 || index == 5){ digitalWrite(5, HIGH); digitalWrite(6, LOW); digitalWrite(7, HIGH); }
}
Atualização 13/12/2015
No início desse artigo mostrei uma função chamada time, bem simples, que recriei agora de modo que de pra ser executado algo a cada tantos millissegundos. Segue o código:
boolean time(unsigned long * mref, unsigned long t){
if (millis() > t && millis() - *mref > t){ *mref = millis(); return true; }
return false;
}
void setup() {
Serial.begin(9600) ;
}
void loop() {
static unsigned long mref1=0; //millis de referencia. inicializado em 0
if (time(&mref1, 2000)){
Serial.print("1-");
Serial.println(millis());
}
static unsigned long mref2=300; //millis de referencia. inicializado em 300
if (time(&mref2, 1800)){
Serial.print("2-");
Serial.println(millis());
}
}
