Dado electrónico

Dado electrónico

En este post os vamos a exponer como construir y desarrollar un dado electrónico (ver Ilustración I).

I. Ilustración: Dado eléctronico

Se pretende diseñar un dado electrónico que al pulsar un botón pulsador va a hacer una secuenciación de luces en los 6 diodos leds que constituyen el dado, y que al soltar el botón nos sacará un número aleatorio del uno al seis. Después de 3 segundos, los diodos leds se apagaran.

Para construir este prototipo es necesario hacer el siguiente acopio de material:

  • 7 Diodos led
  • 1 Array de resistencias de 330 Ohm
  • 1 Regulador  7805
  • 1 Condensador  220 Kpf , K5m
  • 1 Resistencia Pull up, 10kOhm
  • 1 Pulsador
  • 2 Interruptores
  • 1 Conectores molex 9pin
  • 2 Conectores molex 2 pin
  • 1 PIC  16F886
  • 1 PCB a doble cara
  • 1 Caja diseñada e imprimida en una impresora 3D

Las Ilustraciones II, III y IV muestran los esquemas en Proteus y Ares que se han utilizado en las diferentes fases de desarrollo del dado:

.

Ilustracion II: Esquema ISIS para la simulación

 

Ilustracion III: Esquema ISIS para la PCB

 

Ilustracion IV: Esquema ARES de la PCB

.
Este es el código fuente que se ha generado para programar el PIC16F886:

 #include <16f886 data-blogger-escaped-.h="">
#FUSES NOWDT                    //No Watch Dog Timer
#FUSES XT                       //High speed Osc (> 4mhz for PCM/PCH) (>10mhz for PCD)
#FUSES PUT                      //Power Up Timer
#FUSES MCLR                     //Master Clear pin enabled
#FUSES NOPROTECT                //Code not protected from reading
#FUSES NOCPD                    //No EE protection
#FUSES NOBROWNOUT               //No brownout reset
//#FUSES IESO                     //Internal External Switch Over mode enabled
//#FUSES FCMEN                    //Fail-safe clock monitor enabled
#FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NODEBUG                  //No Debug mode for ICD
#FUSES NOWRT                    //Program memory not write protected
#FUSES BORV40                   //Brownout reset at 4.0V
#FUSES INTRC_IO
//#FUSES INTRC

#use delay(clock=4000000)

int numale=0;   //Creamos una variable donde guardaremos el numero aleatorio
int x=0x01;  //Inicializamos una variable que luego utilizaremos en la secuenciacion de los leds

#int_RTCC //Inicio del tratamiento de la interrupción del TMR0
void rtcc_secuenciacion(void)     //Funcion del TMR0 Secuenciacion de los LEDS
{
   rotate_left(&x,1);  //Funcion rotate para desplazar un bit hacia la izquierda
   output_b(x);  // Mostramos el valor de la variable X
   delay_ms(300); // Esperamos 300ms
}

void main(void) //Programa principal
{
    setup_adc_ports(NO_ANALOGS);
    set_tris_a(0b11111111);  //Declaramos el Puerto “A” como entrada
    set_tris_b(0b00000000);  // Declaramos el Puerto “B” como salida
    setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);    //TMR0 interno con preescaler de 1
    set_timer0 (0); // Cargar el TMR0 al maximo valor
    setup_timer_1 ( T1_INTERNAL | T1_DIV_BY_1 ); //Timer1 interno
    set_timer1(0); // Cargar el Timer1 al maximo valor
    enable_interrupts(global); //Habilita interrupciones
    disable_interrupts(int_timer0); // desabilitar interrupcion del TMR0
    disable_interrupts(int_timer1); // deshabilitar interrupcion del TMR1
    output_b(0); // Inicializacion de los LED a apagados
    
    while(1) //Bucle infinito
    {
        while(input(PIN_A0)==0)  // Esperamos a que se pulse el boton, mientras no se pulse no pasa de este bucle
            ;
        delay_ms(20);  // un delay para evitar el efecto rebote de los pulsadores
        enable_interrupts(int_timer0);    //habilitamos interrupcion del TMR0
        while(input(PIN_A0)==1)  //Un bucle que parara en cuanto se deje de pulsar el boton
            ;
        delay_ms(20);
        disable_interrupts(int_timer0);  // desabilitar interrupcion del TMR0
        numale=(get_timer1()%6)+1; //Obtencion del numero aleatorio que guardaremos en una variable, con la function get_timer1 conseguimos un numero practicamente aleatorio con la formula aplicada
        if (numale==1){ // Nos mostrara el numero 1 en los LEDs en caso de que el numero aleatorio sea 1
            output_b(0b10000000);
            
        }
        else if (numale==2){
            output_b(0b00011000);
            
        }
        else if (numale==3){
            output_b(0b10011000);
            
        }
        else if (numale==4){
            output_b(0b01011010);
            
        }
        else if (numale==5){
            output_b(0b11011010);
            ;
        }
        else if (numale==6){
            output_b(0b01111110);
        
        }
        delay_ms(3000); // Esperamos 3 seg
        output_b(0);
     }
}

La caja o envolvente del dado (ver ilustracion V) ha sido bajada de thingiverse en esta dirección:

http://www.thingiverse.com/thing:26278/#files

Ilustracion V: Diseño 3D de la caja

Trás ensamblar todos los elementos que constituyen el proyecto este es el producto final (ver Ilustración VI y VII):

Ilustración VI: Vista interna del proyecto

Ilustración VII: Dos dados diferentes

 

.

Control de acceso RFID y pantalla ULCD

Control de acceso RFID y pantalla ULCD

En este caso hemos creado un Control de Accesos que permite el acceso a los usuarios que tengan una tarjeta de identificación válida mediante un lector RFID, y a la vez acertar la contraseña que irá a continuación de la lectura de la tarjeta y que saldrá en una pantalla µLCD. Cuando se acierte la contraseña se abrirá la puerta.


El proceso de este proyecto:

Edición del esquema: En este caso se ha creado con el programa Capture Cis del software OrCad.

                .
Prueba del circuito: Se ha montado en una placa-board, ya con los componentes fisicos y se comprueba que se consiguen los valores necesarios para su correcto funcionamento. Para ello dejamos un video:

.
Diseño de la PCB: Se ha creado utilizando el programa Layout Plus, en la siguiente imagen lo podrás ver.
.

.
Fabricación de la PCB: Utilizando el programa Layout Plus hemos imprimido la cara TOP y la cara BOT para así poder hacer los cliches. Imprimimos también el archivo .DRD para hacer los agujeros de la placa.
.

DRD
.

TOP Y BOT
.
CLICHES

.

En este caso es necesario metalizar los agujeros, ya que es una placa de dos caras, se ha realizado mediante un proceso quimico en cubetas. Lo mismo pasa con la placa, la hemos hecho por quimico, entonces se ha realizado mediante procesos quimicos en cubetas.
.
.
.
.
    –Montaje y soldadura: Es el último paso, una vez comprobada la placa y ver que no esta defectuosa, es colocar los componentes y soldarlos para que quede como en la siguiente imagen.
.
.
.
    –Maqueta del control de accesos: Una vez echa la placa, utilizando la impresora 3D, se ha creado la maqueta del control de accesos (puerta, pared, marco, suelo, corredera, cremallera, sin fin, engranaje)
.
.
.
Material utilizado para la creación del control de accesos
         -L293D
          -PIC18F2550
          -JACK
          -OSCILADOR 4MHZ
          -DIODO
          -INTERRUPTOR
          -7805
          -LED
          -LED RGB
          -2 CONDENSADORES 22 uF
          -2 CONDENSADORES 100nF
          -BATERIA LIPO 7,4V
          -3 RESISTENCIAS 100K
          -4 RESISTENCIAS 330OHM
          -4 CONECTORES DOBLES
          -CONECTOR DE 5
          -2 CONECTORES DE 4

          -BOTON RESET

Archivos para descargar:

Proyecto_v1.c:

Proyecto_v1.h:
http://dl.dropbox.com/u/61585409/Blogspot/Control%20de%20accesos%20Urtzi%20Aitor%202012-2013/proiekto_v1.h

Proyecto_v1.cof:
http://dl.dropbox.com/u/61585409/Blogspot/Control%20de%20accesos%20Urtzi%20Aitor%202012-2013/proiekto_v1.cof 

Proyecto_v1.hex:
http://dl.dropbox.com/u/61585409/Blogspot/Control%20de%20accesos%20Urtzi%20Aitor%202012-2013/proiekto_v1.hex

Proeycto_v1.PJT:
http://dl.dropbox.com/u/61585409/Blogspot/Control%20de%20accesos%20Urtzi%20Aitor%202012-2013/proiekto_v1.PJT

Archivos OrCad y Layout:
http://dl.dropbox.com/u/61585409/Blogspot/Control%20de%20accesos%20Urtzi%20Aitor%202012-2013/plaka_proyeko.rar

Todas las piezas hechas por impresora 3D están en Thiingiverse:
http://www.thingiverse.com/search?q=elektronikadonbosco&sa= 

VIDEO

.

Tanquebot-Construcción y desarrollo de un robot laberinto

Tanquebot-Construcción y desarrollo de un robot laberinto

En esta entrada trataremos de explicar como construir y desarrollar un robot laberinto. Tanquebot ha sido diseñado para participar en pruebas de robótica que consisten en ser capaz de salir de un laberinto. Para ello, el robot puede utilizar diferentes estrategias.
 .
Para su correcto funcionamiento, el robot tiene tres sensores de ultrasonidos colocados adelante y en ambos costados para detectar y ser capaz de esquivar los obstáculos, como se aprecia en la imagen 1.
.
Su funcionamiento tiene dos maneras diferentes de empezar, colocando el «switch» en el modo manual y dando al interruptor de marcha o colocandolo en el modo automático para utilizar una aplicación Android y mediante Bluetooth mandarle ordenes.
.
 1. Robot inteligente
.
El proceso que se ha utilizado en la creación del robot ha sido la de seguir estas etapas:
.
        –Edición del esquema: En este caso se ha creado con el programa ISIS del software PROTEUS, en la imagen 2 se puede ver.
.
2. Esquema en ISIS
 .
        –Simulación del circuito: Se simula en el ISIS, para ver si los resultados que se obtienen son los esperados, para ello, se utiliza la tabla de comandos que aparece en la imagen.
.
3. Comandos para la simulación
  
        –Prueba del circuito: Se ha montado en una placa-board, como se aprecia en la cuarta imagen, ya con los componentes físicos y se comprueba que se consiguen los valores necesarios para su correcto funcionamiento.
 .
 4. Placa board con el sensor

        –Diseño de la PCB: Se ha creado utilizando el programa ARES del software PROTEUS, como se observa en la imagen 5.
5. Diseño en ARES

        –Fabricación de la PCB: Utilizando el programa CIRCUITCAM, se crea el archivo necesario para hacer la placa en la protomat S62, la, maquina de LPKF que se puede ver en la imagen 6, utilizando para ello, el programa BoardMaster. En este caso también ha sido necesario metalizar los agujeros, ya que es una placa de dos caras, se ha realizado mediante un proceso químico en cubetas.
.
6. Protomat S62

        –Montaje y soldadura: Es el último paso, una vez comprobada la placa y ver que no esta defectuosa, es colocar los componentes y soldarlos para que quede como en la siguiente imagen.
  .
7. Placa con componentes soldados
   .
Formato del robot: Una vez obtenida las dimensiones de la placa, utilizando una impresora 3D,la que se ve en la imagen 8, se ha creado el chasis del robot y el soporte donde se colocara la placa, los motores y los sensores en la imagen 9 se puede apreciar el resultado.
.
 8. Impresora 3D
.
9. Chasis del robot
.

Material utilizado para la creación del robot y enlaces de los componentes:

COMPONENTES
L293D 3 Interruptores
PIC 16f876 Switch doble
Condensador 100 nF 3 Sensores ultrasonido 28015
2 Condensadores 22 uF Batería lipo 7,4V
Regulador 7805 Pila 9V
LED Receptor Bluetooth
3 Resistencias 10K Conector Jack
Resistencia 5K8 2 Motores de continua
2 Diodos 4 Conectores dobles
Oscilador 4000 MHz

   
Programas y maquinas utilizados para la creación del robot:

  • Software PROTEUS:


             – ISIS (para hacer el esquema y simularlo virtualmente)
             – ARES (para diseñar la PCB, donde colocar los componentes)

  • CIRCUITCAM (para crear los archivos para la protomat S62)
  • BOARDMASTER (para hacer la PCB, pistas y agujeros)
  • Proceso de metalizado por cubetas (para metalizar los agujeros)
  • Impresora 3D (para hacer el chasis del robot)
  • MPLAB (para programar el pic)
  • Placa-Board (para hacer las pruebas con los componentes)
  • Dispositivo Android (para probar la conexión Bluetooth)

 

Os dejamos el video-demostración que hemos preparado para la presentación del proyecto y los archivos para la construcción del robot.

 

DB Sariak 2013

DB Sariak 2013

Este año por 3º año se celebrará el 18 de Mayo la competición DB Sariak 2013. Como en años anteriores se realizarán 2 pruebas:

  • Proiekton – Concurso de proyecto cientifico tecnológico
  • DB Bots – Concurso de robots velocistas siguelineas
Hasta ahora el concurso estaba dirigido hacia los alumnos de ESO, Bachiller y FP. Este año como gran novedad hemos abierto la posibilidad para cualquier persona pueda participar junto con los proyectos de FP.
.
.
Estamos depurando detalles de las competiciones, como premios, bases del concurso, así que estar atentos ante los cambios. Mas información en la página web de IEFPS Don Bosco
.
Unidad de control de un motor de gasolina

Unidad de control de un motor de gasolina

 

La idea u objetivo del proyecto es controlar un motor de un automóvil, para después de ponerlo en funcionamiento,  poder controlar diferentes reacciones. Para ello hemos creado una CPU o Unidad de control que controle diferentes parámetros. También se conoce como centralita y su función es controlar varios parámetros para poder dar respuesta a las peticiones del usuario. El motor es de la marca OPEL, tiene 4 cilindros y en cada cilindro tiene un inyector y una bujía para poder crear la combustión  necesaria para su funcionamiento.

La CPU o Unidad de control debe controlar los siguientes parámetros:

  • Cantidad de masa de aire de entrada al motor en porcentajes (%0, %5, %25, %50, %75, %100).
  • Tiempo de inyección de gasolina en milisegundos (de 0ms a 16ms).
  • Angulo de avance del salto de chispa respecto al PMS (Punto muerto superior) y PMI (Punto muerto inferior). También conocido como ángulo Dwell.

Para poder controla todos estos parametros tendremos una señal situada en el motor.

Esta señal nos la proporcionara un sensor inductivo situado en el bolante motor. Interpretando esta señal y conociendo los diferentes parámetros debemos dar respuesta a las peticiones del usuario.

 

Tiempo de inyeccion y angulo Dwell
(Alimentacion, etapa de control y etapa de potencia)

.
Medidor de masa de aire
(Etapa de control )
.
(Etapa de potencia; puente en H)
.
.
.
PROGRAMA
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*********************************************************************
*********************************************************************
                 AUTOAREN CPU OPEL 2000 16v
                 MOTOREAN PROBATZEKO BERTSIOA
********************************************************************
OPEL: Sensor Inductivo: 57+1 Dientes=58 flanko positibo
                                                    Tiempo inyeccion+Angulo Dwell
*********************************************************************/
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include <16F877.H>  //16F877 PIC-a erabiliko dugu Inyekzioa eta txispa kontrolatzeko
#device ADC=10       //Bihurgailu analogiko/digitalak 10 byte edukiko ditu//1024
#fuses XT,NOWDT,NOPROTECT,NOLVP
#use delay(clock=4M) //4MHz-tako kristal harria
#use RS232(baud=19200, xmit=PIN_C6, rcv=PIN_C7,DISABLE_INTS)//Serie Portua
#include <math.h>                                           //19200Abiadura//Pin C6 datuak bidaltzeko
                                                            //Disable_Ints Etendurak desabilitatzen ditu RS232 Serie Portutik                    datuak bidaltzerakoan
int1 k=0;         //RPM-ak kalkulatzeko agindua
float t1=0;       //Hortzen arteko oraingo denbora
float t2=0;       //Hortzen arteko aurreko denbora
int8 kont_dient=0;  //Bira batean hortz kopurua
float aux_rpm=0;  //Abiadura RPM-tan
int16 rpm;        //Abiadura RPM-tan
int16 t_grado;    //Gradu bat igarotzeko behar den denbora
int16 pot_iny;    //Inyekzio denbora; Potentziometroa balio digitala
int16 pot_av;     //Angulo Avance; Potentziometroa balio digitala
int16 VDmax=1024; //Balio digital maximoa;ADC=10(byte) bada->1024/ADC=8(byte) bada->255
int8 Tmax=17;     //Inyekzio denbora maximoa
int8 T=0;         //Inyekzio denbora
int8 Gmax=43;     //Gradu maximoa ez errealak;24 gradu negatibo+18 gradu positibo=42 gradu guztira
int8 G=0;         //Graduak ez errealak; 0 gradutik 43 gradu arte
signed int8 Gr=0; //Gradu errealak; Gradu ez errealak-24
float a=0;        //Hortzetik hortzera dagoen denbora segunduetan, hau da t1-etik t2-ra dagoen denbora
float b=0;        //1 bira zenbat segundu diren kalkulatzeko;1 bira = 360º = 58 flanko positibo = 60 hortz
int8 i;
char bidali[7];   //Portu serietik bidaltzeko datuak;
                  //rpm (2 digitu)/angelu (zeinua + 2 digitu)/inyekzio (2 digitu)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/********************************************************************
   Interrupcion TIMER 2 Etendura
   Inyekzioa mozteko erabiliko dugu
********************************************************************/
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#int_timer2
void tiempo2(void)
{
   output_low(PIN_C2);  //Inyektorea itzali
   output_low(PIN_C3);  //Inyektorea itzali
   disable_interrupts(INT_TIMER2);   //Timer 2 Etendura desaktibatu
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**********************************************************************
   Kampoko Etendura PIN_B0
   Birak kontatzeko erabiliko dugu
***********************************************************************/
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#int_ext
void birak(void)
{
   t1=get_timer1(); //2 hortzen harteko denbora hartu//get timer-aren bidez momentuan timerraren akumulagailuan dagoen balioa artuko du
   set_timer1(0);  //Timer1 Hasieratu, momentu honetan timer-a kontatzen hasiko da
   if((t1>1.5*t2)||(kont_dient>=58))    //Oraingo denbora, aurreko denbora baino andiagoa bada
   {                                   //PMS -ean dagoela esan nahi du beraz kontaketa hasi
      kont_dient=1;
   }
   else
   {
      kont_dient ++; //Kont_dient inkrementatu
      if((kont_dient==5)||(kont_dient==34)) //Gasolina inyektatu
      {
         output_high(PIN_C2); //Inyectar
         output_high(PIN_C3); //Inyectar
         setup_timer_2 ( T2_DIV_BY_16,pot_iny/4,4 ); //Timer 2 konfiguratu//Inkrementu bakoitzak 16uS,potentziometroaren bidez kargatu behar dugun balioa artuko du.
         set_timer2(0); //Timer2 Hasieratu//etendura abilitatu bezahin laster asiko da kontaketa gainezka egin arte, timer-ak gainezka egitean etendurara joango da eta inyektoreak itzali egingo ditu
         enable_interrupts(INT_TIMER2);   //Timer 2 Etendura aktibatu
      }
      if(kont_dient==10)    //RPM-ak kalkulatzeko
      {
         k=1;
      }
   }
   t2=t1; //Oraingo denbora aurreko bezala gorde
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**********************************************************************
   Funtzio Nagusia
**********************************************************************/
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void main(void)
{
   delay_ms(2000);
   setup_timer_1 ( T1_INTERNAL | T1_DIV_BY_1 );  //Timer 1 konfiguratu//Inkrementu bakoitzak 1uS
   set_timer1(0);  //Timer1 Hasieratu
   //setup_timer_0 ( RTCC_INTERNAL | RTCC_DIV_64 );   //Timer 0//0-16,320ms//Inkrementu bakoitzak 64uS
   //set_rtcc(0); //Timer0 hasieratu
   setup_timer_2 ( T2_DIV_BY_16,0xff,4 );   //Timer 2 konfiguratu//Inkrementu bakoitzak 16uS
   set_timer2(0); //Timer2 Hasieratu
   enable_interrupts(INT_TIMER2);   //Timer 2 Etendura aktibatu
   enable_interrupts(GLOBAL);       //Etendura guztiak aktibatu
   enable_interrupts(INT_EXT); //Kampoko etendura aktibatu B0 portua, B0 portuan kanpoko seinale bat jasotzean programa nagusia utzi eta programa zati zehatz batetara joaten da
   ext_int_edge(H_TO_L);      //Kampoko etendura aktibatu LtoH(goranzko flankoa), hau da 0v-tik 5v-rako aldaketa somatzen duenean exekutatzen hari den programa utzi eta int_ext etendurara joango da bertan dauden aginduak exekutatzeko
   setup_adc_ports(AN0_AN1_AN3);      //PIN A0,A1 eta A3 Analogiko bezala konfiguratu, hau da pin hauetan balio analogiko bat sartuko dugu eta pic-ak balio hau digital bihurtuko du//ADC=10 bada 10 byteraino hau da 1024 arteko balio tartea// ADC=8 bada 8 byterain, hau da 255 arteko balio tartea.
   setup_adc(adc_clock_internal);    //CAD Konfiguratu
   while(1)
   {
      //RPM//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
      if(k==1)
      {
         a=((t1/1000.0)/1000.0); //Hortzetik hortzera dagoen denbora microsegundutatik segundutara pasatu //3300uS = 0,0033s
         b=a*58.0;       //1 bira zenbat segundu diren kalkulatzeko// Motorrean 58 hortz
         aux_rpm=60.0/b; //Bira kopurua minutuko RPM    //60/0,2=300rpm
         rpm=aux_rpm;    //aux_rpm:float/rpm:int16
         k=0;            //RPM-ak kalkulatzeko balioa 0-an jarri
      }
      //TIEMPO INYECCION/////////////////////////////////////////////////////////////////////////////////////////////////////
      set_adc_channel(0);   //A0 kanala aktibatu
      delay_us(10);
      pot_iny=read_adc();   //A0-tik sartutako balioa irakurri
      T=pot_iny*Tmax/VDmax; //Inyekzio denbora milisegundutan
      //ANGULO AVANCE////////////////////////////////////////////////////////////////////////////////////////////////////////
      set_adc_channel(1);   //A1 kanala aktibatu
      delay_us(10);
      pot_av=read_adc();    //A1-etik sartutako balioa irakurri
      G=pot_av*Gmax/VDmax;  //Angulo avance gradutan
      Gr=G-24;
      //DATUAK EGOKITU///////////////////////////////////////////////////////////////////////////////////////////////////////
      bidali[0]=rpm/1000;   bidali[0]=bidali[0]+0x30;//RPM; Milakoak kalkulatu eta ASCII kodera pasa
      bidali[1]=(rpm%1000)/100;  bidali[1]=bidali[1]+0x30;//RPM; Ehunekoak kalkulatu eta ASCII kodera pasa
      if(Gr<0) //Angulo de Avance negatiboa
         bidali[2]=’-‘;
      else     //Angulo de Avance positiboa
         bidali[2]=’+’;
      bidali[3]=fabs(Gr)/10;   bidali[3]=bidali[3]+0x30;//Angulo de Avance; Hamarrekoa kalkulatu eta ASCII kodera pasa
      bidali[4]=fabs(Gr)%10;   bidali[4]=bidali[4]+0x30;//Angulo de Avance; Batekoak kalkulatu eta ASCII kodera pasa
      bidali[5]=T/10;   bidali[5]=bidali[5]+0x30;//Inyekzioa: Hamarrekoak kalkulatu eta ASCII kodera pasa
      bidali[6]=T%10;   bidali[6]=bidali[6]+0x30;//Inyekzioa; Batekoak kalkulatu eta ASCII kodera pasa
      //PORTU SERIEA RS232////////////////////////////////////////////////////////////////////////////////////////////////////
      disable_interrupts(global);   //Etendurak desaktibatu
      putc(‘Z’); //Komunikazioa hasteko marka
      for(i=0;i<7;i++)
         putc(bidali[i]);  //Datuak bidali portu serietik
      enable_interrupts(global); //Etendurak aktibatu
     //BUJIAK////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
      if((Gr<=18)&&(Gr>12))   //18º
      {
         while(kont_dient!=3)
         {
            output_high(PIN_C0); //Bujias 1-4 kargatu
            output_high(PIN_C1); //Bujias 2-3 kargatu
         }
         output_low(PIN_C0); //Bujias 1-4 Deskargatu!!¡!¡!
         delay_us(500);
         while(kont_dient!=32)
         {
            output_high(PIN_C0); //Bujias 1-4 kargatu
            output_high(PIN_C1); //Bujias 2-3 kargatu
         }
         output_low(PIN_C1); //Bujias 2-3 Deskargatu!!¡!¡!
         delay_us(500);
      }
      else if((Gr<=12)&&(Gr>6))  //12º
      {
         while(kont_dient!=2)
         {
            output_high(PIN_C0); //Bujias 1-4 kargatu
            output_high(PIN_C1); //Bujias 2-3 kargatu
         }
         output_low(PIN_C0); //Bujias 1-4 Deskargatu!!¡!¡!
         delay_us(500);
         while(kont_dient!=31)
         {
            output_high(PIN_C0); //Bujias 1-4 kargatu
            output_high(PIN_C1); //Bujias 2-3 kargatu
         }
         output_low(PIN_C1); //Bujias 2-3 Deskargatu!!¡!¡!
         delay_us(500);
      }
      else if((Gr<=6)&&(Gr>0)) //6º
      {
         while(kont_dient!=1)
         {
            output_high(PIN_C0); //Bujias 1-4 kargatu
            output_high(PIN_C1); //Bujias 2-3 kargatu
         }
         output_low(PIN_C0); //Bujias 1-4 Deskargatu!!¡!¡!
         delay_us(500);
         while(kont_dient!=30)
         {
            output_high(PIN_C0); //Bujias 1-4 kargatu
            output_high(PIN_C1); //Bujias 2-3 kargatu
         }
         output_low(PIN_C1); //Bujias 2-3 Deskargatu!!¡!¡!
         delay_us(500);
      }
      else if((Gr<=2)&&(Gr>=-2))    //0º
      {
         while(kont_dient!=58)//PMS//
         {
            output_high(PIN_C0); //Bujias 1-4 kargatu
            output_high(PIN_C1); //Bujias 2-3 kargatu
         }
         output_low(PIN_C0); //Bujias 1-4 Deskargatu!!¡!¡!
         delay_us(500);
         while(kont_dient!=29)//Erdia PMI//
         {
            output_high(PIN_C0); //Bujias 1-4 kargatu
            output_high(PIN_C1); //Bujias 2-3 kargatu
         }
         output_low(PIN_C1); //Bujias 2-3 Deskargatu!!¡!¡!
         delay_us(500);
      }
      else if((Gr<0)&&(Gr>=-6))  //-6º
      {
         while(kont_dient!=57)
         {
            output_high(PIN_C0); //Bujias 1-4 kargatu
            output_high(PIN_C1); //Bujias 2-3 kargatu
         }
         output_low(PIN_C0); //Bujias 1-4 Deskargatu!!¡!¡!
         delay_us(500);
         while(kont_dient!=28)
         {
            output_high(PIN_C0); //Bujias 1-4 kargatu
            output_high(PIN_C1); //Bujias 2-3 kargatu
         }
         output_low(PIN_C1); //Bujias 2-3 Deskargatu!!¡!¡!
         delay_us(500);
      }
      else if((Gr<-6)&&(Gr>=-12))  //-12º
      {
         while(kont_dient!=56)
         {
            output_high(PIN_C0); //Bujias 1-4 kargatu
            output_high(PIN_C1); //Bujias 2-3 kargatu
         }
         output_low(PIN_C0); //Bujias 1-4 Deskargatu!!¡!¡!
         delay_us(500);
         while(kont_dient!=27)
         {
            output_high(PIN_C0); //Bujias 1-4 kargatu
            output_high(PIN_C1); //Bujias 2-3 kargatu
         }
         output_low(PIN_C1); //Bujias 2-3 Deskargatu!!¡!¡!
         delay_us(500);
      }
      else if((Gr<-12)&&(Gr>=-18))  //-18º
      {
         while(kont_dient!=55)
         {
            output_high(PIN_C0); //Bujias 1-4 kargatu
            output_high(PIN_C1); //Bujias 2-3 kargatu
         }
         output_low(PIN_C0); //Bujias 1-4 Deskargatu!!¡!¡!
         delay_us(500);
         while(kont_dient!=26)
         {
            output_high(PIN_C0); //Bujias 1-4 kargatu
            output_high(PIN_C1); //Bujias 2-3 kargatu
         }
         output_low(PIN_C1); //Bujias 2-3 Deskargatu!!¡!¡!
         delay_us(500);
      }
      else if((Gr<-18)&&(Gr>=-24))  //-24º
      {
         while(kont_dient!=54)
         {
            output_high(PIN_C0); //Bujias 1-4 kargatu
            output_high(PIN_C1); //Bujias 2-3 kargatu
         }
         output_low(PIN_C0); //Bujias 1-4 Deskargatu!!¡!¡!
         delay_us(500);
         while(kont_dient!=25)
         {
            output_high(PIN_C0); //Bujias 1-4 kargatu
            output_high(PIN_C1); //Bujias 2-3 kargatu
         }
         output_low(PIN_C1); //Bujias 2-3 Deskargatu!!¡!¡!
         delay_us(500);
      }
   }  //While(1)bukaera
}  //main() bukaera
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*********************************************************************
**********************************************************************
                 AUTOAREN CPU OPEL 2000 16v
                 MOTOREAN PROBATZEKO BERTSIOA
**********************************************************************
LCD
**********************************************************************/
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include <16F876.H>//16F876 PIC-a erabiliko dugu datuak jaso eta LCD-an pantailaratzeko
#fuses XT,NOWDT,NOPROTECT
#use delay(clock=4M)
#use RS232(baud=19200, xmit=PIN_C6, rcv=PIN_C7) //Portu seriea Pin C6 datuak jasotzeko
#include «LCD.c»  //LCD-a erabiltzeko Programa gehigarria
char datuak[7];//Portu serietik jasotako datuak gordetzeko
int8 i;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/***********************************************************************
   Funtzio Nagusia
************************************************************************/
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void main(void)
{
   lcd_init();       //LCD Hasieratu
   lcd_gotoxy(6,1);   //Lehenengo lerroa,6.posizioa
   printf(lcd_putc,»RPM»);
   lcd_gotoxy(4,2);  //Bigarren lerroa, 5.posizioa
   printf(lcd_putc,»ms»);
   lcd_gotoxy(12,2);  //Bigarren lerroa, 11.posizioa
   printf(lcd_putc,»Gradu»);
   while(1)
   {
      while(getc()!=’Z’);  //Itxaron datuak jasotzeko marka jaso arte
      for(i=0;i<7;i++)
         datuak[i]=getc(); //Portu serietik datuak jaso
      for(i=0;i<7;i++)
         write_eeprom(i,datuak[i]); //Eeprom memorian jasotako datuak gorde
      //LCD RPM///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
      lcd_gotoxy(1,1);                 //Lehenengo lerroa,1.posizioa
      printf(lcd_putc,»%c»,datuak[0]);    //RPM; Milakoak
      printf(lcd_putc,»%c»,datuak[1]);    //RPM; Ehunekoak
      printf(lcd_putc,»00″);              //RPM; Hamarrekoak eta Batekoak
      //LCD ANGULO AVANCE///////////////////////////////////////////////////////////////////////////////////////////
      lcd_gotoxy(8,2);                 //Bigarren lerroa,8.posizioa
      printf(lcd_putc,»%c»,datuak[2]);    //Angulo Avance; Seinua +-
      printf(lcd_putc,»%c»,datuak[3]);    //Angulo Avance; Hamarrekoa
      printf(lcd_putc,»%c»,datuak[4]);    //Angulo Avance; Batekoa
      //LCD TIEMPO INYECCION///////////////////////////////////////////////////////////////////////////////////////
      lcd_gotoxy(1,2);                 //Bigarren lerroa, 1.posizioa
      printf(lcd_putc,»%c»,datuak[5]);    //Inyekzioa; Hamarrekoa
      printf(lcd_putc,»%c»,datuak[6]);    //Inyekzioa; Batekoa
   }//while(1) bukara
}//main() bukaera
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*********************************************************************************************
                VDO
Medidor masa de aire
**********************************************************************************************
output_high(PIN_c3);//1
output_low(PIN_c4);//0
delay_ms(5000);
output_low(PIN_c3);//0
output_low(PIN_c4);//0
delay_ms(5000);
output_low(PIN_c3);//0
output_high(PIN_c4);//1
delay_ms(5000);
output_high(PIN_c3);//1
output_high(PIN_c4);//1
***********************************************************************************************/
#include <16F876A.H>
#device ADC=10
#fuses XT,NOWDT,NOPROTECT,NOLVP
#use delay(clock=4M)
int16 a;
int1 b,c,d,e,f,g;
void main(void)
{
   setup_adc_ports(AN0);
   setup_adc(adc_clock_internal);
   set_adc_channel(0);
   while(1)
   {
      a=read_adc();
      b=input(PIN_B1);//0%
      c=input(PIN_B2);//punto muerto
      d=input(PIN_B3);//25%
      e=input(PIN_B4);//50%
      f=input(PIN_B5);//75%
      g=input(PIN_B6);//100%
      if(b==0)
      {
         output_low(PIN_c4);//guztiz itxi
         output_high(PIN_c3);
      }
      else if(c==0)
      {
         output_high(PIN_c4);//jetsi baina motorrak lagunduta
         output_high(PIN_c3);//punto muerto
      }
      else if(d==0)
      {
         if(a>637)//50%   380
         {
            output_high(PIN_c4);//Ireki
            output_low(PIN_c3);
         }
         else
         {
            output_high(PIN_c3);//jetsi baina motorrak lagunduta
            output_high(PIN_c4);
         }
      }
      else if(e==0)
      {
         if(a>515)//50%   380
         {
            output_high(PIN_c4);//Ireki
            output_low(PIN_c3);
         }
         else
         {
            output_high(PIN_c3);//jetsi baina motorrak lagunduta
            output_high(PIN_c4);
         }
      }
      else if(f==0)
      {
         if(a>392)//50%   380
         {
            output_high(PIN_c4);//Ireki
            output_low(PIN_c3);
         }
         else
         {
            output_high(PIN_c3);//jetsi baina motorrak lagunduta
            output_high(PIN_c4);
         }
      }
      else if(g==0)
      {
         if(a>392)//50%   380
         {
            output_high(PIN_c4);//Ireki
            output_low(PIN_c3);
         }
      }
   }
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////