ASM51

Alguém teve a curiosidade de reescrever os exemplos do livro "Desbravando o PIC" em "C"? E pode enviar-me por email?
Tenho um conhecido que quer usar o livro como referência no aprendizado em C e pediu-me que "traduzisse-os" para o CCS. Teria q instalar o CCS e em 30 dias, tempo da licença demo, resolver tudo.
Não faria outra coisa nêsse período, em prol da amizade... Por isso, apelo a voces, mesmo que seja um outro exemplo.

um outro exemplo seria "desbravando o pic24". tá tudo em c. tenho o livro (que nunca li) que ganhei em 2008. voce pode comprar ou "comprar" ele na net.
não preciso dizer que voce tem alternativas a versão demo (vá-te reto!) de qualquer compilador né?
com relação aos 30 dias, cogite usar o sdcc que também se integra ao mplab e funciona pra sempre. veja como em:
https://sites.google.com/site/rmaalmeid ... dccnomplab
com alguma troca troca de email com o autor consegui fazer BEM MAIS que um pisca led com ele e rapidin. são todos legais: o sdcc nos 2 sentidos e o autor do blog
abç&sucessos!

Lellis,

Obrigado pela ajuda, mas o PIC24 não é o foco.
O Kra quer pq quer a linha 16F(8 bits), o CCS e o "Desbravando o PIC" tb. Como é uma pessoa que não posso deixar na mão, estou traduzindo pro CCS(Argh!!!). Vou converter e mandar sem testar mesmo.
E não! Como o CCS é requisito obrigatório, nada de alternativas para os 30 dias.

Obrigado.

hummm isto é que é amizade. rs
seu projeto é interessante. se não fosse o pic antigo e não fosse ... (argh!) até que poderia pensar em colaborar por amizade.(note o tom de macho!)

enviei-te uma mp com um link do (argh!) que supõe-se funcionar por + de 30 dias caso queira continuar este projeto depois. tomara que tenha virus. mas se eu fosse voce eu nem abria porque voce (no caso eu) teria ódio do ...(ughh!)

e caso sinta vontade, compartilhe seu projeto pois tem muito otár... programador iniciante que tende a usar o ... (iéca!)

abç & sejam felizes. rs

Pois iéca!

Vou converter, mas não vou testar.
Depois eu posto no fórum, pode ser que alguém queira... sofrer.

Abs.

Primeiro Exemplo: PiscaPisca

Código: Selecionar todos

#include <16F877A.h>

#FUSES NOWDT                    //No Watch Dog Timer
#FUSES XT                       //Crystal osc <= 4mhz for PCM/PCH , 3mhz to 10 mhz for PCD
#FUSES PUT                      //Power Up Timer
#FUSES NOPROTECT                //Code not protected from reading
#FUSES NODEBUG                  //No Debug mode for ICD
#FUSES NOBROWNOUT               //No brownout reset
#FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOCPD                    //No EE protection
#FUSES NOWRT                    //Program memory not write protected

#use delay(clock=20000000)

#define LED PIN_A2

void main()
{

    //Example blinking LED program
    while(true){
      output_low(LED);
      delay_ms(1000);
      output_high(LED);
      delay_ms(1000);
    }

}

Segundo Exemplo: BotaoLED

Código: Selecionar todos

#include <16F877A.h>

#FUSES NOWDT                    //No Watch Dog Timer
#FUSES XT                       //Crystal osc <= 4mhz for PCM/PCH , 3mhz to 10 mhz for PCD
#FUSES PUT                      //Power Up Timer
#FUSES NOPROTECT                //Code not protected from reading
#FUSES NODEBUG                  //No Debug mode for ICD
#FUSES NOBROWNOUT               //No brownout reset
#FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOCPD                    //No EE protection
#FUSES NOWRT                    //Program memory not write protected

#use delay(clock=20000000)

#define BOTAO  PIN_A2

#define LED    PIN_B0

#define HIGH   1
#define LOW    0

//=====================================
// The following macro is used by the Button function.
#define read_bit_var(x)  bit_test(*(int8 *)(x >> 3), x & 7)

void main()
{

   //TODO: User Code
   
   set_tris_a(0x04);  // Set Pin A2 as input
   set_tris_b(0x00);  // Set Pin B0 as ouput

   while(true) {
      if (input_state(BOTAO)==LOW)   { // BOTAO está pressionado?
         output_high(LED);             //SIM, Acende o LED
      }
      else  {                          //NÃO, Apaga o LED
         output_low(LED);
      }
   }
}

Terceiro exemplo: Incrementa/Decrementa Contador

Código: Selecionar todos

#include <16F877A.h>

#FUSES NOWDT                    //No Watch Dog Timer
#FUSES XT                       //Crystal osc <= 4mhz for PCM/PCH , 3mhz to 10 mhz for PCD
#FUSES PUT                      //Power Up Timer
#FUSES NOPROTECT                //Code not protected from reading
#FUSES NODEBUG                  //No Debug mode for ICD
#FUSES NOBROWNOUT               //No brownout reset
#FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOCPD                    //No EE protection
#FUSES NOWRT                    //Program memory not write protected

#use delay(clock=20000000)

#define BOTAO     PIN_A2

#define HIGH      1
#define LOW       0

#define SOMA      0
#define SUBTRAI   1


void main()
{

   //TODO: User Code
   
   set_tris_a(0x02);
   set_tris_b(0x00);
   
   int8  Tfiltro = 230,
         min = 10,
         max = 30,
         contador = min,
         filtro = 0,
         sentido = 0;
   
   while(1) {
   
      filtro = Tfiltro;
      output_a(contador);
     
      while(input_state(BOTAO)==LOW || filtro>0) {
         filtro--;
      }
     
      if(filtro==0)  {
         if(sentido==SOMA)   { //É pra somar?
            contador++;
            if(contador>=max) {
               sentido = SUBTRAI;
               contador = max;
            }
         }
         else  {
            contador--;
            if(contador<=min) {
               sentido=SOMA;
               contador = min;
            }
         }
      }   
     
   }

}

Quarto exemplo: Incrementa/Decrementa Contador e exibe no Diplay 7 segmentos

Código: Selecionar todos

#include <16F877A.h>

#FUSES NOWDT                    //No Watch Dog Timer
#FUSES XT                       //Crystal osc <= 4mhz for PCM/PCH , 3mhz to 10 mhz for PCD
#FUSES PUT                      //Power Up Timer
#FUSES NOPROTECT                //Code not protected from reading
#FUSES NODEBUG                  //No Debug mode for ICD
#FUSES NOBROWNOUT               //No brownout reset
#FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOCPD                    //No EE protection
#FUSES NOWRT                    //Program memory not write protected

#use delay(clock=20000000)

#define BOTAO1     PIN_A1
#define BOTAO2     PIN_A2

#define HIGH      1
#define LOW       0

//A CONSTANTE DISPLAY REPRESENTA O SÍMBOLO QUE APARECERÁ PISCANDO NO
//DISPLAY. 1=LED LIGADO E 0=LED DESLIGADO. A RELAÇÃO ENTRE BITS E
//SEGMENTOS É A SEGUINTE: 'EDC.BAFG'
//      a
//     **********
//     *        *
//   f *        * b
//     *    g   *
//     **********
//     *        *
//   e *        * c
//     *    d   *
//     **********  *.

    int8 DISPLAY[] = {  0xEE,    // B'11101110'   ; 00 - RETORNA SÍMBOLO CORRETO 0
                        0x28,    // B'00101000'   ; 01 - RETORNA SÍMBOLO CORRETO 1
                        0xCD,    // B'11001101'   ; 02 - RETORNA SÍMBOLO CORRETO 2
                        0x6D,    // B'01101101'   ; 03 - RETORNA SÍMBOLO CORRETO 3
                        0x2B,    // B'00101011'   ; 04 - RETORNA SÍMBOLO CORRETO 4   
                        0x67,    // B'01100111'   ; 05 - RETORNA SÍMBOLO CORRETO 5   
                        0xE7,    // B'11100111'   ; 06 - RETORNA SÍMBOLO CORRETO 6   
                        0x2C,    // B'00101100'   ; 07 - RETORNA SÍMBOLO CORRETO 7   
                        0xEF,    // B'11101111'   ; 08 - RETORNA SÍMBOLO CORRETO 8   
                        0x6F,    // B'01101111'   ; 09 - RETORNA SÍMBOLO CORRETO 9   
                        0xAF,    // B'10101111'   ; 10 - RETORNA SÍMBOLO CORRETO A   
                        0xE2,    // B'11100011'   ; 11 - RETORNA SÍMBOLO CORRETO b   
                        0xC6,    // B'11000110'   ; 12 - RETORNA SÍMBOLO CORRETO C   
                        0xE9,    // B'11101001'   ; 13 - RETORNA SÍMBOLO CORRETO d   
                        0xC7,    // B'11000111'   ; 14 - RETORNA SÍMBOLO CORRETO E   
                        0x87};   // B'10000111'   ; 15 - RETORNA SÍMBOLO CORRETO F   


void atualiza(int8 idx)   {
   output_b(DISPLAY[idx]);
   return;
}

void main()
{

    //TODO: User Code
   
    int8    contador,
            flags,
            filtro1,
            filtro2,
            min =0,
            max = 15,
            Tfiltro = 255;
   
   set_tris_a(0x06);
   set_tris_b(0x00);
   
   output_a(0x00);
   output_b(DISPLAY[0]);
   contador = min;
   
   while(true) {
   
      filtro1 = filtro2 = Tfiltro;
      while(input_state(BOTAO1)==LOW)  {  //Botão1 pressionado?
                                       //Sim, incrementa.
         if(filtro1-- <= 0)  {         // O filtro1 é 0(zero)?
            if(bit_test(FLAGS,0)==1) { // Botao1 não está pressionado?
                                       // Sim, decrementa.
               contador--;
               if(contador <= min) {
                  contador = min;
               }
               atualiza(DISPLAY[contador]);
            }
         }
         else  {
            break;
         }
      }
     
      while(input_state(BOTAO2)==LOW)  {  //Botão2 pressionado?
                                       //Sim, decrementa.
         if(filtro2-- <= 0)  {         // O filtro2 é 0(zero)?
            if(bit_test(FLAGS,1)==1) { // Botao2 não está pressionado?
                                       // Sim, incrementa.
               contador++;
               if(contador >= min) {
                  contador = max;
               }
               atualiza(DISPLAY[contador]);
            }
         }
         else  {
            break;
         }
      }
     
   }

}

Quinto exemplo: Decrementa no Display com Timer0

Não fiz nenhuma conta para adequar os valores ao PIC alvo.

Código: Selecionar todos

#include <16F877A.h>

#FUSES NOWDT                    //No Watch Dog Timer
#FUSES HS                       //High speed Osc (> 4mhz for PCM/PCH) (>10mhz for PCD)
#FUSES PUT                      //Power Up Timer
#FUSES NOPROTECT                //Code not protected from reading
#FUSES NODEBUG                  //No Debug mode for ICD
#FUSES NOBROWNOUT               //No brownout reset
#FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOCPD                    //No EE protection
#FUSES NOWRT                    //Program memory not write protected

#use delay(clock=20000000)

#DEFINE   F_FIM    FLAGS,0      // FLAG DE FIM DE TEMPO
#DEFINE   ST_BT1   FLAGS,1      // STATUS DO BOTÃO 1
#DEFINE   ST_BT2   FLAGS,2      // STATUS DO BOTÃO 2

#define   Vinicio    15         // VALOR INICIAL DO TIMER (1 A 15 SEG.)
#define   Tfiltro    255        // VALOR DO FILTRO DOS BOTÕES

#define BOTAO1     PIN_A1
#define BOTAO2     PIN_A2

#define HIGH      1
#define LOW       0

#define LED       PIN_A3

//A CONSTANTE DISPLAY REPRESENTA O SÍMBOLO QUE APARECERÁ PISCANDO NO
//DISPLAY. 1=LED LIGADO E 0=LED DESLIGADO. A RELAÇÃO ENTRE BITS E
//SEGMENTOS É A SEGUINTE: 'EDC.BAFG'
//      a
//     **********
//     *        *
//   f *        * b
//     *    g   *
//     **********
//     *        *
//   e *        * c
//     *    d   *
//     **********  *.

    int8 DISPLAY[] = {  0xEE,    // B'11101110'   ; 00 - RETORNA SÍMBOLO CORRETO 0
                        0x28,    // B'00101000'   ; 01 - RETORNA SÍMBOLO CORRETO 1
                        0xCD,    // B'11001101'   ; 02 - RETORNA SÍMBOLO CORRETO 2
                        0x6D,    // B'01101101'   ; 03 - RETORNA SÍMBOLO CORRETO 3
                        0x2B,    // B'00101011'   ; 04 - RETORNA SÍMBOLO CORRETO 4   
                        0x67,    // B'01100111'   ; 05 - RETORNA SÍMBOLO CORRETO 5   
                        0xE7,    // B'11100111'   ; 06 - RETORNA SÍMBOLO CORRETO 6   
                        0x2C,    // B'00101100'   ; 07 - RETORNA SÍMBOLO CORRETO 7   
                        0xEF,    // B'11101111'   ; 08 - RETORNA SÍMBOLO CORRETO 8   
                        0x6F,    // B'01101111'   ; 09 - RETORNA SÍMBOLO CORRETO 9   
                        0xAF,    // B'10101111'   ; 10 - RETORNA SÍMBOLO CORRETO A   
                        0xE2,    // B'11100011'   ; 11 - RETORNA SÍMBOLO CORRETO b   
                        0xC6,    // B'11000110'   ; 12 - RETORNA SÍMBOLO CORRETO C   
                        0xE9,    // B'11101001'   ; 13 - RETORNA SÍMBOLO CORRETO d   
                        0xC7,    // B'11000111'   ; 14 - RETORNA SÍMBOLO CORRETO E   
                        0x87};   // B'10000111'   ; 15 - RETORNA SÍMBOLO CORRETO F   
   
   int8 temp1;   // VARIÁVEIS AUXILIARES
   int8  tempo,   // ARMAZENA O VALOR DO TEMPO
         FLAGS,   // ARMAZENA OS FLAGS DE CONTROLE
         filtro1, // FILTROS DOS BOTÕES
         filtro2;
         
void  atualiza(int idx) {
   output_b(DISPLAY[idx]);
}

void ligaTimer0(void)  {

   clear_interrupt(INT_TIMER0);
   
   set_timer0(256-125);
   temp1 = 125;
   enable_interrupts(INT_TIMER0);
   output_high(LED);
   
}

void desligaTimer0(void)   {

   set_timer0(0);
   output_low(LED);
   
}

#int_timer0
void  timer0ISR(void)   {

   clear_interrupt(INT_TIMER0);
   set_timer0(256-125);
   
   if(--temp1 > 0) {
      return;
   }
   
   temp1 = 125;
   if(bit_test(F_FIM)==1)  {
      return;
   }
   
   if(--tempo > 0 )  {
      return;
   }
   
   bit_set(F_FIM);
   
}
         
void main()
{
   set_tris_a(0x06);
   set_tris_b(0x00);
   
   output_a(0x00);         // LIMPA O PORTA
   output_b(0x00);         // LIMPA O PORTB
   flags = 0;              // LIMPA TODOS OS FLAGS
   tempo = Vinicio;        // INICIA TEMPO = V_INICIO
   atualiza(tempo);
   
   while(true) {
   
      if(bit_test(F_FIM)==1)  {
         desligaTimer0();
      }
      atualiza(tempo);
      filtro1 = filtro2 = Tfiltro;

      while(input_state(BOTAO1)==LOW)  {  //Botão1 pressionado?
                                          //Sim, incrementa.
         if(--filtro1 < 1)  {             // O filtro1 é 0(zero)?
            if(bit_test(ST_BT1)==0) {     // Botao1 já estava pressionado?
                                          // Sim, ACAO_ BT1.
               bit_set(ST_BT1);
               ligaTimer0();
            }
            break;
         }
      }
   
      if(filtro1-- <= 0) {           // A saída foi por break?
         continue;
      }

      if(input_state(BOTAO1)==HIGH) {
         bit_clear(ST_BT1);
      }

      while(input_state(BOTAO2)==LOW)  {  //Botão2 pressionado?                                    //Sim, decrementa.
         if(filtro2-- <= 0)  {         // O filtro1 é 0(zero)?
            if(bit_test(ST_BT2)==0) { // Botao2 já estava pressionado?
                                       // Sim, ACAO_ BT2.
               bit_set(ST_BT2);
               ligaTimer0();
            }
            break;
         }
      }
     
      if(input_state(BOTAO2)==HIGH) {
         bit_clear(ST_BT2);
      }
   }
}

Sexto exemplo: Incrementa/Decrementa Contador guardando o valor na E2PROM.

Código: Selecionar todos

#include <16F877A.h>

#FUSES NOWDT                    //No Watch Dog Timer
#FUSES XT                       //Crystal osc <= 4mhz for PCM/PCH , 3mhz to 10 mhz for PCD
#FUSES PUT                      //Power Up Timer
#FUSES NOPROTECT                //Code not protected from reading
#FUSES NODEBUG                  //No Debug mode for ICD
#FUSES NOBROWNOUT               //No brownout reset
#FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOCPD                    //No EE protection
#FUSES NOWRT                    //Program memory not write protected

#use delay(clock=20000000)

#define MIN       0
#define MAX       15
#define TFILTRO   255
#define POS_MEM   0x00

#DEFINE ST_BT1   FLAGS,0        // STATUS DO BOTÃO 1
#DEFINE ST_BT2   FLAGS,1        // STATUS DO BOTÃO 2

#define BOTAO1     PIN_A1
#define BOTAO2     PIN_A2

#define HIGH      1
#define LOW       0

//A CONSTANTE DISPLAY REPRESENTA O SÍMBOLO QUE APARECERÁ PISCANDO NO
//DISPLAY. 1=LED LIGADO E 0=LED DESLIGADO. A RELAÇÃO ENTRE BITS E
//SEGMENTOS É A SEGUINTE: 'EDC.BAFG'
//      a
//     **********
//     *        *
//   f *        * b
//     *    g   *
//     **********
//     *        *
//   e *        * c
//     *    d   *
//     **********  *.

    int8 DISPLAY[] = {  0xEE,    // B'11101110'   ; 00 - RETORNA SÍMBOLO CORRETO 0
                        0x28,    // B'00101000'   ; 01 - RETORNA SÍMBOLO CORRETO 1
                        0xCD,    // B'11001101'   ; 02 - RETORNA SÍMBOLO CORRETO 2
                        0x6D,    // B'01101101'   ; 03 - RETORNA SÍMBOLO CORRETO 3
                        0x2B,    // B'00101011'   ; 04 - RETORNA SÍMBOLO CORRETO 4   
                        0x67,    // B'01100111'   ; 05 - RETORNA SÍMBOLO CORRETO 5   
                        0xE7,    // B'11100111'   ; 06 - RETORNA SÍMBOLO CORRETO 6   
                        0x2C,    // B'00101100'   ; 07 - RETORNA SÍMBOLO CORRETO 7   
                        0xEF,    // B'11101111'   ; 08 - RETORNA SÍMBOLO CORRETO 8   
                        0x6F,    // B'01101111'   ; 09 - RETORNA SÍMBOLO CORRETO 9   
                        0xAF,    // B'10101111'   ; 10 - RETORNA SÍMBOLO CORRETO A   
                        0xE2,    // B'11100011'   ; 11 - RETORNA SÍMBOLO CORRETO b   
                        0xC6,    // B'11000110'   ; 12 - RETORNA SÍMBOLO CORRETO C   
                        0xE9,    // B'11101001'   ; 13 - RETORNA SÍMBOLO CORRETO d   
                        0xC7,    // B'11000111'   ; 14 - RETORNA SÍMBOLO CORRETO E   
                        0x87};   // B'10000111'   ; 15 - RETORNA SÍMBOLO CORRETO F   


void atualiza(int8 idx)   {
   output_b(DISPLAY[idx]);
   return;
}

void main()
{

    //TODO: User Code
   
    int8    contador,
            FLAGS,
            filtro1,
            filtro2;
   
   set_tris_a(0x06);
   set_tris_b(0x00);
   
   output_a(0x00);
   FLAGS = 0;
   contador = read_eeprom(POS_MEM);
   
   output_b(DISPLAY[0]);

   while(true) {
   
      filtro1 = filtro2 = TFILTRO;
      while(input_state(BOTAO1)==LOW)  {  //Botão1 pressionado?
                                       //Sim, incrementa.
         if(--filtro1 < 1)  {         // O filtro1 é 0(zero)?
            if(bit_test(ST_BT1)==1) { // Botao1 não está pressionado?
                                       // Sim, decrementa.
               contador--;
               write_eeprom(POS_MEM, contador);
               if(contador <= min) {
                  contador = min;
               }
               atualiza(DISPLAY[contador]);
            }
         }
         else  {
            ;                          //comando vazio pq o else SEMPRE
                                       //se refere ao último if testado
         }
      }
     
      if(input_state(BOTAO1)==HIGH) {
         bit_clear(ST_BT1);
      }
     
      while(input_state(BOTAO2)==LOW)  {  //Botão2 pressionado?
                                       //Sim, decrementa.
         if(--filtro2 < 1)  {         // O filtro2 é 0(zero)?
            if(bit_test(ST_BT2)==1) { // Botao2 não está pressionado?
                                       // Sim, incrementa.
               contador++;
               write_eeprom(POS_MEM, contador);
               if(contador >= max) {
                  contador = max;
               }
               atualiza(DISPLAY[contador]);
            }
         }
         else  {
            ;                          //comando vazio pq o else SEMPRE
                                       //se refere ao último if testado
         }
      }
     
      if(input_state(BOTAO2)==HIGH) {
         bit_clear(ST_BT2);
      }
     
   }

}

Limitações:

- Nenhum exemplo está testado!
- Procurei fazer a conversão mantendo + ou - a mesma lógica do livro(ASM). O que quer dizer que os exemplos estão "escritos" em "C" e não programados em "C", pois a lógica de programação seria um pouco diferente.
- Fontes para o PIC16F877A, pois o CCS trial tem esta limitação.

Se alguém testar e corrigir os erros, por favor, atualize este post.