ASM51

Olá galera, eu sou novo aqui no forum e também sou novo em programação com PIC. Aprendi na facudade e agora estou colocando em prática já vai fazer uns 2 meses.

Peguei vários projetos e até agora estava indo bem, até eu pegar um painel com 144 LEDS que devem ser controlados individualmente. Existe outras funções de comunicação e entrada a dispositivo externo, como teclado numérico e LCD. Há um protocolo de comunicação e torna o programa já bem extenso.

Quando cheguei na parte de controlar os 144 LEDs eu não tenho mais espaço na memória de programa. Estou utilizando o PIC16F877a, os 144LEDs podem apresentar 3 status, piscando lento, piscando rápido e aceso. Estava controlando os primerios 2 LEDs com Timer1.

O que eu preciso é o seguinte: Eu como programador sei que devido a experiência, podemos ter uma menor quantidade de linhas. Eu gostaria de saber qual o melhor método que eu deveria seguir para controlar os LEDs individualmente.

Se vc escreveu o programa em linguagem C, vc acabou de descobrir porque é inviável usar essa linguagem em chips com pouca memoria.

De qualquer forma, fica dificil dar sugestão sem examinar o hardware.

A linguagem está em Assembly.
PIC é o 16F877a.
Uso o MPLAB.

vc já viu se está usando corretamente as páginas do pic? prq o pic16f877a vai até 8kb d flash sendo q possui 4 páginas de 2kb e q quando chega-se no limite d cada uma é preciso fazer o desvio para a página correta...bom senão for isso kra usa um pic18 ai da vida q tenha uns 32kb d flash...ai acho q nesse caso vc nao vai se preocupar tanto e ainda é otimizado para programar em C.

http://www.youtube.com/watch?v=s6pobdSJev4

Eu usei o MAX6952

Como não estava acostumado com programas grandes, não tinha o conhecimento dessas páginas, vou pesquizar, provavelmente é isso.

Vou ver também este Max6952 para controlar os LEDs

Muito Obrigado, após isso estarei postando o resultado das minhas pesquisas.

alessandrotga escreveu:Olá galera, eu sou novo aqui no forum e também sou novo em programação com PIC. Aprendi na facudade e agora estou colocando em prática já vai fazer uns 2 meses.

Peguei vários projetos e até agora estava indo bem, até eu pegar um painel com 144 LEDS que devem ser controlados individualmente. Existe outras funções de comunicação e entrada a dispositivo externo, como teclado numérico e LCD. Há um protocolo de comunicação e torna o programa já bem extenso.

Quando cheguei na parte de controlar os 144 LEDs eu não tenho mais espaço na memória de programa. Estou utilizando o PIC16F877a, os 144LEDs podem apresentar 3 status, piscando lento, piscando rápido e aceso. Estava controlando os primerios 2 LEDs com Timer1.

O que eu preciso é o seguinte: Eu como programador sei que devido a experiência, podemos ter uma menor quantidade de linhas. Eu gostaria de saber qual o melhor método que eu deveria seguir para controlar os LEDs individualmente.

Eu sinceramente näo consigo imaginar como um programa para piscar leds pode ser täo grande assim... apesar de serem 144 leds, vocë apenas criará uma base de tempo e a cada estouro (por interrupçäo) atualiza os leds... coisa simples.

as vezes vale mais a pena testar o conceito antes no PC e soh entao partir para o microcontrolador:

Código: Selecionar todos

#include <stdio.h>

#define LED_OFF    0
#define LED_BLINK_SLOW    1
#define LED_BLINK_FAST    2
#define LED_ON       3

unsigned char buffer[36];

unsigned char get_led(unsigned char led)
{
  unsigned char shift = (led&3)<<1;
  unsigned char mask =  (0x03<<shift);
 
  return (buffer[led>>2] & mask) >> shift;
}

void set_led(unsigned char led, unsigned char value)
{
  unsigned char shift = (led&3)<<1;
  unsigned char mask = ~ (0x03 << shift);
  value = value<<shift;
 
  buffer[led>>2] = (mask & buffer[led>>2]) | value;
}

void refresh()
{
  unsigned char i;
  unsigned char v;

  static unsigned char slow;
  static unsigned char fast;
  static unsigned blink_slow;
  static unsigned blink_fast;

  if(!slow--)
  {
    slow=49;
    blink_slow = !blink_slow;
  }

  if(!fast--)
  {
    fast=4;
    blink_fast = !blink_fast;
  }
 
  printf("\33[2J\33[H");
 
  for(i=0;i!=144;i++)
  {
    if(i%12==0 && i!=0)
    {
      printf("\n");
    }
    v = get_led(i);
   
    switch(v)
    {
      case LED_ON:
        printf("O ");
        break;
      case LED_BLINK_SLOW:
        printf(blink_slow?"S ":". ");
        break;
      case LED_BLINK_FAST:
        printf(blink_fast?"F ":". ");
        break;       
      default:
        printf(". ");
        break;
    }
  }
 
  printf("\n");
}

int main()
{
  unsigned char i;
  unsigned char v;

  for(i=0;i!=144;i++)
  {
    set_led(i,LED_OFF);
  }

  set_led(0,LED_BLINK_SLOW);
  set_led(1,LED_BLINK_FAST);
  set_led(2,LED_ON);
  set_led(3,LED_ON);

  set_led(10,LED_BLINK_SLOW);
  set_led(21,LED_BLINK_FAST);
  set_led(32,LED_ON);
  set_led(43,LED_ON);

  set_led(143,LED_ON);

  while(1)
  {
    refresh();
    usleep(1000000/50);
  }
}


imagino que trata-se de um array de 12x12 e eh necessario fazer refresh continuamente. neste caso eu chutei 50Hz para refresh, 10Hz para o led piscando rapido e 1Hz para o led piscando lento. alem da parte de temporizacao, o principal sao os metodos de acesso (set e get) para a estrutura de dados, que esta organizada como 144 entradas de 2 bits. tendo isso, o negocio fica compacto e simples.

o codigo eh bastante compacto e o refresh pode ficar em uma interrupcao periodica. soh precisa trocar a interface de i/o (no lugar de printf possivelmente eh uma interface serial bit a bit) e adicionar uma interface de comunicacao (eu setei os leds no braco!). em termos de simulacao, ateh rodou bem e gerou o seguinte resultado:

Código: Selecionar todos

S F O O . . . . . . S .
. . . . . . . . . F . .
. . . . . . . . O . . .
. . . . . . . O . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . O


onde os leds S e F piscam em cadencias corretas! :)

Alessandrotga,

Eu fiz algo parecido com o AVR acionando uma matriz 32X8 ou 256 leds.
As colunas dos leds são ativadas por contadores hc4017, onde entra o clk da varredura e reset.
A tecnica que usei foi reservar uma matriz na ram do mcu com 32bytes, e neste espaço de ram carrego os dados a serem apresentados no display, assim o mcu pega os valores deste espaço de ram e mostra no display. Isto é, para cada byte de informação a ser colocado na coluna de leds, o mcu gera um pulso de clk para o hc4017 dar o shift. Usei intervalo de 3ms entre apagar a ligar uma coluna de leds(8 leds por coluna).
O programa ocupou mais ou menos 4K, tendo rotinas de I2C para leitura de um RTC e rotinas serial e acionamento do display.
Pra ter ideia, o programa foi compilado em C, tem agora 1100linhas, mas dá para otimizar.
Como o AVR é RISC como o PIC, acho que a quantidade de codigo executavel deve ser proximo.

Eu revi os meus contextos e agora estou estudando um array da forma citada acima.
Estava fazendo realmente de uma forma complicada e no lugar de utilizar um loop pequeno e inteligente estava com uma repetição enorme de linhas de programa. Lembrando que já há neste programa um controle de uma rede com 77 terminais, um teclado numérico e LCD.

Estes LEDs são para indicar o status de cada terminal na minha rede num grande painel.


Muito obrigado pela ajuda.

Olá!

Tava lendo o tópico e imaginando. Seria possível a criação de um painel semelhante ao do link abaixo?

http://www.harbaum.org/till/ledmatrix/index.html

O módulo que o cara usou no painel eu não consegui encontrar. Como poderia substituí-lo? O MAX6952 faria o trabalho junto com microcontrolador?

ATT,

Marcelo Teixeira
www.eletromaniacos.com

Outra opção é você usar um µC exclusivo ao contrôle do Painél de LEDs

Sugestão mude para Atmel, não agora é claro, são bem mais simples e muito melhor que PIC.

Agora por favor não retorne com "Olá galera" que eu geralmente ignoro quem aqui
chega sem noção de quantas pessoas esforçadas e de talento aqui há.

DJ

Álessandro

Dá uma olhada nesse tópico aqui onde esse assunto já foi debatido :
http://asm51.eng.br/phpBB/viewtopic.php?t=8856

No caso fiz um apinel com esse mesmo PIC16F877A mas foi em C e tinha 864 LEDs ( 9 caracteres de 8x12 ). O resultado pode ser visto aqui :
http://www.teprom.eng.br/arquivos/painel/video.AVI

Nessa linguagem de programação demorei 6 meses para fazer. É bem verdade que tinha outros recursos mas se for em Assembly pode esquecer; a menso que tenha bastante tempo pra isso.

+++

andre_teprom escreveu:Álessandro

Dá uma olhada nesse tópico aqui onde esse assunto já foi debatido :

No caso fiz um apinel com esse mesmo PIC16F877A mas foi em C e tinha 864 LEDs ( 9 caracteres de 8x12 ). O resultado pode ser visto aqui :
http://www.teprom.eng.br/arquivos/painel/video.AVI

Nessa linguagem de programação demorei 6 meses para fazer. É bem verdade que tinha outros recursos mas se for em Assembly pode esquecer; a menso que tenha bastante tempo pra isso.

+++

Esse assunto é interessante, na maioria das vezes são apresentadas diversas formas de se fazer.

André,

Faltou colocar o link do tópico.

Abraço,
Jorge

Faltou colocar o link do tópico...

Acabei de corrigir lá em cima....obg