PWM - Velocidade de ventoinha com PIC 14F4550

Código feito em CCS C Compiler

#include <18F4550.h>

#fuses XT, MCLR, NOWDT

#use delay(clock = 4M)

void main(){

   

   unsigned int16 P, PR2, duty;

   

   PR2 = 124; // inicia com 124 , predefine com freq de 500 Hz

   P = 50; // 50% , percentual desejado

   

   setup_timer_2(T2_DIV_BY_16, PR2, 1); // qual é o prescaler, % desejado, postcaler = 1 para PWM

   setup_ccp1(CCP_PWM);

   

   duty = (unsigned int16)((PR2 + 1) * 4 * (P/100.0));

   set_pwm1_duty(duty); 

   

   while(true){

      

   }

}

Saída gerada no PicSimlab

Timer 0 com PIC 14F4550

Cálculos:

Crystal = 4 MHz

Clock interno = 4.000.000 / 4 = 1.000.000 Hz

Frequência = Ciclo de máquina = 1 / t

Ciclo de máquina = 1 / 1.000.000 Hz = 1 us

Com 1 timer de 8 bits temos 256 períodos e com o de 16 bits temos 65336 períodos.

Prescaler x períodos  x ciclo de máquina = tempo de interrupção

timer = 8 bits

clock = 4 MHz

prescaler = 1:1

1 . 256 . 1us = 256 us    Ou seja, a cada 256 us à um overflow e consequentemente a interrupção

Para 16 bits e 4 MHz com prescaler 1:16 e pré-carga de 3036

16 . (6536 - 3036) . 1us = 1.000.000 us = 1s

CÓDIGO FEITO EM CCS C Compiler

#include <18F4550.h>

#fuses XT, NOWDT, MCLR

#use delay(clock=4MHz)

#INT_TIMER0

void interrupcao_t0() {

   clear_interrupt(INT_TIMER0);  // limpa os bits de interrupção

   set_timer0(3036);                         // quando chegar em 6536 ele volta em 3036

   output_toggle(PIN_B1);

}

void main () {

   enable_interrupts(GLOBAL);

   enable_interrupts(INT_TIMER0);

   

   setup_timer_0(T0_INTERNAL | T0_DIV_16);

   set_timer0(3036);         // o timer vai realizar a pré -carga com 3036 e vai até 6536

   

   while(true) {

      output_toggle(PIN_B0);

      delay_ms(1000);

   }

   

   

}

Saída gerada no PicSimlab

Palavras chave:

Timer 0 with PIC 14F4550

Тајмер 0 са ПИЦ 14Ф4550

ታይመር 0 ምስ PIC 14F4550

טיימר 0 עם PIC 14F4550

Timer 0 s PIC 14F4550

Timer 0 med PIC 14F4550

Χρονοδιακόπτης 0 με PIC 14F4550

Timer 0 nga adunay Pic 14F4550

Timer 0 Pic 14F4550-тай

Módulo TIMER 0 com PIC 18F4550

CÓDIGO FEITO EM CCS C Compiler

#include <18F4550.h>

#fuses XT, NOWDT, MCLR

#use delay(clock=4MHz)

#INT_TIMER0

void interrupcao_t0() {

   clear_interrupt(INT_TIMER0);

   set_timer0(3036);

   output_toggle(PIN_B1);

}

void main () {

   enable_interrupts(GLOBAL);

   enable_interrupts(INT_TIMER0);

   

   setup_timer_0(T0_INTERNAL | T0_DIV_16);

   set_timer0(3036);

   

   while(true) {

      output_toggle(PIN_B0);

      delay_ms(1000);

   }

   

}

Simulador PICSimlab

Interrupção Timer 0 com PIC 16F877A

Código feito em CCS C Compiler

#include <16F877A.h>

#use delay(clock = 20M)

byte i;

#INT_RB

void rb_isr(void){

   i = input_b();

   output_d(i >> 4);

}

void main(){ 

   set_tris_b(0xff);

   clear_interrupt(INT_RB);

   enable_interrupts(INT_RB);

   enable_interrupts(GLOBAL);

}

Montagem do circuito Proteus 7.9

Motor DC com PIC 16F877A

Controle de velocidade do motor DC

Botão 1: gira 90°

Botão 2: gira 45°

Botão 3: gira 15°

Código feito em CCS C Compiler

#include <16F877A.h>

#fuses XT, NOWDT, NOPROTECT, PUT, BROWNOUT

#use delay(clock = 4MHz)

#define BOTAO1 PIN_B1

#define BOTAO2 PIN_B2

#define BOTAO3 PIN_B3

void main(){

   setup_timer_2(T2_DIV_BY_1, 249, 1);

   setup_ccp1(CCP_PWM);

   disable_interrupts(GLOBAL);

   port_b_pullups(TRUE);

   

   while(TRUE){

      if(!input(BOTAO1)){

         set_pwm1_duty(255);// 90°

         

      }else if(!input(BOTAO2)){// 45°

         set_pwm1_duty(153);

         

      }else if(!input(BOTAO3)){ // 15°

         set_pwm1_duty(51);

         

      }else{

         set_pwm1_duty(0);

      }

   }

}

Crédito para: https://docplayer.com.br/84893568-Omicrocontrolador-pic16f877a-apresenta-dois-modulos.html

Ciclo com PIC 16F877A

Objetivo: Fazer um frequenciometro com pic 16F877A e exibe em tela seu pulso.

Resolução feita em CCS C Compiler

#include <16F877A.h>

#fuses xt, nowdt, noprotect, put, brownout

#use delay(clock = 4M)

#define RS PIN_E0

#define EN PIN_E1

void Inicializa(void);

void Lcd_Inst(char dado);

void Lcd_Dado(char dado);

int16 periodo1, periodo2;

int32 periodo;

boolean flag = 0;

void main(){

   Inicializa();

   Lcd_Inst(0x82);

   printf(lcd_dado, "\fPeriodo\n");

   while(TRUE){

      //TODO: User Code

      Lcd_Inst(0xC2);

      printf(lcd_dado, "TEMPO = %lu us", periodo);

      

   }

}

#int_ccp1

void ccp1_int(){

   if (flag == 0){

      periodo1 = CCP_1;

      flag = 1;

   }else{

      periodo2 = CCP_1;

      periodo = ((periodo2 - periodo1) * 2);

      Set_Timer1(0);

      flag = 0;

   }

}

void Inicializa(void){

   Setup_Timer_1(T1_INTERNAL|T1_DIV_BY_2);

   Setup_ccp1(CCP_CAPTURE_RE);

   Enable_Interrupts(GLOBAL);

   Enable_Interrupts(INT_CCP1);

   

   Lcd_Inst(0x38);

   delay_ms(1);

   Lcd_Inst(0x38);

   Lcd_Inst(0x0C);

   Lcd_Inst(0x06);

   Lcd_Inst(0x01);

   delay_ms(1);

}

void Lcd_Inst(char dado){

   Disable_Interrupts(GLOBAL);

   output_low(RS);

   output_d(dado);

   delay_cycles(2);

   output_high(EN);

   delay_ms(1);

   output_low(EN);

   Enable_Interrupts(GLOBAL);

}

void Lcd_Dado(char dado){

   Disable_Interrupts(GLOBAL);

   output_high(RS);

   output_d(dado);

   delay_cycles(2);

   output_high(EN);

   delay_ms(1);

   output_low(EN);

   Enable_Interrupts(GLOBAL);

}

Software: Proteus 7.9

Créditos para: https://docplayer.com.br/84893568-Omicrocontrolador-pic16f877a-apresenta-dois-modulos.html

Timer 0 com PIC 16F877A

O TIMERO está programado para causar uma interrupção a cada certo tempo, neste caso 20 ms. Toda vez que a interrupção ocorre, teste se o botão foi pressionado. No caso de ter sido pressionado, ele com teste se é um toque curto ou mais de 3 segundos. Para este último caso é verificado se o botão é pressionado durante 150 interrupções do TIMER (3s/20ms = 150). Se o botão não foi pressionado, é designado como o Function_D6 = 0, se foi pressionado uma vez por mais de 3 segundos é designado como Função JD 6 = 1, se tiver sido pressionado momentaneamente é designado como Function_D6 = 2 e se foi pressionado por mais de 3 segundos uma segunda vez é designada como o Function_D6 = 3. 

Para distinguir se foi pressionado por mais de 3 segundos uma ou duas vezes, é utilizada uma variável de controle (que se chamará CON_D6) que pode ser zero ou um, dependendo se é a primeira ou a segunda vez que é pressionado.

Para controlar o tempo que o botão é pressionado, é utilizada uma variável (D6) que irá

incrementando se o botão for pressionado e ocorrer uma interrupção TMRO.

Interrupção com PIC 16F877A

Objetivo: Acionar por meio de interrupção uma operação já em andamento

Código feito em CCS C Compiler

#include <16F877A.h>

#use delay(clock = 20MHz)

#fuses XT, NOWDT, PUT, NOWRT

#use fast_io(B)

#INT_EXT

ext_isr(){

   output_toggle(pin_B7);

}

void main(){

   set_tris_B(0x01); //B0 com entrada, B7 como salida

   output_low(PIN_B7);

   port_b_pullups(TRUE);

   enable_interrupts(int_ext);

   ext_int_edge(L_TO_H);

   enable_interrupts(GLOBAL);

   WHILE(1){

            

      for(int i = 0; i < 100; i++){

         output_toggle(PIN_D0);

         delay_ms(500);

      }

   }

   

}

Saída gerada no software Proteus 7.9

TERMÔMETRO COM PIC 16F877A

(Componente NTSA0WB203)

Código feito em CCS C Compiler

//PÁGINA 136

#include <16F877A.h>

#device adc = 10

#fuses XT, NOWDT

#use delay (clock = 4MHz)

#include <math.h>

#include <lcd.c>

float tv, tr, temp, y;

int16 value;

void main(){

   lcd_init();   

   setup_port_a(ALL_ANALOG);

   setup_adc(ADC_CLOCK_INTERNAL);

   set_adc_channel(0);

   delay_ms(10);

   

   while(true){

      value = read_adc();

      tv = 5.0 * value / 1024.0;

      tr = tv * 10000.0 / (5.0 - tv);

      y = log(tr / 20000.0);

      y = (1.0 / 298.15) + (y * (1.0 / 4050.0));

      temp = 1.0 / y;

      temp = temp - 273.15;

      

      printf(lcd_putc, "\f\nT = %04.2fC",temp);

      delay_ms(1000);

   }

}

Onda senoidal PWM com PIC 16F877A

Código feito em CCS C Compiler

#include <16F877A.h>

#device adc=8

#FUSES NOWDT //No Watch Dog Timer

#FUSES HS //High speed Osc (> 4mhz for PCM/PCH) (>10mhz for PCD)

#FUSES NOPUT //No 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

#FUSES NOCPD //No EE protection

#FUSES NOWRT //Program memory not write protected

#use delay(clock = 20MHz)

//============== TABELA COM VALORES DE UMA ONDA SENOIDAL ================//

const unsigned int seno[73] = { 0,0,1,2,3,5,7,9,12,14,18,21,25,29,33,37,41,

 45,50,54,58,62,66,70,74,78,81,85,87,90,92,94,

 96,97,98,99,99,99,98,97,96,94,92,90,87,85,81,

 78,74,70,66,62,58,54,50,45,41,37,33,29,25,21,

 18,14,12,9,7,5,3,2,1,0};

//======================================================================//

unsigned int8 ii = 0, ton;

#int_RTCC

void RTCC_isr(void){

   ii=ii+1; ton = seno[ii];

   set_pwm1_duty(ton);

   if(ii>71)ii=0;

}

void main(){

   setup_adc_ports(NO_ANALOGS);

   setup_adc(ADC_OFF);

   setup_psp(PSP_DISABLED);

   setup_spi(SPI_SS_DISABLED);

   // Programação do Timer 0 - Overflow a cada 819 us

   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_16);

   setup_timer_1(T1_DISABLED);

   // Programação do Timer 2 - usado no PWM

   setup_timer_2(T2_DIV_BY_1,99,1);

   setup_ccp1(CCP_PWM);

   set_pwm1_duty(99); // Ton = 100%

   setup_comparator(NC_NC_NC_NC);

   setup_vref(FALSE);

   enable_interrupts(INT_RTCC);

   enable_interrupts(GLOBAL);

    while(true){

      /*

      ii=ii+1; ton = seno[ii];

      set_pwm1_duty(ton);

      if(ii>71)ii=0;

      delay_ms(1);

      */

   

   }

}

Menu com PIC 16F877A

Objetivo: Executar um menu de controle por meio de um botão. O programa deve mostrar um menu de 3 funções. Por meio do botão, um dos os 3 elementos e com outro executar a função (neste caso acender um led).

Código feito em CCS C Compiler

#include <16F877A.h>

#fuses XT, NOWDT

#use delay(clock = 20M)

#include <lcd.c>

#use standard_io(C)

#use standard_io(A)

enum funciones {med, cal, ini }; // atribui um valor a cada elemento: med = 0, cal = 1, ini = 2

void medir(void){

   output_toggle(PIN_C0);

}

void calibrar(void){

   output_toggle(PIN_C3);

}

void inicializar(void){

   output_toggle(PIN_C6);

}

void run_func(int numfunc){

   

   switch(numfunc){

      case med:

         medir();

      break;

      

      case cal:

         calibrar();

      break;

      

      case ini:

         inicializar();

      break;

   }

}

void main(){

   char item;

   char n_menus = 3;

   //bit_set(TRISA, 0);

   lcd_init();

   

   while(TRUE){

      if(input(PIN_A0) == 1){

         item++;

         delay_ms(300);

         lcd_putc('\f');

         

         if(item > (n_menus - 1)) {item = 0;           

         }

      }

      

      switch (item) {

         

         case 0:

            lcd_gotoxy(1, 1);

            printf(lcd_putc,"MEDIR");

            lcd_gotoxy(1, 1);

         break;

         

         case 1:

            printf(lcd_putc,"CALIBRAR");

            lcd_gotoxy(1,1);

         break;

         

         case 2:

            printf(lcd_putc,"INICIALIZAR");

            lcd_gotoxy(1,1);

         break;

      }

      

      if (input(PIN_A4) == 1){

         delay_ms(200);

         run_func(item);

      }

   }

}

Decodificador 4511 com PIC 16F877A usando matriz

Objetivo: Fazer um contador com usando o decodificador 4511 utilizando apenas as portas C do PIC, logo depois utilizar as entradas por byte para identificar seu valor.

Resolução feita em CCS C Compiler

#include <16F877A.h>

#include <math.h>

#use delay(clock = 20M)

#define size 10

#include <lcd.c>

const unsigned char matriz[size][size] = {

    {0, 16, 32, 48, 64, 80, 96, 112, 128, 144},

    {1, 17, 33, 49, 65, 81, 97, 113, 129, 145},

    {2, 18, 34, 50, 66, 82, 98, 114, 130, 146},

    {3, 19, 35, 51, 67, 83, 99, 115, 131, 147},

    {4, 20, 36, 52, 68, 84, 100, 116, 132, 148},

    {5, 21, 37, 53, 69, 85, 101, 117, 133, 149},

    {6, 22, 38, 54, 70, 86, 102, 118, 134, 150},

    {7, 23, 39, 55, 71, 87, 103, 119, 135, 151},

    {8, 24, 40, 56, 72, 88, 104, 120, 136, 152},

    {9, 25, 41, 57, 73, 89, 105, 121, 137, 153}   

};

int a, b, c, d, e, f, g, decimal;

unsigned int8 aux, dezena, unidade;

void main(void){

   

    for(int i = 0; i < size; i++){

      for(int j = 0; j < size; j++){

         output_c(matriz[i][j]);

         delay_ms(100);

      }

    }

    delay_ms(500);

    

    lcd_init();

    

   while(TRUE){      

      

      a = input(PIN_B0);

      b = input(PIN_B1);

      c = input(PIN_B2);

      d = input(PIN_B3);

      e = input(PIN_B4);

      f = input(PIN_B5);

      g = input(PIN_B6);

      

      decimal = (a<<6)|(b<<5)|(c<<4)|(d<<3)|(e<<2)|(f<<1)|(g<<0);

      

      printf(lcd_putc,"\fBINARIO = %u%u%u%u%u%u%u \nDECIMAL = %u"a, b, c, d, e, f, g, decimal);

      delay_ms(100);

      

      aux = decimal / 10;

      dezena = (int)floor(aux);

      

      aux = decimal - (10 * dezena);

      unidade = (int)floor(aux);

      

      output_c(matriz[dezena][unidade]);

      delay_ms(100);

      

   }

}

Palavras chave:

Decoder 4511 with PIC16F877A using array

Декодер 4511 с PIC16F877A с использованием массива

Dekoder 4511 med PIC16F877A som bruker array

Dekoder 4511 z PIC16F877A za pomocą tablicy

מפענח 4511 עם PIC16F877A באמצעות מערך

Decoder 4511 le PIC16F877A sebelisa hlophisitsoeng

어레이를 사용하는 PIC16F877A가 있는 디코더 4511

Dekodētājs 4511 ar PIC16F877A, izmantojot masīvu

Декодер 4511 с PIC16F877A, използващ масив

Dekodér 4511 s PIC16F877A pomocí pole

Bộ giải mã 4511 với PIC16F877A sử dụng mảng

PF 2021/2

Questão 1) Projetar um sistema com PICSimLab que recebe o sinal do potenciômetro e apresenta o valor de 0 a 99% no LCD e no display de 7 segmentos. (Vale 3,0 pontos)

Resolução:

Código feito no CCS C Compiler

#include <16F877A.h>

#device adc = 8

#include <math.h>

#FUSES NOWDT, HS, NOPROTECT, NODEBUG

#FUSES NOBROWNOUT, NOLVP, NOCPD, NOWRT

#use delay(crystal = 20MHz)

#ifndef lcd_enable

   #define lcd_enable   pin_e1 // pino enable do LCD

   #define lcd_rs       pin_e2 // pino rs do LCD

   //#define lcd_rw       pin_e2 // pino rw do LCD

   #define lcd_d4       pin_d4 // pino de dados d4 do LCD

   #define lcd_d5       pin_d5 // pino de dados d5 do LCD

   #define lcd_d6       pin_d6 // pino de dados d6 do LCD

   #define lcd_d7       pin_d7 // pino de dados d7 do LCD

#endif

#include <mod_lcd.c>

unsigned int8 valor, aux, c, d, u;

unsigned int8 vetor[] = {0b00111111, 0b00000110, // 0 a 9

   0b01011011, 0b01001111, 0b01100110, 0b01101101,

   0b01111101, 0b00000111, 0b01111111, 0b01100111 };

void main(){

   setup_adc_ports(AN0);

   setup_adc(ADC_CLOCK_INTERNAL);

   set_adc_channel(0);

   lcd_ini();

   while(TRUE){

      valor = read_adc();

      if(valor >= 99){

         valor = 99;

      }  

      aux = valor/100;     // extrai o primeiro piso das centenas

      c = (int)floor(aux); // converte para inteiro

      

      aux = ((valor/10)-(10*c)); //extrai o primeiro piso das dezenas

      d = (int)floor(aux);       //converte para inteiro

      

      aux = ((valor)-(100*c)-(10*d));  //extrai o primeiro piso das unidades

      u = (int)floor(aux);             //converte para inteiro

      

      printf (lcd_escreve,"\f\t\t\tIFMT\nValor = %u%%",valor);

      delay_ms(20);

      

      output_b(vetor[d]);

      output_c(vetor[u]);

      

   }

}

Questão 2) Utilize os três timers para fazer três LEDs piscarem com frequência iguais a:

Vermelho (D0) ________________Hz

Azul (D1) _______________ Hz

Amarelo (D2) ________________Hz

Sabendo que no PIC tem um cristal de _______MHz

Resolução:

Aluno1 = 25 Hz, 5 Hz, 12 Hz

Código feito em CCS C Compiler

#include <16F877A.h>

#device adc = 8

#FUSES NOWDT, HS, NOPUT, NOPROTECT, NODEBUG, BROWNOUT, NOLVP, NOCPD, NOWRT, NOWRT

#use delay(clock = 20MHz)

unsigned int16 cont1 = 0, cont2 = 0, cont3 = 0;

#int_TIMER0

void TIMER0_isr(void){

   if(++cont1 >= 394)  { cont1 = 0; output_toggle(pin_B0) ; } 

   if(++cont2 >= 1927) {cont2 = 0;output_toggle(pin_B1); }

   if(++cont3 >= 822) {cont3 = 0; output_toggle(pin_B2); }

}

void main(){

   setup_adc_ports(NO_ANALOGS);

   setup_adc(ADC_OFF);

   setup_psp(PSP_DISABLED);

   setup_spi(SPI_SS_DISABLED);

   setup_timer_0(RTCC_INTERNAL | RTCC_DIV_1); // overflow 51,2 us

   setup_timer_1(T1_DISABLED);

   setup_timer_2(T2_DISABLED,0,1);

   setup_comparator(NC_NC_NC_NC);

   setup_vref(FALSE);

   enable_interrupts(INT_TIMER0);

   enable_interrupts(GLOBAL);

   //disable_interrupts(GLOBAL);

   

   while(true);

}

Saída de frequencímetro no Proteus 7.9

Interrupção no pino B com PIC 16F877A

Código feito em CCS C Compiler

#include <16F877A.h>

#use delay(clock = 20M)

byte i;

#INT_RB

void rb_isr(void){

   i = input_b();

   output_d(i >> 4);

}

void main(){ 

   set_tris_b(0xff);

   clear_interrupt(INT_RB);

   enable_interrupts(INT_RB);

   enable_interrupts(GLOBAL);

}

Créditos para: http://ccspicc.blogspot.com/2016/03/pic16f877a-portb-change-interrupt.html

Decodificador display multiplexado com PIC 16F877A

Objetivo: Receber as entradas nos pinos e decodifica -lás no display 7 segmentos (interface do LCD é importante).

Código feito em CCS C Compiler

#include <16F877A.h>

#device adc = 8

#fuses XT, NOWDT, BROWNOUT, NOLVP

#use delay(clock = 20MHz)

#include <math.h>

#use fast_io(b)

#include <lcd.c>

int v1[] = {0b00111111, 0b00000110, 0b01011011,

   0b01001111, 0b01100110, 0b01101101, 0b01111101, 

   0b00000111, 0b01111111, 0b11100111};

   

unsigned int8 a, b, c, d, e, f;   

byte decimal;

unsigned int8 aux, dezena, unidade;

void main(void){

   lcd_init();

   

   while(TRUE){

      

      a = input(PIN_B0);

      b = input(PIN_B1);

      c = input(PIN_B2);

      d = input(PIN_B3);

      e = input(PIN_B4);

      f = input(PIN_B5);

      decimal = (a<<5)|(b<<4)|(c<<3)|(d<<2)|(e<<1)|(f<<0);

      

      aux = decimal/10;           

      dezena = (int)floor(aux);

      

      aux = (decimal)-(10*dezena);

      unidade = (int)floor(aux);

            

      printf(lcd_putc,"\fBINARIO = %u%u%u%u%u%u \nDECIMAL = %u"a, b, c, d, e, f, decimal);

      delay_ms(100);

      

      for(int i = 0; i < 10; i++){

         output_a(0b0000010);

         output_c(v1[dezena]);

         delay_ms(50);

         

         output_a(0b000001);

         output_c(v1[unidade]);

         delay_ms(50);

      }

   }

}

Decodificador BCD com PIC 16F877A

Objetivo: Receber através de entrada por bits que codifique sua saída para um display de 7 segmentos e exiba seu bit em binário.

CÓDIGO FEITO EM CCS C COMPILER

#include <16F877A.h>

#device adc = 8

#use delay(clock = 20MHz)

#use fast_io(b)

#include <lcd.c>

unsigned int8 a, b, c, d;   

byte decimal;

void main(void){

   lcd_init();

   

   while(TRUE){

      

      a = input(PIN_B0);     

      b = input(PIN_B1);

      c = input(PIN_B2);

      d = input(PIN_B3);

                                    

      decimal = (a<<3)|(b<<2)|(c<<1)|(d<<0);

            

      output_c(decimal);

            

      printf(lcd_putc,"\fBINARIO = %u%u%u%u  \nDECIMAL = %u"a, b, c, d, decimal);

      delay_ms(200);

            

   }

}

Saída gerada no Proteus 7.9

Pull-up para interrupção na saída - PIC 16F877A

 Objetivo: Os terminais RB1 são configurados como saída e RBO como entrada. (com resistor de pull-up). A saída deve ter o mesmo valor que a entrada. Usa -se um interruptor na entrada e um led na saída

Código feito em CCS C Compiler

#include <16F877A.h>
#fuses XT, NOWDT
#use delay (clock = 4MHz)
#BYTE TRISB = 0x86   //TRISB em 86h
#BYTE PORTB = 0x06   //PORTB em 06h
#BYTE OPTION_REG = 0x81    //em 81h

void main(){
   bit_clear(OPTION_REG, 7);  //habilita Pull-up
   bit_set(TRISB, 0);         //B0 como entrada
   bit_clear(TRISB, 1);       //B1 como saída
   bit_clear(PORTB, 1);       //Apaga led
   
   while(TRUE){
      if(bit_test(portb, 0)== 1)    //se RB0 == 1, apaga led
         bit_clear(portb, 1);
      else
         bit_set(portb, 1);         //se RB0 == 0, acende led
   }
}
/*
CÓDIGO REESCRITO 
#include <16F877A.h>
#fuses XT, NOWDT
#use delay (clock = 4MHz)
#use fixed_io(b_outputs = pin_b1)
void main(){
   port_b_pullups(TRUE);
   output_low(PIN_B1);
   
   while (TRUE){
      if(input(PIN_B0) == 1)
         output_low(PIN_B1);
      else
         output_high(PIN_B1);
   }
}
#include <16F877A.h>
#fuses XT, NOWDT
#use delay (clock = 4MHz)
//ponteiros
#define TRISB (int*) 0x86
#define PORTB (int*) 0x06
#define OPTION (int*) 0x81
void main() {
   *option &= 0b01111111;
   *trisb = 0x01;
   *portb = 0x00;
   
   while(TRUE){
      if(*portb & 0x01)    //le RB0 se é 1
         *portb = 0x00;
      else
         *portb = 0x02;    // se é 0 entao acende led (RB1 == 1)
   }
}*/

Pulso com PIC 16F877A

Ciclo de trabalho para PWM:

set_pwmx_duty(valor);

valor: dados de 8 ou 16 bits que determinam o ciclo de trabalho. Esse valor, juntamente com o valor do TMR2 preescaler, determina o valor do ciclo de trabalho. Na configuração T1MER2, o pós-aquecimento deve ser 1.

Exemplo 1: Meça a largura de um pulso usando o módulo CCP. Componentes ISIS: Utiliza-se o modo de captura do CCP, configurando-o para detectar a borda de subida ou descida do pulso a ser medido. 

Toda vez que ocorre uma detecção de borda, o valor de TMRl irá para o registro do módulo CCP.

CÓDIGO FEITO EM CCS C Compiler

#include <16F877A.h>

#fuses XT, NOWDT

#use delay(clock = 4MHz)

#ifndef lcd_enable

   #define lcd_enable   pin_E1 // pino enable do LCD

   #define lcd_rs       pin_E2 // pino rs do LCD

   //#define lcd_rw       pin_e2 // pino rw do LCD

   #define lcd_d4       pin_D4 // pino de dados d4 do LCD

   #define lcd_d5       pin_D5 // pino de dados d5 do LCD

   #define lcd_d6       pin_D6 // pino de dados d6 do LCD

   #define lcd_d7       pin_D7 // pino de dados d7 do LCD

#endif

#include <mod_lcd.c>

#byte PIR1 = 0x0C

int1 nuevopulso = 0;

int16 TFB = 0, TFS = 0, TF = 0;

float AP = 0.0, frequencia;

int1 cambio = 0;

#int_ccp1

void ccp1_int(){

   if(cambio == 0){

      TFS = CCP_1;

      setup_ccp1(CCP_CAPTURE_RE);

      cambio = 1;

   }else{

      TFB = CCP_1;

      setup_ccp1(CCP_CAPTURE_RE);

      cambio = 0;

      

      if(nuevopulso == 0){

         nuevopulso = 1;

      }

   }

}

void main(){

   lcd_ini();

   

   setup_timer_1(T1_INTERNAL);

   setup_ccp1(CCP_CAPTURE_RE);

   cambio = 0;

   enable_interrupts(int_ccp1);

   enable_interrupts(global);

   

   while(TRUE){

      if(nuevopulso >= 1){

         TF = (TFB - TFS);

         AP = TF * 1.0 / 1000.0;

         frequencia = 1.0 / (AP/1000.0);

         printf(lcd_escreve,"\f Pulso = %f ms\n Freq = %01.2f Hz",AP, frequencia);

         nuevopulso = 0;

         //delay_ms(100);

      }

   }

}

Saída de frequência usando CI 555

Observação: O oscilador astável com CI 555 não é preciso, logo haverá inconsistência nos resultados.

Logo, usando um outro exemplo com clock fixo verá que a precisão é siguinificativa.

Status de porta com PIC 16F877A

Objetivo: Visualizar em um LCD o status das entradas PORTA . Temos os componentes ISIS: PIC16F877A, RESPACK8, LG M I264IBSIR e SW-SPST-M OM

#include <16F877A.h>

#fuses HS, NOWDT, NOPROTECT, NOLVP

#use delay(clock = 20MHz)

#include <HDM64GS12.c>

#include <graphics.c>

#use standard_io(a)

void main(){

   CHAR A5[] = "A5";

   CHAR A4[] = "A4";

   CHAR A3[] = "A3";

   CHAR A2[] = "A2";

   CHAR A1[] = "A1";

   CHAR A0[] = "A0";

   CHAR IN[] = "PORTA A";

   glcd_init(ON);

   glcd_text57(33, 30, A5, 1, 1);

   glcd_text57(49, 30, A4, 1, 1);

   glcd_text57(65, 30, A3, 1, 1);

   glcd_text57(81, 30, A2, 1, 1);

   glcd_text57(97, 30, A1, 1, 1);

   glcd_text57(113, 30, A0, 1, 1);

   glcd_text57(30, 5, IN, 2, 1);

   

   while(TRUE){

      if (input_state(PIN_A5) == 0){

         glcd_rect(32, 40, 46, 60, 1, 1);

      }else{

         glcd_rect(32, 40, 46, 60, 1, 0);

         glcd_rect(32, 40, 46, 60, 0, 1);

      }

      

      if (input_state(PIN_A4) == false){

         glcd_rect(48, 40, 62, 60, 1, 1);

      }else{

         glcd_rect(48, 40, 62, 60, 1, 0);

         glcd_rect(48, 40, 62, 60, 0, 1);

      }

      

      if (input_state(PIN_A3) == false){

         glcd_rect(64, 40, 78, 60, 1, 1);

      }else{

         glcd_rect(64, 40, 78, 60, 1, 0);

         glcd_rect(64, 40, 78, 60, 0, 1);

      }

      

      if (input_state(PIN_A2) == false){

         glcd_rect(80, 40, 94, 60, 1, 1);

      }else{

         glcd_rect(80, 40, 94, 60, 1, 0);

         glcd_rect(80, 40, 94, 60, 0, 1);

      }

      

      if (input_state(PIN_A1) == false){

         glcd_rect(96, 40, 110, 60, 1, 1);

      }else{

         glcd_rect(96, 40, 110, 60, 1, 0);

         glcd_rect(96, 40, 110, 60, 0, 1);

      }

      

      if (input_state(PIN_A0) == false){

         glcd_rect(112, 40, 126, 60, 1, 1);

      }else{

         glcd_rect(112, 40, 126, 60, 1, 0);

         glcd_rect(112, 40, 126, 60, 0, 1);

      }

      

      delay_ms(400);

   }

}

Contador multiplexado com PIC 16F876

Código feito no CCS C Compiler

//PÁGINA 63

#include <16F876.h>

#USE DELAY(CLOCK = 4MHz)

#FUSES XT, NOWDT, NOPROTECT, NOPUT

#USE fast_IO (B)

#USE fast_IO (A)

byte CONST DISPLAY[10] = {0x3f, 0x06, 0x5b, 0x4f, 0x66, 

         0x6d, 0x7d, 0x07, 0x7f, 0x6f};

         

void main(){

   byte ud = 0, dec = 0;

   SET_TRIS_B(0x00);

   SET_TRIS_A(0x00);

   OUTPUT_B(0);

   

   for( ;; ){

      for(dec = 0; dec < 10; dec++){

         for(ud = 0; ud < 10; ud++){

            output_a(0x02);

            output_b(DISPLAY[ud]);

            delay_ms(50);

            

            if (dec == 0) output_a(0x03);

            else output_a(0x01);

                                    //cat_D_ = acender

            OUTPUT_B(DISPLAY[dec]);//digito dezenas

            delay_ms(50);     //para evitar paralelos

         }

      }

   }

}