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. El depósito de agua debe tener un flotador eléctrico que mande señal de que no hay agua. Los mensajes deben verse en el LCD. Además, implementar una aplicación sencilla de labview.
Para más detalles puede consultar: https://www.dropbox.com/s/hjyeaymroexqjgf/Proyecto%20de%20Microcontroladores.zip?dl=0
  • Código:
#include <sistemaderiego.h>
#define LCD_ENABLE_PIN PIN_D3
#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
int i,flag, cont,dato[8],leds[8],tt=0,lola=1;
int music[8]={00,0b01111,0b01001,0b01001,0b11011,0b11011,00};
float valor,valorn;
#include <lcd.c>
#define nDO     0    // DO
#define nDO_    1    // DO#
#define nRE     2    // RE
#define nRE_    3    // RE#
#define nMI     4    // MI
#define nFA     5    // FA
#define nFA_    6    // FA#
#define nSOL    7    // SOL
#define nSOL_   8    // SOL#
#define nLA     9    // LA
#define nLA_    10   // LA#
#define nSI     11   // SI
#define Speaker   PIN_B2      // Altavoz conectado a RB2
#define valvula   PIN_C0     //activo bomba
int16 FreqNota[12]={// retardos entre estado alto y bajo para generar las notas                        
15289, // DO
14430, // DO#
13620, // RE
12856, // RE#
12134, // MI
11453, // FA
10810, // FA#
10204, // SOL
9631,  // SOL#
9090,  // LA
8580,  // LA#
8099   // SI
};
//-------------------------------------------------Función de audio
void Play(int nota, int octava, int16 duracion){
 int16 fn;
 int16 mS_Transcurridos=0;  // Contadores necesarios
                            // para controlar la duración
 int16 CiclosL=0;           // Contandor de uS
 fn=FreqNota[nota];         // Define los retardos para generar
                            // la frecuencia de cada nota
 fn>>=(octava);             // Adapta la frecuencia a la octava actual
                            // haciendo una rotación
                            // a la derecha por octava
do{
    output_high(Speaker);   // Genera la frecuencia
    delay_us(fn);           // con los retardos mientras
    CiclosL+=(fn);          // aumenta el contador de
                            // ciclos transcurridos
    output_low(Speaker);    // en dos partes para repartir el
    delay_us(fn);           // trabajo entre estado alto y bajo.
    CiclosL+=(fn);          //
    CiclosL+=25;            // Compensador.
    while(CiclosL>999){     // Se queda en el bucle mientras CiclosL
                            // sea menor a 1000 (1 mS)
       CiclosL-=1000;       // Le resta 1000 a CiclosL
       mS_Transcurridos++;  // y le suma 1 a mS_Transcurridos.
       CiclosL+=25;         // Compensador.
    }
 }while (duracion>mS_Transcurridos); // Repite el bucle hasta que haya
                                     // pasado el tiempo indicado.
}
void playcancion(){  //city of stars
        for(i=0;i<2;i++){
        play (nSOL   ,4,250);
        play (nLA   ,4,250);
        play (nSI   ,4,250);
        play (nRE   ,5,1250);
        delay_ms(125);
        play (nRE   ,5,125);
        play (nMI   ,5,250);
        play (nFA   ,5,250);
        play (nRE   ,5,250);
        play (nMI   ,5,250);
        play (nDO   ,5,250);
        play (nRE   ,5,250);
        play (nLA   ,4,1300);
        delay_ms(250);}
        delay_ms(250);
        play (nLA   ,4,500);
        play (nSI   ,4,1000);
        delay_ms(250);
        play (nRE   ,5,125);
        play (nDO   ,5,250);
        play (nRE   ,5,250);
        play (nDO   ,5,250);
        play (nRE   ,5,250);
        play (nDO   ,5,250);
        play (nRE   ,5,250);
        play (nLA   ,4,750);
        play (nLA   ,4,125);
        play (nLA   ,4,125);
        play (nLA   ,4,500);
        play (nLA   ,4,750);
        delay_ms(250);
        play (nSOL   ,5,500);
        play (nSOL   ,5,1000);
        play (nRE   ,5,1000);
        play (nMI   ,5,1300);
        delay_ms(250);
        play (nDO   ,5,125);
        play (nRE   ,5,250);
        play (nSOL   ,5,250);
        play (nFA   ,5,500);
        play (nMI   ,5,500);
        play (nRE   ,5,1000);}
void playcancion2(){  //yesterday
        play (nSOL   ,4,250);
        play (nFA   ,4,250);
        play (nFA   ,4,1200);
        delay_ms(250);
        play (nLA   ,4,250);
        play (nSI   ,4,250);
        play (nDO_   ,4,250);
        play (nRE   ,5,250);
        play (nMI   ,5,250);
        play (nFA   ,5,250);
        play (nMI   ,5,500);
        play (nRE   ,5,250);
        play (nRE   ,5,1200);
        delay_ms(250);
        for(i=1;i<2;i++){
        play (nRE   ,5,250);
        play (nRE   ,5,250);
        play (nDO   ,5,250);
        play (nSI   ,4,250);
        play (nLA   ,4,250);
        play (nSOL   ,4,250);
        play (nLA   ,4,500);
        play (nLA   ,4,250);
        play (nLA   ,4,250);
        play (nLA   ,4,750);
        play (nSOL   ,4,500);
        play (nFA   ,4,500);
        play (nLA   ,4,250);
        play (nSOL   ,4,750);
        delay_ms(250);
        play (nRE   ,4,125);
        play (nFA   ,4,500);
        play (nLA   ,4,250);
        play (nLA   ,4,250);
        play (nLA   ,4,750);
        delay_ms(250);
        play (nSOL   ,4,250);
        play (nFA   ,4,1400);
        delay_ms(250);
        play (nLA   ,4,250);
        play (nSI   ,4,250);
        play (nDO_   ,5,250);
        play (nRE   ,5,250);
        play (nMI   ,5,250);
        play (nFA   ,5,250);
        play (nMI   ,5,500);
        play (nRE   ,5,250);
        play (nRE   ,5,1250);
        delay_ms(250);}
        play (nLA   ,4,1000);
        play (nLA   ,4,1000);
        play (nRE   ,5,1000);
        play (nMI   ,5,1000);
        play (nFA   ,5,1000);
        play (nMI   ,5,250);
        play (nRE   ,5,250);
        play (nMI   ,5,1400);
        play (nRE   ,5,125);
        play (nDO   ,5,500);
        play (nRE   ,5,1000);
        play (nLA   ,4,1400);
        delay_ms(250);
        play (nLA   ,4,1000);
        play (nLA   ,4,1000);
        play (nRE   ,5,500);
        play (nMI   ,5,500);
        play (nFA   ,5,500);
        play (nMI   ,5,250);
        play (nRE   ,5,250);
        play (nMI   ,5,750);
        play (nRE   ,5,125);
        play (nDO   ,5,500);
        play (nRE   ,5,500);
        play (nLA   ,4,1400);
        play (nLA   ,4,250);
        play (nSI   ,4,250);
        play (nDO   ,5,250);
        play (nRE   ,5,250);
        play (nMI   ,5,250);
        play (nFA   ,5,250);
        play (nMI   ,5,200);
        play (nRE   ,5,250);
        play (nRE   ,5,750);
        play (nRE   ,5,750);
        delay_ms(250);
        play (nRE   ,5,250);
        play (nRE   ,5,250);
        play (nDO   ,5,250);
        play (nSI   ,4,250);
        play (nLA   ,4,250);
        play (nSOL   ,4,250);
        play (nSI   ,4,500);
        play (nLA   ,4,250);
        play (nLA   ,4,700);
        play (nSOL   ,4,500);
        play (nFA   ,4,500);
        play (nLA   ,4,250);
        play (nSOL   ,4,800);
        play (nRE   ,4,500);
        play (nFA   ,4,500);
        play (nLA   ,4,250);
        play (nLA   ,4,700);
        delay_ms(250);
        play (nFA   ,4,500);
        play (nLA   ,4,500);
        play (nSOL   ,4,500);
        play (nRE   ,4,500);
        play (nFA   ,4,500);
        play (nLA   ,4,500);
        play (nLA   ,4,1400);}
void playcancion3(){ //Himno de la alegria
   play (nSI   ,5,500);
   play (nDO_   ,6,250);
   play (nRE_   ,6,250);
   play (nRE_   ,6,250);
   play (nDO_   ,6,250);
   play (nSI   ,5,250);
   play (nLA_   ,5,250);
   play (nSOL_   ,5,250);
   play (nSOL_   ,5,250);
   play (nLA_   ,5,250);
   play (nSI   ,5,250);
   play (nSI   ,5,400);
   play (nLA_   ,5,125);
   play (nLA_   ,5,500);
   play (nSI   ,5,500);
   play (nDO_   ,6,250);
   play (nRE_   ,6,250);
   play (nRE_   ,6,250);
   play (nDO_   ,6,250);
   play (nSI   ,5,250);
   play (nLA_   ,5,250);
   play (nSOL_   ,5,250);
   play (nSOL_   ,5,250);
   play (nLA_   ,5,250);
   play (nSI   ,5,250);
   play (nLA_   ,5,400);
   play (nSOL_   ,5,125);
   play (nSOL_   ,5,500);
   play (nLA_   ,5,500);
   play (nSI   ,5,250);
   play (nSOL_   ,5,250); 
   play (nLA_   ,5,250);
   play (nSI   ,5,125);
   play (nDO_   ,6,125);
   play (nSI   ,5,125);
   play (nSOL_   ,5,250);
   play (nLA_   ,5,250);
   play (nSI   ,5,125);
   play (nDO_   ,6,125);
   play (nSI   ,5,125);
   play (nLA_   ,5,250);
   play (nSOL_   ,5,250);
   play (nLA_   ,5,250);
   play (nRE_   ,5,500);
   play (nSI   ,5,500);
   play (nDO_   ,6,250);
   play (nRE_   ,6,250);
   play (nRE_   ,6,250);
   play (nDO_   ,6,250);
   play (nSI   ,5,250);
   play (nLA_   ,5,250);
   play (nSOL_   ,5,250);
   play (nSOL_   ,5,250);
   play (nLA_   ,5,250);
   play (nSI   ,5,250);
   play (nLA_   ,5,400);
   play (nSOL_   ,5,125);
   play (nSOL_   ,5,250);
}
//----------------------------------------------FUNCION PRINCIPAL
void main()
{
   setup_adc_ports(AN0_TO_AN1);
   setup_adc(ADC_CLOCK_INTERNAL|ADC_TAD_MUL_0);
   lcd_init();
   lcd_set_cgram_char(1,music);
  
   //-----------------------------------------------------------------------------------CONTORL USB
   /*usb_init();
   usb_wait_for_enumeration();//espera a que la pc enumere al pic (asigna posicion */
  
   lcd_gotoxy(1,1);
   lcd_putc("Hola, se activo");
   lcd_gotoxy(1,2);
   lcd_putc("control nocturno");
   delay_ms(3000);
   lcd_putc("\f");
   flag=1;
   cont=10;
       
   //-----------------------CONTROL NOCTURNO verificando si es noche o dia
   while(TRUE)
   {      
    //--------------------------------------------PARA USAR USB LABVIEW
    /*usb_task();
         
   while(input(PIN_B4) && lola==1){
      lcd_putc("\f");
      lcd_gotoxy(5,1);
      lcd_putc("Labview");
      lcd_gotoxy(5,2);
      lcd_putc("activado");
      if (usb_kbhit(1))//siempre va a ser 1 por que es un solo pic el end point verifica el canal
       {
      usb_get_packet(1, dato,8);
      dato[0]=dato[0]-0x30;
      output_c(dato[0]);
      }
      leds[0]=read_adc();
      leds[1]=pin_C0;
      leds[2]=pin_B1;
      usb_put_packet(1, leds, 3, USB_DTS_TOGGLE);
      delay_ms(20);
     
      if(!input(PIN_B4))
         lola=0;
   }*/
  
      //-----------------------------------------------------------------PARTE DE PROYECTO NORMAL
      do{
   valor=read_adc();
   valorn=((5*valor)/1023);
      
   if(valorn>3.5)
        cont=10;
  
   while(valorn>3.5 && input(PIN_B1) && tt==0){  //PIN_B1 Flotador   
      lcd_putc("\f");
      lcd_gotoxy(7,1);
      lcd_putc("Riego");
      lcd_gotoxy(5,2);
      lcd_putc("activado");
      delay_ms(2000);
      output_HIGH(valvula);  //--------------------Encender bomba       
      delay_ms(20);
      lcd_putc("\f");
      lcd_gotoxy(5,1);
      lcd_putc("Bomba ON");
      delay_ms(16000);
      lcd_putc("\f");
      lcd_gotoxy(5,1);
      output_LOW(valvula);
      lcd_putc("Bomba OFF");
      delay_ms(5000);
      tt=1;
      }
   
    while(!input(PIN_B1)){ 
      lcd_putc("\f");
      lcd_gotoxy(7,1);
      lcd_putc("Agua");
      lcd_gotoxy(5,2);
      lcd_putc("insuficiente"); 
      delay_ms(3000);
      cont==0;
      if(input(PIN_B1)){
      lcd_putc("\f");
      lcd_gotoxy(7,1);
      lcd_putc("Agua");
      lcd_gotoxy(5,2);
      lcd_putc("suficiente");
      delay_ms(2000);
      break;}
     
    }
   
    if(valorn<3.5){ //---------de dia poner canciones
      delay_ms(10);
      lcd_putc("\f");
      lcd_gotoxy(7,1);
      lcd_putc("Riego");
      lcd_gotoxy(4,2);
      lcd_putc("Desactivado");
      delay_ms(3000);
      output_LOW(valvula);
      flag=0;
      lcd_putc("\f");
      lcd_gotoxy(1,1);//---------City of stars
      lcd_putc("Reproduciendo...");
      lcd_gotoxy(1,2);  lcd_putc(1);
      lcd_gotoxy(3,2);
      lcd_putc("City of stars");
      lcd_gotoxy(16,2); lcd_putc(1);
      playcancion();
      delay_ms(3000);
      lcd_putc("\f");//---------Yesterday
      lcd_gotoxy(1,1);
      lcd_putc("Reproduciendo...");
      lcd_gotoxy(1,2);  lcd_putc(1);
      lcd_gotoxy(3,2);
      lcd_putc("Yesterday");
      lcd_gotoxy(13,2); lcd_putc(1);
      playcancion2();
      delay_ms(3000);
      lcd_putc("\f");//---------Himno de la alegria
      lcd_gotoxy(1,1);
      lcd_putc("Reproduciendo...");
      lcd_gotoxy(1,2); lcd_putc(1);
      lcd_gotoxy(2,2);
      lcd_putc("Himno alegria");
      lcd_gotoxy(16,2); lcd_putc(1);
      playcancion3();
      delay_ms(3000);}
   }while(flag=1);
 
   }
}
  • Visualización en Labview:



  • Simulación en Proteus:


  • Armado en físico:
en No hay comentarios:

MASTER Y ESCLAVO EN PIC

Este programa contiene el código del master y un esclavo. Se debe disponer de 2 PIC's, los cuales, están conectados a través del protocolo SPI y se enviarán valores del potenciómetro.
  • Código del Master:
#include <clase14.h>
//SPI MASTER
#use spi (MASTER, SPI1, MODE=0, BITS=8, STREAM=SPI_1)
#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 valor;
void main()
{
   setup_adc_ports(AN0);
   setup_adc(ADC_CLOCK_INTERNAL|ADC_TAD_MUL_0);
   lcd_init();
   lcd_gotoxy(1,1);
   lcd_putc("Susana master");
   lcd_gotoxy(1,2);
   lcd_putc("valor=");
  
   while(TRUE)
   {
      valor=read_adc();
      lcd_gotoxy(9,2);
      printf(lcd_putc,"%X",valor);
      output_toggle(PIN_B4);
      delay_ms(100);     
      SPI_WRITE(valor);
   }
}

  • Código del esclavo:
#include <slave.h>
//SPI slave, el slave es como una impresora a un computadora, varias compus a una principal
#use spi (SLAVE, SPI1, MODE=0, BITS=8, STREAM=SPI_1)
#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 valor;
#INT_SSP
void  SSP_isr(void) //interrupcion SPI
{
   valor=spi_read();
   lcd_gotoxy(9,2);
   printf(lcd_putc,"%X",valor);
}
void main()
{
   //la interrupcion es cuando master manda un dato, se interrumpe el toggle
   enable_interrupts(INT_SSP);
   enable_interrupts(GLOBAL);
   lcd_init();
   lcd_putc("Susana slave");
   lcd_gotoxy(1,2);
   lcd_putc("Valor=");
  
   while(TRUE)
   {
      output_toggle(PIN_A5); //para este entretenido el programa y se interumpa
     
   }
}

  • Simulación en Proteus:

en No hay comentarios:

DECODIFICADOR DE PULSOS DE CUADRATURA (QEP)

Este programa puede aplicarse a un odómetro, el cual calcula la distancia total o parcial recorrida por un objeto o cosa. El odómetro se armará en parejas y el programa mostrará en centímetros la distancia recorrida en sentido recto y de reversa.
  • Código:
#include <pasos.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>
float cuenta=0;
float cm;
#INT_EXT
void  EXT_isr(void)
{
   if (input(PIN_B1)) //reversa
     cuenta=cuenta-1;
  
   else           //B0, directo
      cuenta=cuenta+1;

   cm=(cuenta*1.2)/2;
   lcd_gotoxy(5,2);
   printf(lcd_putc,"%3.1f",cm);
}
void main()
{
   enable_interrupts(INT_EXT);
   enable_interrupts(GLOBAL);
   lcd_init();
   lcd_gotoxy(1,1);
   lcd_putc("Susi y Marco");
   lcd_gotoxy(1,2);
   lcd_putc("Cm= ");
   while(TRUE)
   {
     if (input(PIN_B2)) //reset
         cuenta=0;  
   }
}

  • Simulación en Proteus:
  • Armado y ejecución:




en No hay comentarios:

CONTROL DE MOTOR CD CON PWM

Este programa puede variar la velocidad de un motor cd con el PWM del PIC, además de que se puede seleccionar el sentido de giro de éste. Para poder dar la intensidad al motor para que funcione se empleará un puente H, para esta práctica, el puente H se hará con transistores Darlington (TIP122 y TIP127).

  • Código:
#include <clase12.h>
//motor CD con PWM
int16 vel;
void main()
{
   setup_adc_ports(AN0);
   setup_adc(ADC_CLOCK_INTERNAL|ADC_TAD_MUL_0);
   setup_timer_2(T2_DIV_BY_4,124,1);      //500 us overflow, 500 us interrupt
   setup_ccp1(CCP_PWM|CCP_PWM_FULL_BRIDGE|CCP_SHUTDOWN_AC_L|CCP_SHUTDOWN_BD_L);
   set_pwm1_duty((int16)248);
   while(TRUE)
   {
      vel=(int16)(read_adc());
      set_pwm1_duty(vel);
      if(input(PIN_B0))
          setup_ccp1(CCP_PWM|CCP_PWM_FULL_BRIDGE); //CW clock wise
      else
         setup_ccp1(CCP_PWM|CCP_PWM_FULL_BRIDGE_REV); //CCW clock contrary wise
         
     
   }
}
  • Simulación en Proteus:
  • Armado y ejecución:


en No hay comentarios:

COMUNICACIÓN INFRARROJA



Este programa que pueda realizar una comunicación infrarroja empleando la codificación Manchester.

Además de que se requiere de haya un emisor y un receptor. En esta ocación yo seré el receptor y un compañero será el emisor. Se emplearán un LED infrarrojo y un módulo receptor que pueda modular la señal.
  • Código del receptor:
#include <receptor.h>
//recibe
#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 tecla,i;
#INT_EXT
void  EXT_isr(void) //interrupt service request
{
   delay_us(300); //para estar a la mitad del dato
   output_toggle(Pin_B5);//ve muestreo
   output_toggle(Pin_B5);
   if(!input(PIN_B0))
   {  delay_us(1200);
      for(i=0;i<=7;i++)
      {
         if(!input(PIN_B0))  
            bit_clear(tecla,i); //el 0 de la tecla lo pone en 0
         else 
            bit_set(tecla,i); //el 1 de la tecla lo pone en 1
         output_toggle(Pin_B5);
         output_toggle(Pin_B5);
         delay_us(1200);
        
      }
      if(input(Pin_B0)) tecla='N';//de que no es numero, si es basura muestra N
      lcd_gotoxy(10,2);
      lcd_putc(tecla);
   }
}
void main()
{
   enable_interrupts(INT_EXT);
   ext_int_edge( H_TO_L ); // detecta flancos de bajada
   enable_interrupts(GLOBAL);
   lcd_init();
   lcd_gotoxy(1,1);
   lcd_putc("SUSANA");
   lcd_gotoxy(1,2);
   lcd_putc("Tecla RX= ");
   while(TRUE)
   {
      output_toggle(Pin_B7);//para dejar espacio a la interrupción
   }
}
  • Código del emisor:
#include <clase11.h>
//transmite
#include <KBD.C>
#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 tecla, i, j;
void cero()
{
   //se modula a 600 us, entonces si fsk=38KHz, 600/26 = 23 pulsos
   for (i=0;i<=23;i++)
   {
      output_high(Pin_B0);
      delay_us(10);
      output_low(Pin_B0);
      delay_us(7);
   }
   delay_us(580);
}
void main()
{
   kbd_init();
   lcd_init();
   lcd_gotoxy(1,1);
   lcd_putc("SUSANA");
   lcd_gotoxy(1,2);
   lcd_putc("Dato TX= ");
   while(TRUE)
   {
      while (tecla=='\0')
         tecla= kbd_getc();
        
      lcd_gotoxy(1,2);
      lcd_putc("Dato TX= ");
      lcd_putc(tecla);
      cero();
     
      for(j=0;j<=7;j++)
      {
         if(bit_test(tecla,j))//ve que bit hay TRUE si es 1, FALSE si es 0
            delay_us(1200);
         else
            cero();
      }  
         cero();
         tecla='\0';
      }  
}

  • Simulación en Proteus:
  • Armado y ejecución:


en No hay comentarios:

EEPROM

Este programa puede escribir y leer registros en la memoria EEPROM. Los datos serán ingresados mediante el teclado, donde la tecla de # se encarga de escribir el dato en el registro, y la tecla * se encarga de la lectura del dato que haya en el registro ingresado.
  • Código:
#include <clase10.h>
#include <KBD.C>
#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 <string.h>
#include <stdlib.h>
int tecla, i,dato[4],dir[4];
char a[1],b[1],c[1];
void main()
{
   kbd_init();
   lcd_init();
   lcd_gotoxy(1,1);
   lcd_putc("Susana Lopez");
   lcd_gotoxy(1,2);
   lcd_putc("A="); //numero de registro
   lcd_gotoxy(8,2);
   lcd_putc("D=");   //dato que esta en el registro
   tecla='\0';
   //prueba
   //dir[3]=125;
   //dato[3]=0x18;
  
   while(TRUE)
   {
      while(tecla=='\0')
            tecla=kbd_getc();
      if (tecla!='#' && tecla!='*')
      {for (i=0;i<=2;i++)
      {
         while(tecla=='\0')
            tecla=kbd_getc();
           
        lcd_gotoxy(i+3,2);
        lcd_putc(tecla); 
        dir[i]=tecla-48; //para que el vector sea un numero de mas de 1 cifra
        tecla='\0';
      }
     
      sprintf(a,"%d",dir[0]);
      sprintf(b,"%d",dir[1]);
      sprintf(c,"%d",dir[2]);
      strcat(a,b);
      dir[3]=atoi(a);
      /*
      lcd_gotoxy(14,2);
      printf(lcd_putc,"%d",dir[3]);*/
     
      while(tecla=='\0')
            tecla=kbd_getc();
      if (tecla!='#' && tecla!='*')
      {
      for (i=0;i<=2;i++)
      {
         while(tecla=='\0')
            tecla=kbd_getc();
           
        lcd_gotoxy(i+10,2);
        lcd_putc(tecla); 
        dato[i]=tecla-48;
       
        tecla='\0';
      }
      }}
      sprintf(a,"%d",dato[0]);
      sprintf(b,"%d",dato[1]);
      sprintf(c,"%d",dato[2]);
      strcat(a,b);
      dato[3]=atoi(a);
      /*prueba
      lcd_gotoxy(14,1);
      printf(lcd_putc,"%d",dato[3]);*/
 
     
      while(tecla=='\0')
            tecla=kbd_getc();
      if (tecla=='*')
      {
        dato[3]=read_EEPROM(dir[3]); //lee el dato especificado en dir pos 3
        lcd_gotoxy(10,2);
        printf(lcd_putc,"%3X",dato[3]); //imprime valor en hexadecimal
        tecla='\0';
      }
     
      if (tecla=='#')
      {
        dato[3]=write_EEPROM(dir[3],dato[3]); //escribe el dato en direccion indicada (direccion, dato)
        tecla='\0';
      }
     
   }
}

  • Simulación en Proteus:
  • Armado y ejecución:

“En el registro 010 se escribió el dato 052.”

en No hay comentarios:

COMUNICACIÓN SERIAL


Este programa puede enviar un PIC un dato y que se puede recibir en otro PIC, mediante comunicación serial RS-232, donde la conexión de la comunicación se hará con un cable de par trenzado.

Deben estar sincronizados los tiempos, por eso se emplea el uso del cristal de 4 MHz, el cual se conecta al pin 13 y 14 del PIC. Además, para poder visualizar como se ve el dato que se manda de un PIC a otro, se emplea un osciloscopio, configurándolo en el menú de trigger, para poder ver el disparo del dato.

  • Código:
#include <nueve.h>
#include <KBD.C>
#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 tecla;
#INT_RDA
void  RDA_isr(void)
{
   tecla=getc();
   lcd_gotoxy(9,2);
   lcd_putc("RX=");
   lcd_putc(tecla);
}
void main()
{
   kbd_init();
   enable_interrupts(INT_RDA);
   enable_interrupts(GLOBAL);
   lcd_init();
   lcd_gotoxy(1,1);
   lcd_putc("Susana");
   while(TRUE)
   {
        while (tecla=='\0')
         tecla= kbd_getc();
         lcd_gotoxy(1,2);
         lcd_putc("TX=");
         lcd_putc(tecla);
         putc(tecla);
         tecla='\0';
      }
}
  • 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....

  • 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 pu...
  • Resistencia dibujada
    En este programa se dibuja una resistencia usando 5 instancias, para que al momento de dibujarla fuera más fácil y rápido. El usuario ingre...
  • Operaciones con matrices
    Para poder realizar operaciones que estén bien hechas con matrices, se debe de importar de  numpy la librería matrix. Ya solo antes de u...