OHMETRO EN LCD

Este programa puede mostrar el efecto de un carácter comiéndose letras de un nombre y después regresarlas, además de que se pudiera visualizar caracteres inventados, con la ayuda de la matriz de 5x8 que tienen los LCD.

Además de que en la segunda línea se puede ver la medición de valores de resistencia mediante un óhmetro, el cual tiene entrada en el canal AN0. El valor de la resistencia se verá variado mediante un potenciómetro de 10 kΩ.
  • Código:
#include <clase7.h>
#define LCD_ENABLE_PIN PIN_D0
#define LCD_RS_PIN PIN_D1
#define LCD_RW_PIN PIN_D2
#define LCD_DATA4 PIN_D4
#define LCD_DATA5 PIN_D5
#define LCD_DATA6 PIN_D6
#define LCD_DATA7 PIN_D7
#include <lcd.c>
//int flecha[8]={0x04,0x0E,0x1F,0x04,0x04,0x04,0x04,00}; //posiciones en matriz de 5x8
int ch[8]={0b01110,27,28,25,31,14,0};
int ch1[8]={14,27,31,30,31,31,14,0};
int mickey[8]={0b11011,0b11011,0b01110,0b01110,00,00,00,00};
int pacmane[8]={0b01110,0b11011,0b01111,31,31,0b01110,00};
int pacmanr[8]={0b01110,0b11011,0b00111,0b10011,31,0b01110,00};
int music[8]={00,0b01111,0b01001,0b01001,0b11011,0b11011,00};
int i,j;
char nombre[16]="  Susana Lopez  ";
void main()
{
   lcd_init();
   //lcd_set_cgram_char(0,flecha);  //(w,p) w=posicion de RAM, p=nomre de dato
   lcd_set_cgram_char(0,ch);
   lcd_set_cgram_char(1,ch1);
   lcd_set_cgram_char(2,mickey);
   lcd_set_cgram_char(3,pacmane);
   lcd_set_cgram_char(4,pacmanr);
   lcd_set_cgram_char(5,music);
   lcd_gotoxy(3,1);
   lcd_putc("Susana Lopez");
   delay_ms(1000);
   //lcd_putc(0); //imprimira flecha 
   //ciclo de un pacman comiendose las letras
   for(i=1;i<=16;i++)
     {
        lcd_gotoxy(i,1);
        lcd_putc(0);
        delay_ms(200);
        lcd_gotoxy(i,1);
        lcd_putc(1);
        delay_ms(200);
        lcd_gotoxy(i,1);
        lcd_putc(' ');
     }
  
   for(j=16;j>=2;j--)
   {
      lcd_gotoxy(j,1);
      lcd_putc(4);
      printf(lcd_putc,("%c"),nombre[j]);
      delay_ms(200);
      lcd_gotoxy(j,1);
      lcd_putc(3);
      delay_ms(200);
      lcd_gotoxy(j,1);
      lcd_putc(' ');
   }
  
   lcd_gotoxy(1,1);
   lcd_putc(2);
   lcd_gotoxy(16,1);
   lcd_putc(5);
  
}

  • Simulación en Proteus:

  • Armado y ejecución:


en No hay comentarios:

ADC, PWM con AC en LCD

Este programa puede además de medir el voltaje de corriente alterna, puede variar el PWM generado por el PIC, el cual se puede ver su variación mediante el uso del osciloscopio.
Para poder medir la corriente alterna sin que se queme el PIC se emplea un circuito externo, para que pueda rectificar la corriente y poder bajarla a 5 volts, mediante un divisor de voltaje. Para el uso del PWM, el cual lo que hace es generar una señal cuadrada, la cual se puede variar para dejar en ciertos tiempos los ciclos de trabajo, ya sea en ON o en OFF.

  • Código:
#include <clase6.h>
#define LCD_ENABLE_PIN PIN_D0
#define LCD_RS_PIN PIN_D1
#define LCD_RW_PIN PIN_D2
#define LCD_DATA4 PIN_D4
#define LCD_DATA5 PIN_D5
#define LCD_DATA6 PIN_D6
#define LCD_DATA7 PIN_D7
#include <lcd.c>
#include <math.h>
float valor,max2,max=0,vol=0; 
float valorp,valorpw;
int i;
void main()
{
   setup_adc_ports(AN0_TO_AN1);
   setup_adc(ADC_CLOCK_INTERNAL|ADC_TAD_MUL_0);
   setup_timer_1(T1_INTERNAL|T1_DIV_BY_1);      //32.7 ms overflow
   setup_timer_2(T2_DIV_BY_16,249,1);      //2.0 ms overflow, 2.0 ms interrupt, frec. 500Hz
   setup_ccp1(CCP_PWM|CCP_SHUTDOWN_AC_L|CCP_SHUTDOWN_BD_L);
   //pulse width modulation, envia información de manera analogica
   set_pwm1_duty((int16)498); //configura el pwm, puede ser de 10bits (0-1023), en este caso hara de (0-996)
 
   lcd_init();
   lcd_gotoxy(13,1);
   lcd_putc('M');
   lcd_putc('S');
   lcd_putc('L');
   lcd_putc('A');
   while(TRUE)
   {
      set_adc_channel(0);
      delay_us(10);
                  
     //visualizacion del voltaje AC
     for (i=0;i<50;i++)
     {
       valor=read_adc();
       vol+=valor;
       delay_ms(20);
     }

      vol=vol/50; //para conversion VCA
      lcd_gotoxy(1,1);
      max2=(20*vol)/1023 ;
      printf(LCD_PUTC, "volts=%0.2g", max2); //voltaje
   
      lcd_gotoxy(1,2);
      set_adc_channel(1);
      delay_us(10);
   
    //visualizacion % del pwm
    for (i=0;i<50;i++)
     {
      valorpw=read_adc();
      //if(valorpw>max)
       max+=valorpw;
         delay_ms(20);
     }
          
      max=max/10; //para calculos del PWM
      valorp=((996*max)/1023);
    
      //printf(LCD_PUTC, "VAC=%0.3g ",max/10);
     
     
      set_pwm1_duty((int16)valorpw);
     
      printf(LCD_PUTC, "%%PWM=%0.2g",(valorp/50)-10.67); //PWM
      lcd_gotoxy(10,2);
     
      //printf(LCD_PUTC, "VA=%0.2g",max2); //Volt AC
      //max=0;
   
   }
}

  • Simulación en Proteus:


  • Armado y ejecución:


en No hay comentarios:

ADC y LCD en ‘C’



Este programa puede mostrar en un display LCD el valor del voltaje medido mediante el periférico ADC que tiene el PIC18F4550.
  • Código:
#include <clase5.h>
//incluye los pines del LCD
#define LCD_ENABLE_PIN PIN_D0
#define LCD_RS_PIN PIN_D1
#define LCD_RW_PIN PIN_D2
#define LCD_DATA4 PIN_D4
#define LCD_DATA5 PIN_D5
#define LCD_DATA6 PIN_D6
#define LCD_DATA7 PIN_D7
#include <lcd.c>  //incializa el LCD, ver arcvhi lcd.c para comandos para usar LCD
float valor;  //ocupa 2 byte
float valorn;
void main()
{
   setup_adc_ports(AN0);
   setup_adc(ADC_CLOCK_INTERNAL|ADC_TAD_MUL_0);
   lcd_init(); //iniciar lcd
   //los comandos ya hacen los tiempos por la funcion
   lcd_gotoxy(7,1); //cursor se posiciona en col 5 linea 1
   lcd_putc('M'); //envia caracter M al LCD
   lcd_putc('S');
   lcd_putc('L');
   lcd_putc('A');
  
   //lcd_set_cgram_char(0,mi);   comando para caracter
   while(TRUE)
   {
      valor=read_adc(); //lectura al adc, lectura canal 0, valores del 000 al 3FF
      //buscar en built in fuctions printf
      //para mostrar un valor con formato en especifico
      valorn=((5*valor)/1023);
      lcd_gotoxy(3,2);
      //ejemplo para que ponga: valor=0033
      printf(LCD_PUTC, "volts=%0.3g", valorn); //mostrara el valor con 4 cifras en hexadecial 
      //lcd_gotoxy(1,1);
      //printf(lcd_putc,"%c",0);    instrucciones para imprimir caracter
      //delay_ms(5000);
     
   }
}

  • Simulación en proteus:

  • Armado y ejecución:


en No hay comentarios:

DISPLAY LCD


Este programa que pueda mostrar un mensaje en un display LCD. Para poder usar el LCD fue necesario realizar unas configuraciones para poder empezar a mandar mensajes a éste para y para que se pudieran visualizar.

Las configuraciones necesarias de tiempos y de valores iniciales se pueden encontrar en el datasheet del LCD. Por medio de funciones se puede programar fácilmente los tiempos, además de que el mensaje o las letras que se quieran mandar al LCD no tienen por qué ponerse en su valor hexadecimal, simplemente se pone entre comillas simple.
  • Código:
#include <clase4.h>
//procedimiento de flanco de bajada
#include <lcd.c>
int mi[8]={
               0b11011,
               0b11011,
               0b01110,
               0b01110,
               0b00100,
               0b01110,
               0b01110,
               0b00000
           };
void main()
{
   lcd_init();
  
  
   lcd_set_cgram_char(0, mi);
   lcd_set_cgram_char(1, mi);
   lcd_set_cgram_char(2, mi);
   lcd_set_cgram_char(3, mi);
   lcd_set_cgram_char(4, mi);
   lcd_set_cgram_char(5, mi);
   lcd_set_cgram_char(6, mi);
   lcd_set_cgram_char(7, mi);
   lcd_set_cgram_char(8, mi);
   lcd_gotoxy(2,1);
   lcd_putc("m");
  
   while(TRUE)
   {
      lcd_gotoxy(2,1);
     
     
    lcd_putc("m");
      //las letras van a parpadear
     // output_bit(PIN_C0, 0); //RS=0  write command
      //output_D(0x08);    
      //pulso();
      //delay_ms(300);
      //output_D(0x0C);     
      //pulso();
      //delay_ms(300);
     
   }
}

  • Simulación en Proteus:

  • Armado y ejecución:


en No hay comentarios:

CONVERTIDOR ANALOG-DIGITAL (EN LENGUAJE ENSAMBLADOR)



Es un programa que por medio de los pines A/D (análogo digital) se pueda leer señales analógicas y poder mostrarlas en forma digital (por medio de los displays).

Todo esto mediante el uso del módulo conversor de analógico a digital (A/D), el cual tiene 13 entradas en los PIC de 40/44 pines. Este módulo permite la conversión de una señal de entrada analógica a un número digital de 10 bits.
  • Código:
#include <clase3.h>
#define Dir_C 0xF94
#define Dir_D 0xF95
#define Puerto_C 0xF82
#define Puerto_D 0xF83
#define T0CON 0xFD5     //REGISTRO DE CONTROL DEL TIMER
#define TMR0 0xFD6      //REGISTRO DE CONTROL DEL TMR0
#define PRODL 0xFF3     //REGISTRO DEL MULTIPLICADOR
#define PCL 0xFF9     //REGISTRO BAJO DEL CONTADOR DE PROGRAMA
#define ADCON2 0xFC0 
#define ADCON1 0xFC1    //REGISTROS del ADC
#define ADCON0 0xFC2
#define ADRESH 0xFC4
int temp;
void main()
{
#asm
   inicio:
            movlw    0x00
            movwf    Dir_C    //configurado como salida
            movlw    0x00
            movwf    Dir_D    //configurado como salida
            movlw    0x01
            movwf    ADCON0  //ADCON0 <- 01 se activa el ADC
            movlw    0x0E  
            movwf    ADCON1  //ADCON1 <- 01 se configura AN0 como analogica
            movlw    0x07
            movwf    ADCON2  //justificación (izquierda o derecha) y reloj
                   
   
      ciclo:
         ADC:
            bsf      ADCON0, 1  //GO=1
            btfsc    ADCON0, 1   //hace la pregunta de si ADCON0 es un 1, si es uno se brinca la linea
            bra      ADC
    
            bsf      Puerto_C, 1
            movf     ADRESH, 0
            andlw    0x0F 
            call     display
            movwf    Puerto_D
            bcf      Puerto_C, 0
            call     tiempo
            swapf    ADRESH, 0  
            andlw    0x0F
            call     display
            bsf      Puerto_C,0
            movwf    Puerto_D
            bcf      Puerto_C, 1
            call     tiempo
            bra      ciclo   
  
   display:
            mullw    0x02    
            movf     PRODL,0 
            addwf    PCL     
            retlw    0x40  //CERO
            retlw    0x79  //UNO
            retlw    0x24  //DOS
            retlw    0x30  //TRES
            retlw    0x19  //CUATRO
            retlw    0x12  //CINCO
            retlw    0x02  //SEIS
            retlw    0x78  //SIETE
            retlw    0x00  //OCHO
            retlw    0x18  //NUEVE
            retlw    0x08  // A
            retlw    0x03  // B
            retlw    0x46  // C
            retlw    0x21  // D
            retlw    0x06  // E
            retlw    0x0E  // F     
           
   tiempo:
            decfsz   temp
            bra      tiempo
            retlw    0
  #endasm
}

  • Simulación en Proteus:

  • Armado y ejecución:

en No hay comentarios:

CONTADOR (EN LENGUAJE ENSAMBLADOR)

El programa es capaz de contar los pulsos que le lleguen al pin 6 (donde se encuentra el timer0 external clock input).  Además de que se pueda visualizar el conteo por medio de dos displays, los cuales se verá el conteo desde 00 hasta FF.
  • Código:
#include <clase2.h>
#define Dir_C 0xF94
#define Dir_D 0xF95
#define Puerto_C 0xF82
#define Puerto_D 0xF83
#define T0CON 0xFD5     //REGISTRO DE CONTROL DEL TIMER  para configurar timer0
#define TMR0 0xFD6      //REGISTRO DE CONTROL DEL TMR0 
#define PRODL 0xFF3     //REGISTRO DEL MULTIPLICADOR
#define PCL 0xFF9     //REGISTRO BAJO DEL CONTADOR DE PROGRAMA
int temp;
void main()
{
#asm
   inicio:
         movlw    0x00 //a {w}<-0
         movwf    Dir_C //(TRISC)<-{w} configuramos como salida
         movlw    0x00 //dato
         movwf    Dir_D // (TRISD)<-{w} conf como salida
         //para config el timer0 CON ver pag. 127 del manual = E8
         movlw    0xE8
         movwf    T0CON //conf timer0 como contador de 8 bits
        
   ciclo:
            //para utilidad de ejemplo se quiere mostrar la explicacion para que los 2 displays muestren A5
            //el timer en RA4 se le dran pulsos y contara de 00 a FF
            //se debe partir en 2
            bsf      Puerto_C, 1 //bit set file RC1=1, pone a ese pin en 1, despues de la coma va el # de pin
           //display con 02 en hex = 6 decimal
           // movlw    0x02
            //movwf    Puerto_D
            //bcf      Puerto_C, 0 //bit clear file RC0=0, pone a ese pin en 0
            //call     tiempo
            //1° display con 24 en hex = 2 decimal
            //bsf      Puerto_C, 0
            movf     TMR0, 0 //W<- Timer00
            andlw    0x0F  //and    (multiplica para quitar la A y dejar el bit)  w <- w and 0xoF,
            //si queremos un A5, le quitara la A y dejara el 05  (A5*0F)=05
            call     display //llama a display (ver etiqueta de display
            //el puerto D manda dato al display y el puerto C manda voltaje para activar display
            movwf    Puerto_D // ahora vale w=12
            bcf      Puerto_C, 0 //activamos digito y muestra el 5
            call     tiempo
            swapf    TMR0,0   //intercambio, se tenia A5, con swapf da 5A
            andlw    0x0F  // queda 0A
            call     display
            bsf      Puerto_C,0
            movwf    Puerto_D
            bcf      Puerto_C, 1
            call     tiempo
            bra      ciclo   
  
   display:
            //se tiene primero 5
            //luego se tiene la A
            //recordar que el contador de programa va de 2 en 2
            mullw    0x02     //multiplica w por 2,  5*2= 0A
            movf     PRODL,0  //w= 0A el resultado de la multiplicacion se almacena en PRODL
            addwf    PCL      //el contador del programa tiene un num que es 4C
            // se suma lo de w + 4C + 2 = 4C + 0A + 2 = 58, se va al registro 58, en el cual esta retlw con el dato 0x12 = 5 en display
            retlw    0x40  //CERO
            retlw    0x79  //UNO
            retlw    0x24  //DOS
            retlw    0x30  //TRES
            retlw    0x19  //CUATRO
            retlw    0x12  //CINCO
            retlw    0x02  //SEIS
            retlw    0x78  //SIETE
            retlw    0x00  //OCHO
            retlw    0x18  //NUEVE
            retlw    0x08  // A
            retlw    0x03  // B
            retlw    0x46  // C
            retlw    0x21  // D
            retlw    0x06  // E
            retlw    0x0E  // F
           
           
   tiempo:
            decfsz   temp //decfsz ocupa de 2 ciclos
            bra      tiempo
            retlw    0
  #endasm
}

  • Simulación en proteus:

  • Armado y ejecución:

en No hay comentarios:

MANEJO DE PUERTOS (EN LENGUAJE ENSAMBLADOR)

En este programa se verá como con lenguaje ensamblador se puede hacer una secuencia con leds dependiendo de si se ingresa un 1 o un 0 en su entrada correspondiente del PIC. Además del uso de los puertos para ponerlos como entrada o como salida.
  • Código:
#include <clase1.h>
//declaramos tris B, D y puertos B y D
//definimos los SFR utilizados a variables
#define Dir_B 0xF93
#define Dir_D 0xF95
#define Puerto_B 0xF81
#define Puerto_D 0xF83
int temp; //variable temporal para tiempo
void main()
{
#asm //se pone porque escribimos en ensamblador
   inicio: //etiqueta
         movlw    0x00 //a {w}<-0
         movwf    Dir_B //(TRISB)<-{w} configuramos como salida
         movlw    0xFF //dato
         movwf    Dir_D // (TRISB)<-{w} conf como entrada
        
   ciclo: //etiqueta
         //bit test file skip if set (lo del if) va a saltar si NO cumple condicion, si no lee la sig linea
         //si es 1 salta la linea de bra ciclo1, sino la lee y se va a la etiqueta ciclo1
         btfss    Puerto_D,0 //rd0 =0?
         //cuando RD=1
      bra ciclo1 //salta a etiqueta de ciclo 1
            movlw    0
            movwf    Puerto_B
            call     tiempo
            movlw    0xFF              //mientras sea 1 hara este bloque de lineas
            movwf    Puerto_B
            call     tiempo
            bra      ciclo
        
      ciclo1:
            movlw    0xAA
            movwf    Puerto_B
            call     tiempo
            movlw    0x55
            movwf    Puerto_B
            call     tiempo
            bra      ciclo 
           
      tiempo: //funcion repetitiva de tiempo
            //checar los ciclos de maquina de los comandos 1 ciclo de maquina= (Frec de osc)/4
            //31kHz/4 = tardara 100ms
            decfsz   temp //decfsz ocupa de 2 ciclos
            bra      tiempo
         sub:  
            decfsz   temp //decfsz ocupa de 2 ciclos
            bra      sub
            retlw    0
  #endasm
}

  • Simulación en proteus:


  • Armado y ejecución:

en No hay comentarios:
Suscribirse a: Entradas (Atom)

Ultima entrada ingresada

SISTEMA DE RIEGO AUTOMÁTICO CON MÚSICA

El objetivo era hacer un programa que pueda activar una bomba de agua en la noche, y que por las mañanas reproduzca música para las plantas....