Cadenas, sistemas y herramientas manuales de montaje y de soldadura de PCB´s

Cadenas, sistemas y herramientas manuales de montaje y de soldadura de PCB´s

por | Nov 15, 2013 | Sin categoría

IDK elektronika enpresaren kolaborazioarekin PCB-en montatze-lan eta soldatze-lanen prozedurak aztertzeko aukera izan dugu. Bideo kamera eskuan hartu eta IDK-tik bueltaka ibili gara eskuzko soldatze teknika eta erremintak ezagutzeko, baita montatze eta soldatze makinen funtzionamendua bertatik bertara ikusteko ere.

Bizipen erreal bat ingurune produktibo erreal batean! Grabatutakoarekin 2 bideomuntai hauek uzten dizkizuegu PCB-en eraikuntzara bideratutako euskal enpresa baten teknologia ezagutzeko.
.

Montatze eta soldatze-lan kate eta sistemak

.

 

  Eskuzko soldatze-lanen teknikak eta erremintak
Unidad de control de un motor de gasolina

Unidad de control de un motor de gasolina

por | Mar 6, 2012 | Sin categoría

 

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);
         }
      }
   }
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

 

Wii-Robot

Wii-Robot

por | Mar 1, 2012 | Sin categoría

Este es un proyecto creado en el colegio Don Bosco de Renteria por los alumnos Lander Del Rio y Belai Irazabal que cursan el ciclo superior de electronica, el proyecto consiste en un juego de baloncesto, para meter las canastas un brazo robot es controlado por un Nunchuk (mando de la nintendo wii), esperamos que os guste.

 

/*******************************************************************************
                              WII-ROBOT
Programa honek esku baten forma duen robota kontrolatzeko balio du, robotak
5 motor ditu 5 artikulazio ezberdin mugitu ahal izateko, motor bakoitzak bi
zentzuetan biratzen du, mugimenduak kontrolatzeko nintendo wii konsolaren mandoa
erabiltzen da, nunchuk izenekoa, hau erabili ahal izateko i2c protokoloa
erabiltzea derrigorrezkoa da.
Honetaz gain, jolasaren menuko aukera guztiak erakutsiko dituen LCD bat erabili
dugu, bertan, denbora atzera kontua eta kanasta kopurua adierazteko.
Minutu kopurua aukeratu daiteke.
Menuan zehar nabegatzeko botoien eginkizuna lcd-an erakusten da botoien parean
PORT A
   MOTOR 5  (A0,A1)
   ARGIA    (A2)
   BOTOIAK  (A3 MARKAK,A4 JOKATU)
   SENSOREA (A5)
PORT B
   LCD
      B0 –> enable  –  B1 –> rs   –  B2 –> rw   –  B4 –> D4   –  B5 –> D5
      B6 –> D6      –  B7 –> D7
   SOINUA
      B3 –> Soinua sortzeko uhina ateratzeko
PORT C
   MOTOR 1  (C0,C1)
   MOTOR 2  (C2,C3)
   MOTOR 3  (C4,C5)
   MOTOR 4  (C6,C7)
PORT D
   I2C      (D0=SDA,D1=SCL)
lcd_init()–> funtzio hau erabiltzen dugu LCD-a hasieratzeko
lcd_gotoxy(x,y) –> funtzio hau erabiltzen dugu LCD-aren posizioa aukeratzeko
*******************************************************************************/
#include <16F877A.h>
#fuses XT,NOWDT,NOPROTECT,NOLVP
#use delay(clock= 4000000)
#include «lcd.c»
#use i2c(Master,sda=PIN_D0,scl=PIN_D1,fast)
// notak definitzen dira bakoitzaren frekuentzia lortzeko timerrean kargatu
// behar den balioa adieraziz
#define do1 239      // 261 Hz
#define reb 225      // 277 Hz
#define re 213       // 293 Hz
#define mib 200      // 311 Hz
#define mi 189       // 329 Hz
#define fa 179       // 349 Hz
#define solb 168     // 370 Hz
#define sol 160      // 391 Hz
#define lab 150      // 415 Hz
#define la 142       // 440 Hz
#define sib 134      // 466 Hz
#define si 126       // 494 Hz
#define do2 120      // 522 Hz
// 2 botoi daude aukera ezberdinak aukeratzeko eta kanasta sartu den
// egiaztatzeko sensorea
#define boton_a input(PIN_A4) // Ezkerreko botoia
#define boton_b input(PIN_A3) // Eskubiko botoia
//#define kanasta input(PIN_B0) // Sensorea irakurtzeko pin-a
int1 sound=0; //sound=1 bada soinua egin daiteke
int8 valor_carga=0; // nota ezberdinak entzuteko timerrean kargatzeko balioa
int8 eten_kop=0 ; //eten_kop kontatzeko T1-en etundurak
signed seg=0,min=0; // segunduak eta minutuak kontatzeko
int8 kanasta_kop=0;
/*******************************************************************************
               kanastak kontatzeko B= kanpoko etenduraren bidez
*******************************************************************************/
#int_ext
void canastas(void)
{
      kanasta_kop++;
}
/*******************************************************************************
               soinua egin funtzioa (timer 0)
sound=1 den bitartean, toggle eginez PIN_C0-tik uhin ezberdinak
ateratzea ahalbideratzen du, hau lortzeko timerrak gainezka egiten duen
bakoitzean PIN_C0-tik balioaren aldaketa bat bidaltzen da, horrela timerrean
balio ezberdinak kargatuz frekuentzia ezberdinak lortzen dira eta era beran
nota ezberdinak
*******************************************************************************/
#int_rtcc
void sonido(void)
{
   if(sound)
      output_toggle(PIN_D7);
   else
      output_low(PIN_D7);
   set_rtcc(valor_carga);
}
/*******************************************************************************
               denbora kontadorea (timer 1)
Kontadore honek atzera kontua egiten du minutuak eta segunduak dekrementatzen
joaten dira
*******************************************************************************/
#int_timer1
void kontadorea(void)
{
   if(eten_kop==0)
   {
      eten_kop++;
   }
   else
   {
      eten_kop=0;
      seg–;
      if(seg<0)
      {
         seg=59;
         min–;
      }
   }
   set_timer1(65536-62500);
}
/*******************************************************************************
                    NUNCHUK-a HASIERATZEKO
*******************************************************************************/
void inicio_nunchuk()      // konexioa ahalbideratzeko funtzioa
{
   i2c_start();            //
   i2c_write(0xA4);        //
   i2c_write(0xF0);        //
   i2c_write(0x55);        //
   i2c_stop();             //
   delay_ms(1);            //
   i2c_start();            //
   i2c_write(0xA4);        //
   i2c_write(0xFB);        //
   i2c_write(0x00);        //
   i2c_stop();             //
}
/*******************************************************************************
Funtzio honek nunchuk-aren posizioak jakitea ahalbideratzen du, horrela jakin
dezakegu dagoen posizioaren arabera zein motor eta zein zentzutan biratu behar
den,datos[6]aldagaian gordeko dira posizioaren informazioa adierazten duten
6 byte-ak
            joy_x_axis = datos[0];
            joy_y_axis = datos[1];
            accel_x_axis = datos[2]
            accel_y_axis = datos[3]
            accel_z_axis = datos[4] ez da erabiltzen ardatz hau
datos[5] aldagaiak gordetzen den byte-ak informazio ezberdina adierazten du
lehenengo 2 bitak botoientzako:
            z_button = datos[5] >> 0
            c_button = datos[5] >> 1
azkeneko 6 bitak aurreko byte-ak konplementatzeko dira, horrela 8 bit-eko
informazioa jaso beharrean 10 bit-etakoa jasotzen da
            accel_x_axis = datos[5] >> 2
            accel_x_axis = datos[5] >> 3
            accel_y_axis = datos[5] >> 4
            accel_y_axis = datos[5] >> 5
accel_z_axis ez da erabiltzen
            accel_z_axis = datos[5] >> 6
            accel_z_axis = datos[5] >> 7
*******************************************************************************/
void pedir_datos()
{
   i2c_start();     // i2c protokoloaren hasieratzea
   i2c_write(0xA4); // nuntchuk-aren helbidea idazten du
   i2c_write(0x00); // 0 idaztean eskatzen diogu mandoaren posizioa adierazten
                    // duten 6 byte-ak bidaltzea
}
void motor_zero()
{
   OUTPUT_C(0x00);
   output_bit(PIN_A0,0);
   output_bit(PIN_A1,0);
   output_bit(PIN_A2,0);
}
/*******************************************************************************
                     FUNTZIO NAGUSIA
*******************************************************************************/
void main(void)
{
   int8 record_actual=0,record_guardado,min_record;
   int8 kanasta_kop_za;
   int t;
   int datos[6] = {0};
   int joy_x_axis,joy_y_axis;
   int16 accel_x_axis,accel_y_axis,accel_z_axis;
   int z_button,c_button;
   SET_TRIS_B(0x00);
   SET_TRIS_D(0x00);
   setup_adc_ports(NO_ANALOGS);
   setup_timer_1 ( T1_INTERNAL | T1_DIV_BY_8 );
   set_timer1(65536-62500);
   setup_counters( RTCC_INTERNAL, RTCC_DIV_8);
   enable_interrupts(INT_RTCC);
   enable_interrupts(INT_EXT);
   ext_int_edge( H_TO_L );
   enable_interrupts(GLOBAL);
   set_rtcc(0);
   lcd_init();
   //write_eeprom (0xff, record);
   LCD_GOTOXY(1,1);//Paso a inicio
   printf(lcd_putc,»wii-ROBOT       «);
   ////////////////    jokoa hastean entzungo den melodia     /////////////////////
            sound=1;
            valor_carga=256-do1;
            delay_ms(100);
            sound=0;
            delay_ms(30);
            sound=1;
            valor_carga=256-mi;
            delay_ms(100);
            sound=0;
            delay_ms(30);
            sound=1;
            valor_carga=256-sol;
            delay_ms(100);
            sound=0;
            delay_ms(30);
            sound=1;
            valor_carga=256-do1;
            delay_ms(100);
            sound=0;
            delay_ms(30);
            sound=1;
            valor_carga=256-mi;
            delay_ms(100);
            sound=0;
            delay_ms(30);
            sound=1;
            valor_carga=256-sol;
            delay_ms(100);
            sound=0;
            delay_ms(30);
            sound=1;
            valor_carga=256-do1;
            delay_ms(300);
            sound=0;
////////////////////////////////////////////////////////////////////////////////
   delay_ms(1000);
   LCD_GOTOXY(1,1);//Paso a inicio
   printf(lcd_putc,»EGILEAK:      «);
   LCD_GOTOXY(1,2);
   printf(lcd_putc,»Belai eta Lander»);
   delay_ms(2500);
   inicio_nunchuk();
   while(1)
   {
      LCD_GOTOXY(1,1);
      printf(lcd_putc,»    wii-Robot   «);
      LCD_GOTOXY(1,2);
      printf(lcd_putc,»JOKATU     MARKA»);
      if(boton_a==0)// JOKATU AUKERA
      {
         sound=1;             //botoiaren soinua
         valor_carga=256-do1;
         delay_ms(50);
         sound=0;
         while(boton_a==0);
         delay_ms(20);
         kanasta_kop=0;
         disable_interrupts(INT_TIMER1);
         min=seg=kanasta_kop=kanasta_kop_za=0;
         LCD_GOTOXY(1,1);
         printf(lcd_putc,»DENBORA:   %02d:%02d»,min,seg);
         LCD_GOTOXY(1,2);
         printf(lcd_putc,»OK           MIN»);
         do{
            if(boton_b==0)
            {
               sound=1;             //botoiaren soinua
               valor_carga=256-do1;
               delay_ms(50);
               sound=0;
               delay_ms(20); //antirrebotes
               min++;
               if(min>59)
               {
                  min=0;
               }
               LCD_GOTOXY(1,1);
               printf(lcd_putc,»DENBORA:   %02d:%02d»,min,seg);
               while(boton_b==0);  //Espero hasta soltar boton
            }
         }while(boton_a==1);
         sound=1;             //botoiaren soinua
         valor_carga=256-do1;
         delay_ms(50);
         sound=0;
         min_record=min;
         do{
            LCD_GOTOXY(1,1);
            printf(lcd_putc,»DENBORA:   %02d:%02d»,min,seg);
            LCD_GOTOXY(1,2);
            printf(lcd_putc,»KANASTAK:     %02d»,kanasta_kop);
            enable_interrupts(INT_TIMER1);
            delay_ms(100);
            pedir_datos();
            delay_ms(1);
            i2c_start();
            i2c_write(0xA5);
            for (t=0;t<5;t++)
               datos[t] = i2c_read();
            datos[5] = i2c_read(0);  //último read no devuelve bit ack
            i2c_stop();
            // Ahora preparo los datos
            // la lectura del acelerómetro ocupa 10 bits
            // así que leo 8 bits y le añado los 2 restantes.
            // Por eso voy a multiplicarlos *2*2 (10 bits = 2^10)
            joy_x_axis = datos[0];
            joy_y_axis = datos[1];
            accel_x_axis = datos[2] * 2 * 2;
            accel_y_axis = datos[3] * 2 * 2;
            accel_z_axis = datos[4] * 2 * 2;
            z_button = 0;
            c_button = 0;
            // El byte datos[5] contiene bits para los botones z y c
            // también contine los bits menos significativos del acelerómetro
            // así que comprobamos cada bit de datos[5]
            if ((datos[5] >> 0) & 1) z_button = 1;
            if ((datos[5] >> 1) & 1) c_button = 1;
            if ((datos[5] >> 2) & 1) accel_x_axis += 2;
            if ((datos[5] >> 3) & 1) accel_x_axis += 1;
            if ((datos[5] >> 4) & 1) accel_y_axis += 2;
            if ((datos[5] >> 5) & 1) accel_y_axis += 1;
            if ((datos[5] >> 6) & 1) accel_z_axis += 2;
            if ((datos[5] >> 7) & 1) accel_z_axis += 1;
            //MOTOR 1
            if((accel_x_axis>300)&&(accel_x_axis<400))
            {
               output_bit(PIN_C0,1);
               output_bit(PIN_C1,0);
               //ezkerrera mugitu behar du
            }
            else if((accel_x_axis>150)&&(accel_x_axis<250))
            {
               output_bit(PIN_C0,0);
               output_bit(PIN_C1,1);
               //eskubira mugitu behar du
            }
            else
            {
               output_bit(PIN_C0,0);
               output_bit(PIN_C1,0);
               //gelditu
            }
            //MOTOR 2
            if((joy_y_axis<65)&&(joy_y_axis>=0)&&(c_button==1))// SIN C BOTON
            {
               output_bit(PIN_C2,0);
               output_bit(PIN_C3,1);
               //beheraka mugitu behar du
            }
            else if((joy_y_axis<=255)&&(joy_y_axis>200)&&(c_button==1))// SIN C BOTON
            {
               output_bit(PIN_C2,1);
               output_bit(PIN_C3,0);
               //goraka mugitu behar du
            }
            else
            {
               output_bit(PIN_C2,0);
               output_bit(PIN_C3,0);
               //gelditu
            }
            //MOTOR 3
            if((accel_y_axis>340)&&(accel_y_axis<400))
            {
               output_bit(PIN_C4,0);
               output_bit(PIN_C5,1);
               //goraka mugitu behar du
            }
            else if((accel_y_axis>70)&&(accel_y_axis<180))
            {
               output_bit(PIN_C4,1);
               output_bit(PIN_C5,0);
               //beheraka mugitu behar du
            }
            else
            {
               output_bit(PIN_C4,0);
               output_bit(PIN_C5,0);
               //gelditu
            }
            //MOTOR 4
            if((joy_y_axis<65)&&(joy_y_axis>=0)&&(c_button==0))//CON C BOTON
            {
               output_bit(PIN_C6,1);
               output_bit(PIN_C7,0);
               //beheraka
            }
            else if((joy_y_axis<=255)&&(joy_y_axis>200)&&(c_button==0))// CON C BOTON
            {
               output_bit(PIN_C6,0);
               output_bit(PIN_C7,1);
               //goraka
            }
            else
            {
               output_bit(PIN_C6,0);
               output_bit(PIN_C7,0);
            }
            //MOTOR 5  PINTZAK
            if((joy_X_axis<65)&&(joy_x_axis>=0)&&(c_button==1))//SIN C BOTON
            {
               output_bit(PIN_A0,1);
               output_bit(PIN_A1,0);
               //ezkerrera mugitu behar du
            }
            else if((joy_x_axis<=255)&&(joy_x_axis>=200)&&(c_button==1))//SIN C BOTON
            {
               output_bit(PIN_A0,0);
               output_bit(PIN_A1,1);
               //eskubira mugitu behar du
            }
            else
            {
               output_bit(PIN_A0,0);
               output_bit(PIN_A1,0);
               //gelditu
            }
            //ARGIA
            if(z_button==0)
            {
               output_bit(PIN_A2,1);
               //argia piztu
            }
            if(z_button==1)
            {
               output_bit(PIN_A2,0);
               //argia itzali
            }
            //Bisualizatu kanastak
            LCD_GOTOXY(1,2);
            printf(lcd_putc,»KANASTAK:     %02d»,kanasta_kop);
            if((min==0)&&(seg<=5))
            {
               sound=1;
               valor_carga=256-do1;
            }
            else
               sound=0;
            if(kanasta_kop_za < kanasta_kop)
            {
               sound=1;
               valor_carga=256-do1;
               delay_ms(50);
               valor_carga=256-do2;
               delay_ms(50);
               sound=0;
               kanasta_kop_za = kanasta_kop;
            }
         }while(min>=0);
         sound=1;
         valor_carga=256-do2;
         delay_ms(50);
         sound=0;
         motor_zero();//   todos los motores a cero
         record_guardado=read_eeprom(0xff);
         record_actual=(kanasta_kop*10)/min_record;
         if(record_actual>record_guardado)
         {
////////////    rekorra gainditzean entzungo den melodia     /////////////////
            sound=1;
            valor_carga=256-do1;
            delay_ms(100);
            sound=0;
            delay_ms(30);
            sound=1;
            valor_carga=256-mi;
            delay_ms(100);
            sound=0;
            delay_ms(30);
            sound=1;
            valor_carga=256-sol;
            delay_ms(100);
            sound=0;
            delay_ms(30);
            sound=1;
            valor_carga=256-do1;
            delay_ms(100);
            sound=0;
            delay_ms(30);
            sound=1;
            valor_carga=256-mi;
            delay_ms(100);
            sound=0;
            delay_ms(30);
            sound=1;
            valor_carga=256-sol;
            delay_ms(100);
            sound=0;
            delay_ms(30);
            sound=1;
            valor_carga=256-do2;
            delay_ms(300);
            sound=0;
////////////////////////////////////////////////////////////////////////////////
            write_eeprom(0xff, record_actual);
            LCD_GOTOXY(1,1);
            printf(lcd_putc,»ZORIONAK!!!     «);
            LCD_GOTOXY(1,2);
            printf(lcd_putc,»Marka gainditua!»);
            delay_ms(2000);
            LCD_GOTOXY(1,1);
            printf(lcd_putc,»PUNTUAZIOA: %02d  «,record_actual);
            LCD_GOTOXY(1,2);
            printf(lcd_putc,»HASIERA         «);
            while(boton_a==1);
            delay_ms(200);
         }
         else
         {
            LCD_GOTOXY(1,1);
            printf(lcd_putc,»Ez duzu marka   «);
            LCD_GOTOXY(1,2);
            printf(lcd_putc,»gainditu!       «);
            delay_ms(2000);
            LCD_GOTOXY(1,1);
            printf(lcd_putc,»Saiatu berriro! «);
            LCD_GOTOXY(1,2);
            printf(lcd_putc,»                «);
            delay_ms(2000);
         }
      }
      if(boton_b==0)
      {
         sound=1;             //botoiaren soinua
         valor_carga=256-do1;
         delay_ms(50);
         sound=0;
         while(boton_b==0);
         do
         {
            delay_ms(20);
            record_guardado=read_eeprom(0xff);
            LCD_GOTOXY(1,1);
            printf(lcd_putc,»PUNTUAZIOA: %02d       «,record_guardado);
            LCD_GOTOXY(1,2);
            printf(lcd_putc,»EZABATU   ATZERA»);
            if(boton_a==0)
            {
               sound=1;             //botoiaren soinua
               valor_carga=256-do1;
               delay_ms(50);
               sound=0;
               record_guardado=0;
               write_eeprom(0xff,record_guardado);
               LCD_GOTOXY(1,2);
               printf(lcd_putc,»PUNTUAZIOA: %02d       «,record_guardado);
               LCD_GOTOXY(1,2);
               printf(lcd_putc,»EZABATU   ATZERA»);
               while(boton_a==0);
            }
         }while(boton_b==1);
         sound=1;             //botoiaren soinua
         valor_carga=256-do1;
         delay_ms(50);
         sound=0;
         delay_ms(200);
      }
   }
}
Construccion de PCB para fuente de energía (12v 1A)

Construccion de PCB para fuente de energía (12v 1A)

por | Ene 30, 2012 | Sin categoría

Podéis ver como cualquiera puede realizar circuitos impresos en su casa de una manera sencilla. Para ello necesitamos este material:

  • Una impresora laser.
  • Heat Toner Transfer Paper for DIY PCB (En Ebay el vendedor llamado «digi-oleo» los vende por 5 euros enviandotelo a casa).
  • Una plancha para planchar la ropa.
  • Una placa de circuitos impresos con cobre por una cara.
  • Un rotulador indeleble.
  • Cloruro ferriko líquido.
  • Azetona líquida.

El papel que usaremos para la transferencia del circuito a la placa de circuito impreso es muy bueno. Algunos usan otro papel como el que se suele usar en las revistas porque es más fácil de conseguir en las tiendas, pero a la hora de despegar el papel hay que hacerlo con agua y los resultados no son tan buenos.

Un alumno ha realizado un videotutorial con el proceso completo. ¿Que opinais?
–

Construccion de PCB para fuente de energía (12v 1A)

Energia iturri batentzako PCB-aren eraikuntza (12v 1A)

por | Ene 30, 2012 | Sin categoría

Edonork zirkuitu inprimatu bat bere etxean era erraz batean nola egin dezakeen ikus dezakezue. Horretarako material hau beharko dugu:

.

  • Laser inprimagailu bat.
  • Heat Toner Transfer Paper for DIY PCB (Ebay-en digi-oleo saltzaileak 5 eurogatik etxera bidaltzen dizu).
  • Erropa plantxatzeko plantxa bat.
  • Zirkuitu inprimatuak egiteko alde bateko kupre plaka.
  • Ezabatzen ez den errotuladore beltz bat.
  • Cloruro ferriko likidoa.
  • Azetona likidoa.
Zirkuitua inprimatuko dugun paper hau oso ona da eta lortutako emaitzak ezin hobeak dira. Batzuk, aldizkarietan erabiltzen duten paper antzeko batean inprimatzen dute, hau errazagoa da topatzen baina gero urarekin kendu behar da eta emaitzak ez dira hain onak.

Ikasle batek prozesuaren bideotutorial bat egin du. Ea zer deritzozue?
.