Publicidade:

sexta-feira, 25 de setembro de 2015

Arduino - Array de bits

Como sabemos arrays são estruturas de dados utilizados para armazenar dados de um mesmo tipo em sequência. A sintaxe utilizada para a declaração de um array é a seguinte:

type nome_do_array [ tamanho ];

por exemplo,

int valores[10] = {1, 3, 2, 5, 6, 4, 8, 9, 7, 0};

É muito comum termos a necessidade de utilizarmos arrays para representar conjunto de dados como os listados acima.

Os tipos de dados a serem armazenados podem ser qualquer tipo de dado aceito em C.

boolean
char
unsigned char
byte
int
unsigned int
word
long
unsigned long
short
float
double
string - char array
String - object


Cada um dos tipos de dados tem um determinado tamanho que terá quer ser reservado na memória ao ser declarado um array. Um int, por exemplo, ocupa dois bytes de memória, um char ocupa um byte, um long ocupa 4 bytes.

Mas se tratando de programação para micro controladores, algo importante na hora de declarar um array, é escolhermos o tipo de dados mais adequado para armazenarmos os dados pretendidos. Por exemplo, se eu pretendo ter um array de números inteiros, mas os valores armazenados não ultrapassam o valor de 255, poderia utilizar um tipo de dados que não ocupasse mais de um byte, como word, ou byte. Caso contrário, teria que ser utilizado outro tipo, como int, ou ainda long. A escolha de cada um desses tipos de dados resulta em maiores ou menores quantidades de memória utilizadas. Em aplicações pequenas, talvez isso não faça diferença, mas algumas situações acaba fazendo.

Uma situação especial, e bastante comum, é necessitarmos armazenar arrays com informações binárias, ou seja, valor do tipo 1 ou 0. ou true ou false, ou HIGH ou LOW. enfim, apenas dois valores distintos podem ser armazenados em cada posição.

Um exemplo comum, seria por exemplo criar um array pra controlar o estado de um conjunto de lâmpadas, onde elas podem estar ou ligadas ou desligadas.

Vamos supor que fossem 20 lampadas.

Uma maneira fácil seria criar um array assim:

int lampadas[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

Mas será que essa é a melhor forma de declarar esse array?

Como sabemos, int ocupa dois bytes. Multiplicado por 20, totalizaria 40 bytes.

Outra opção seria mudar int, para byte:

byte lampadas[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

O que totalizaria 20 bytes. ou seja a metade.

Mas e se quisermos diminuir ainda mais? Nesse caso teríamos que ter um tipo de dados que ocupasse menos de um byte, mas isso infelizmente a linguagem C não nos oferece, mas ainda assim há um jeito de diminuirmos.

Como sabemos, 1 byte é formado por 8 bits. E cada bit pode assumir apenas dois estados, ou seja, 1 ou 0. Uma saída então, seria utilizar 1 byte, pra controlar 8 lâmpadas. Com isso precisaríamos ter 20 / 8 (2.5 --> 3) bytes para representar os estados das 20 lâmpadas. ou seja, algo assim:

byte lampadas[3];  //24 bits disponíveis

O que totalizaria apenas 3 bytes de memória para gerenciar o estado de 20 lâmpadas.

Sem dúvida essa é uma estratégia bem útil quando temos limitações de memória importante, o que é bem comum quando se trata de micro controladores.

Mas como tudo tem seu preço, teremos agora que criarmos meios de alterarmos bit a bit de cada um dos bytes e para isso precisaremos utilizar operadores de bitwise.

Já fiz um vídeo explicando como funcionam operadores de bitwise, quem não conhece, vale muito a pena aprender.



Pra facilitar o uso desses recursos, criei uma classe que encapsula toda essa parte "complicada", a qual está abaixo:



class BitArray{
  private:
    int _num_bits;   //quantidade de bits a serem gerenciados
    int _num_bytes;  //quantidade de bytes utilizados para armazenar os bits a serem gerenciados
    byte * _bytes;   //array de bytes onde estaram armazenados os bits
  public:
    BitArray(int num_bits){
      _num_bits  = num_bits;
      _num_bytes = _num_bits/8 + (_num_bits%8 ? 1 : 0) + 1;
      _bytes = (byte *)(malloc( _num_bytes * sizeof(byte) ) );
    }
    
    void write(int index, byte value) {
      byte b = _bytes[ index/8 + (index%8 ? 1 : 0) ];
      unsigned int bit = index%8;
      if (value) { b |= (1 << bit); } else { b &= ~(1 << bit);  }
      _bytes[ index/8 + (index%8 ? 1 : 0) ] = b;
    }
    
    void write(byte value) {
      for(int j=0; j<_num_bytes;j++) { _bytes[j] = value ? B11111111 : B00000000;  } 
    }
    
    int read(int index) {
      byte b = _bytes[ index/8 + (index%8 ? 1 : 0) ];
      unsigned int bit = index%8;
      return (b & (1 << bit)) != 0;
    }

   ~BitArray(){ free( _bytes ); }

};


Com isso, agora não iremos ter um array, mas sim um objeto, o qual poderá ser utilizado da seguinte maneira:


BitArray lampadas(20); //instancia do objeto com 20 bits

E para alterarmos uma das lâmpadas, fazemos da seguinte maneira:

lampadas.write(0, HIGH);  //liga a primeira lampada
lampadas.write(1, HIGH);  //liga a segunda lampada

if ( lampadas.read(0) ) { Serial.println("a primeira lampada está ligada."); } //verifica o estado da lampada.



Com isso conseguimos ter o menor consumo de memória, sem termos grandes dificuldades na parte de programação.


versão bidimensional :


class BitArray2D {
  private:
    unsigned int _rows;
    unsigned int _columns;
    unsigned int _cols_array; //pra cada 8 colunas, 1 byte é usado 
    byte**       _bits;
  public:
    BitArray2D(unsigned int rows, unsigned int columns){
      _rows       = rows;
      _columns    = columns;
      _cols_array = columns/8 + (_columns%8 ? 1 : 0) + 1; //divide por 8 o número de colunas
      _bits = (byte **)malloc(_rows * sizeof(byte *));
      for(int i=0;i<_rows;i++){ _bits[i] = (byte *)malloc(  _cols_array  *  sizeof(byte)); } //cria varios arrays
      clear();
    }
    
    unsigned int rows(){ return _rows; }
    unsigned int columns(){ return _columns; }
    
    void clear() { 
      for(int i=0;i<_rows;i++){      
        for(int j=0; j<_cols_array;j++) { _bits[i][j] = B00000000; }       
      }   
    }
  
    void write(unsigned int row, unsigned int column, int value){
      byte b = _bits[row][ column/8 + (column%8 ? 1 : 0) ];
      unsigned int bit = column%8;
      
      if (value) { b |= (1 << bit); } else { b &= ~(1 << bit);  }
      
      _bits[row][ column/8 + (column%8 ? 1 : 0) ] = b;
    }
    
    void write(byte value){
      for(int i=0;i<_rows;i++){      
        for(int j=0; j<_cols_array;j++) {      
          _bits[i][j] = value ? B11111111 : B00000000;     
        }       
      }  
    }
    
    int read(unsigned int row, unsigned int column){
      byte b = _bits[row][ column/8 + (column%8 ? 1 : 0) ];
      unsigned int bit = column%8;
      
      return (b & (1 << bit)) != 0;
    }
    
    void toggle(unsigned int row, unsigned int column){ write(row, column, !read(row, column)); }
    void toggle(){ for(int i=0;i<_rows;i++){      for(int j=0; j<_columns;j++) {      toggle(i,j);   }   }   }
};


Arduino - Alterações na biblioteca LedControl

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);
  
}

terça-feira, 22 de setembro de 2015

Arduino - Dicas de programação 08 - int x unsigned int

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.


sexta-feira, 18 de setembro de 2015

Arduino - Pai Nerd

Olá pessoal, ontem postei na página do facebook,  o vídeo abaixo, mostrando um projetinho que fiz pra comemorar o aniversário de um ano do meu filho.


Pai Nerd. Hoje meu filho, o Nicolas, faz 1 ano, e claro que tem Arduino pra comemorar :D

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);
  }
 
 
 
 
   
 
}