Duvidas sobre COL-ROW scanning

Bruno, com o arduino rodando na faixa dos mhz, vc vai precisar de um matriz beeeeeem grande para diminuir a refresh rate a um nivel indesejavel.

Para quase tudo que vc tem sentido falta do multithread, vc pode usar as interrupcoes (interrupts). Da um lida mais a fundo sobre isso, e vc vai ver que resolve o problema de um codigo mais pesado.

Buenas, meus shifts chegaram, 595, montei os exemplos com 2 shifts e rodou blz, mas confeso que fiquei com medo de montar a matrix que passei.

Ainda nao entendi como funciona os shifts, achei muito loco com 3 portas ele fazer tudo aquilo. Seria muito pedir uma explicação de como funicona? vi que nao tem muito haver com a forma que eu tava fazendo.

Outra coisa, seria de mais, numa olhada rapida, dizer que esse esquema [1] vai funcionar? ou tem algo absurdo? nunca trabalhei com os shifts, fiquei meio preocupado, estou até pensando em montar um 5x7 pra testar primeiro, o que acham?

[1] - http://bl-tyrone.student.utwente.nl/~RuudBijnen/electronics/basicschemazonderdrivers.png

Poxa, achei um site [1] muito legal, e muito bem explicadinho, varias coisas. Achei uma aulinha [2] sobre shift-register la, consegui entender certinho como funciona, muito legal esse CI hem? Estou mandando a versão impressa [3] do artigo, por que pelo site, ele tava comendo algumas palavras, mas ta valendo =)))

Mesmo assim, ainda nao consegui entender como controlar tantos leds, se sem os shift eu ja achei complexo, com o shift é mais doido ainda, pq preciso prever o que fazer antes de enviar os binarios, bem diodo =) mas to chegando la :wink:

[1] - http://www.newtoncbraga.com.br/
[2] - http://www.newtoncbraga.com.br/index.php/cursos-on-line/52-eletronica-digital/102-licao-11-como-funcionam-os-registradores-de-deslocamento-shift-registers.html
[3] - http://www.newtoncbraga.com.br/index.php/cursos-on-line/52-eletronica-digital/102-licao-11-como-funcionam-os-registradores-de-deslocamento-shift-registers.html?tmpl=component&print=1&page=

EDITED: Vi e acho que vai fucionar sim, entendi como funcionaria, eu mandaria os bits dos de cima (colunas), e faria o scan das linhas, então eu teria 25/8 iterações nas colunas, e 25 iterações nas linhas. Só estu achando estranho ele usar uma porta da linha para servir de coluna, isso nao vai me dar uma dorzinha de cabeça na hora de programar não?

Pessoal, quando se usa N ou mais shift register, ao invés de mandar 8bits, eu mando (8*n)bits? Como controlar 2 shifts se e o latch é o mesmo? Pensei em separar os pinos da linha com os da coluna, deixa o da linha separado, seria mais fácil de controlar eu acho. Alguma sugestão?

Valeu!

Bruno,

no esquema que você quer montar, você envia todos os dados serialmente (estou com preguiça de ver se primeiro é do mais, para o menos significativo ou vice-versa), então você só tem que lembrar que você enviará primeiro os bits na ordem das ligações das portas e dos shift registers, então ao dar o sinal de latch em todos ao mesmo tempo, você simplesmente irá atualizar todas as saídas, então para usar assim, você só tem que seguir esta rotina sempre: envia todos os bits (mesmo os que não mudarão), e atualiza as saídas.

No caso é o que você disse mesmo, manda 8*n bits toda a vez.

Este método é bastante usado, pois controlando todos simultaneamente, você economiza algumas linhas de programação alem de pinos no controlador.

Quanto ao caso de se irá funcionar ou não o projeto completo, eu tenho minhas dúvidas quanto à tensão... mas não custa tentar, o fato é que você certamente irá precisar de uma fonte de 5V externa com corrente de no mínimo 800mA.

Só mais uma coisa, um fato curioso deste circuito, quanto mais leds da mesma coluna você acende, menor é a corrente de consumo :slight_smile:

Bem, o projeto final ficou assim:

http://picasaweb.google.com/scorninpc/ScornInLed#5500797634401570546

e a placa assim:

http://picasaweb.google.com/scorninpc/ScornInLed#5500797632244553378

Vou tentar confecciona-la hoje, vai ser minha primeira confecção 2 faves, não sei se vai dar muito certo.

Então, é do mais para o menos mesmo, pelos meus testes, e confirmando, tanto faz o ultimo bit controlar a primeira coluna, por que vai tudo num binário só, então tanto faz né.

Sobre a alimentação externa, eu já havia desconfiado, mas ai é duro, tudo que vou fazer preciso testar com 2 fontes. Quais os riscos de eu usar os 5v do arduino? Simplesmente não funcionar e esquentar o regulador?

Uso uma fonte de 12v 1000mA, se eu colocar um regulador na placa, e usar a mesma fonte, tem risco é? 100mA para o arduino, sobra 900mA para a placa, sei la :stuck_out_tongue:

Ja vi que vou ter muito trabalho no código, e eu no começo de tudo achei que o código seria o mais simples, mas to vendo que o código pega forte também =)

Como já disse uma vez, não é nem um pouco aconselhável trabalhar em cima da especificação, se o regulador do Arduino fornece 100mA, tente trabalhar no máximo com uns 80mA, no caso deste projeto, a corrente de consumo será por volta 600 a 900mA então sem chances usar a alimentação do Arduino.

Com esta fonte que você tem , você pode montar um regulador com LM317 ou algum similar (LM350, LM117, LM 338, etc) que fornece uma corrente legal.

Certo, vou providenciar o LM, mas por enquanto vou usando outra fonte que tenho aqui mesmo então.

Poxa, por enquanto, obrigado mesmo ao pessoal que ajudou, e muito hem =D

Vou queimar a placa, dai volto as duvidas ^^

Ai pessoal, adicionei novas fotos da confecção da placa. Teve algumas falhinhas, por que na queima do primeiro lado, acho que o outro nao ficou coberto 100%, mas coisa simples, da pra resolver muito facil, e teve outras que ficou meio grosinha pq passei a caneta pra retocar, mas só por estética =)

http://picasaweb.google.com/scorninpc/ScornInLed

Do mais, ficou uns 97% bom, o que tinha mais medo era de nao acertar os lados, mas consegui.

Não vou poder furar hoje, pq fui furar para dar a medida para o outro lado, minha broca ja "estufou" a placa, entao vou pedir brocas novas para nao haver erro.

Volto a dar noticias, e assim que monta-la, eu posto os arquivos do eagle e tudo mais =)

êee brunão, ta ficando bom a bagaça.....boa sorte!!!

Postei novas fotos, da placa montada, mas nao funcionou, ficou a ultima linha acesa direto, com ou sem os pinos do arduino =/

vou aproveitar a placa, e tentar montar os CIs na protoboard, to achando que é as trilhas da placa =/

Mas vamo que vamo =)

http://picasaweb.google.com/scorninpc/ScornInLed

Parabéns Bruno! Suas placas são muito boas. Quanto ao erro, relaxa que fazer pci é assim mesmo...

Poxa Italo, obrigado =)

Bom, liguei na proto, e aparentemente funcionou, liguei 7x9, 2 shifts, mas nao estou conseguindo controla-los nao!

Veja só

int latchPin = 8;
int clockPin = 12;
int dataPin = 11;

void setup() 
{
  Serial.begin(9600);
  
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  
  Serial.println("Iniciado!");
}

void loop() 
{  
 // digitalWrite(latchPin, LOW);
 // sendBytes(0);
 // digitalWrite(latchPin, HIGH);
 
 
  digitalWrite(latchPin, LOW);
  shiftOut(dataPin, clockPin, MSBFIRST, B00000000+B01111111);
  digitalWrite(latchPin, HIGH);
  
  Serial.println("Loop!");
  delay(800);
}

Deveria ligar tudo, ou seria B1111110+B00000000? (apesar de ja ter tentado tambem)

Estou meio confuso ainda, tem algo errado ai?

EDITED: uma duvida morteira: se eu mandar isso:

  digitalWrite(latchPin, LOW);
  shiftOut(dataPin, clockPin, MSBFIRST, 0xFF);
  shiftOut(dataPin, clockPin, MSBFIRST, 0x00);
  digitalWrite(latchPin, HIGH);

Qual o valor do primeiro SR e o valor do segundo? Ou seja, ja sei que o mais significativo vem primeiro, mas qual a ordem entre os shift registers? =)

Num SR tudo que entra primeiro, sai primeiro.
Imagina o SR como uma fila de 8 bits. Cada vez que vc manda um bit, ele é empurrado pra próxima posição. Quando não cabe mais, ela expulsa aquele bit que entrou lá no começo e, se tiver outro SR conectado, esse bit expulso entra nesse novo SR.

[ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ] 
 2   1

....

[ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ]   ->   [ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ]
 9   8   7   6  5   4   3   2           1

Cara, esse negocio vai me deixar doido. Consegui, em partes, liguei 9 colunas e 7 linhas em 2 595, e fiquei quase o dia todo tentando fazer um código funcionar, enfim, consegui achar um LSB primeiro, e funcionou, muito estranho, achei que o SR quem "ditava" se era MSB ou LSB, enfim, funcionou, to até mandando o códgo, vou fazer um videozinho e ja posto tambem.

agora é ligar o resto das colunas, e se firmar, refazer a PCI =/
Depois disso tudo, preciso bolar um jeito de deixar isso tudo mais claro, pq imaginar qual coluna e qual linha acender e "desenhar" uma letra, nao vi ser facil =)

int latchPin = 8;
int clockPin = 12;
int dataPin = 11;

void setup() 
{
  Serial.begin(9600);
  
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  
  // digitalWrite(latchPin, 0);
  // shiftIt(B11111111); // C2, C3, C4, C5, C6, C7, C8, C9
  // shiftIt(B00000001); // L1, L2, L3, L4, L5, L6, L7, C1
  // digitalWrite(latchPin, 1);
    
  Serial.println("Iniciado!");
}

void loop() 
{ 
  digitalWrite(latchPin, 0);
  shiftIt(B00000000);
  shiftIt(B00000001);
  digitalWrite(latchPin, 1);
  Serial.println("Loop!");
  delay(500);
  
  digitalWrite(latchPin, 0);
  shiftIt(B10000000);
  shiftIt(B00000000);
  digitalWrite(latchPin, 1);
  Serial.println("Loop!");
  delay(500);
  
  digitalWrite(latchPin, 0);
  shiftIt(B01000000);
  shiftIt(B00000000);
  digitalWrite(latchPin, 1);
  Serial.println("Loop!");
  delay(500);
  
  digitalWrite(latchPin, 0);
  shiftIt(B00100000);
  shiftIt(B00000000);
  digitalWrite(latchPin, 1);
  Serial.println("Loop!");
  delay(500);
  
  digitalWrite(latchPin, 0);
  shiftIt(B00010000);
  shiftIt(B00000000);
  digitalWrite(latchPin, 1);
  Serial.println("Loop!");
  delay(500);
  
  digitalWrite(latchPin, 0);
  shiftIt(B00001000);
  shiftIt(B00000000);
  digitalWrite(latchPin, 1);
  Serial.println("Loop!");
  delay(500);
  
  digitalWrite(latchPin, 0);
  shiftIt(B00000100);
  shiftIt(B00000000);
  digitalWrite(latchPin, 1);
  Serial.println("Loop!");
  delay(500);
  
  digitalWrite(latchPin, 0);
  shiftIt(B00000010);
  shiftIt(B00000000);
  digitalWrite(latchPin, 1);
  Serial.println("Loop!");
  delay(500);
  
  digitalWrite(latchPin, 0);
  shiftIt(B00000001);
  shiftIt(B00000000);
  digitalWrite(latchPin, 1);
  Serial.println("Loop!");
  delay(500);
}


// Estudar/Entender =)
void shiftIt(byte dataOut) {
  // Shift out 8 bits LSB first,
  // on rising edge of clock
  boolean pinState;
  //clear shift register read for sending data
  digitalWrite(dataPin, LOW);
  // for each bit in dataOut send out a bit
  for (int i=0; i<8; i++) {
    //set clockPin to LOW prior to sending bit
    digitalWrite(clockPin, LOW);
    // if the value of DataOut and (logical AND) a bitmask
    // are true, set pinState to 1 (HIGH)
    if ( dataOut & (1<<i) ) {
      pinState = HIGH;
    }
    else {
        pinState = LOW;
    }
    //sets dataPin to HIGH or LOW depending on pinState
    digitalWrite(dataPin, pinState);
    //send bit out on rising edge of clock
    digitalWrite(clockPin, HIGH);
    digitalWrite(dataPin, LOW);
  }
  //stop shifting
  digitalWrite(clockPin, LOW);
}

EDITED: Estou usando os 5v do arduino mesmo, sem problemas até agora, nem esta esquentando direito, estou usando resistores de 150R =)

EDITED: Arduino + Painel de LED 9x7 - YouTube

Ai pessoal, só pra constar e eu poder ir dormir hoje depois de 1 semana uaheuhae

Consegui ligar os 25x7 leds numa boa, a zica ficou na placa mesmo, confirmado, vou desenhar outra, ja que ja até achei uns erros de layout que eu posso melhorar =)

Showw!!

Só falta codar agora :wink:

Pessoal, show de bola, a coisa ta ficando melhor a cada momento =)

Consegui escrever, texto fixo, proximo passo é achar um jeito de conseguir montar texto dinamico, por que o interessante é ser dinamico, como mostrar hora, temperatura, sei la, vamo que vamo

ps: segue novas fotos, e até o print de um programinha que eu fiz com php-gtk :wink:

Fotos: http://picasaweb.google.com/scorninpc/ScornInLed
Código: http://pastebin.com/GMwLS7Zz

Ai pessoal, grandes progressos =)

Bem, segue o ultimo código, ja consegui converter a matrix para binarios e mandar para o display, assim, posso ter um vetor bidimensional, e fazer ele aparecer no display. Preciso agora de ideias para poder criar esse vetor dinamicamente, por exemplo, quero fazer um relogio, dai mostro 10:35, ja ja, 10:36, entao preciso montar as letras, esse é o proximo passo, e espero que alguem ja tenha pensado nisso =D

Bem pessoal, vou montar uma sessão sobre arduino no meu blog, e ja vou postar os eagles e os fontes, para o pessoal poder confeccionar tambem :wink:

Posto o link assim que pronto =)

// Modo debug
boolean DEBUG_MODE=false;

// Pinos do shift register
int latchPin = 8;
int clockPin = 12;
int dataPin = 11;

// Tamanho do display
int screenWidth = 25;
int screenHeight = 7;

// Tela
char screenPixels[7][26] = {
  {"0111000000000000000000000"},
  {"0100100000000000000000000"},
  {"0100100000000000000000000"},
  {"0111000000000000000000000"},
  {"0100100110100100110011100"},
  {"0100101000100101001010100"},
  {"0111001000011001001011100"}
};

// Configura o arduino
void setup() 
{
  Serial.begin(9600);
  
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  
  printDebug("Iniciado", true);
}

// Main inicial
void loop() 
{ 
  printScreen();
}

// Função para atualizar o display
void printScreen()
{
  // Percorre as linhas/atualizações da tela
  for(int i=0; i<screenHeight; i++)
  {
    digitalWrite(latchPin, 0);
    digitalWrite(dataPin, LOW);
    
    // Percorre as colunas enviando a bitagem
    for(int j=(screenWidth-1); j>=0; j--)
    {
      if(screenPixels[i][j] == '1')
      {
        sendBit(HIGH);
        printDebug("1", false);
      }
      else
      {
        sendBit(LOW);
        printDebug("0", false);
      }
    }
    
    // Cria os bits das linhas
    for(int j=screenHeight-1; j>=0; j--)
    {
      
      if(j == i)
      {
        sendBit(LOW);
        printDebug("0", false);
      }
      else
      {
        sendBit(HIGH);
        printDebug("1", false);
      }
    }
    
    // Termina a atualização da tela
    digitalWrite(clockPin, LOW);
    digitalWrite(latchPin, 1);
    printDebug("", true);
  }
}

// Função para enviar o bit ao shift register
void sendBit(boolean pinState)
{
  digitalWrite(clockPin, LOW);
  digitalWrite(dataPin, pinState);
  digitalWrite(clockPin, HIGH);
  digitalWrite(dataPin, LOW);
}

// Função para enviar mensagens para debug
void printDebug(char *msg, boolean newLine)
{
  if( DEBUG_MODE )  
  {
    if(newLine)
    {
      Serial.println(msg);
    }
    else
    {
      Serial.print(msg);
    }
  }
}

Pois é pessoa, não consegui =/

Se alguém tiver ideia de como juntar letras, seria muito bem vindo :stuck_out_tongue:

Ja to até de vagar ...