PIC como usar o max 7219 em cascata

joelTGA · 11 de novembro de 2019

gente eu comprei dois modulo desse com 4 matriz 8x8 e 4 max7219 ligado em cascata, mais n consigo entender o funcionamento dele em cascata ja procurei no google e so acho com arduino. Alguem aqui que entende desse bichinho poderia me da ao menos uma luz

vtrx · 11 de novembro de 2019

voce não entende o software ou ou hardware?

.if · 11 de novembro de 2019

Amigo a 1ª coisa a se fazer é ler o datasheet do max. Depois de entender e fazer um deles acender, o resto é fácil

Ele nada + é do que um shift register hc595 anabolizado... Quase sinto vontade publicar um vidinho dum projetinho que fiz com 595 + pic16f pra desestressar há alguns anos... pensando...

...ei-lo... na página não aparece completo mas complete mental e espiritualmente a mensagem

+ tarde publico os fontes...

Se me estressar muito hj, porto pro 12f629+max kk

Você pode se basear nos exemplos que acha em arduíno e portar pra sua linguagem com relativa facilidade.

joelTGA · 11 de novembro de 2019

@vtrx @vtrx n estou entendendo o soft na hora de conectar um Max ao outro

adicionado 6 minutos depois

@Isadora Ferraz meu Deus Isadora q coisa linda isso aí é nível hard reprogramação. Usando o 595 eu consegui fazer uma com 3 matriz 7x5 mais ficou um negócio meia boca pois ainda to aprendendo essa há e se fizer com Max quero ver tá quero muito e vou aprender usar

.if · 11 de novembro de 2019

De fato percebo que o arduíno "contaminou" a maioria das buscas sobre este max. Mas achei isso

https://www.ccsinfo.com/forum/viewtopic.php?t=48237

(e o carinha tem a mesma dúvida sua kk)

É do ccs que é da mesma "linhagem" do arduino mas que é coerente com o d.s. e pode lhe ser útil.

2 horas atrás, joelTGA disse:

o soft na hora de conectar um Max ao outro

Olha o que diz o d.s.

"No-Op Register
The no-op register is used when cascading MAX7219s
or MAX7221s. Connect all devices’ LOAD/CS inputs
together and connect DOUT to DIN on adjacent
devices. DOUT is a CMOS logic-level output that easily
drives DIN of successively cascaded parts. (Refer to
the Serial Addressing Modes section for detailed infor-
mation on serial input/output timing.) For example, if
four MAX7219s are cascaded, then to write to the

fourth chip, sent the desired 16-bit word, followed by
three no-op codes (hex 0xXX0X, see Table 2). When
LOAD/CS goes high, data is latched in all devices. The
first three chips receive no-op commands, and the
fourth receives the intended data."

Eu quase entendi, e você?

aphawk · 13 de novembro de 2019

Dá uma lida neste texto:

Paulo

.if · 14 de novembro de 2019

Olá. Anexo o projeto completo. Detalhes: apenas educativo, 100% original, apenas com consulta ao data sheet, sem consulta na net, não montado, pra você membro do cdh, etc. O pulo do gato é a fofa função

void outmax(unsigned char disp, unsigned char address, unsigned char dado)

que define qual ci, qual linha e qual desenho aplico nos leds. E claro, a motivação foi...

Em 10/11/2019 às 21:12, joelTGA disse:

entender o funcionamento dele em cascata

//programa para matriz de leds max7219 e pic12f629
#include <pic.h>

//#define _tmr1h 0xfb //100hz
//#define _tmr1l 0x1d

#define _tmr1h 0xfd //200hz
#define _tmr1l 0x8f

#define DIN GPIO0
#define LOAD GPIO1
#define CLK GPIO2
#define pb GPIO3 //push botom
#define LED GPIO5

//configuração = proteção do código, etc.
__CONFIG( CP_OFF & FOSC_INTRCIO & PWRTE_ON & WDTE_OFF & BOREN_ON & MCLRE_OFF);

unsigned char tmp1,dl,d[32];
static bit b;
//******************************************************
static void interrupt
timer_int(void)
{
TMR1H=_tmr1h;TMR1L=_tmr1l; // 200Hz
TMR1IF=0;
LED=tmp1>>7;
tmp1++;
dl--;
}

void delay(unsigned char dly)
{
dl=dly;
while(dl);
}

//   adress               data
//11 10 09 08     07 06 05 04 03 02 01 00
#define NOOP     0x00 //controles
#define NODECODE 0x09
#define INTENS   0x0a
#define SCANLIM 0x0b
#define SHUTDOWN 0x0c
#define DISPTEST 0x0f

#define D0 0x01 //dados
#define D1 0x02
#define D2 0x03
#define D3 0x04
#define D4 0x05
#define D5 0x06
#define D6 0x07
#define D7 0x08

//************************************************************************
// qual chip , qual linha , padrão do desenho
void outmax(unsigned char disp, unsigned char address, unsigned char dado)
{
unsigned char i;
LOAD=CLK=DIN=0;

for (i=0;i<8;i++)
   {
   DIN=address>>7;
   CLK=1;asm("nop");asm("nop");asm("nop");CLK=0;
   address<<=1;
   }

for (i=0;i<8;i++)
   {
   DIN=dado>>7;
   CLK=1;asm("nop");asm("nop");asm("nop");CLK=0;
   dado<<=1;
   }
DIN=0;
while(disp--) //pra posicionar em qual display o padrão vai ser apresentado
for (i=0;i<16;i++)
   {
   CLK=1;asm("nop");asm("nop");asm("nop");CLK=0;
   }

LOAD=1;asm("nop");asm("nop");asm("nop");LOAD=0; //strobe
}

//******************************************************
void setupmax()
{
unsigned char i;
for (i=0;i<4;i++) //programa os 4 chips
   {
   outmax(i,NODECODE,0x00); //desenho livre
   outmax(i,INTENS,0x0f); //maior brilho
   outmax(i,SCANLIM,0x07); //aciona todos
   outmax(i,SHUTDOWN,0x01); //não desliga
   }

}

//******************************************************
main()
{
unsigned char a;
OPTION_REG=0b11000110;//des. pull-up, tmr0 clock=fosc/4,increment lowtohigh, wdt/128
TRISIO=0b000000;//
CMCON=0x07; //comparador=digital
T1CON=0b00010001;
TMR1H=_tmr1h;TMR1L=_tmr1l; //100Hz
PIE1=PEIE=1; //hab. int. timer1
GIE=1; //hab. int
setupmax();

outmax(0,D0,0b11111100);
outmax(0,D1,0b11111100);
outmax(0,D2,0b11000000);
outmax(0,D3,0b11000000); //C
outmax(0,D4,0b11000000);
outmax(0,D5,0b11000000);
outmax(0,D6,0b11111100);
outmax(0,D7,0b11111100);

outmax(1,D0,0b11100000);
outmax(1,D1,0b11110000);
outmax(1,D2,0b11001000);
outmax(1,D3,0b11000100); //D
outmax(1,D4,0b11000010);
outmax(1,D5,0b11000100);
outmax(1,D6,0b11111000);
outmax(1,D7,0b11100000);

outmax(2,D0,0b11000110);
outmax(2,D1,0b11000110);
outmax(2,D2,0b11000110);
outmax(2,D3,0b11111110); //H
outmax(2,D4,0b11111110);
outmax(2,D5,0b11000110);
outmax(2,D6,0b11000110);
outmax(2,D7,0b11000110);

outmax(3,D0,0b10101010);
outmax(3,D1,0b01010101);
outmax(3,D2,0b10101010);
outmax(3,D3,0b01010101);
outmax(3,D4,0b10101010); //alternados
outmax(3,D5,0b01010101);
outmax(3,D6,0b10101010);
outmax(3,D7,0b01010101);

delay(200);

for (;;)
{
for (a=0;a<8;a++)
{
outmax(3,D0,1<<a); //teste
outmax(3,D1,1<<a+1);
outmax(3,D2,1<<a+2);
outmax(3,D3,1<<a+3);
outmax(3,D4,1<<a+3);
outmax(3,D5,1<<a+2);
outmax(3,D6,1<<a+1);
outmax(3,D7,1<<a);
delay(100);
}
}

}

Um testezinho bobo pra demonstrar o controle bit a bit dos leds. Pra escrever/desenhar algo útil mesmo, você deve lançar mão de alguma ferramenta pra criar padrões de textos/desenhos e portar pra uma tabela. No momento não lembro qual usei no 1º video exemplo.

Vou editar este post se me der vontade alterar algo ok? p.ex. as variáveis b, d[32] não usei e estão comendo memória a toa. Eram pra aprimoramento mas fiquei com preguiça de aprimorar +. + pra frente, quem sabe. Extremamente simples portar pra virtualmente qualquer mc até mesmo pra linguagem arduína.

ok.. você já deve ter entendido. Mas me deu vontade registrar + este vidinho pro c ter uma ideia do controle bit a bit do leds de novo...

Paulão não é bascom mas se desejar incorpore-se este conteúdo naquele seu post...

Bom apetite...

matriz de leds.zip

aphawk · 14 de novembro de 2019

@Isadora Ferraz ,

Sim, só postei porque eu explico no artigo como configurar os registradores e como enviar os bits quando os módulos estão em cascata.

Infelizmente nem todos conseguem usar o Bascom .... ( kkkkkkkkkkk ) !

Paulo

.if · 14 de novembro de 2019

É isso aí Paulão.

2 horas atrás, aphawk disse:

quando os módulos estão em cascata.

O pulo do gato é enviar 16 bits em 0, ou apenas 16 pulsos de clock "puros" seguido de um pulso de strobe pra pular o chip no qual não desejo alterar a saída. É o disse o d.s. e o que fiz no trecho...

while(disp--) //pra posicionar em qual display o padrão vai ser apresentado
for (i=0;i<16;i++)
   {
   CLK=1;asm("nop");asm("nop");asm("nop");CLK=0;
   }
   
LOAD=1;asm("nop");asm("nop");asm("nop");LOAD=0; //strobe
}

Como pode (não você kk) ver, disp é um dos argumentos da função e é o número de displays que vão ser "esquipados"

O qual, modéstia a parte foi criação minimalista 100% minha que me custou minutos preciosos, e considero a resposta à inquietação básica do autor do tópico.

E pode ser uma alternativa minimamente curiosa pra programador c que quer

Em 10/11/2019 às 21:12, joelTGA disse:

entender o funcionamento dele em cascata ja procurei no google e so acho com arduino

abç

Bacana. Se achar que deve, publique o fonte ou a parte dele que abrange a questão. Mais um 'desintoxicador' de arduíno. Além claro de lhe proporcionar a impagável sensação de contribuição

1 hora atrás, vtrx disse:

Eu implementei esse CI num ARM(plaquinha blue Pill),e também não achei na net como implementar mais de um em C puro.

Apanhei um pouco mas consegui

vtrx · 14 de novembro de 2019

Eu implementei esse CI num ARM(plaquinha blue Pill),e também não achei na net como implementar mais de um em C puro.

Apanhei um pouco mas consegui.

joelTGA · 22 de abril de 2021

@.if if beleza cara! eu n morri ainda nao kkkk depois de quase dois anos eu voltei pra falar q ainda n consegui se acredita kkkk. Depois desse post q fiz em 2019 eu dei uma pequena evoluida, mais tenho muita duvida mesmo ainda. eu tenho aqui um codigo q fiz mais os caracteres correm para cima ou para baixo na matriz, eu preciso q corra para o lado, e eu também n consegui desenvolver uma funcao que escreve uma frase por exemplo para aparecer em duas matriz (dois max).

abaixo vou postar um codigo q ja passei noites e mais noites em claro ,mais n consigo evoluir mano, mais eu nao quero desistir!! ja ate to fazendo um curso na macrogenios para aprender .... Por favor me ajuda se puder

sbit MAX7219_CS at GP1_bit;
sbit SoftSpi_CLK at GP0_bit;
sbit SoftSpi_SDI at GP3_bit;//NO CONECT
sbit SoftSpi_SDO at GP2_bit;

sbit MAX7219_CS_Direction at TRISIO1_bit;
sbit SoftSpi_CLK_Direction at TRISIO0_bit;
sbit SoftSpi_SDI_Direction at TRISIO3_bit;//NO CONECT
sbit SoftSpi_SDO_Direction at TRISIO2_bit;

const unsigned char symbol[10][8] =
{
     { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, //Ascii-32
     { 56, 68, 68, 68, 124, 68, 68, 68 }, //Ascii-33
     { 0x00,0x07,0x07,0x00,0x00,0x07,0x07,0x00 }, //Ascii-34
     { 0x24,0x7E,0x7E,0x24,0x7E,0x7E,0x24,0x00 }, //Ascii-35
     { 0x00,0x24,0x2E,0x6B,0x6B,0x3A,0x12,0x00 }, //Ascii-36
     { 0x00,0x66,0x36,0x18,0x0C,0x66,0x62,0x00 }, //Ascii-37
     { 0x30,0x7A,0x4F,0x5D,0x37,0x72,0x50,0x00 }, //Ascii-38
     { 0x00,0x00,0x00,0x07,0x07,0x00,0x00,0x00 }, //Ascii-39


};
//prototipos de funçoes
//void iniciaMax();
void EscreveMax(unsigned char fila, unsigned char valor,unsigned char fila1, unsigned char valor1);



void max7219_init(char display,char segmento)
{
 char disp = display;
  Soft_SPI_Init();

 MAX7219_CS_Direction = 0;


 MAX7219_CS = 0;                    // SELECT MAX
 Soft_SPI_Write(0x09);               //  Disable BCD mode for digit decoding
 Soft_SPI_Write(0x00);
  while(disp >1){
 disp --;
 Soft_SPI_Write(0x00);
 Soft_SPI_Write(0x00);
 }
  disp = display;
 MAX7219_CS = 1;                    // DESELECT MAX

 MAX7219_CS = 0;
 Soft_SPI_Write(0x0A);               //  Max segment luminosity intensity
 Soft_SPI_Write(0x0F);
  while(disp >1){
 disp --;
 Soft_SPI_Write(0x00);
 Soft_SPI_Write(0x00);
 }
  disp = display;
 MAX7219_CS = 1;

 MAX7219_CS = 0;
 Soft_SPI_Write(0x0B);
 Soft_SPI_Write(0x07);               // Display refresh
  while(disp >1){
 disp --;
 Soft_SPI_Write(0x00);
 Soft_SPI_Write(0x00);
 }
  disp = display;
 MAX7219_CS = 1;

 MAX7219_CS = 0;
 Soft_SPI_Write(0x0C);
 Soft_SPI_Write(0x01);               // Turn on the display
   while(disp >1){
 disp --;
 Soft_SPI_Write(0x00);
 Soft_SPI_Write(0x00);
 }
  disp = display;
 MAX7219_CS = 1;

MAX7219_CS = 0;
 Soft_SPI_Write(0X0F);//No test
 Soft_SPI_Write(0X00);
  while(disp >1){
 disp --;
 Soft_SPI_Write(0x00);
 Soft_SPI_Write(0x00);
 }
  disp = display;
 MAX7219_CS = 1;

 MAX7219_CS = 0;
 Soft_SPI_Write(0x00);
 Soft_SPI_Write(0xFF);               // No test  (0xFF) Test (0xxF)
 while(disp >1){
 disp --;
 Soft_SPI_Write(0x00);
 Soft_SPI_Write(0x00);
 }
  disp = display;
 //Soft_SPI_Write(0x00);              // Bypass the 1st Chip

 MAX7219_CS = 1;
}





/*const unsigned char letras[3][90] ={{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,56, 68, 68, 68, 124, 68, 68},
                                    {56, 68, 68, 68, 124, 68, 68, 68},
                                    {56, 68, 68, 68, 124, 68, 68, 68}
                                    };*/

void main()
{
int i,in,l;
 CMCON = 7;

// iniciaMax();
max7219_init(1,8);
max7219_init(2,8);

 while(1)
 {

      for(in=1;in<64;in++)
      {
          for(i=1;i<9;i++)
          {
           EscreveMax(i,symbol[l] [i-1+in],   i,symbol[l+1] [i-1+in]);
          }
        delay_ms(300);
      }




 }//fim while

}//fim main

///////////////funçoes/////////////////////////////////
void EscreveMax(unsigned char fila, unsigned char valor,  unsigned char fila1, unsigned char valor1 )
{ 
 char display=2;
 char disp = display;
 MAX7219_CS = 0;
 Soft_SPI_write(fila);
 Soft_SPI_write(valor);
   MAX7219_CS = 1;
 
 MAX7219_CS = 0;
  while(disp > 1){
          disp--;
          Soft_SPI_write(fila1);
          Soft_SPI_write(valor1);
          Soft_SPI_Write(0x00);
          Soft_SPI_Write(0x00);
          }
          disp = display;

 MAX7219_CS = 1;
}/*void iniciaMax()
{
 Soft_SPI_Init();

 MAX7219_CS_Direction = 0;

 MAX7219_CS = 0;
 Soft_SPI_write(0x09);
 Soft_SPI_write(0x00); //Code B
 MAX7219_CS = 1;

 //Configura a luminosidade do display(0-15)
 MAX7219_CS = 0;
 Soft_SPI_write(0x0a);
 Soft_SPI_write(0x0f);  //maximo
 MAX7219_CS = 1;

 //Configura o numero de displays escaneados(0-7)
 MAX7219_CS = 0;
 Soft_SPI_write(0x0b);
 Soft_SPI_write(0x07);  //scan limit
 MAX7219_CS = 1;

 MAX7219_CS = 0;
 Soft_SPI_write(0x0c);
 Soft_SPI_write(0x01);  //ShutDown off
 MAX7219_CS = 1;

 MAX7219_CS = 0;
 Soft_SPI_write(0x00);
 Soft_SPI_write(0xff);
 MAX7219_CS = 1;

}*/

.if · 23 de abril de 2021

Se você domar os bits um a um na sua matriz será capaz de fazer o que quiser deles. Me lembro que ralei 1 pouco na época pra criar e escrever textos e transformar num simples printf("TUDO POSSO NAQUELE QUE ME FORTALECE"); Foi tudo na unha sem consulta a net quando arduino sequer tinha nascido. Repito que hoje em dia você deve achar tudo pronto na net. Portanto faça sua escolha: tentar fazer ou copiar código. Ambos tem seu mérito. Como percebo que tens todo o tempo do mundo, vai tentando aí. Se não conseguir daqui um ano ou 2 procuro os fontes da minha "criatura" ... que acho que já publique neste ou outros foruns... vai que você acha

aphawk · 23 de abril de 2021

14 horas atrás, joelTGA disse:

ja ate to fazendo um curso na macrogenios para aprender

Nem sabia que tinha isso de macrogenius kkk fazem dezenas de anos o que eu conhecia como escola era Microgenius ....

A escola te ensina o básico. Mais nada ... a engenhosidade tem de ser sua mesmo, e você precisa treinar bastante, isso não vem de uma hora para outra, tem de ralar mesmo, meu jovem amigo....

Existe muita coisa pronta na Internet, eu também sugiro você fazer uma pesquisa, pegar os fontes e ver como os outros fizeram, aí com certeza você vai "abrir" o seu leque de opções de programação !

Paulo