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

Intrudera6 · 24 de novembro de 2014

Bem vindo de volta

MOR_AL · 24 de novembro de 2014

Bem-vindo, Paulo.

MOR_AL

vtrx · 24 de novembro de 2014

@aphawk,que bom que esta se 'recuperando',pois não sei os detalhes,apenas lí um post do Mor falando que estava em 'recuperação'(talvez de matemática).

Na primeira semana percebi que não estava postando,então mandei uma MP para o Matheus e ele respondei que não estava sabendo de nada.

Como não gosto de incomodar quem esta com algum problema,fiquei na espera.

aphawk · 24 de novembro de 2014

Amigos Vtrx, Mor e Intruder,

Obrigado pelas mensagens, passei por três problemas graves que começaram com um apêndice suporado.... mas estou me recuperando da nefrite que foi a gota d'água disso tudo.

Devagarinho, um pouco a cada dia, vou me movimentando novamente e entrando aqui no Fórum , já estava doido de saudades daqui...

Paulo

aphawk · 12 de janeiro de 2015

Pessoal,

Começei a fazer um Analisador de Baterias ( pilhas Alcalinas e também Ni-Me e 16850 recarregáveis ) para testar a real capacidade de carga de uma bateria. Escolhi como display colorido o ILI9341 , que pode ser comprado no Ebay por menos de US$ 4,30 , o que o torna uma excelente escolha para qualquer projeto, pois é colorido, tem resolução de 240 x 320, e possui interface SPI, que utiliza apenas 4 sinais para controle.

Um usuário do Fórum do Bascom na Alemanha postou um código completo para utilizar o display, mas foi escrito em Basic mesmo e acaba sendo um pouco lento. E além de tudo, foi feito para o Atmega2560. Tive um pequeno trabalho para converter a um simples Atmega328p, e o resultado foi que usamos quase toda a capacidade da memória flash de programa do Arduíno Uno....

Resolví reescrever as rotinas básicas do display ( as chamadas funções primitivas ) em Asm, e finalmente ficou pronto. E decidi manter apenas duas fontes diferentes para escrita de texto no display, assim o driver de display acabou ocupando cerca de 50% da memória ce programa, e a velocidade ficou bem maior.

Vou publicar primeiro as rotinas de uso do display, e depois quando o programa final estiver pronto, publicarei o projeto do analisador de baterias.

Para ir adoçando, segue um vídeo :

Paulo

alexandre.mbm · 2 de maio de 2015

Por favor, atualize a primeira mensagem do post. Não consegui baixar o arquivo do 4shared.

aphawk · 2 de maio de 2015

Por favor, atualize a primeira mensagem do post. Não consegui baixar o arquivo do 4shared.

Eu acabei de testar e baixei direitinho.

voce precisa ter uma conta em alguns dos sites que ele pede ou faça uma conta no 4Shared mesmo, e faça o login, assim não vai te perguntar nenhuma outra conta, ok ?

Paulo

aphawk · 3 de maio de 2015

Comprei alguns módulos de Rotary Encoder chineses muito baratos, e só quando chegaram percebí o porque eram tãoooo baratos :

GERAM UMA QUANTIDADE ABSURDA DE RUÍDOS QUANDO GIRAMOS PARA QUALQUER LADO !!!

Vejam quais são :

Para pode usar eles, tive de melhorar bastante uma rotina que eu uso fazem muitos anos, e ficou muito bom, sem nenhum ruído e sem perder nenhuma girada para qualquer lado !

Segue aqui o programa para ajudar outros que estejam passando pelo mesmo problema.

'*******************************************************************************

' Demo sobre uso de um Rotary Encoder em um programa simples

' Pode ser rodado direto em um Arduíno Uno sem modificações,

' basta ligar o Rotary Encoder nos pinos Digital 6 e 7, e o

' pino do Push Button no pino Digital 3

'

'Agora, existem alguns Rotary Encoder chineses bem baratinhos e

'muito ruidosos, então tive de reescrever o meu programa anterior.

'

'Este roda sem perder nenhum giro, e sem ruidos loucos !

'

'*******************************************************************************

$regfile = "m328pdef.dat"

$crystal = 16000000

$hwstack = 32

$swstack = 32

$framesize = 250

$baud = 9600

Config Com1 = 9600 , Synchrone = 0 , Parity = None , Stopbits = 1 , Databits = 8 , Clockpol = 0



'Create a buffer to send data with interrupts

Config Serialout = Buffered , Size = 64



Print "Encoder Test"



'Encoder Push_Button

Config Pind.3 = Input : Set Portd.3

'Encoder pin1

Config Pind.6 = Input : Set Portd.6

'Encoder pin2

Config Pind.7 = Input : Set Portd.7



'Configure the time to debounce buttons = 50 mseg

Config Debounce = 50



Dim Half_right As Bit

Dim Half_left As Bit



Dim Flag_enc_novo As Bit

Dim Flag_dir_h As Bit

Dim Dado As Byte

Dim Old_val As Byte

Dim X_enc As Byte





Dado = Pind

Old_val = Dado



'Let's enable PIN CHANGE interrupt on the pins from encoder shaft

'enable pin change interrupt on pinD.7 and  pinD.6

Pcmsk2 = &B11000000

' These two pins on Port D can set PCINT1, then we must enable it

Pcicr.2 = 1



On Pcint2 Isr_pcint2_encoder



Enable Pcint2

Enable Interrupts



Do

 If Flag_enc_novo = 1 Then

   If Flag_dir_h = 1 Then

     Print "-> ";

   Else

     Print "<- ";

   End If

   Print X_enc

   Reset Flag_enc_novo

 End If

' Now if we press the Push Button, we will call the sub Push_b

 Debounce Pind.3 , 0 , Push_b , Sub

 Loop



'****************************

Push_b:

Print "Apertado"

Return





'****************************

Isr_pcint2_encoder:

push r23

Disable Pcint2

Enable Interrupts

Dado = Pind



If Old_val.7 = 1 And Dado.7 = 0 Then

  Goto A_pin2

End If

If Old_val.6 = 1 And Dado.6 = 0 Then

  Goto A_pin1

End If



If Old_val.7 = 0 And Dado.7 = 1 Then

   Old_val.7 = 1

   Goto Isr2_fim

End If

If Old_val.6 = 0 And Dado.6 = 1 Then

   Old_val.6 = 1

   Goto Isr2_fim

End If

Goto Isr2_fim



A_pin1:

Waitms 1

If Dado.6 = 0 Then

  If Dado.7 = 1 And Half_right = 0 Then

     Set Half_right

  End If

  If Dado.7 = 0 And Half_left = 1 Then

     Reset Half_left

     Decr X_enc

     Reset Flag_dir_h

     Set Flag_enc_novo

  End If

  Old_val.6 = 0

End If

Goto Isr2_fim



A_pin2:

Waitms 1

If Dado.7 = 0 Then

  If Dado.6 = 1 And Half_left = 0 Then

     Set Half_left

  End If

  If Dado.6 = 0 And Half_right = 1 Then

     Reset Half_right

     Incr X_enc

     Set Flag_dir_h

     Set Flag_enc_novo

  End If

  Old_val.7 = 0

End If

Isr2_fim:

Waitus 100

Enable Pcint2

POP R23

Return



End

Paulo

aphawk · 22 de junho de 2015

Ao pessoal que gosta de rádio-amador :

Já pensaram em montar o seu próprio rádio VHF / UHF, usando a tecnologia mais moderna atualmente existente ?

Um pequeno módulo que custa menos de US$ 13 , um simples Atmega, um simples display de celular Nokia, e um bom programa em Bascom ! Só isso !

Vejam estas imagens :

Primeiro, vejam esta PCB , simples, o módulo de vhf/uhf está no lado direito, reparem o tamanho dele comparando ao Atmega na esquerda :

Agora, vejam o primeiro prótotipo, onde era usado um display simples tipo 16x2 caracteres :

Depois, foi trocado o display por um tipo gráfico, simples, e muito barato :

E finalmente, o rádio pronto :

Todo esse projeto deve sair em um artigo na revista DUBUS , destinada aos radioamadores.

Esse rádio vai estar presente na feira HAMRADIO na Alemanha :

http://www.hamradio-friedrichshafen.de/ham-en/

O autor, um grande colaborador do Bascom, autor de um livro sobre ele, e de dezenas de projetos open source na área de radioamadores, postou o arquivo com todas as informações para quem quiser montar, inclusive o programa fonte !

Para quem preferir comprar a placa PCB, a placa PCB + o módulo, ou o kit completo, segue o link :

http://www.svet-el.si/english/index.php/shop/product/69-kit-weekend-project-radio-station-uhf-modul-pcb

Nessa mesma página voce pode baixar oesquema completo, com o desenho da placa PCB !!!

Os módulos utilizados são deste tipo :

http://www.dorji.com/docs/data/DRA818V.pdf

Muito simples de se programar, usam comandos seriais tipo AT+ , igual aos modens, Bluetooths, etc !

O projeto é muito barato, e o software pode ser fácilmente modificado, podendo ser implementada outras funções além das já existentes.

O arquivo completo do projeto está anexo.

Paulo

DRA818V.zip

aphawk · 24 de junho de 2015

Um exemplo do que pode se fazer com um simples Attiny e o Bascom :

Paulo

test man*~ · 12 de julho de 2015

@aphawk vou começar a ler e estou com umas dúvidas...

> Você usa a versão DEMO do BASCON AVR (com a limitação de 4KB)?

> Você pode me indicar um Atmel bem simples (tipo o PIC16F628A) para eu ler o datasheet e me acostumar com os registradores básicos dos AVRs?

> O PIC (16F, 18F) precisa de 4 ciclos de clock para executar uma instrução, os AVRs executam com apenas um único ciclo?

Obrigado.

aphawk · 12 de julho de 2015

@test man*~,

Olha, todos os programas do tutorial rodam na versão demo.

Eu sempre crio soluções para alguns clientes, e algumas ultrapassaram os 4K, portanto acabei comprando o Bascom oficial, sem limitação. Não é um produto muito caro, se não me engano custa hoje na faixa de US$ 100 . Desde que eu comprei , em 2010, todas as atualizações foram gratuítas. Muito diferente do Proteus, que eu também tenho oficial ( esse doeu viu.... ), e tenho de pagar pelas atualizações. Só como exemplo, para atualizar o Proteus, daria para comprar 5 Bascom oficiais !!!!! E só garante 1 ano de atualização ..... agora, só vou atualizar quando sair a versão 9.

Quanto a indicar um para voce se familiarizar, vai direto no Atmega48 . É o mesmo datasheet do Atmega328.

Mesmo os modelos de outras famílias de AVR são todos muito semelhantes, até os Attiny são práticamente idênticos.

Mas para brincar, vá de cara ao Atmega328 mesmo, ou ainda melhor, compre um Arduíno Uno R3 . Para o Bascom, ele é apenas um Atmega328 rodando a 16 Mhz !

Os AVR's todos precisam de apenas 1 ciclo de clock para executar uma instrução, mas algumas instruções precisam de dois ciclos de clock.

Se voce pegar um programa em Asm usando um PIC, e reescrever para usar o Avr, ele vai ficar bem menor , porque o AVR tem 32 registradores que podemos usar de quase tudo que é maneira, inclusive em pares trabalhando como 16 bits, tem endereçamento de memória linear em 16 bits, e possui algumas instruções muito poderosas usando os registradores X, Y e Z ( na verdade esses três são pares de registradores, os últimos 6 dos 32, que trabalham juntos como se fossem de 16 bits reais ) . Assim, além de o programa ficar menor, acaba executando bem mais rápido, fora o fato de que voce pode rodar o clock a 20 Mhz, e mesmo nos Pic18F com PLL voce não vai passar de 48 Mhz, mas como precisam de 4 ciclos para executar uma instrução, equivale a dizer que o clock real máximo dos Pic16F é de 12 Mhz.

Mas no caso dos Atmega328P muita gente usa ele a 32 Mhz, descobriram que ele funciona perfeitamente...

Mas antes de ficar fuçando os datasheets, dá uma passada pelo tutorial do Bascom. Usando ele, é muito raro precisar de alguma coisa em Asm !

Paulo

test man*~ · 12 de julho de 2015

Um vendedor fez uma promoção e acabei comprando um UNO SMD (com o conversor USB<>SERIAL CH340), um UNO R3 (aquele que usa outro AVR para fazer a conversão USB<>SERIAL) e um DUEMILANOVE (FT232 para USB<>SERIAL com os pinos CTS DSR DCD e RI disponíveis)... Ficou em US $2.72 vai demorar para chegar... Mas uma dia chega HAHAHAHA, o Arduíno mega (ATmega2560) estava US $1.20 quando cliquei para comprar a oferta acabou =D...

Perguntei do DATASHEET pois gosto de entender o que o compilador está fazendo. Depois de aprender assembly p/ o PIC a programação em C ficou mais eficiente, consigo fazer a mesma coisa gastando bem menos tempo e memória de programa...

Mas vou seguir seu conselho. Vou direto para o BASIC... Depois dou uma espiada no datasheet (assim como foi com os PICs)

Obrigado!

aphawk · 13 de julho de 2015

@test man*~,

Opa, excelentes compras ! voce vai ter boas plaquinhas para brincar. Que belos preços voce conseguiu !!!!!

Olha, eu programei muito em Assembler no passado. Era uma época onde o C era novidade, e tudo o que fazíamos era em Asm mesmo, para 8080 e z-80. Alguns anos depois, começei a usar o Basic nos IBM-PC como uma maneira de fazer fácilmente os programas, e onde necessário eu fazia programas tipo Terminate and Stay Resident ( TSR ), e passava do Basic para o Asm ( 8088, 80286 ) quando precisava. A mesma técnica eu usava no Apple também ( 6502 ) , e no CPM-80 do Apple ( 6502 E Z-80 ao mesmo tempo !!!! ) .

Hoje em dia, com a qualidade das funções e do compilador do Bascom, só precisei usar o Asm dentro dele uma vez, para uma rotina de captura de dados a alta velocidade para um analizador lógico...

O que voce precisa saber do datasheet é apenas uma leitura sobre os módulos internos dos Avrs, que não mudam muito dos Pics, como o conversor A/D ( até 8 entradas analógicas ) , os Timers nos modos de CTC e PWM, as interrupções, o módulo serial multifunções ( SPI, TWI, USART, ... ), pois isso tudo voce precisa saber pelo menos os nomes e características para usar no Bascom. Mas veja bem, é conheçer o Hardware, não o Asm !

Porisso que eu estou insistindo para voce primeiro ver o Bascom. Vai ver que pode fazer tudo com ele. Mas como o Asm dos AVR's é muito simples de usar, pode também depois aprender ele mais a fundo, afinal nunca se sabe o que pode aparecer pela frente !

Ah, a versão atual do compilador Bascom tem umas novidades bem legais, uma delas é a possibilidade de vários Bus I2c ao mesmo tempo.....

Mande bala no tutorial, eu tenho certeza que logo voce vai ter a mesma opinião !

Paulo

test man*~ · 14 de julho de 2015

@test man*~,

O que voce precisa saber do datasheet é apenas uma leitura sobre os módulos internos dos Avrs, que não mudam muito dos Pics, como o conversor A/D ( até 8 entradas analógicas ) , os Timers nos modos de CTC e PWM, as interrupções, o módulo serial multifunções ( SPI, TWI, USART, ... ), pois isso tudo voce precisa saber pelo menos os nomes e características para usar no Bascom. Mas veja bem, é conheçer o Hardware, não o Asm !

Isso que eu queria ... Mas pulei tudo e fui direto para o tutorial... Você diz no tutorial: "o que importa aos iniciantes é que conheçam muito bem o que que o hardware existente em um AVR pode fazer, apenas isto, não se preocupem em COMO FAZER ISTO, pois é justamente aí que entra o BASCOM e sua linguagem BASIC!"

E é verdade... Fiz algumas coisas um pouco complicadas (usando o CCS) lendo quase que nada o Datasheet do PIC usado...

Fui direto para o tutorial e se precisar leio o Datasheet!

Mas aquela coisa dos 32 Working Registers conectados diretamente à ALU é muito massa

Obrigado Paulo!

aphawk · 14 de julho de 2015

@test man*~,

Heheh é verdade, saber o que que o hardware de um AVR pode executar é o que mais importa no Bascom, pois ELE sabe como fazer kkkkk !

Logo voce vai perceber a extrema simplicidade para se fazer as coisas bem complicadas. Hoje ví um programa que um cara postou no Fórum do Bascom, que decodifica a tecla de um controle remoto, em 3 protocolos diferentes, e o que é mais legal : independente do clock da CPU !!!!! O pior é que o programa do cara é a metade do programa que eu fiz , e que só decodificava o protocolo Nec !!!!!!

Se voce gosta tanto assim de programas em ASM, voce pode fazer mix nos seus programas, usando o bascom para as tarefas mais sofisticadas, como inicializar hardware, conversar com displays, I2c, etc, e voce pode fazer todo o corpo do programa em Asm direto. Pode misturar o Asm em qualquer parte do programa, e quantas vezes for necessário !

Vai mandando bala aí na leitura, mas faz uns programinhas e veja eles rodarem no Proteus, é muito legal !

Paulo

test man*~ · 14 de julho de 2015

É daqui a pouco

$asm$end asm

Igual no C.

@aphawk, eu estou pensando uma coisa... Se existisse um gravador barato e que permitisse a alteração dos FUSES facilmente (crystal externo/interno mesmo sem o crystal conectado, SPIEN abilitado/desabilitado, etc.), assim como existe o PICKIT 2 para os uc's da Microchip, os AVRs seriam mais famosos.

Até existe o AVR Dragon (pelo que eu entendi) mas ele é bem carinho (pra mim)

Enfim, estou indo com a programação, o BASIC é bem fácil de entender (mais fácil que o C) só gastei muiiiiiiiiiiiiiiiiiiiiiiiiiiiiittttttooooooooooo tempo para entender o funcionamento do gravador (sem/com crystal, SPIEN, clock da programação deve ser menor que o clock do chip a ser gravado, etc.)... Agora vou voltar para o tutorial PROJETO 2.

aphawk · 15 de julho de 2015

@test man*~,

Poxa, gravador mais barato do que um USB ASP, ( US$ 3 !!!! ) acho que nunca mais vamos ver ..... mas quanto a serem mais famosos, acho que é impossível !!!!

Eles estão em tudo que é lugar, em tutoriais, em sites de hackers, em projetos de conclusão de cursos, onde eu já postei que até existem satélites com dezenas de mini-arduínos trabalhando e sendo até reprogramados em temo real por um Arduino Mega2560 para fazerem outras experiências ou aprimoramentos.

No mes passado um cara fez algo que eu considero a maior obra de arte de programação que eu ví nestes ultimos dez anos : ele conseguiu emular um Apple ][ usando um mísero Arduíno Uno R3 , onde até vídeo o Arduíno está gerando !!!! Isso sem falar na emulação de um microprocessador 6502, que é a base do Apple !!!

Sabe o que que ele fez ? repare que existem DOIS microcontroladores Atmega no Arduino Uno R3, um deles está programado para servir de conversor USB-SERIAL. O cara reprogramou este para que virasse um gerador de vídeo !!!!!! E o Atmega328P faz o resto ......

Olhe na Internet : veja que a partir de 2010 de cada 10 montagens na Internet, 8 são usando AVR's ! Claro, fora do Brasil, porque aqui os professores continuam ensinando PICs Pic16F .... e pior ainda, exigindo que alguns TCCs só possam ser feitos com Pics..... Porisso que formamos técnicos e engenheiros sem a mínima condição de competitividade em qualquer lugar ! Se ainda ensinassem os DSPics, vai lá .......

Realmente, quanto a gravador, os AVR's foram projetados para ter uma programação simplificada, usando o ICSP. Existem alguns programadores do tipo High-voltage, que podem fazer isso tudo que voce citou, mas custam em torno de US$ 70 na China.

Antigamente muita gente reclamava de ter programado errado os FUSES e depois ter perdido o microcontrolador, mas isso era quando custavam caro. Hoje, raramente vejo alguém reclamar.

Eu comprei o meu programador no Mercado Livre, é muito interessante porque ele também tem um soquete ZIF 40 pinos , e tem um gerador de clock também embutido, assim eu simplesmente pego o microcontrolador e coloco no gravador, independente se ele estava programado para clock interno ou externo.

Não perca muito tempo com isso, afinal pelo que custam esses microcontroladores eu nem reaproveito eles..... eu comprei um monte de Attiny85 e de Atmega328P, paguei menos de R$ 8 reais cada um, e tento projetar tudo com eles. Assim, me acostumo com o hardware de cada um, e com as vantagens, por exemplo com um Attiny85 eu consigo gerar PWMs de 10 Bits acima de 100 Khz fácilmente ! Ou de mais de 400 Khz em 8 bits.

Hoje, eu simplesmente faço os programas na plataforma Arduíno Uno, o qual o Bascom consegue gravar sem nenhuma complicação. Só uso o programador USBASP quando tenho o projeto concluido e preciso programar os chips de fábrica, quando então também fecho o chip para que não possam copiar o mesmo..... Aí sim tem de saber usar o programa PROGISP 1.68 ou 1.72, que fazem tudo nos Fuses.

Esqueça o AVR Dragon, isso é bem antigo já, de antes dos Arduínos. Se voce pensar que hoje voce compra um Arduino Mega2560 pela bagatela que custa, com todos os recursos de Flash e Ram, é algo que 5 anos atrás era considerado um sonho !

Mas não pense que tudo é festa com esses Mega2560. Quando o seu programa passar de 64K , existem algumas pequenas "alterações" que devem ser incluidas no programa para tudo funcionar corretamente. é algo pareçido com chaveamento de banco de memória, usando dois registradores especiais.... além do fato de voce não poder cruzar as fronteiras de 64K nas chamadas de subrotinas. Eu mesmo ainda não precisei disso, e nem tive a curiosidade de ler com calma sobre esse assunto.

Porisso que sugiro que use um Arduino Uno R3, primeiro porque ele trabalha com 5 Volts e facilita bastante, enquanto o Mega2560 só aceita 3,3 Volts.

Mas isso é para o futuro..... Só como curiosidade, voce sabia que é possível o seu programa alterar a própria memória Flash para executar outro código ????????? E que existem Bootloaders que podem atualizar automáticamente o seu programa, usando serial, ou wireless, ou RF ? Isto é avançado e eu não coloquei no tutorial, mas voce pode olhar direto nos Fórums do Bascom oficial.

Vai brincando com o tutorial, e não esqueça de ver os programas funcionarem no Proteus. Na parte final do tutorial eu expliquei bem detalhado sobre a simulação.

Paulo

alexandre.mbm · 15 de julho de 2015

com um Attiny85 eu consigo gerar PWMs de 10 Bits acima de 100 Khz fácilmente ! Ou de mais de 400 Khz em 8 bits

Como se mede essas coisas?

aphawk · 15 de julho de 2015

@alexandre.mbm,

Se você se refere a medir quantos bits , diretamente não dá. O que voce pode fazer é criar um programa, e ir variando linearmente a forma de onda, de 0 até 1023 ( 10 bits ) , ou de 0 a 255 ( 8 bits ). Usando um osciloscópio, voce verifica tanto a frequência gerada como a relação Ton / Ttotal a cada instante, o que vai dar aproximadamente o valor do PWM utilizado naquele instante.

A maneira que eu faço é sempre antes de montar simular as partes principais do programa no Proteus, e ver se o PWM está variando de acordo.

Paulo

test man*~ · 15 de julho de 2015

[...] repare que existem DOIS microcontroladores Atmega no Arduino Uno R3, um deles está programado para servir de conversor USB-SERIAL. O cara reprogramou este para que virasse um gerador de vídeo !!!!!! E o Atmega328P faz o resto [...]

Eu baixei os esquemáticos (há um tempo atrás) dos Arduínos e vi que eles trocaram o FT232 pelo ATmega16U2... Acho que é foi pelo fato da FTDI ter usado uma atualização no driver para "brickar" os FT232 falsos (Product ID = 0).

[...] Mas isso é para o futuro..... Só como curiosidade, voce sabia que é possível o seu programa alterar a própria memória Flash para executar outro código ????????? E que existem Bootloaders que podem atualizar automáticamente o seu programa, usando serial, ou wireless, ou RF ? Isto é avançado e eu não coloquei no tutorial, mas voce pode olhar direto nos Fórums do Bascom oficial [...]

Pois é... Quando peguei os esquemáticos percebi que havia algo estranho pois o que ligava o PC (software do Arduíno) ao ATmega328P era uma comunicação serial (através do FT232, CH340 ou ATmega16U2), mas como o 328P era programado? Fui procurar e trombei com o bootloader... Assisti a um vídeo com um cara explicando como o bootloader funciona mas só para ter uma noção mesmo... Nesse momento entendi como um cara (em um outro vídeo que vi há uns anos atrás) programou um PIC com um par de XBEE...

[...] Olhe na Internet : veja que a partir de 2010 de cada 10 montagens na Internet, 8 são usando AVR's ! Claro, fora do Brasil, porque aqui os professores continuam ensinando PICs Pic16F .... e pior ainda, exigindo que alguns TCCs só possam ser feitos com Pics..... Porisso que formamos técnicos e engenheiros sem a mínima condição de competitividade em qualquer lugar ! Se ainda ensinassem os DSPics, vai lá [...]

É... Às vezes dou uma navegada pelo site da Adafruit, lá aparece algumas coisas interessantes... Só que, mesmo que o cara usou um AVR, o mesmo projeto poderia ser feito com o PIC... Agora, isso dos professores ensinarem, na maioria das vezes, somente PIC16F eu não entendo o porquê...

Tipo, na minha opinião, se o programa for feito em uma linguagem de alto nível o AVR e o PIC ficam empatados (projetos de hobby)... Em casos de projetos profissionais cada um se enquadrará melhor em uma determinada situação... Eu gosto de microcontrolador, qualquer um... PIC, AVR, motorola (nunca usei HAHHA)... Aliás, qualquer coisa que dê para quebrar a cabeça... Instrumentação, CLP, Redes industriais, Supervisório e por ai vai!!!

Voltando ao BASCOM, estou achando estranho ontem fiz um contador 0-99 (Modificação do projeto 2 adicionando 2 CIs 4411) e o proteus não mostrou a variáveis, declaradas no programa, durante o debug...

'------------------------------------- Descrição -------------------------------------'' Fazer dois leds piscarem a uma frequencia de 1Hz '------------------------ Modelo do AVR e velocidade de clock ------------------------'$regfile = "m48pdef.dat"                                     ' ATmega48P$crystal = 8000000                                          ' Oscilador interno 8MHz (configurado nos Fuses) '------------------------- Configuração da direção dos pinos -------------------------'Config Portb = Output                                       ' Poderia ser:                                                            ' Config Portb &B11111111 (1 = Saída | 0 = Entrada)                                                            ' Config Pinb.0 Input/Output '----------------------------------- Nomeando pinos ----------------------------------' '------------------------------ Declaração de variáveis ------------------------------'Dim Contador As ByteDim Aux1 As ByteDim Aux2 As Byte '---------------------------- Inicialização de variáveis -----------------------------'Contador = 0 '------------------------ Inicialização dos estados dos pinos ------------------------'Portb = &H00                                                ' inicializa os displays com zero (00) '----------------------------- Declaração de constantes ------------------------------' '--------------------------------- Código principal ----------------------------------'Do   Aux1 = Contador / 10                                     ' EX: contador = 15 | Aux1=15/10=1   Aux2 = Aux1 * 10                                         ' Aux2=1*10=10   Aux2 = Contador - Aux2                                   ' Aux2=15-10=5    Shift Aux1 , Left , 4                                    ' Aux1=Aux1<<4 | Aux1<<=4   Aux1 = Aux1 Or Aux2                                      ' Aux1= DIGITO1 (4MSBits) DIGITO2(4LSBits)    Portb = Aux1    Contador = Contador + 1   If Contador = 100 Then      Contador = 0   End If    Waitms 200Loop '-------------------------------------------------------------------------------------'End '------------------------------------ Sub-rotinas ------------------------------------'

Faltou o VCC conectado ao AREF e AVCC

Mas de boa! Agora vou para o 3.

Uma coisa, aquela parte que você fala como debugar com o proteus, aqueles macetes... Ficou muito bacana, na época eu aprendi (mais ou menos) aos trancos e barrancos HEHE

aphawk · 15 de julho de 2015

Voltando ao BASCOM, estou achando estranho ontem fiz um contador 0-99 (Modificação do projeto 2 adicionando 2 CIs 4411) e o proteus não mostrou a variáveis, declaradas no programa, durante o debug...

'------------------------------------- Descrição -------------------------------------'' Fazer dois leds piscarem a uma frequencia de 1Hz '------------------------ Modelo do AVR e velocidade de clock ------------------------'$regfile = "m48pdef.dat"                                     ' ATmega48P$crystal = 8000000                                          ' Oscilador interno 8MHz (configurado nos Fuses) '------------------------- Configuração da direção dos pinos -------------------------'Config Portb = Output                                       ' Poderia ser:                                                            ' Config Portb &B11111111 (1 = Saída | 0 = Entrada)                                                            ' Config Pinb.0 Input/Output '----------------------------------- Nomeando pinos ----------------------------------' '------------------------------ Declaração de variáveis ------------------------------'Dim Contador As ByteDim Aux1 As ByteDim Aux2 As Byte '---------------------------- Inicialização de variáveis -----------------------------'Contador = 0 '------------------------ Inicialização dos estados dos pinos ------------------------'Portb = &H00                                                ' inicializa os displays com zero (00) '----------------------------- Declaração de constantes ------------------------------' '--------------------------------- Código principal ----------------------------------'Do   Aux1 = Contador / 10                                     ' EX: contador = 15 | Aux1=15/10=1   Aux2 = Aux1 * 10                                         ' Aux2=1*10=10   Aux2 = Contador - Aux2                                   ' Aux2=15-10=5    Shift Aux1 , Left , 4                                    ' Aux1=Aux1<<4 | Aux1<<=4   Aux1 = Aux1 Or Aux2                                      ' Aux1= DIGITO1 (4MSBits) DIGITO2(4LSBits)    Portb = Aux1    Contador = Contador + 1   If Contador = 100 Then      Contador = 0   End If    Waitms 200Loop '-------------------------------------------------------------------------------------'End '------------------------------------ Sub-rotinas ------------------------------------'

Faltou o VCC conectado ao AREF e AVCC

Mas de boa! Agora vou para o 3.

Uma coisa, aquela parte que você fala como debugar com o proteus, aqueles macetes... Ficou muito bacana, na época eu aprendi (mais ou menos) aos trancos e barrancos HEHE

Legal que voce aproveitou aquele truques do Proteus !!!

Acho que isso incentiva muito as pessoas a fazerem alguns projetinhos, pois poder ver funcionar antes de montar é um baita dum incentivo !

Agora, isso de não mostras as variáveis :

O Proteus, quando lançou a versão 8, modificou um pouco o formato do arquivo para poder simular perfeitamente. Isso exigiu que os compiladores fossem atualizados, e a AVR atualizou o compilador dela, o AVR Stúdio. Assim, o novo Bascom , que é compilado pelo AVR Stúdio, também modificou o formato do arquivo gerado, e agora é totalmente compatível com o Proteus 8 , mas se você abrir no Proteus 7 fica esse problema de algumas variáveis não serem mostradas !

Mas se você mudar a sequência das declarações DIM, pode ser que elas aparecem..... eu fiz alguns testes logo depois que saiu o Bascom atualizado, e mudando tamanho do programa, local de declarações, etc, fazia mostrar no Proteus 7.

Mas o motivo que me fez gastar com a atualização do roteus 7 para o 8 foi exatamente esse !

Sugiro voce partir para o Proteus 8 , pode até simular com a versão demo baixada do site deles.

Paulo

test man*~ · 16 de julho de 2015

O PROTEUS 8 resolveu o problema!!

Eita... O projeto 3 foi mais complicadinho HEHE, o bom que é complicado só na primeira vez.

Fiquei com algumas dúvidas se você puder me responder...

1 - Fiz um teste (deu certo) mas quero confirmar... Para escrever diretamente em um registrador qualquer basta escrever o nome dele igual ao valor desejado?

'Ex:TCNT0 = 61OCR2B = 254

2 - Para o timer0 foi usado:

On -->> Timer0 <<-- Timer0_isr Save

Dei uma procurado no help e não encontrei o nome a ser usado para insterrupções do módulo TWI:

Qual seria o nome?

3 - O que as funções PUSH e POP fazem dentro da ISR?

Tim0_isr:push r23::pop r23Return

Estou chutando que está relacionado com STACK mas tirei elas do meu programa e ele funcionou corretamente, eu até procurei no help mas não encontrei coisa alguma.

Obrigado Paulo!

Intrudera6 · 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.

aphawk · 16 de julho de 2015

@test man*~,

1 - Sim, isso é comum.

2 - Se é para usar em ASM, são usadas as interrupções do módulo USI para isso, veja exemplos abaixo :

on USI_START ISR_USI_start ' Detect start condition of I2C
on USI_OVF ISR_USI_Received ' 9 bits received

3 - Sempre que ocorre uma interrupção, devemos salvar o contexto anterior do programa, isto é, os flags e registradores que podem ser afetados pela nossa rotina de interrupção. A maneira mais simples é colocar esses valores no Stack, e ao final de nossa rotina de interrupção, retiramos do Stack e devolvemos aos registradores . Isso é feito pelas instruções PUSH e POP.

Muitos registradores não são usados pelo Bascom. Dá uma olhada aqui mesmo neste Fórum, tem um post meu explicando alguns dos registradores que são usados, creio que foi numa conversa com o Mor.

A boa norma , em qualquer microprocessador, diz para fazermos o seguite : primeiro salvar o registrador de status, que contém os flags da CPU, e depois salvar os registradores que iremos usar em nossa rotina de interrupção. A grande maioria das instruções em Basic no Bascom são auto-suficientes, isto é, elas começam e terminam sem depender dos registradores afetados em uma instrução anterior. 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 ?

Paulo