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

aphawk · 19 de outubro de 2016

@Intrudera6 e @lucianolcoa e @alexandre.mbm

Segue agora o programa completinho. Se simular no Proteus, vai aparecer a hora a cada 10 segundos no terminal serial, e quando você aperta um dos dois botões de acerto de hora ou de minuto, também aparece uma mensagem mostrando NOVA HORA : xx:xx:xx.

E ao apertar o botão de cronometro, começa a contagem dos milisegundos; quando apertar de novo, a contagem encerra e aparece no terminal serial a mensagem Milisegundos : com o total de milisegundos.

Simples e pequeno....

Ocupou apenas 2.108 bytes se não me engano.

$regfile = "m8def.dat"
$crystal = 16000000
$hwstack = 80
$swstack = 80
$framesize = 80
$baud = 19200

Dim Second_tick As Long
Dim Tick As Long
Dim Mili As Long
Dim Elapsed As Long
Dim Flag_cron As Bit
Dim Mostra As Byte

Button_cron Alias Pind.3
Button_hr Alias Pind.6
Button_min Alias Pind.7
Config Button_cron = Input
Config Button_hr = Input
Config Button_min = Input
Set Portd.3
Set Portd.6
Set Portd.7

Config Clock = User
Config Date = Dmy , Separator = /                           'Day/Month/Year
Config Timer1 = Timer , Prescale = 8 , Compare A = Toggle , Clear Timer = 1
Stop Timer1
'Ocr1a = 64536
Ocr1a = 999

Config Int0 = Rising
On Int0 1miliseg

Config Int1 = Falling
On Int1 Start_cron

Tick = 0
Mili = 0
Mostra = 0
Date$ = "01.10.16"
Time$ = "00:00:00"
Enable Timer1
Start Timer1
Enable Int0
Enable Int1
Enable Interrupts


Print "Inicio : " ; Time$

Do
  Debounce Button_min , 0 , Setminute , Sub
  Debounce Button_hr , 0 , Sethour , Sub
  If Mostra = 10 Then
     Print "Horario : " ; Time$
     Mostra = 0
  End If
Loop
End

'=== Subs ===
Setminute:
 Disable Interrupts
 Incr _min
 If _min > 59 Then _min = 0
 Gosub Settime
 Print "Nova Hora : " ; Time$
 Enable Interrupts
Return

Sethour:
Disable Interrupts
 Incr _hour
 If _hour > 23 Then _hour = 0
 Gosub Settime
 Print "Nova Hora : " ; Time$
 Enable Interrupts
Return


1miliseg:                                                   'Int0 IRQ (once per second)
Incr Tick
Incr Mili
If Tick = 1000 Then
   Incr Mostra
   Incr Second_tick
   Time$ = Time(second_tick)
   Tick = 0
End If
Return

Settime:
Second_tick = Secofday()
Return

Getdatetime:
Return

Setdate:
Return


Start_cron:
If Flag_cron = 0 Then
  Mili = 0
  Flag_cron = 1
Else
  Elapsed = Mili
  Enable Int0
  Print "Milisegundos = " ; Elapsed
  Flag_cron = 0
End If
Return

Paulo

alexandre.mbm · 19 de outubro de 2016

7 horas atrás, Intrudera6 disse:

O que eu gostava dos AVR é a documentação, eu sabia quase exatamente como as interrupções funcionavam, e isto facilita muito a programação.

Não tenho gostado do datasheet da família onde está o ATtiny85. É longo e muito discursivo. Eu esperava algo mais direto. Ensina muito o baixo nível e sei que isso é grande ponto positivo, mas eu esperava encontrar também uma "introdução" mais direta.

Retiro o que disse. É minha ignorância. Vai clareando aos poucos...

aphawk · 19 de outubro de 2016

9 horas atrás, Intrudera6 disse:

O que eu gostava dos AVR é a documentação, eu sabia quase exatamente como as interrupções funcionavam, e isto facilita muito a programação. Eu gostei tanto deste meu primeiro que o aperfeicei colocando um DS3231, a precisão dele não era ruim, mas realmente piorava um pouco quando eu aumentava a quantidade de interrupções, ele está rodando até hoje num AVR.

Repare o controle que eu tenho das interrupções : tem hora que eu desabilito elas e logo a seguir habilito, e tem uma hora que DENTRO de uma rotina de interrupção eu habilito elas novamente ANTES de terminar a rotina da interrupção anterior !

Esse domínio do hardware é que me faz falta nos ESP . Não me sinto seguro sem saber o que o programa faz....

Mesmo os AVR's sendo tão simples de usar e com um só nível de interrupção, eu tiro leite de pedra no Bascom, e se precisar ainda uso o ASM para ter o controle total.

E consigo programinhas bem pequenos .....

adicionado 6 minutos depois

@alexandre.mbm,

Entendí o que você quis dizer quando postou isso. Mas se isto lhe ajuda, eu devo ter lido com afinco apenas umas 50 páginas do datasheet do Atmega328P.... principalmente a parte dos Timers / counters, conversor A/D, e a parte de clock dele. Ah, as INT0 e INT1 e as PCINT's eu passei por cima lendo apenas o que eu procurava saber pra usar.

Nunca precisei do restante !

É por isso que uso o Bascom... ele sabe como fazer o restante de todo o hardware funcionar !

Os comando prontos de altíssimo nível para conversar com o hardware me dão a tranquilidade de poder ignorar mais de 80 % do datasheet ! Cansei de perder tempo na vida com isso....

Paulo

test man*~ · 19 de outubro de 2016

2 horas atrás, aphawk disse:

É por isso que uso o Bascom... ele sabe como fazer o restante de todo o hardware funcionar !

Os comando prontos de altíssimo nível para conversar com o hardware me dão a tranquilidade de poder ignorar mais de 80 % do datasheet ! Cansei de perder tempo na vida com isso....

Eu lembro que fazia os programas mas frequentemente eu me pegava pensando: "O que o microcontrolador realmente está fazendo nessa linha?"... Daí resolvi ler o datasheet inteiro do PIC16F628A foi uma experiencia muito bacana, toda hora eu pensava: "Putz, então é assim que funciona?"... Quando terminei de ler fiz vários exercícios em Assembly para dar uma fixada e documentar o aprendizado.

De tanto o @aphawk falar eu acabei me interessando pelos AVRs... Aprendi sobre eles usando o livro do @aphawk... Mas sempre que um novo assunto era introduzido eu dava uma lida no datasheet para realmente entender...

Sei lá... Eu gosto de ler datasheet, é meio que gratificante saber como as coisas funcionam, principalmente datasheet desses módulos sensores para Arduíno... É bom ler, entender e fazer biblioteca pro Bascom ou CCS

alexandre.mbm · 19 de outubro de 2016

1 hora atrás, test man*~ disse:

AVRs... Aprendi sobre eles usando o livro do @aphawk...

Que livro?

1 hora atrás, test man*~ disse:

ler datasheet, é meio que gratificante saber como as coisas funcionam, principalmente datasheet desses módulos sensores para Arduíno...

Pena que nem todos tem. Eu gostaria de ter o datasheet exato de cada LED.

É até uma questão de segurança...

aphawk · 19 de outubro de 2016

35 minutos atrás, alexandre.mbm disse:

2 horas atrás, test man*~ disse:

AVRs... Aprendi sobre eles usando o livro do @aphawk...

Que livro?

Acho que ele se referiu à minha apostila.... tá certo que ficou com quase 170 páginas !!!

Paulo

alexandre.mbm · 20 de outubro de 2016

1 hora atrás, aphawk disse:

Acho que ele se referiu à minha apostila.... tá certo que ficou com quase 170 páginas !!!

Apostila ou livro, onde está?

aphawk · 20 de outubro de 2016

@alexandre.mbm ,

http://www.4shared.com/rar/x8u4oNuF/Tutorial_AVR.html

Paulo

alexandre.mbm · 20 de outubro de 2016

@aphawk , consegui pegar não. O link não funciona direito. Se ele tem a obra, ela não está em outro canto da Internet? Dê-me palavras-chaves e eu a buscarei no Google.

aphawk · 20 de outubro de 2016

Existe uma ferramenta criada por um usuário do Bascom que é muito interessante, vou tentar explicar aqui:

Quando ocorre uma interrupção, antes de a rotina de interrupção ser chamada , o compilador Bascom salva todos os registradores do microcontrolador no stack, como uma medida de precaução contra qualquer alteração de dados. Na verdade, ele executa uma instrução do Bascom chamada PUSHALL , que é um Push de todos os registradores ( são 32 ... ), mesmo sem a gente precisar declarar isto no código.

E ao final da rotina de interrupção, ele repõe todos os registradores, para que o programa possa executar normalmente, executando a instrução POPALL, mesmo sem a gente precisar deixar isto implícito.

Bom, só o tempo perdido nisso ( PUSHALL e POPALL ) passa de 120 ciclos de clock... o que faz com que muitas vezes nossas rotinas de interrupção não consigam terminar antes de ocorrer alguma outra interrupção, e aí estraga o programa.

Quando definimos uma rotina de interrupção no Bascom, podemos acrescentar um comando chamado NOSAVE, e o compilador não vai mais fazer esse salvamento automático, deixando para nós, os programadores, fazermos o salvamento apenas dos registradores envolvidos, e dessa forma perde-se menos tempo salvando registradores que não seriam modificados na interrupção.

Mas, como saber quais são os registradores necessários ?

Isso já foi discutido neste tópico fazem alguns anos, mas mesmo assim muitas vezes salvamos registradores desnecessários.

Aí, veio essa ferramenta que um usuário criou : chama-se NoSaveTool !

Você chama esse programa, mostra para ela onde está o arquivo .obj gerado pelo compilador, e ela faz a análise do código, mostrando para você quais são os registradores que são mesmo necessários serem salvos e repostos !

Não é gratuita, custa US$ 15 , com suporte a upgrades vitalício, e eu acabei comprando.

Para quem programa profissionalmente com o Bascom, é uma boa ajuda por um baixo custo.

Segue uma das telas de saída dessa ferramenta, aplicada ao programa do relógio com cronômetro de milisegundos que publiquei anteriormente :

Na tela de Quick Info aparecem todos os registradores que são modificados dentro de cada rotina de interrupção. São os que temos de salvar, além do registrador de estado (SREG).

Ao se clicar nos dois botões verdes, embaixo, com o nome da interrupção, aparece o código já prontinho para ser copiado e introduzido ao início e ao final de cada uma dessas rotinas !

Vejam como ficou uma delas :

1miliseg:
                                              'Int0 IRQ (once per second)
$asm
  PUSH R16
  PUSH R17
  PUSH R18
  PUSH R19
  PUSH R20
  PUSH R21
  PUSH R22
  PUSH R23
  PUSH R24
  PUSH R25
  PUSH R26
  PUSH R27
  PUSH R30
  PUSH R31
  !in R24, sreg
  PUSH  R24
$end Asm

Incr Tick
Incr Mili
If Tick = 1000 Then
   Incr Mostra
   Incr Second_tick
   Time$ = Time(second_tick)
   Tick = 0
End If

$asm
  POP  R24
  !out sreg, r24

  POP R31
  POP R30
  POP R27
  POP R26
  POP R25
  POP R24
  POP R23
  POP R22
  POP R21
  POP R20
  POP R19
  POP R18
  POP R17
  POP R16
$end Asm
Return

Reparem os Push no início, e os Pops ao final, antes do Return. Com isso o programa ficou menor de tamanho, e a rotina de interrupção teve sua duração ( em ciclos de máquina ) reduzida em mais de 50 ciclos.

Neste caso em particular esta redução não era necessária, pois eu já havia calculado com o Proteus que no pior caso a duração dessa rotina de interrupção chegaria a menos de 0,27 milisegundos. Mas serve como exemplo.

E a instrução que define o atendimento dessa interrupção ficou assim :

On Int0 1miliseg Nosave

adicionado 21 minutos depois

@alexandre.mbm ,

Ué, acabei de baixar nesse mesmo link , que está no primeiro post deste tópico, na página 1 !.

É que o 4Shared agora fica colocando umas telas que enchem o saco, é só pedir o download FREE, esperar os 20 segundos, e o link aparece para baixar.

Vou anexar aqui pois agora com a conta VIP consigo anexar arquivos maiores.

Paulo

Tutorial_AVR.zip

alexandre.mbm · 20 de outubro de 2016

Consegui baixar do 4shared. Chegou uma hora que estava funcionando.

aphawk · 20 de outubro de 2016

@alexandre.mbm ,

Eu acabei de mudar, agora tirei o 4shared.... fica direto armazenado no CDH mesmo.

Boa diversão, porque tem muiiita informação nesse arquivo, tem meses e meses de escrita aí .....

Paulo

test man*~ · 20 de outubro de 2016

Eu estava falando da apostila mesmo =D... Que é basicamente um livro hehe. Interessante o NoSave Tool... O que eles deviam fazer é lançar o Bascom ARM daí o @aphawk criaria outra apostila e todos nós aprendiríamos ARM

Eu estou no meio das compras para construção de um braço robótico, vou usar o ATmega2560 (Placa arduíno)...

Alguns dos componentes:

O Suction Cup foi enviado com comprimento errado

Vamos ver se isso vai sair, hehe...

Off:

Intrudera6 · 20 de outubro de 2016

Programar um controlador ARM no Arduino, só se for com a IDE Arduino. Eu até me interessaria muito por algo assim com BASCOM, mas por enquanto nada.

aphawk · 21 de outubro de 2016

@test man*~ ,

Kkkkk reparou no diretório da Isadora né kkkkk

Foi um programinha que eu postei em um tópico onde discutimos sobre temporização para gravar 4 bytes na EEprom do Arduíno ... ela achou que o Bascom fazia um código muito menos eficiente do que fazendo na marra no C, e eu afirmava que se demora em média 12 milissegundos para o hardware "aceitar" os 4 bytes ( mais de 11.000 ciclos de clock ! ), se houvesse uma diferença de 100 ciclos de clock entre o código do C e o código do Bascom , não seria significante frente os mais de 11.000 ciclos que o hardware demora kkkkk !

Paulo

lucianolcoa · 22 de outubro de 2016

Aphawk, estou tendo outro problema com uma variavel

queria converter um valor de um sensor em porcentagem, so que quando simulo no protheus da um erro pra lá de esquisito.

Vou postar a parte da conversão do código

dim variavel as integer
config adc= single, prescaler=auto
start adc

do
variavel= Getadc(0)
variavel=variavel*100
variavel=variavel/1023
print variavel
loop
end

tentei converter em single a variavel como vi no exemplo da sua apostila mas sempre da erro, nem deixa compilar x_x

Consegui resolver, so setar a variavel como long, mals incomodar, novato iniciante e ***** x_x

aphawk · 22 de outubro de 2016

@lucianolcoa ,

Tranquilo, isso acontece ! Pelo menos você está aprendendo !

Eu costumo dimensionar as variáveis conforme o hardware usa elas :

Conversão A/D : uso WORD

Entrada ou saída digital : uso BYTE

Por exemplo no caso de calcular porcentagem, eu criaria uma SINGLE , mas só a usaria no final mesmo, na hora de fazer a conversão para porcentagem.

O programa calcula tudo bem mais rápido com variáveis Word ou Byte, lembre de que um processador de 8 bits sempre demora bastante quando tem de fazer qualquer tipo de cálculo com variáveis que aceitam ponto flutuante.

Mesmo se usar o INCR nela, vai demorar uma eternidade....

Paulo

alexandre.mbm · 23 de outubro de 2016

Em 22/10/2016 às 11:44, aphawk disse:

lembre de que um processador de 8 bits sempre demora bastante quando tem de fazer qualquer tipo de cálculo com variáveis que aceitam ponto flutuante.

Podemos pensar na ordem de quanto?

aphawk · 23 de outubro de 2016

@alexandre.mbm ,

Vou te dar uma ideia em termos de ciclos de clock de um AVR.

Para ter ideia em um PIC, multiplique no mínimo por 4 o resultado...

adição : 123

subtração : 121

multiplicação : 156

Divisão : 492

Isto se o conteúdo das variáveis já estiver em formato de ponto flutuante, senão ainda tem de converter ela , e dependendo do tipo pode demorar facilmente mais uns 150 ciclos.

Paulo

test man*~ · 23 de outubro de 2016

Ai está um exemplo (PIC16F877A, compilador CCS C):


float resultado_float = 0;
int resultado_int = 0, variavel_1 = 10, variavel_2 = 20;

....................   resultado_float = (float) variavel_1 * variavel_2; 
00E7:  BCF    03.5
00E8:  CLRF   2C
00E9:  MOVF   25,W
00EA:  MOVWF  2B
00EB:  CALL   004
00EC:  MOVF   7A,W
00ED:  MOVWF  2A
00EE:  MOVF   79,W
00EF:  MOVWF  29
00F0:  MOVF   78,W
00F1:  MOVWF  28
00F2:  MOVF   77,W
00F3:  MOVWF  27
00F4:  CLRF   2C
00F5:  MOVF   26,W
00F6:  MOVWF  2B
00F7:  CALL   004
00F8:  MOVF   2A,W
00F9:  MOVWF  2E
00FA:  MOVF   29,W
00FB:  MOVWF  2D
00FC:  MOVF   28,W
00FD:  MOVWF  2C
00FE:  MOVF   27,W
00FF:  MOVWF  2B
0100:  MOVF   7A,W
0101:  MOVWF  32
0102:  MOVF   79,W
0103:  MOVWF  31
0104:  MOVF   78,W
0105:  MOVWF  30
0106:  MOVF   77,W
0107:  MOVWF  2F
0108:  GOTO   021
0109:  MOVF   7A,W
010A:  MOVWF  23
010B:  MOVF   79,W
010C:  MOVWF  22
010D:  MOVF   78,W
010E:  MOVWF  21
010F:  MOVF   77,W
0110:  MOVWF  20

....................   resultado_int = (int) variavel_1 * variavel_2; 
0111:  MOVF   25,W
0112:  MOVWF  27
0113:  MOVF   26,W
0114:  MOVWF  28
0115:  GOTO   098
0116:  MOVF   78,W
0117:  MOVWF  24

Intrudera6 · 23 de outubro de 2016

Já programei muito em ASM (rotinas pequenas) e compiladores e a diferença é brutal entre calcular com numero inteiro e com ponto flutuante. E eu sempre faço de tudo para que os cálculos sejam com números inteiro, só uso número float quanto é estritamente necessário. Os processadores modernos de desktop tem coprocessadores aritméticos, o que diminui muito a diferença brutal entre o cálculo com inteiro com relação ao ponto flutuante, mas mesmo assim ainda prefiro números inteiros, e evito ao máximo operações de divisão, que tem um custo computacional muito maior que a multiplicação.

O timer do ESP8266 é ótimo para avaliar o tempo gasto nas operações, é só botar para calcular e ver quantos microssegundos demorou, mas é melhor que sejam muitas operações (looping de mil por exemplo compilando no Arduino IDE) senão nem a resolução de microssegundo é suficiente para isso, a velocidade de execução no ESP8266 é muito alta.

lucianolcoa · 23 de outubro de 2016

@aphawk Novamente preciso da sua ajuda. Queria usar um timer pra dar um refresh numa variavel e atualizar o valo no display lcd, usava a função waitms pra dar o refresh na variável mas penso eu que seria que nem a função delay do arduino, que trava o código. Queria dar o refresh se possível com timers.

Teste esse código exemplo aqui no protheus mas não funcionou:

--------------

$regfile = "2313def.dat"

$crystal = 4000000

Config Pind.6 = Output

Config Pinb.1 = Output

Config Timer0 = Timer , Prescale = 64

Dim Wtime As Byte

On Timer0 Pulse:

Wtime = 100

Enable Interrupts

Enable Timer0

Do Set Portd.6

Waitms Wtime

Reset Portd.6

Waitms Wtime

Loop

Pulse: Toggle Portb.1

Return

End

--------------

aphawk · 24 de outubro de 2016

@lucianolcoa ,

Código doido, não funciona mesmo, o LOOP não sabe para onde voltar kkkkk !

Mas me diga exatamente que sinais você precisa nas duas saídas, e qual a temporização deles, e eu faço para você.

Paulo

lucianolcoa · 24 de outubro de 2016

@aphawk Aqui esse e o codigo que le um sensor, mostra num display lcd e de acordo com a porcentagem ele faz alguma coisa, so que o "refresh" ta em waitms, queria em timers, apesar de botar 200 como refresh, que seria algo de 0,2 segundos acho, queria em 1 segundo.

-------------------------------

$regfile = "m328pdef.dat"
$crystal = 8000000
$hwstack=40
$swstack=16
$framesize=32

Config Portb.0 = Output
Config Portb.1 = Output
Config Portb.2 = Output
Config Portd.2 = Output
Config Portd.3 = Output
Config Portd.4 = Output
Config Portd.5 = Output
Config Portd.6 = Output
Config Portd.7 = Output

Portb.0 = 0
Portb.1 = 0
Portb.2 = 0
Dim Leitura As Long
                         Dim Escala As Byte
                         Dim Contador As Integer
                                       Contador = 0

Config Adc = Single , Prescaler = Auto
Start Adc

Config Lcdpin = Pin , E = Portd.2 , Rs = Portd.3 , Db4 = Portd.4 , Db5 = Portd.5 , Db6 = Portd.6 , Db7 = Portd.7

Config Lcd = 16 * 2

Do

Leitura = Getadc(3)
     Leitura = Leitura * 100
     Leitura = Leitura / 1023

    Locate 1 , 1
    Lcd "sensor em"
    Lcd Leitura
    Lcd "%"

       If Leitura < 20 Then Gosub Rotina1
       If Leitura >= 20 And Leitura <= 80 Then Gosub Rotina2
       If Leitura > 80 Then Gosub Rotina3
    If Escala = 1 Then
    Locate 2 , 1
    Lcd "alarme ligado"
    End If
    If Escala = 2 Then
    Locate 2 , 1
    Lcd "na margem,ok"
    End If
    If Escala = 3 Then
    Locate 2 , 1
    Lcd "acima 80,ok"
    End If

      Waitms 200
    Loop
    End
      Rotina1:
        Portb.0 = 1
        Portb.1 = 0
       Portb.2 = 0
         Escala = 1
         Return
         '----------------
         Rotina2:
         Portb.0 = 0
         Portb.1 = 1
        Portb.2 = 0
         Escala = 2
         Return
         '---------------
         Rotina3:
        Portb.0 = 0
         Portb.1 = 0
         Portb.2 = 1
         Escala = 3
         Return

adicionado 13 minutos depois

antes que eu me esqueca, valeu mano, valeu mesmo

aphawk · 25 de outubro de 2016

Em 24/10/2016 às 06:57, lucianolcoa disse:

@aphawk Aqui esse e o codigo que le um sensor, mostra num display lcd e de acordo com a porcentagem ele faz alguma coisa, so que o "refresh" ta em waitms, queria em timers, apesar de botar 200 como refresh, que seria algo de 0,2 segundos acho, queria em 1 segundo.

-------------------------------

Bom, segue aí prontinho para voce :

$regfile = "m328pdef.dat"
$crystal = 8000000
$hwstack=40
$swstack=16
$framesize=32


Config Portb.0 = Output
Config Portb.1 = Output
Config Portb.2 = Output
Config Portd.2 = Output
Config Portd.3 = Output
Config Portd.4 = Output
Config Portd.5 = Output
Config Portd.6 = Output
Config Portd.7 = Output

Portb.0 = 0
Portb.1 = 0
Portb.2 = 0
Dim Leitura As Long
Dim Escala As Byte
Dim Contador As Integer
Contador = 0
Dim Contagem As Word
Dim Limite_dado As Word
Dim Flag_estourou As Bit

Limite_dado = 1000
' configurado tempo de espera para 1000 milisegundos

Config Timer2 = Timer , Prescale = 64
Stop Timer2
On Timer2 Sub_contador

Timer2 = 125


Config Adc = Single , Prescaler = Auto , Reference = Avcc

Start Adc

Config Lcdpin = Pin , E = Portd.2 , Rs = Portd.3 , Db4 = Portd.4 , Db5 = Portd.5 , Db6 = Portd.6 , Db7 = Portd.7

Config Lcd = 16 * 2

Enable Timer2
Start Timer2
Enable Interrupts

Do


  Leitura = Getadc(3)
  Leitura = Leitura * 100
  Leitura = Leitura / 1023

  Locate 1 , 1
  Lcd "sensor em"
  Lcd Leitura
  Lcd "%"



  If Leitura < 20 Then Gosub Rotina1
  If Leitura >= 20 And Leitura <= 80 Then Gosub Rotina2
  If Leitura > 80 Then Gosub Rotina3
  If Escala = 1 Then
    Locate 2 , 1
    Lcd "alarme ligado"
  End If
  If Escala = 2 Then
    Locate 2 , 1
    Lcd "na margem,ok"
  End If
  If Escala = 3 Then
    Locate 2 , 1
    Lcd "acima 80,ok"
  End If

Espera:
  If Flag_estourou = 0 Then Goto Espera
  Flag_estourou = 0
  Contagem = 0
  Loop
  End

  Sub_contador:
  Incr Contagem
  If Contagem = Limite_dado Then
    Set Flag_estourou
  End If
  Timer2 = 132
  ' e agora , porque 132 e não 125 ???????
  Return




  Rotina1:
  Portb.0 = 1
  Portb.1 = 0
  Portb.2 = 0
  Escala = 1
  Return

  '----------------
  Rotina2:
  Portb.0 = 0
  Portb.1 = 1
  Portb.2 = 0
  Escala = 2
  Return

  '---------------
  Rotina3:
  Portb.0 = 0
  Portb.1 = 0
  Portb.2 = 1
  Escala = 3
  Return

Basta clocar o tempo que você quer em milissegundos na variável Limite_dado.

Esse tempo pode ser mudado em tempo real no programa também.

O que vai te deixar maluco é o porque no inicio eu configuro o contador do Timer2 com 125, mas antes de sair da interrupção coloco ele com 132 ... Se fizer a conta, verá que para interromper o Timer2 em exatos 1 milissegundo precisaria recarregar com 125. Deixo para voce pesquisar, meu amigo !

Repare que os tempos estão bem precisos, com menos de 1 milissegundo de erro em cada 10 segundos.

Existe uma outra maneira, usando os dois Timers e acionando uma interrupção de Int0 ou Int1, que permite a temporização exata, sem nenhum erro, só dependendo da precisão de seu cristal.... eu usei isso em um exemplo anterior cerca de uma semana atrás.

Agora você já pode comemorar indo no "ninjo da coruja" tomar um choppinho...

Ou um pedaço de pizza no "Vesúvio" kkkk

Paulo