Projetos com Avr : Design, Programação em Basic e Assembly

xyko-2020 · 16 de julho de 2015

Não conheço o assembler do AVR, mas do que eu conheço de assembler é que : Push coloca um valor na pilha (registrador r23) e o Pop retira o valor da pilha (o valor do registrador r23). Se faz isto para preservar o valor do registrador nas interrupções para caso se faça operações que alterem o valor do registrador. Se você dentro da interrupção não fizer nenhuma operação que altere o registrador não é necessário colocar ele na pilha, mas caso contrario acontecem erros "misteriosos" na execução do programa se você não preservar ele na pilha.

Muita gente usa o PUSH e esquece do POP.

Isto bagunça tudo!

test man*~ · 17 de julho de 2015

Obrigado @aphawk e @Intrudera6... Agora estou entendendo, nos PICs no início da ISR é salvo o registrador WORK, dentre outros, porém, nos AVRs são vários 'WORKS' (R31 ao R0) daí é necessário salvar todos, não estou falando besteira né

?

@test man*~,

[...]Mas sabe como é, seguro morreu de velho, então EU SEMPRE SALVO OS REGISTRADORES QUE MEU PROGRAMA VAI USAR. Ignorar esta regra simples e velha pode te dar problemas muito difíceis de serem solucionados, ok ?

Ok

Eu tenho que prestar mais atenção, antes de ontem olhei e não achei (apesar te ter passado pela informação)... Agora olhei e achei! Help > Index > Índice > ON INTERRUPT

OBRIGADO!

alexandre.mbm · 17 de julho de 2015

Nunca procurei muito, é verdade, mas este tópico foi a página mais informativa sobre PICs que já encontrei na Internet. Alguém tem dicas nesse sentido, tipo uma coleção de links do tipo "faz assim, programar PIC ou Arduino é assim"?

aphawk · 17 de julho de 2015

@test man*~,

Bem , não é que tenha falado besteira kkkk, mas ....

Tem de ter bem desenhado na sua cabeça o que que acontece quando ocorre uma interrupção. A instrução ASM atualmente sendo executada termina, o endereço que seria o da próxima instrução é armazenado no stack pointer, e é carregado o endereço da rotina de interrupção e feito um Jump para lá.

Agora, existe o conceito de contexto. O contexto engloba o registrador de status, SREG, que contém os flags alterados pela última instrução , e os registradores R0 até R31.

Se a gente, na nossa rotina de interrupção, não alterar nada , também não precisaremos salvar nada !

Então, temos de salvar pelo menos os registradores que iremos alterar, e com certeza quase absoluta, entre eles está o SREG, pois uma simples operação matemática, ou comparação, ou teste de bit muda algum flag de status do SREG, e quando a gente devolve o programa ao fim da interrupção pode ferrar tudo o que estava fazendo.

Agora, sabendo que o Bascom não usa todos os registradores, não precisamos salvar todos eles !!!!!

Porisso que eu falo, EU SEMPRE SALVO O SREG E OS REGISTRADORES QUE EU UTILIZO ! Mesmo que eu saiba que o Bascom não usa algum registrador que eu estou usando, se EU usar, EU prefiro salvar .... afinal nunca sabemos se pode mudar a versão do compilador e de repente usa algum registrador que antes nunca usava.

Costumo dizer sempre : o uso do cachimbo faz a boca ficar torta. Prefiro me obrigar a fazer o procedimento seguro, assim não crio dúvidas....

@alexandre.mbm,

Não tenho nada desse tipo, coletânea de links, mas acho que tem tanta informação espalhada aqui neste tópico e em outros tópicos que voce consegue começar sem nenhum problema !

Para quem quer começar, acho que o Bascom é um excelente caminho, pois é muito fácil fazer os programas, veja a opinião do Testman. E se não quiser ir pelo Bascom, vai pelo Arduíno mesmo, que é totalmente grátis.

Paulo

alexandre.mbm · 17 de julho de 2015

Hoje existem blogs e comunidades com conteúdo muito interessante sobre Arduino: projetos, tutoriais, DIY. Procuro algo assim sobre PIC. Posso estar enganado, mas estou supondo que pequenos projetos PIC com frequência ainda sairão mais baratos do que projetos usando Tiny85. Só que se o nível for baixo demais, aí já não me interessa. Se puder ser próximo da programação Arduino, melhor.

aphawk · 18 de julho de 2015

@alexandre.mbm

Existem alguns projetos malucos, que criaram um tipo de "Arduino com Pic", criaram até uma IDE com os comandos práticamente idênticos, então em teoria poderia partir daí. Mas tem dois grandes problemas :

1 - Um Pic que tenha a capacidade de um Atmega328 custa três vezes mais do que ele ....

2 - Bibliotecas. Elas que definem o ganhador do jogo. Se não criarem as mesmas bibliotecas que existem para o Arduíno, de que adianta usar um Pic ?????? Existem zilhões de bibliotecas para Arduíno, para tudo que é hardware que aparece logo aparece uma biblioteca para usar ele !

voce disse que devem existir pequenos projetos onde o uso de Pic possa ser vantajoso. Concordo com voce, pois os Pics minúsculos para usos bem dedicados podem custar bem baratos. Mas isto seria para uso industrial, em grande volume.

Mas aonde voce conseguiria usar um Pic com Flash de 1k, 128 bytes de Ram, e hardware mínimo dentro dele ?

Não existe apenas o Attiny85, ele é um membro bem poderoso dos Attinys, existem outros bem menores, com bem menos recursos, e que se comprados em grande quantidade ( igual aos Pics minúsculos ) conseguirá um preço bem menor.

Mas aqui já estamos falando do uso industrial, produção em grande quantidade, não tem muito a ver com o que lidamos aqui no Fórum, afinal somos hobbystas, claro que nada impede de criarmos aplicações comerciais, como eu faço de vez em quando, e ganharmos dinheiro com isto !

A partir de uma ideia que voce tenha, voce pode usar qualquer microprocessador. Preço baixo sempre é bom, mas muitas vezes opta-se para um custo um pouco maior para que possamos ter uma sobrevida maior do nosso produto, podendo ser atualizado, ou até reprogramado em um tempo muito pequeno.

Já ví algumas empresas insistirem em que um produto seja programado em Asm para que não tivessem de gastar com um compilador. Mas já pensou que o tempo para chegar ao término do produto pode ser várias vezes maior do que se fosse tudo escrito em C, ou em Basic ?

E quando o programador saí da empresa, a dificuldade de um outro programador pegar o código e entender para poder modificar é uma outra quantidade absurda de tempo.

Enfim, tem muitas variáveis em jogo.

Não se iluda com os Pics, voce não vai encontrar nem 10% dos projetos que existem para os Arduínos, simplesmente porque os Pics comuns não possuem a capacidade dos Atmegas.

Paulo

test man*~ · 18 de julho de 2015

Entendi @aphawk... É que tipo, Como entendo bem os PICs para entender os AVRs eu tento fazer um paralelo na minha mente HEHE... No PIC quando uma interrupção é gerada os registradores STATUS e W (WORD) também devem ser salvos (se alterados na ISR):



; Código ASM ISR PIC16F

 

INTERRUPT

    movwf   w_temp           ; save off current W register contents

    movf    status,w         ; move status register into W register

    movwf   status_temp      ; save off contents of STATUS register

    movf    pclath,w         ; move pclath register into w register

    movwf   pclath_temp      ; save off contents of PCLATH register

    

; isr code can go here or be located as a call subroutine elsewhere

 

    movf    pclath_temp,w    ; retrieve copy of PCLATH register

    movwf   pclath           ; restore pre-isr PCLATH register contents

    movf    status_temp,w    ; retrieve copy of STATUS register

    movwf   status           ; restore pre-isr STATUS register contents

    swapf   w_temp,f

    swapf   w_temp,w         ; restore pre-isr W register contents

    retfie                   ; return from interrupt

Nos AVRs é a mesma coisa... Porém é possível salvar os 'WORKS' (R0 - R31) na pilha com as funções PUSH, nos PICs você salva em outro registrador. É claro... Se não houver alterações nos registradores durante o tratamento das interrupções, também não haverá necessidade de salvá-los...

Um coisa muito interesante (tomara que eu esteja correto!! UHAuHAUhUah) é que não há limite para o tamanho da pilha dos AVRs, a única limitação é o tamanho da SRAM e o seu uso... Mesmo assim... Eu ainda amo os PICs

!!!

@alexandre.mbm, olha este link: https://www.youtube.com/watch?v=64vVI5kgbCo&list=PL4DE4A7AD9EE36E77 Não assisti aos vídeos mas pela quantidade de views eles devem ser bons... O cara usa o CCS nos tutoriais ele é extremamente simples, muito fácil... Ele possui um Project Wizard que te dá tudo na mão, você apenas escreve o código... Parece que o cara também ensina simular usando o Proteus...

Quanto as bibliotecas, realmente são poucas se comparadas com a quantidade existente para o Arduíno, o CCS vem com várias mas mesmo assim são poucas... Mas ai que está o pulo do gato, é muito mais interessante você pegar o datasheet do componente, quebrar a cabeça e criar a sua própria biblioteca (que funcionará exatamente como você quer)...

Dá uma olhada lá... Quem sabe você curti...

Voltando para os projetos o Need For Speed Most Wanted 2005 me atrasou

alexandre.mbm · 18 de julho de 2015

Não existe apenas o Attiny85, ele é um membro bem poderoso dos Attinys, existem outros bem menores, com bem menos recursos, e que se comprados em grande quantidade ( igual aos Pics minúsculos ) conseguirá um preço bem menor.

Mas aqui já estamos falando do uso industrial, produção em grande quantidade, não tem muito a ver com o que lidamos aqui no Fórum,

Você poderia citar alguns desses Attinys fazendo notas suas principais diferenças?

Por que só para uso industrial?

Preço baixo sempre é bom, mas muitas vezes opta-se para um custo um pouco maior para que possamos ter uma sobrevida maior do nosso produto, podendo ser atualizado, ou até reprogramado em um tempo muito pequeno.

Eu não estava lembrando dessas importantes conveniências. Obrigado.

Mas ai que está o pulo do gato, é muito mais interessante você pegar o datasheet do componente, quebrar a cabeça e criar a sua própria biblioteca (que funcionará exatamente como você quer)...

Pra mim, quase sempre, não.

Dá uma olhada lá... Quem sabe você curti...

Pode até ser. Vou ver. Obrigado.

aphawk · 18 de julho de 2015

@test man*~,

Sim, o seu limite é a Sram mesmo !

Fazer um paralelo entre um Pic e um Avr funciona muito bem em termos de hardware. Em software, não dá para comparar, porque a estrutura de registradores sobrando e instruções muito mais poderisas dos Avr torna inútil a comparação do Assembler deles.

Muita gente boa já disse que usando um Avr que custa 1/3 de um Pic voce faz a mesma função dele, mas rodando no mínimo 8 vezes mais rápido. E hoje eu sei que isso é verdade na grande maioria dos casos. E me faz sempre pensar em continuar usando os Avrs, mesmo sabendo de opções em ARM que fazem com os Avrs a mesma coisa que os Avrs fazem com os Pics, pois a minha experiência com eles me faz ter um excelente background, e isso não se joga fora nunca, a menos que seja extremamente necessário.

Hehehe isso de sua paixão pelo Pic é normal ! É a mesma coisa de falar que voce ama o primeiro Fusquinha que dirigiu, ou sobre a primeira namoradinha kkkkk !

Eu também tenho esse sentimento pelo Z-80 ! Um maravilhoso projeto , centenas de instruções diferentes, e muitas lembranças !

Mas lembro sempre de voltar os pés no chão : estamos em 2015, na era dos Avrs, e usar eles me faz ganhar dinheiro justamente porque fica muito simples, rápido e barato fazer o que me pedem !!!

"Em terra de cego, que tem um olho é Rei !" - Pensem nisso sempre ....

@alexandre.mbm,

Eu digo uso industrial, porque se voce for comprar hoje um Avr, vai ser muito difícil comprar algum modelo mais barato do que um Atmega328p !!!! Mesmo os Attinys, por modelo mais simples que existir, mesmo de capacidade muito inferior, vai custar quase a mesma coisa, justamente porque o volume da sua compra vai ser baixo. Já quando o uso vai ser em grande quantidade ( conceito de uso industrial ) aí sim voce pode comprar dos grandes distribuidores a um preço competitivo.

Olha, em vez de eu ficar maluco descrevendo eles, dá uma olhada na página principal da Atmel :

http://www.atmel.com/products/microcontrollers/avr/tinyAVR.aspx

E para comparar eles, tem esta página :

http://www.atmel.com/v2PFResults.aspx#(actives:!(8238,8394,8362,8282,8431,8300,8358,8392,8378,8445,8236,8449,8474,8248,8264,8447,8256,8254,8286,8462,8429,8458,8466,8400,8302,8278),data:(area:'',category:'34864[33180[33086]]',pm:!((i:8238,v:!(1,7)),(i:8394,v:!(0,7)),(i:8362,v:!(5,12)),(i:8282,v:!(5)),(i:8431,v:!(1,8)),(i:8300,v:!(1,5)),(i:8358,v:!(2,20)),(i:8392,v:!(0,1)),(i:8378,v:!n),(i:8445,v:!(5,6,9)),(i:8236,v:!(0,9)),(i:8449,v:!(1,3)),(i:8474,v:!(0)),(i:8248,v:!(0,1)),(i:8264,v:!(1,2)),(i:8447,v:!(0,1)),(i:8256,v:!(1,4)),(i:8254,v:!(3,16)),(i:8286,v:!(0)),(i:8462,v:!(0,2)),(i:8429,v:!(1,2)),(i:8458,v:!(0,1)),(i:8466,v:!(4)),(i:8400,v:!(0,7)),(i:8302,v:!(0)),(i:8278,v:!(0))),view:table),sc:1)

Se não funcionar o link, entre no link anterior e clique no alto em SEARCH.

Paulo

alexandre.mbm · 18 de julho de 2015

Eu digo uso industrial, porque se voce for comprar hoje um Avr, vai ser muito difícil comprar algum modelo mais barato do que um Atmega328p !!!! Mesmo os Attinys, por modelo mais simples que existir, mesmo de capacidade muito inferior, vai custar quase a mesma coisa, justamente porque o volume da sua compra vai ser baixo. Já quando o uso vai ser em grande quantidade ( conceito de uso industrial ) aí sim voce pode comprar dos grandes distribuidores a um preço competitivo.

Agora eu entendi o X da questão. Excelente colocação! Muitíssimo obrigado.

Olha, em vez de eu ficar maluco descrevendo eles, dá uma olhada na página principal da Atmel :

http://www.atmel.com/products/microcontrollers/avr/tinyAVR.aspx

É verdade. Desculpe-me. Mas eu estava imaginando apenas uma pequena listinha com uma sintética expressão "marcando a diferença" de cada Attiny; só dos mais conhecidos e "compráveis" aqui no Brasil.

aphawk · 19 de julho de 2015

@alexandre.mbm,

Eu não sei o que se compra aqui no Brasil..... compro tudo de fora pois custa muito mais barato.

Vou te falar o que que eu padronizei : Eu uso apenas três AVR's em tudo o que faço :

1 - Atmega644 - Com 40 pinos, tá cheio de I/O, tem hardware interno de monte, com 4K de SRAM , 2K de EEPROM, e 64K de memória de programa !!!!!!

Só precisei dele em um projeto até agora.

2 - Atmega328P - Com 28 pinos, bastante hardware interno, I/O quase sempre mais do que eu preciso, tem 2K de SRAM, 1K de EEPROM, e 32K de memória de programa.

É o que eu mais uso.

3 - Attiny85 - com 8 pinos, tem I/O limitado, mas permite comunicação de tudo que é maneira, e tem um hardware interno bem interessante, tem 512 bytes de SRAM, 512 bytes de EEPROM, e 8K de memória de programa.

Usei em duas aplicações até o momento.

Sobre o Attiny85, embora é pequeno, não deixe ele te iludir ! O hardware interno tem coisas que não tem nos outros dois modelos acima ! Por exemplo, ele gera PWM em frequências 8 vezes maiores do que os outros; o conversor A/D tem entrada diferencial com ganho programável x1 e x20 ; sensor de temperatura interno.

Ou seja, tem Timer, Counter, PWM, A/D, I2C, SPI, serial comum, comparador analógico, interrupção externa, enfim é um excelente processador para aquelas aplicações onde o tamanho é fator preponderante.

Eu só uso esses 3 modelos, pois com eles consigo fazer tudo o que eu precisei até o momento. O Atmega644 custa pouco mais do que o dobro do Atmega328, e o Attiny85 custa quase a mesma coisa do Atmega328. Claro, fora do Brasil ..... Compro quase tudo via Ebay, Aliexpress , e DX .

Paulo

alexandre.mbm · 20 de julho de 2015

1 - Atmega644 - [...] Só precisei dele em um projeto até agora.

2 - Atmega328P - [...] É o que eu mais uso.

3 - Attiny85 - [...] Usei em duas aplicações até o momento.

Você pode nos falar, por alto, um papel representativo que cada um teve? Por alto: um projeto, um papel.

aphawk · 20 de julho de 2015

@alexandre.mbm,

Vou citar todos eles na mesma área :

O Atmega644 foi usado em um projeto onde tinha de monitorar o funcionamento de 24 roteadores Mikrotik, avisando o sistema central em caso de travamento, e inclusive mandando mensagem SMS para até 4 responsáveis. Imaginou o numero de entradas de I/O só para o monitoramento : 24 .... fora o bus I2C interno, os pinos de TX/RX serial para o módulo SMS, etc ....

O Atmega328 foi usado também na mesma função, mas para sistemas menores, de até 8 roteadores Mikrotik.

Já os Attiny85 eu uso na monitoração de temperatura, acionando até 2 sistemas de ventilação forçada conforme a temperatura, podendo medir a temperatura em até 4 pontos diferentes. Possui um sistema de Log de todos os sensores e valores das saídas de 10 em 10 minutos, em uma EEprom serial, com soquete, para casos extremos.

Mas tenho outros projetos, como um sistema de monitoramento de picos de tensão, subtensão e sobretensão, podendo tomar decisão sózinho enviando sinal de comutação para no-breaks, ou recebendo comando por SMS, e voltando à rede normal caso a variação cesse ou receba o comando SMS, e também podendo comunicar via SMS com até 4 responsáveis. Também possui sistema de Log em EEPROM serial.... Isso é bastante usado em locais bem quentes, Tipo norte / Nordeste .

Enfim, reparou que existe uma certa modularização nos programas, por exemplo a parte de envio de SMS é a mesma, e a parte de Log em EEPROM serial também, usados em vários projetos diferentes. Facilita a manutenção.

Paulo

test man*~ · 20 de julho de 2015

[...] Estamos em 2015, na era dos Avrs [...]

Típico "AVR Freak" HAHAHAHAHAHAHA... Você possui uma camisa desta:

http://www.atmelbrandshop.com/ProductDetails.asp?ProductCode=0151-B

HEHEHEHE

Brincadeira... Eu até queria ter =)

Estou indo com os projetos... No projeto 4 usei o DIDR0 para para desativar a entrada digital e assim consumir menos energia (característica bacana essa), no do relógio (Pj 5) achei interessante o esquema do 32,768KHz externo =D, ainda estou terminando ele falta programar o alarme!

No fim vou fazer uma comunicação SPI entre um PIC e um AVR e uma I2C multimestre com dois PIC e dois AVR como mestres e escravos HAHAHAHAHAHAHHAHAHAHhUHAuhuahuhuaHUAH!!!!!

Tutorial excelente... Uma coisa, eles pararam de atualizar o BASCOM?

aphawk · 20 de julho de 2015

@test man*~,

KKKK bela camiseta não é ????? Eu também queria uma, mas pro meu tamanho fica complicado kkkkkk ! 1,94 mts com 124 Kgr num é qqr uma que entra heheheh.

Tem um monte de maneira de fazer ter baixo consumo, embora isso eu não cito no tutorial... mas se voce se interessar, pesquisa no Fórum do Bascom, no site da MCS. Tem como desligar a parte analógica, tem modos de baixo consumo, tem modos de "dormir" e acordar por uma interrupção externa ou do próprio Timer ( olha que legal ! ) e com consumo abaixo de 50 uA !

Caramba, voce gosta de sofrer ein ???? SPI entre as duas famílias, depois I2C, fica uma baita bagunça isso !

Alias, voce sabe que existe uma biblioteca que permite que os AVR's se tornem dispositivos mestre ou escravo usando I2C, e assim voce pode "criar" o seu próprio componente inteligente ???????

Tem um exemplo no Help do Bascom, voce pode usar um Attiny ou um Avr, e criar o seu próprio componente dedicado !!!

O Bascom recebe atualizações sempre, inclusive eu estou testando a versão Beta, que tem algumas novidades legais. e sempre são acompanhadas de novas bibliotecas para novas aplicações, inclusive suporte para vários displays que vão aparecendo no mercado.

Paulo

test man*~ · 22 de julho de 2015

@test man*~,

Alias, voce sabe que existe uma biblioteca que permite que os AVR's se tornem dispositivos mestre ou escravo usando I2C, e assim voce pode "criar" o seu próprio componente inteligente ???????

Ao abrir o BASCOM ele mostra aquelas dicas ai apareceu falando da $lib "i2c_twi.lbx"... Dá até para ver o Erro após cada envio/recepção =D

Sobre o projeto 7, não existe uma forma de fixar o número de casas que serão imprimidas após a vírgula com a função Lcd? Tipo assim (se fosse em C):

printf("%.2f",single_var);

Eu converti no código mesmo...

aphawk · 22 de julho de 2015

@test man*~,

Sim, existe a função FUSING , veja no Help, voce vai gostar dela kkkkk !

Paulo

test man*~ · 22 de julho de 2015

Olhei lá... Entendi como funciona, aproveitei e olhei também a função FORMAT =D ficou tudo mais claro hehe.

Estou querendo usar um PCF8574 (que o pessoal usa com o Arduíno) para enviar caracteres para o LCD. O CCS possui um esquema que é assim:

printf(escrever_lcd_i2c,"Hello World");

Assim o printf chama a função "escrever_lcd_i2c" onde há o código para enviar cada caractere para o LCD via I2C.

Pelo que eu entendi (ainda não fiz o código para o CCS) o printf cria o caractere "H" e chama a função "escrever_lcd_i2c" depois cria o "e" e chama a função "escrever_lcd_i2c" e assim por diante...

Existe algo parecido no BASCOM?

Obrigado Paulo!

aphawk · 23 de julho de 2015

@test man*~,

Que eu saiba essa função printf que você colocou recebe em um buffer o "hello world" e trata o envio serialmente via I2C. É uma função aninhada, que o C permite sem problema.

Olhe aqui, acho que voce vai gostar, não precisa mudar a função original do Print para fazer exatamente a mesma coisa no Bascom :

http://www.mcselec.com/index2.php?option=com_forum&Itemid=59&page=viewtopic&t=12506

Essa library foi criada fazem alguns anos, e foi modificada recentemente para permitir controlar backlite.

Paulo

test man*~ · 24 de julho de 2015

Eu queria criar um biblioteca... Até achei uma solução mas não resultaria em algo "limpo"... Então resolvi usar o MAX7219 e fazer um painelzinho de leds, já entendi o funcionamento do MAX agora estou lendo a parte sobre SPI do datasheet do Atmega, farei uns testes e então começarei o programa... Vou ser se faço um esquema para receber dados da serial e mostrar no painel (mensagem rolando).

Quando o código ficar pronto eu posto aqui..

Obrigado @aphawk!

aphawk · 24 de julho de 2015

@test man*~,

Opa, legal, eu já pensei em fazer algo desse tipo também ! Eu acho muito legal usar eses Max7219, são uma mão na roda !

Pode se divertir à vontade !

Paulo

test man*~ · 27 de julho de 2015

Sim o MAX7219 é muito bom... Ele faz todo o trabalho pesado, o primeiro painelzinho que eu fiz foi usando o 74HC595 (deu uma trabalheira danada hehe).

Eu comecei o código e apanhei (MUITO) na inicialização do vetor, em C eu poderia fazer assim:

PROGMEM prog_uchar CH[] = {3, 8, B00000000, B00000000, B00000000, B00000000, B00000000, // space1, 8, B01011111, B00000000, B00000000, B00000000, B00000000, // !3, 8, B00000011, B00000000, B00000011, B00000000, B00000000, // "5, 8, B00010100, B00111110, B00010100, B00111110, B00010100, // #4, 8, B00100100, B01101010, B00101011, B00010010, B00000000, // $5, 8, B01100011, B00010011, B00001000, B01100100, B01100011, // %5, 8, B00110110, B01001001, B01010110, B00100000, B01010000, // &1, 8, B00000011, B00000000, B00000000, B00000000, B00000000, // '3, 8, B00011100, B00100010, B01000001, B00000000, B00000000, // (3, 8, B01000001, B00100010, B00011100, B00000000, B00000000, // )5, 8, B00101000, B00011000, B00001110, B00011000, B00101000, // *5, 8, B00001000, B00001000, B00111110, B00001000, B00001000, // +2, 8, B10110000, B01110000, B00000000, B00000000, B00000000, // ,4, 8, B00001000, B00001000, B00001000, B00001000, B00000000, // -2, 8, B01100000, B01100000, B00000000, B00000000, B00000000, // .4, 8, B01100000, B00011000, B00000110, B00000001, B00000000, // /4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // 03, 8, B01000010, B01111111, B01000000, B00000000, B00000000, // 14, 8, B01100010, B01010001, B01001001, B01000110, B00000000, // 24, 8, B00100010, B01000001, B01001001, B00110110, B00000000, // 34, 8, B00011000, B00010100, B00010010, B01111111, B00000000, // 44, 8, B00100111, B01000101, B01000101, B00111001, B00000000, // 54, 8, B00111110, B01001001, B01001001, B00110000, B00000000, // 64, 8, B01100001, B00010001, B00001001, B00000111, B00000000, // 74, 8, B00110110, B01001001, B01001001, B00110110, B00000000, // 84, 8, B00000110, B01001001, B01001001, B00111110, B00000000, // 92, 8, B01010000, B00000000, B00000000, B00000000, B00000000, // :2, 8, B10000000, B01010000, B00000000, B00000000, B00000000, // ;3, 8, B00010000, B00101000, B01000100, B00000000, B00000000, // <3, 8, B00010100, B00010100, B00010100, B00000000, B00000000, // =3, 8, B01000100, B00101000, B00010000, B00000000, B00000000, // >4, 8, B00000010, B01011001, B00001001, B00000110, B00000000, // ?5, 8, B00111110, B01001001, B01010101, B01011101, B00001110, // @4, 8, B01111110, B00010001, B00010001, B01111110, B00000000, // A4, 8, B01111111, B01001001, B01001001, B00110110, B00000000, // B4, 8, B00111110, B01000001, B01000001, B00100010, B00000000, // C4, 8, B01111111, B01000001, B01000001, B00111110, B00000000, // D4, 8, B01111111, B01001001, B01001001, B01000001, B00000000, // E4, 8, B01111111, B00001001, B00001001, B00000001, B00000000, // F4, 8, B00111110, B01000001, B01001001, B01111010, B00000000, // G4, 8, B01111111, B00001000, B00001000, B01111111, B00000000, // H3, 8, B01000001, B01111111, B01000001, B00000000, B00000000, // I4, 8, B00110000, B01000000, B01000001, B00111111, B00000000, // J4, 8, B01111111, B00001000, B00010100, B01100011, B00000000, // K4, 8, B01111111, B01000000, B01000000, B01000000, B00000000, // L5, 8, B01111111, B00000010, B00001100, B00000010, B01111111, // M5, 8, B01111111, B00000100, B00001000, B00010000, B01111111, // N4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // O4, 8, B01111111, B00001001, B00001001, B00000110, B00000000, // P4, 8, B00111110, B01000001, B01000001, B10111110, B00000000, // Q4, 8, B01111111, B00001001, B00001001, B01110110, B00000000, // R4, 8, B01000110, B01001001, B01001001, B00110010, B00000000, // S5, 8, B00000001, B00000001, B01111111, B00000001, B00000001, // T4, 8, B00111111, B01000000, B01000000, B00111111, B00000000, // U5, 8, B00001111, B00110000, B01000000, B00110000, B00001111, // V5, 8, B00111111, B01000000, B00111000, B01000000, B00111111, // W5, 8, B01100011, B00010100, B00001000, B00010100, B01100011, // X5, 8, B00000111, B00001000, B01110000, B00001000, B00000111, // Y4, 8, B01100001, B01010001, B01001001, B01000111, B00000000, // Z2, 8, B01111111, B01000001, B00000000, B00000000, B00000000, // [4, 8, B00000001, B00000110, B00011000, B01100000, B00000000, // \ backslash2, 8, B01000001, B01111111, B00000000, B00000000, B00000000, // ]3, 8, B00000010, B00000001, B00000010, B00000000, B00000000, // hat4, 8, B01000000, B01000000, B01000000, B01000000, B00000000, // _2, 8, B00000001, B00000010, B00000000, B00000000, B00000000, // `4, 8, B00100000, B01010100, B01010100, B01111000, B00000000, // a4, 8, B01111111, B01000100, B01000100, B00111000, B00000000, // b4, 8, B00111000, B01000100, B01000100, B00101000, B00000000, // c4, 8, B00111000, B01000100, B01000100, B01111111, B00000000, // d4, 8, B00111000, B01010100, B01010100, B00011000, B00000000, // e3, 8, B00000100, B01111110, B00000101, B00000000, B00000000, // f4, 8, B10011000, B10100100, B10100100, B01111000, B00000000, // g4, 8, B01111111, B00000100, B00000100, B01111000, B00000000, // h3, 8, B01000100, B01111101, B01000000, B00000000, B00000000, // i4, 8, B01000000, B10000000, B10000100, B01111101, B00000000, // j4, 8, B01111111, B00010000, B00101000, B01000100, B00000000, // k3, 8, B01000001, B01111111, B01000000, B00000000, B00000000, // l5, 8, B01111100, B00000100, B01111100, B00000100, B01111000, // m4, 8, B01111100, B00000100, B00000100, B01111000, B00000000, // n4, 8, B00111000, B01000100, B01000100, B00111000, B00000000, // o4, 8, B11111100, B00100100, B00100100, B00011000, B00000000, // p4, 8, B00011000, B00100100, B00100100, B11111100, B00000000, // q4, 8, B01111100, B00001000, B00000100, B00000100, B00000000, // r4, 8, B01001000, B01010100, B01010100, B00100100, B00000000, // s3, 8, B00000100, B00111111, B01000100, B00000000, B00000000, // t4, 8, B00111100, B01000000, B01000000, B01111100, B00000000, // u5, 8, B00011100, B00100000, B01000000, B00100000, B00011100, // v5, 8, B00111100, B01000000, B00111100, B01000000, B00111100, // w5, 8, B01000100, B00101000, B00010000, B00101000, B01000100, // x4, 8, B10011100, B10100000, B10100000, B01111100, B00000000, // y3, 8, B01100100, B01010100, B01001100, B00000000, B00000000, // z3, 8, B00001000, B00110110, B01000001, B00000000, B00000000, // {1, 8, B01111111, B00000000, B00000000, B00000000, B00000000, // |3, 8, B01000001, B00110110, B00001000, B00000000, B00000000, // }4, 8, B00001000, B00000100, B00001000, B00000100, B00000000, // ~};

Tirei as letras daqui: https://brainy-bits.com/tutorials/scroll-text-using-the-max7219-led-dot-matrix/

No BASIC tive que fazer na raça:

Dim E(570) As Byte , I As Word   E(1) = 3E(2) = &B00000000E(3) = &B00000000E(4) = &B00000000E(5) = &B00000000E(6) = &B00000000                                           'SpaceE(7) = 1E(8) = &B01011111E(9) = &B00000000E(10) = &B00000000E(11) = &B00000000E(12) = &B00000000                                          ' !E(13) = 3E(14) = &B00000011E(15) = &B00000000E(16) = &B00000011E(17) = &B00000000E(18) = &B00000000                                          ' ""E(19) = 5E(20) = &B00010100E(21) = &B00111110E(22) = &B00010100E(23) = &B00111110E(24) = &B00010100                                          ' #:::E(559) = 3E(560) = &B01000001E(561) = &B00110110E(562) = &B00001000E(563) = &B00000000E(564) = &B00000000                                         ' }E(565) = 4E(566) = &B00001000E(567) = &B00000100E(568) = &B00001000E(569) = &B00000100E(570) = &B00000000                                         ' ~ For I = 1 To 570   Writeeeprom E(i) , INext

Tentei coisas do tipo: https://msdn.microsoft.com/en-us/library/y13tek7e.aspx mas nada de funcionar (o compilador não reconhece o comando).

Estou pensando em armazenar os bytes dos caracteres na EEPROM (570 bytes) assim sobra mais espaço na SRAM para a mensagem que rodará no painel...

Este código apenas mostra todos os caracteres:

http://www.4shared.com/rar/6PIKnnJ9ce/LED_MAT_Todos_Carcteres_MAX_AV.html?

Agora vou para o painel com os 6 MAX7219.

Valeu Paulo @aphawk

aphawk · 27 de julho de 2015

@test man*~,

Muito trabalhoso isso que voce fez... existem muitos recursos no Bascom para fazer isso bem mais simples, olha este exemplo :

'-----------------------------------------------------------------------------------------
'name                     : eeprom2.bas
'copyright                : (c) 1995-2005, MCS Electronics
'purpose                  : shows how to use labels with READEEPROM
'micro                    : Mega48
'suited for demo          : yes
'commercial addon needed  : no
'----------------------------------------------------------------------------------------- 
$regfile = "m48def.dat"                                   ' specify the used micro
$crystal = 4000000                                         ' used crystal frequency
$baud = 19200                                               ' use baud rate
$hwstack = 32                                               ' default use 32 for the hardware stack
$swstack = 10                                               ' default use 10 for the SW stack
$framesize = 40                                             ' default use 40 for the frame space 
'first dimension a variable
Dim B As Byte
Dim Yes As String * 1 
'Usage for readeeprom and writeeprom :
'readeeprom var, address 
'A new option is to use a label for the address of the data
'Since this data is in an external file and not in the code the eeprom data
'should be specified first. This in contrast with the normal DATA lines which must
'be placed at the end of your program!! 
'first tell the compiler that we are using EEPROM to store the DATA
$eeprom 
'the generated EEP file is a binary file.
'Use $EEPROMHEX to create an Intel Hex file usable with AVR Studio.
'$eepromhex 
'specify a label
Label1:Data 1 , 2 , 3 , 4 , 5
Label2:Data 10 , 20 , 30 , 40 , 50 
'Switch back to normal data lines in case they are used
$data 
'All the code above does not generate real object code
'It only creates a file with the EEP extension 
'Use the new label option
Readeeprom B , Label1
Print B                                                     'prints 1
'Succesive reads will read the next value
'But the first time the label must be specified so the start is known
Readeeprom B
Print B                                                     'prints 2
Readeeprom B , Label2
Print B                                                     'prints 10
Readeeprom B
Print B                                                     'prints 20 
'And it works for writing too :
'but since the programming can interfere we add a stop here
Input "Ready?" , Yes
B = 100
Writeeeprom B , Label1
B = 101
Writeeeprom B 
'read it back
Readeeprom B , Label1
Print B                                                     'prints 100
'Succesive reads will read the next value
'But the first time the label must be specified so the start is known
Readeeprom B
Print B                                                     'prints 101
End

Repare que usando $eeprom e a estrutura DATA fica muito mais simples ....

E lembre-se de que o tempo para ler dados da Eprom é bem maior do que da SRAM normal.

Paulo

aphawk · 28 de julho de 2015

@test man*~,

Me lembrei de outra coisa que fica muito pareçida com a inicialização do vetor em C que você mostrou.

As fontes de display gráfico no Bascom são arquivos tipo .FON , que na verdade são apenas um montão de DATA seguidos dos valores para fazer cada um dos caracteres. Experimenta no diretório de Samples tem alguns arquivos desse tipo, abre eles e dá uma olhada.

É uma estrutura quase idêntica .

Paulo

test man*~ · 28 de julho de 2015

É eu vi esse esquema da EEPROM mas o que causou o trabalho foi "iniciar o vetor com os valores".

Eu até criei o arquivo .bin com o BASCOM AVR mas o proteus não o reconheceu

... O Correios está fazendo pirraça

com as importações por isso estou somente na simulação.

Sim ler a EEPROM é um processo lento mas ela será lida apenas quando o usuário enviar a frase via serial, quando isso acontecer o AVR lerá a EEPROM e atualizará um vetor que será lido toda hora (este ficará na SRAM).

Olhei o esquema dos arquivos .FON isso certamente seria a forma "certa" de fazer a coisa...

Mas como já fiz vou ficar com aquela monstruosidade mesmo HEHE.

Montei circuito completo, e fiz um teste para ver se os MAX mostrariam as letras corretamente:

AphaUk com "U"

Estou tentando fazer de uma forma que fique fácil aumentar ou diminuir a quantidade de MAX/Matriz (alterando apenas 2 linhas). Aqui está o arquivo:

http://www.4shared.com/rar/WusLRub1ce/6_MAX_7219.html?

Dei uma parada para entender como usar o USART com o BASCOM AVR e é bem interessante... Aquela coisa do buffer e tal



_RS_HEAD_PTRW0, byte that stores the head of the buffer

_RS_TAIL_PTRW0, byte that stores the tail of the buffer

_RS232OUTBUF0, array of bytes for the ring buffer that stores the printed data.

_RS_BUFCOUNTW0, a byte that holds the number of bytes in the buffer.

Obrigado novamente @aphawk, um dia fica pronto

.