Eco-clutch, Shell Eco-Marathonen lehiaketarako enbragearen kontrola

Eco-clutch, Shell Eco-Marathonen lehiaketarako enbragearen kontrola

Proiektu hau, Don Bosco ikastetxeko Automozio departamentuari, urtero parte hartu ohi duen Shell Eco-Marathon lehiaketan laguntzeko asmoz sorturikoa da.
.

.

Shell Eco-Marathon lehiaketa, urtero ospatu ohi den norgehiagoka bat da eta bertan mundu guztiko ikastetxe eta unibertsitatetako ikaslee hartu ohi dute parte, urte guztian zehar diseinatu eta hobetu duten prototipoarekin. Gure proiektuaren helburua, Automizokoekin batera lan egitea eta beraien zailtasunetan laguntzea izan da, lehiaketan emaitza hobeak lortzeko asmoz.
.

.

Shell Eco-Marathon lehiaketaren helburua, litro bat erregairekin ahalik eta kilometro gehien egitean datza eta honetarako autoek ahalik eta arinenak eta aerodinamikoenak izan behar dute. Hau dela eta, auto hauek honela funtzionatzen dute: motorraren bidez komeni zaien abiadura hartzen dute (30-40 km/h) eta ondoren motorra gelditu eta inertziaren bidez jarraitzen dute. Jakina den bezala autoak pixkanaka abiadura galtzen du, eta abiadura hori oso mantxoa denean (10-15 km/h) berriro motorra martxan jartzen dute abiadura egokia hartu arte ondoren berriro ere motorra geldituz.
Hau guztia jakiñik, gure proiektuak bi helburu ditu: autoaren abiaduraren eta motorraren RPM-en arabera enbrage elektromagnetiko bat aktibatu edo desaktibatu eta gidariari autoaren abidura adierazi. Honetarako bi PCB sortu ditugu: PCB nagusia eta PCB erakuslea.
.

PCB nagusia
.

PCB erakuslea
.

Erabilitako materiala
Ondorengo hauek izan dira erabili ditugun materialak. Informazio zabalagoa jasotzeko, egin klik bakoitzaren gainean.
1x PIC 18F2550
2x Display kontrolagailuak 74LS47
2x 7 segmentuko display-ak 7segm
1x Tentsio erreguladorea 7805

2x Array erresistentziak 4116R

Eskema Simulagarria

Lehenik eta behin eskema simulagarri bat egin zen, bertan konponenteen arteko konexioak egin ziren eta honen funtzionamendu egokia egiaztatu zen.

.
.
Isis-eko zirkuitu simulagarriaren artxiboak deskargatzeko egin klik hemen.

Simulaziorako eskema egin eta probatu ondoren, bi PCB-en diseinuak egiten hasi ginen. Honetarako, bi eskema desberdin egin behar izan genituen, PCB bakoitzarentzat bat.
.

PCB nagusiaren diseinurako eskema
.
PCB nagusiaren diseinurako eskema deskargatzeko egin klik hemen.
.
PCB erakuslearen diseinurako eskema
.
PCB erakuslearen diseinurako eskema deskargatzeko egin klik hemen.

Ondoren eskema hauen arabera, PCB-en diseinuak egiteari ekin genion. PCB nagusia bi aurpegikoa egin behar izan zen, izan ere, ez ziren pista guztiak alde batean sartzen, eta aldiz PCB erakuslea simpleagoa zenez, aurpegi batekoa egin genuen. Azpiko irudietan agertzen dira gure PCB-en diseinuak.
.

PCB nagusiaren diseinua
.
.
 PCB erakuslearen diseinua
.
Programazioa

18F2550 PIC-a programatzeko software-a PIC C Compiller izenekoa da eta bertan C lenguaia erabiliz programatzen da. Azpian agertzen da guk erabilitako programa.

#include «D:\ECO SHELL\Firmware\Firm_V3\Eco-clutch.h»

int32 temp1=0, t1;    //Buelta baten denbora
int32 temp2=0, t2;    //Buelta baten denbora
int16 rpmMotor;       //Abiadura RPM-tan MOTORRA
int16 rpmGurpil;      //Abiadura RPM-tan GURPILA
float32 a=0;          //Hortzetik hortzera dagoen denbora segunduetan, hau da t1-etik t2-ra
float32 b=0;          //Hortzetik hortzera dagoen denbora segunduetan, hau da t3-etik t4-ra
float aux_rpm1=0;     //Abiadura RPM-tan dezimalekin MOTORRA
float aux_rpm2=0;     //Abiadura RPM-tan dezimalekin GURPILA
float aux_abiadura=0;
unsigned int16 Abiadura_be=0,Abiadura_za=0 ;   //Abiadura berria eta abiadura zaharra
int8 dec, uni;    //Dezenen display-a eta unitarioen display-a

void abiad_kalkulo(void);
void  Belozimetroa(void);

#int_EXT
void  GurpilBirak(void)  //Gurpilaren biren kontagailuaren funtzioa
{
temp1=get_timer1(); //Buelta baten denbora jaso
set_timer1(0);  //Timer1 Hasieratu, momentu honetan timer-a kontatzen hasiko da

}

#int_EXT2
void  MotorBirak(void)   //Motorraren biren kontagailuaren funtzioa
{
temp2=get_timer0(); //Buelta baten denbora
set_timer0(0);  //Timer2 Hasieratu, momentu honetan timer-a kontatzen hasiko da

}

void  Test(void)   //Plaka elikatzean, display-ek ongi funtzionatzen dutela jakiteko funtzioa
{
int i;
for(i=0; i<3; i++)   //Display-en segmentu guztiak piztu segundu erdi batez eta denak itzali beste segundu erdi batez. Hau hiru aldiz egingo dugu.
{
int test1 = 8;  //Segmentu guztiak pizteko aldagaia
int test2 = 15; //Segmentu guztiak itzaltzeko aldagaia
output_A(test1);//A portutik unitarioko display-aren segmentu guztiak piztu

output_bit(PIN_B4,shift_right(&test1,1,0)); //B portuko 4. pinetik dezenen display-a piztu
output_bit(PIN_B5,shift_right(&test1,1,0)); //B portuko 5. pinetik dezenen display-a piztu
output_bit(PIN_B6,shift_right(&test1,1,0)); //B portuko 6. pinetik dezenen display-a piztu
output_bit(PIN_B7,shift_right(&test1,1,0)); //B portuko 7. pinetik dezenen display-a piztu

delay_ms(500);  //Segundu erdiz segmentuak piztuta eduki

output_A(test2);//A portutik unitarioko display-aren segmentu guztiak itzali

output_bit(PIN_B4,shift_right(&test2,1,0));//B portuko 4. pinetik dezenen display-a itzali
output_bit(PIN_B5,shift_right(&test2,1,0));//B portuko 5. pinetik dezenen display-a itzali
output_bit(PIN_B6,shift_right(&test2,1,0));//B portuko 6. pinetik dezenen display-a itzali
output_bit(PIN_B7,shift_right(&test2,1,0));//B portuko 7. pinetik dezenen display-a itzali

delay_ms(500);//Segundu erdiz segmentuak itzalita eduki

}
}

void  Belozimetroa(void)        //Abiadura display-etan azaltzeko funtzioa
{

dec = Abiadura_be / 10;  //Autoaren abiaduraren zenbaki dezena kalkulatu
uni = Abiadura_be % 10;  //Autoaren abiaduraren zenbaki unitarioa kalkulatu

output_A(uni);  //A portutik zenbaki unitarioa atera, modu binarioan

output_bit(PIN_B4,shift_right(&dec,1,0));  //B portuko 4. pinetik zenbaki dezena atera, binarioan
output_bit(PIN_B5,shift_right(&dec,1,0));  //B portuko 5. pinetik zenbaki dezena atera, binarioan
output_bit(PIN_B6,shift_right(&dec,1,0));  //B portuko 6. pinetik zenbaki dezena atera, binarioan
output_bit(PIN_B7,shift_right(&dec,1,0));  //B portuko 7. pinetik zenbaki dezena atera, binarioan

}

void abiad_kalkulo()   //Gurpilaren biren arabera, autoaren abiadura kalkulatzeko funtzioa
{
t1=temp1*8;
b=((t1/1000.0)/1000.0); //Hortzetik hortzerako denbora microsegundutatik segundutara        pasatu //3300uS = 0,0033s
aux_rpm2=60.0/b; //Bira kopurua minutuko RPM    //60/0,2=300rpm
rpmGurpil=aux_rpm2;    //Emaitzari koma kendu eta zenbaki oso bihurtu
aux_abiadura= rpmGurpil*0.075396;  //Lortutako RPM-en emaitza, guk aurrez sortutako konstante batekin biderkatu (gurpilaren zirkunferentzia…)
Abiadura_be=aux_abiadura;   //Emaitzari koma kendu eta zenbaki oso bihurtu
if( Abiadura_be!=Abiadura_za)  //Abiadura berria eta abiadura zaharra desberdinak badira….
{
if (((Abiadura_be – Abiadura_za)<3)||((Abiadura_za – Abiadura_be)<3))   /* Abiadura berria eta zaharraren arteko aldea 3 km/h-ko baino txikiagoa bada…
{                                                                       //8 km/h-tik behera arazoak ematen dituenez, abiadura honetatik behera
//Display-ak zeroan jarriko ditugu*/

Belozimetroa();   //Abiadura display-etan azaldu
Abiadura_za=Abiadura_be;  //Abiadura zaharrari abiadura berriaren aurreko denbora eman

}
/*else                          //Else honetan 8km/h baino mantsoago goanez, display-ak zeroan jarriko ditugu
{
Abiadura_za=Abiadura_be;   //Abiadura zaharrari abiadura berriaren aurreko denbora eman
Abiadura_be=0;   //Display-ak zeroan jartzeko, abiadura zeroan jarri
Belozimetroa();  //Abiadura display-etan azaldu, kasu honetan zero
}*/

}
//}

void main()
{

setup_adc_ports(NO_ANALOGS|VSS_VDD);
setup_adc(ADC_OFF);
setup_spi(SPI_SS_DISABLED);
setup_wdt(WDT_OFF);
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_8);
setup_timer_1(T1_INTERNAL|T1_DIV_BY_8);
setup_timer_2(T2_DISABLED,0,1);
setup_timer_3(T3_DISABLED|T3_DIV_BY_1);
setup_comparator(NC_NC_NC_NC);
setup_vref(FALSE);
enable_interrupts(INT_EXT);
enable_interrupts(INT_EXT2);
enable_interrupts(GLOBAL);
setup_oscillator(OSC_4MHZ|OSC_INTRC|OSC_31250|OSC_PLL_OFF);

Test();
Belozimetroa();

while(TRUE)     // TODO: USER CODE!!
{
while(input(PIN_B1)==1)  // Etengailua Manuala
{
output_high(PIN_C0);//Enbragea aktibatu
abiad_kalkulo();//Abiadura kalkulatu

printf(«Abiadura: %Lu Km/h.\n\r»,Abiadura_be);
}
while(input(PIN_B1)==0)  // Etengailua automatikoa
{

if(input(PIN_C1))  //Itxaron rpmak 200tik pasa arte (Timerrak gaizki ez neurtzeko)
{
delay_ms(1000);
}

t2=temp2*8;
a=((t2/1000.0)/1000.0); //Hortzetik hortzera dagoen denbora microsegundutatik segundutara pasatu //3300uS = 0,0033s
aux_rpm1=60.0/a; //Bira kopurua minutuko RPM    //60/0,2=300rpm
rpmMotor=aux_rpm1;    //aux_rpm:float/rpm:int16

abiad_kalkulo();//Abiadura kalkulatu

if ((rpmMotor-rpmGurpil<15)||(rpmGurpil-rpmMotor<15)) // 15 aztertzekoa da
{
output_high(PIN_C0);  //Enbragatu
}
else
{
output_low(PIN_C0);   //Desenbragatu
}

if(input(PIN_B3))
{
output_low(PIN_C0);     //Desenbragatu
// delay_ms(500);
}

printf(«Abiadura: %Lu K/h.\n\r»,Abiadura_be);

}
}
}


Proiektua osatzeko material eta artxibo guztiak HEMEN eta Tutoriala beheko bideoan.


TraktoBot, Bluetooth bidez kontrolatutako traktorea

TraktoBot, Bluetooth bidez kontrolatutako traktorea

TRAKTOBOT
.
Gure proiektua bluetooth bidez konektatutako traktorean oinarritzen da, eta bluetooth teknologiarekin sekuentzien aldaketa egitea ahalbidetezen du gure mugikorraren bitartez, guk nahi duguna egin dezan traktoreak.
.
.
     Proiektu honek dituen teknologiak:
.
1-Bluetooth: dispositibo inalambriko bat da, non mugikorrarekin konektatzean mikrokontroladoreari mugikorraren bitartez aginduak bidaltzea ahalbidetzen digu. Hau bluecontrol aplikazioaren bitartez kontrola dezakegu, eta aplikazio hau play-estoretik deskargatu daiteke.
.

.
2-L293D: Teknologia honen bitartez, motorren kontrola lortzen dugu, bi aldetara bira dezaketelako. Txip honek 2 motor kontrola ditzazke gehienez, bainan beti ahal izango diozu txertatu besteren bat beste bi motor erabiltzeko.
Proiektuaren funtzionamendua:
     Bluetooth-aren bitartez komando bat  sartuko diogu gure mikrokontroladoreari, eta honek komando bat ala beste jasotzean mikrokontroladoreari barneratutako programaren sekuentzi bat edo beste martxan jartzen da. 5 sekuentzi modu egin ditugu, lehenengoa aurreraka joateko, bigarrena atzeraka joateko, hirugarrena ezkerrera biratzeko, laugarrena eskuinera biratzeko, eta bostgarrena eta azkena motorrak geldi geratzeko.
Proiektua aurrera eramateko pausuak:
.
1-Eskemaren edizioa:
.
     Lehenik eta behin proteus programaren isis atalean eskema bat egitea beharrezkoa da, gure plakan beharrezkoak diren elementuekin, funtzionamendua bermatzeko eta sortutako programarekin simulazioari ekiditeko. Isisa eginda eduki ondoren, hau modifikatu egingo dugu Ares-a sortzeko, eta hau sortu ondoren hurrengo atalera pasatzen gera.
..

     Bigarren hau ares-a egiteko da, eraldatuta:
.
.
2- PCB-aren fabrikazioa:
.
     Issis eko eskema aresera pasa eta pistak eraiki ondoren, LPKF makinara goaz guk egindako plaka imprimatzeko. Hau ongi egiteko, aresean gerberrak sortu behar dira, eta LYT-arekin, boar master programan .lmd duen beste bat lortuko dugu, eta honekin LPKF-ak ulertu dezan bere lanarekin hasteko.
.
.
     -Hau da lpkf-arentzat egindako ares-a.
.
.
3-Konponenteak plakan jartzea:
.

     Plaka ondo eginda dagoela zihurtatu ondoren, hautatutako konponenteak plakan soldatzen jarri ginen, kontuan hartzen bakoitzaren posizioa eta bakoitzaren kokalekua. Hau egiteko dexente denbora tardatu genuen, plakan soldatzeko eremuak ez baitziren guztiz guk esperotakoak, baino lortu genuen ongi soldatzea.

.

.

4- Pic-aren programazioa:
.
Komentarioekin dator, eta hauek gazteleraz daude denek ulertzeko zer egiten duen programaren zati bakoitzak.

/*——————————————-*\

 | proyecto del control de tractor: Iñigo Lazkano

 el programa consiste en controlar un tractor desde el dispositivo android.

\*——————————————-*/

#include <16f87.h>

#FUSES NOWDT                    //No Watch Dog Timer

#FUSES INTRC_IO                 //Internal RC Osc, no CLKOUT

#FUSES PUT                      //Power Up Timer

//#FUSES MCLR                     //Master Clear pin enabled

#FUSES NOBROWNOUT               //No brownout reset

#FUSES NOCPD                    //No EE protection

#FUSES NOWRT                    //Program memory not write protected

#FUSES NODEBUG                  //No Debug mode for ICD

#FUSES NOPROTECT                //Code not protected from reading

#FUSES NOFCMEN                  //Fail-safe clock monitor disabled

#FUSES NOIESO                   //Internal External Switch Over mode disabled

#use delay(clock=4000000)

#use RS232(baud=9600, xmit=PIN_B5, rcv=PIN_B2)      //#use rs232(baud=9600,parity=N,xmit=PIN_A3,rcv=PIN_A2,bits=8)

#use i2c(Master,sda=PIN_B1,scl=PIN_B4)

int8 sekuentzia=’E’;                                                          //declaramos que para empzar esten los motores apagados

void serie(void);

/****************************************************************************

      FUNCION PRINCIPAL

****************************************************************************/

void main(void)

{

   int8 i;

   setup_adc_ports(NO_ANALOGS);                              // para que los puertos sean digitales

   set_tris_b(0b00000100);

//   set_tris_a(0xff);

  

  

     

   while(1)

   {  

      serie();                                                                        //leer bluetooth

      if(sekuentzia==’E’)                                                     //si esta detectando una E entra en este ciclo

      {

         while(sekuentzia==’E’)                                                               

         {

               output_low(PIN_B0),output_low(PIN_B3),output_low(PIN_B1),output_low(PIN_B4);  //parar los motores

               serie();                                                               //lee la entrada del bloetooth

               if(sekuentzia!=’E’)                                             //si lo que lee es diferente a E

                  break;                                                              //sal del ciclo

         }

      }

      else if(sekuentzia==’B’)

      {

         while(sekuentzia==’B’)                                         //Si lee un B entra en este ciclo

         {

               output_low(PIN_B0),output_low(PIN_B3),output_high(PIN_B1),output_high(PIN_B4);//Motores hacia atras

               serie();                                                                //lee la entrada del bloetooth

               if(sekuentzia!=’B’)                                             //si canbia de valor la entrada

                  break;                                                              //sal del ciclo

         }

      }  

      else if(sekuentzia==’C’)                                              //Si lee un C entra en este ciclo

      {

         while(sekuentzia==’C’)

         {

           output_high(PIN_B0),output_low(PIN_B3),output_low(PIN_B1),output_low(PIN_B4);     //girar izquierda

            serie();                                                                   //lee la entrada del bloetooth

            if(sekuentzia!=’C’)                                                 //si canbia de valor la entrada

               break;                                                                  //sal del ciclo

         }

      }  //fin else if sek C

       else if(sekuentzia==’D’)                                              //Si lee un D entra en este ciclo

      {

         while(sekuentzia==’D’)

         {

               output_low(PIN_B0),output_high(PIN_B3),output_low(PIN_B1),output_low(PIN_B4); //girar derecha

               serie();                                                                 //lee la entrada del bloetooth

               if(sekuentzia!=’D’)                                               //si canbia de valor la entrada

                  break;                                                                //sal del ciclo

         }

      }

        else if(sekuentzia==’A’)                                              //Si lee un A entra en este ciclo

      {

         while(sekuentzia==’A’)

         {

               output_high(PIN_B0),output_high(PIN_B3),output_low(PIN_B1),output_low(PIN_B4);//Motores                                                                                                                                hacia delante

               serie();                                                                  //lee la entrada del bloetooth

               if(sekuentzia!=’A’)                                               //si canbia de valor la entrada

                  break;                                                                //sal del ciclo

         }

      }

   }                                                                                       //fin while 1

}                                                                                          //fin main

/****************************************************************************

      FUNCION Serie

****************************************************************************/

void serie(void)

{

   if(kbhit() !=0)                                                                            //si canbia la entrada del bloetooth,

   {

      sekuentzia=getc();                                                                    //guarda lo que recibas en la variable llamado sekuentzia

   }  

}

5- Sekuentziak:

.

Hemen ikus daiteken moduan, pin bakoitza zein egoeratan egon behar den momentu bakoitzean adierazten digu.
Sekuentzia A: bi motoreak aurreraka.
Sekuentzia B: bi motoreak atzeraka.
Sekuentzia C: ezkerreko motorea martxan eta eskuinekoa geldirik.
Sekuentzia D: eskuineko motorea martxan eta ezkerrekoa geldirik.
Sekuentzia E: bi motoreak geldirik.

 

6-Bluecontrol aplikazioa:
.

    Edozein mugikorretan aplikazio hau instalatzean bluetooth-a kontrola dezakezu,baina mugikor batekin konektatuta dagoenean ezin da beste gailuren batekin konektatu. honekin, denbora errealean guk aplikatu nahieko sekuentzia aukeratzean datza.

7- -Prototipoa eraikitzea

.
Plastikozko piezekin sorturiko traktorea da, ABS edo PLA materialak erabili daitezke.Plastikozko piezak eraikitzeari ekin genion, 3D-ko impresoran erraza baizen piezak egitea. Hontaz gain, plastikozko piezak pisu gutxikoak eta arinak dira, eta traktorearen estrukturarako gogorrak ziren.3D-ko imprimagailuak, donbosko ikastolakoak erabili ditugu.
.
     Honako piezak atera dira:
.
.
.

8- -dena kableatzea:
.

     Hau da azken atala, eta plaka basetik motorretara dijoazen kableak eraikitzean datza. Horretarako, kontuan hartu behar da nora dijoan irteera bakoitzeko seinalea, gaizki eraman ezkero beste motore bat piztuko baita.
.
.
Erabilitako materiala
-Pic 16f87 (1)
-L293D (1)
-RES 10k (1)
-Condensador 220nf (1)
-Condensador 27pf (2)
-Cristal de cuarzo (1)
-Bluetooth (1)

-TT-motor (2)

Proiektua egiteko behar dituzuen artxiboak hemendik deskarga ditzakezue.

Balantza Elektronikoa

Balantza Elektronikoa

Proiektu hau kaxak eramateko gurdi batean instalatzeko balantza elektriko bat egitea zen, baina azkenean, proiektu hau egiteko sentsore egokia lortu ezin izan denez balantza arrunt bat egitea erabaki da. Balantza honek LCD bat dauka balioak agertzeko eta menu batean pisu arrunta eta akumulatuaren artean aukeratu ahal izango da. Menu hori kontrolatzeko hiru botoi egongo dira, OK, BERA eta ATZERA.

.
Pisua detektatzeko sentsorea, indar sentsore bat da, flexiforce sentsorea hain zuzen ere.

.

 

Sentsore honek erresistentzia bariable baten moduan funtzionatzen du. Indarrik aplikatu gabe bere erresistentzia oso altua da eta indarra  aplikatzean erresistentzia jaitsi egiten da. Zirkuitu honetan, programtau ahal izateko, mikrokontralagailuak tentsio aldaketak detektatzen ditu gainean aplikatzen zaion indarraren edota pisuaren arabera, kasu honetan bezala. Hau egin ahal izateko pic mikrokontrolagailua erabili da, pic c programaren bitartez programatuz. Sentsoreak bidalitako tentsioak pic-aren bitartez LCD-an kg-tan azaltzeko, konbertsio analogiko bat egin da, while batzuen bitartez botoi bakoitza sakatuta dagoenean zer egin behar duen esanaz.

Balantza elektronikoa egiteko erabili den programa:

#include <16F88.h>
#device ADC=10                  //Conversor ADC/ de 10 bits de resolución

#FUSES NOWDT                    //No Watch Dog Timer
#FUSES INTRC_IO                 //Internal RC Osc, no CLKOUT
#FUSES PUT                      //Power Up Timer
#FUSES MCLR                     //Master Clear pin enabled
#FUSES NOBROWNOUT               //No brownout reset
#FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOCPD                    //No EE protection
#FUSES NOWRT                    //Program memory not write protected
#FUSES NODEBUG                  //No Debug mode for ICD
#FUSES NOPROTECT                //Code not protected from reading
#FUSES NOFCMEN                  //Fail-safe clock monitor disabled
#FUSES NOIESO                   //Internal External Switch Over mode disabled

#use delay(clock=4000000)

#include «lcd.c»

#define OK PIN_A1
#define BERA PIN_A2
#define ATZERA PIN_A3

int16 resultado;           //Variable para el resultado de la conversión AD

/*****************************************************************************
Funcion principal
*****************************************************************************/
void main(void)
{
float pisua,total=0;
//   int8 m1_lerro=1, m2_lerro=1;

lcd_init();                        //Inicia la pantalla LCD

//Se activa el ADC y se selecciona el canal RA0/AN0. Frecuencia de trabajo Fosc/32
setup_adc(adc_clock_internal);     //Ajusta frecuencia de muestreo del ADC ¡¡OJO!!
setup_adc_ports(sAN0);//VSS_VDD|sAN0);   //RA0 entrada analógica
set_adc_channel(0);              //Selección del canal 0 (RA0)
while(TRUE)
{
printf(lcd_putc,»\f%cPisu arrunta»,0x7e);   //Visualiza el texto fijo del
printf(lcd_putc,»\n Akumulutua»);           //Visualiza el texto fijo del

while((input(OK)==1)&&(input(BERA)==1));    //itxaron OK edo BERA sakatu arte
delay_ms(20);                          //Erreboteak ekiditzeko
if(input(OK)==0)
{
pisua=0;
while((input(OK)==0));           //Itxaron OK askatu arte
delay_ms(20);                       //Erreboteak ekiditzeko
printf(lcd_putc,»\fPisua: %.2f kg «,pisua);
printf(lcd_putc,»\nSakatu OK»);   //Visualiza el texto fijo del
while((input(OK)==1));            //itxaron OK sakatu arte
delay_ms(20);                    //Erreboteak ekiditzeko
resultado=read_adc();                 //Inicia la conversión y lee el resultado
pisua=resultado*(11.339/1025.0)-0.9;             //Calculamos la tension

lcd_gotoxy(7,1);
printf(lcd_putc,»%.2f «,pisua);   //Visualiza el resultado
if(pisua<0)
printf(lcd_putc,»\fPisua: 0.00 kg «);
printf(lcd_putc,»\nSakatu ATZERA»);   //Visualiza el texto fijo del
while(input(ATZERA)==1);    //itxaron ATZERA sakatu arte
continue;
}
else if(input(BERA)==0)    //
{
total=0,pisua=0;
printf(lcd_putc,»\f Pisu arrunta»);       //Visualiza el texto fijo del
printf(lcd_putc,»\n%cAkumulutua»,0x7e);    //Visualiza el texto fijo del
while(input(OK)==1);    //itxaron OK sakatu arte
delay_ms(20);                          //Erreboteak ekiditzeko
printf(lcd_putc,»\fPisua: %.2f kg»,pisua);
printf(lcd_putc,»\nTotal: %.2f kg»,total);   //Visualiza el texto fijo del
while((input(OK)==0));           //Itxaron OK askatu arte
delay_ms(20);                       //Erreboteak ekiditzeko
while(TRUE)
{
while((input(OK)==1)&&(input(ATZERA)==1));            //itxaron OK sakatu arte
delay_ms(20);                    //Erreboteak ekiditzeko
if(input(ATZERA)==0)
break;                        //while-etik atera
resultado=read_adc();                 //Inicia la conversión y lee el resultado
pisua=resultado*(11.339/1024.0)-0.9;//Calculamos la tension

lcd_gotoxy(7,1);
printf(lcd_putc,»%.2f «,pisua);   //Visualiza el resultado
if(pisua<0)
printf(lcd_putc,»\fPisua: 0.00 kg «);
printf(lcd_putc,»\nSakatu ATZERA»);   //Visualiza el texto fijo del
total+=pisua;
lcd_gotoxy(7,2);
printf(lcd_putc,»%.2f «,total);   //Visualiza el resultado
while((input(OK)==0));           //Itxaron OK askatu arte
delay_ms(20);                    //Erreboteak ekiditzeko
} //fin de while total
}//fin de if BERA
}//fin de while 1
}//fin de main

Lcd-an agertzen de menua hauxe da, ISIS-en simulatuta:

.
Lehenengo menuan pisu arrunta eta akumulatuaren artean aukeratu ahal izango da. OK botoia sakatu ezgero ondorengo pantaila azalduko litzateke.
.
.
OK botoia berriro sakatzean une horretan snetsoreak detektatzen duen pisua emango du.
.
.
Eta orduan ATZERA botoia sakatuta hasierako menura itzultzen da.
.
.
.
Hasierako menuan pisu arrunta soilik kalkulatu nahi ez bada BERA botoiaren bidez akumulatua aukeratu ahal izango da.
.
.
OK sakatzean une horretan detektatzen duen pisua eta akumulatua kalkulatzeko pantaila azaltzen da.
.
.
 Berriro OK sakatzean une horretan detektatzen duen pisua eta akumulatua emango ditu.
.
.
ISIS-eko simulazioaren ondoren protoboard batean simulatu da proiektua:
.
.
Hasieran simulazioak,  sentsorearen gainean behatzarekin indarra eginaz lortu ziren, sentsorearen azalera baina handiagoak ziren elementuen pisua ez baitzuen detektazen. Horretarako zilindro batek sentsorearen arean presiona zezan, kaxa moduko bat egin zen, azalera handiagoko elementuak jartzeko.
.
.

Programazioa ondo zegoela ikustean PCB-aren txanda da. Lehendabizi ISIS-en bitartez amaierako plakan egongo diren elementu guztiak kokatuz.
.
.
Eta ondoren ARES-ekin PCB-a diseinatuz.
.
.
Hori egin ondoren circuitcam- en soldatu beharreko puntu guztietan hustuketa egiten da, zirkuitu – laburrik ez egoteko. Bertan LMD artxiboa sortu eta prest dago LPKF- ra pasatzeko. LPKF-aren bitartez egiten da plaka.
.
.
Erabilitako materiala:
  • 16F88 Pic-a
  • 7805-a
  • 16X2 LCD-a
  • 100nF-ko kondentsadorea
  • 10k-ko 3 erresistentzia
  • 4k7ko erresistentzia
  • Konektoreak(2 pin 3 pin 4 pin eta 10 pin)
  • Kableak
  • Estainua
Plaka amaieran elementu guztiak kokatuta:
.
.
Proiektuko fitxategiak deskargatzeko sakatu hemen.

EGILEAK: Xabier Izagirre eta Eneko Fuentes

Brazo robot para Teleoperación

Brazo robot para Teleoperación

En los últimos tiempos la robótica está produciendo grandes avances en la tecnología, que se ven reflejadas en diferentes áreas de la ciencia como la medicina. Algunos métodos sirven para la captación de imágenes, que permiten reconstruir modelos virtuales de los órganos que se necesitan examinar, para luego manipularlos para mejorar un diagnóstico y simular operaciones quirúrgicas.

.

Los grandes avances en informática y comunicaciones no solo se ven reflejados en la industria, también vemos un gran desarrollo en la medicina y de forma más particular en la cirugía, que nos ha dado como resultado un acelerado proceso de informatización de todas las áreas de la medicina. Los robots son un instrumento indispensable en la medicina, ya que son herramientas para ayudar a la mejora de procesos quirúrgicos. Además, gracias a la robótica se pueden desempeñar trabajos y tareas en lugares donde antes no se podía llegar y de manera más cómoda, rápida y sencilla.

   Estas han sido las diferentes fases que se han seguido para poder crear nuestro proyecto:

– Estudio y análisis de las tecnologías del proyecto

– Toma de decisiones

– Edición del esquema del proyecto

– Edición del esquema de simulación

– Programación

– Simulación

– Probar/cablear el prototipo

– Diseño y fabricación de la PCB

– Construcción del prototipo

– Construcción de la maqueta

El proyecto es un brazo robot de 5 ejes controlado por Internet. El objetivo de este proyecto consiste en controlar a distancia el brazo robot para teleoperaciones médicas. Para ello este brazo se conecta a la red Internet comunicándose mediante un microservidor Ez Web Lynx con una página web que hemos creado. Desde esta misma página se puede controlar el brazo mediante una botonera virtual pulsando los movimientos en ellos descritos.

.

.
El brazo tiene un motor eléctrico por cada eje, y un Led de color blanco en la parte de la pinza. Estos motores nos permiten mover esos ejes según el sentido de giro de los mismos. Para poder controlar los motores, se ha utilizado un microcontrolador Pic 16F886 cogiendo 11 salidas digitales, 2 por cada motor y una para el Led. Se ha desarrollado un programa en código C que se ha cargado al Pic para que este interprete las órdenes de los movimientos de los motores. También se ha programado una página Web para poder utilizar cómodamente el dispositivo y se ha instalado una cámara web telecontrolable, con un movimiento de 360º, para visualizar sus operaciones.
.
.
   Para poder mover correctamente los motores tuvimos que colocar tres L293D, unos elementos que son capaces de conducir corrientes bidireccionales de hasta 600 mA y con tensiones que van desde los 4,5V hasta los 36V. Cada uno de los L293D sirve para controlar dos motores diferentes, por lo tanto fue necesario utilizar tres en nuestro proyecto. También fue necesario hacer una fuente que regulara los 12 V que nos daba el alimentador, a 5 V para alimentar todos los integrados que lleva la placa.
.
.
 Los programas utilizados para llevar a cabo nuestro proyecto han sido los siguientes:

-ISIS (para diseñar el circuito)
-ARES (para diseñar la placa)
-Pic C compiler (para hacer el programa del Pic)
-PicKit (para programar el Pic)
-Dreamwaver (para programar la página Web)
-Solid Edge (para diseñar el soporte de la cámara y el cubo)
-ReplicatorG (para imprimir los diseños con la impresora 3D)

   Este es el esquema de funcionamiento de la página Web:
.
.
   En la siguiente imagen se muestra la apariencia de la página Web diseñada con Dreamwaver:
.
.

   En este enlace se pueden descargar todos los archivos necesarios para hacer este proyecto

Señales luminosos para peatones y vehículos

Señales luminosos para peatones y vehículos

El proyecto llamado avisador paso de peatones es un proyecto que se ha realizado por los alumnos Andoni Cutillas y Martín Salgado.

El proyecto es una señal de paso peatones a escala real hecha en madera y un poste hecho hechos a madera, solo que estos tienen el añadido de unos leds de 2cm de diámetro que rodean toda la estructura. El objetivo del proyecto es que los leds que rodean tanto al poste como a la señal realicen un juego de luces en el momento que un sensor (cada uno lleva uno) detecte una presencia. El sensor de la señal, se coloca en el paso de cebra para que cuando el peaton vaya a cruzar la señal realice el juego de luces, y el sensor del poste se coloca en la carretera para que cuando el sensor detecte al vehiculo, empiece el juego de luces en el poste. De esta forma conseguipos alertar al vehiculo de que un peaton va a cruzar, y viceversa mediante el juego de luces. Otro objetivo importante es el ahorro de energia, ya que los leds permanecen lebemente encendidos hasta que el sensor detecta presencia, que es cuando es realmente útil encender los leds con la maxima potencia.

.

.

.

Esto se ha logrado gracias a un microcontrolador PIC16F88, un sensor ultrasonido HCSR04, y 2 chips 8574a. En el PIC le hemos cargado un programa que explicaremos mas adelante, el sensor lo utilizados como la entrada a ese programa que en este caso se activa al detectar a un peatón, y los 8574a han sido muy útiles ya que su función es expandir el numero de puertos del PIC en 2 en este caso mediante la tecnología I2C, y necesitábamos 16 salidas salidas en nuestro caso para conectar 16 leds( 8 leds en el caso del poste). Tambien cabe mencionar la importancia de Demetrio, un trabajador de don bosco del sector de mecánica que nos reprodujo en madera los esquemas que le enviamos de la señal y al que estamos agradecidos.

.


Los se han escrito en lenguaje C++ y con el programa PIC C compiler. La programación consta de 2 entradas que necesita el sensor, y 16 salidas para los leds, 8 en cada uno de los 8574a. Todos los leds estan conectados a 12v permanentemente y se encienden cuando se les manda ceros. Pensamos que la mejor opción a la hora de hacer el programa, era enviar un byte entero a uno de los 8574a en la forma de 0b11111110 en el momento en el que el sensor note alguna presencia cercana de forma que se encienda un solo led y activar luego un rotate para que el 0 se mueva una posición a la izquierda y donde estaba el 0 se coloque un 1, de forma que haya un solo led encendido y jamás mas de uno. Una vez teminado con los 8 primeros led, se llamaría mediante el programa al otro 8574a y repetiríamos la secuencia consiguiendo realizar una vuelta completa, y luego realizamos lo mismo para conseguir dos vueltas, tiempo suficiente para que el vehiculo se percatase. En el caso del poste el programa es igual, pero solo necesitabamos activas uno de los I2C, porque solo controlamos 8 salidas

Una vez conseguido que el programa funcione y hemos hecho las simulaciones tanto en ISIS como en protoboard, fabricar la PCB que contiene toda la electrónica del proyecto era el siguiente objetivo. Tanto el diseño del esquema como el de la PCB se hicieron con el paquete de programas proteus , y en concreto con el ISIS y ARES respectivamente. Para proceder a la fabricación de la PCB utilizamos el software circuit cam para generar los archivos que debíamos enviar a la LPKF que esta maquina que se encarga de realizar todas las pistas y agujeros de la placa. Cabe mencionar que las 2 placas (señal y poste) son iguales, solo que  la de los postes contiene un 8574a menos (I2C) y la simplifica un poco mas.
.

.
Después soldamos los componentes que componen la placa mientras se pintaba y se agujereaba la señal y los postes para introducir los leds.

Antes de probar la placa en la señal y en los postes pensamos que era mejos comprobar que todo estaba en orden midiendo tensiones y comprobando continuidades.Una vez realizado todo esto, ya teníamos el prototipo finalizado. Esperamos que ideas asi, ayuden a descender el numero de accidentes en nuestras carreteras a demás de concienciarnos de la importancia del ahorro energético

Agradecimientos:  a los profesores David y Carlos, y a Demetrio por toda la ayuda prestada.

Descargar archivos del proyecto.