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
//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.
De manera sencilla y resumida, la Voladora V2 de Tumaker utiliza una placa llamada Megatronics V3, simplemente es un Arduino Mega 2560 con los pines adaptados para controlar impresoras 3D. Se le ha añadido un modulo Bluetooth a la placa electrónica y se ha creado una aplicación, mediante el programa App Inventor de Google, para controlar la impresora 3D Voladora V2 de Tumaker desde cualquier periférico que utilice el sistema operativo Android.
El objetivo de este proyecto es desarrollar y construir un periférico que controle una impresora 3D, exactamente, la Voladora V2 de Tumaker.
Este proyecto esta formado por tres partes, la comunicación entre el móvil y la impresora 3D Voladora V2 de Tumaker, la aplicación que se crea con App Inventor y el firmaware (el programa que se carga en la placa Megatronics V3) que se llama Marlin.
Comunicación Bluetooth y comunicación Serie
La comunicación Bluetooth es un protocolo de comunicación inalámbrica de voz y datos.
La comunicación Serie o Serial es un protocolo de comunicación mediante cables de voz y datos que se envía y recibe mediante RX y Tx.
El proyecto TWI – TWI funciona,se envían «comandos» desde el móvil, a la impresora 3D y viceversa. El modulo Bluetooth hace de intermediario entre la impresora 3D y el móvil. El modulo Bluetooth recibe los «comandos» desde el móvil y la impresora 3D. Se utilizan dos tipos de comunicación, la comunicación Serie y la comunicación Bluetooth. La comunicaciòn entre el móvil y el modulo Bluetooth es comunicación Bluetooth, es decir, la información es enviado mediante ondas y la comunicación entre el modulo Bluetooth y la impresora 3D es una comunicación Serie.
Programación
En este proyecto se ha llevado a cabo modificando el Marlin en el sketch de Arduino, el lenguaje en el que se basa Arduino es en C y C++.
Arduino es una plataforma de hardware libre, basada en una placa con un microcontrolador y un entorno de desarrollo, diseñada para facilitar el uso de la electrónica en proyectos multidisciplinares.
Firmware (Marlin)
Firmware es un programa que es grabado en una memoria, normalmente de lectura/escritura (ROM, EEPROM, flash, etc.), que establece la lógica de más bajo nivel que controla los circuitos electrónicos de un dispositivo de cualquier tipo.
El firmware que utiliza la impresora 3D Voladora V2 de Tumaker es uno llamado Marlin. El mismo firmware sirve para diferentes impresoras 3D, pero se tiene que modificar adaptándolo a la impresora 3D en funciones.
El primer y gran dilema de este proyecto es que se tiene que crear un nuevo puerto serie, muchos os preguntareis porque si puedes utilizar el puerto serie que trae predeterminado la placa. Si se utiliza el mismo puerto serie, la trasmisión de datos se colapsa y ademas no se podrá utilizar la impresora 3D mediante el uso normal, para ello se modifica el firmware «Marlin». La placa electrónica Megatronics V3 de la impresora 3D te da la opción de abrir puertos serie mediante software y hardware.
Los trozos de programa que se modifica en el Marlin.
#include "NewSoftSerial.h" // Llamada a la libreria NewSoftSerial
#define rxPin 11 // Declara el pin 11 con el nombre de rxPin
#define txPin 15 // Declara el pin 15 con el nombre de rxPin
NewSoftSerial miSerial(rxPin, txPin); // declara en nombre del puerto serie y define los pines rx y tx
void setup()
{
miSerial.begin(9600); // Abre en nuevo puerto serie
pinMode(3,INPUT); // declara el pin 3 como entrada
pinMode(2,OUTPUT); // declara el pin 2 como salida
pinMode(rxPin, INPUT); // declara el pin rxPin como entrada
pinMode(txPin, OUTPUT); // declara el pin txPin como salida
Con el trozo de código de arriba se consigue abrir el nuevo puerto serie y en este caso el pin 11 es Rx y el pin 15 es Tx. Sin olvidar la velocidad en baudios del nuevo puerto serie, en este caso es de 9600 baudios, es una de las razones por las que puede que al dibujar a mano alzada la impresión se atasque, ya que la impresora 3D y el ordenador se comunican a 115200 baudios. 12 veces mas lento.
void loop()
{
int estado; // crear una variable con el nombre estado
estado=digitalRead(3); // guardar la lectura del pin 3 en la variable estado
switch(estado) // mira el valor de la variable estado y ejecutara lo que este dentro del caso 0: caso 1: ...
{
case 0: // ejecutara lo que este dentro siempre que el valor de estado sea 0
if(buflen < (BUFSIZE-1))
get_command();
#ifdef SDSUPPORT
card.checkautostart(false);
#endif
if(buflen)
{
#ifdef SDSUPPORT
if(card.saving)
{
if(strstr_P(cmdbuffer[bufindr], PSTR("M29")) == NULL)
{
card.write_command(cmdbuffer[bufindr]);
SERIAL_PROTOCOLLNPGM(MSG_OK);
}
else
{
card.closefile();
SERIAL_PROTOCOLLNPGM(MSG_FILE_SAVED);
}
}
else
{
process_commands();
}
#else
process_commands();
#endif //SDSUPPORT
buflen = (buflen-1);
bufindr = (bufindr + 1)%BUFSIZE;
}
//check heater every n milliseconds
manage_heater();
manage_inactivity();
checkHitEndstops();
lcd_update();
break;
case 1:
if(buflen < (BUFSIZE-1))
get_command_bluetooth();
#ifdef SDSUPPORT
card.checkautostart(false);
#endif
if(buflen)
{
#ifdef SDSUPPORT
if(card.saving)
{
if(strstr_P(cmdbuffer[bufindr], PSTR("M29")) == NULL)
{
card.write_command(cmdbuffer[bufindr]);
SERIAL_PROTOCOLLNPGM(MSG_OK);
}
else
{
card.closefile();
SERIAL_PROTOCOLLNPGM(MSG_FILE_SAVED);
}
}
else
{
process_commands();
}
#else
process_commands();
#endif //SDSUPPORT
buflen = (buflen-1);
bufindr = (bufindr + 1)%BUFSIZE;
}
//check heater every n milliseconds
manage_heater();
manage_inactivity();
checkHitEndstops();
lcd_update();
break;
}
}
void get_command_bluetooth() // es una funcion que se ha creado para interpretar los datos recibidos desde el móvil y ejecutar las acciones
{
while( miSerial.available() > 0 && buflen < BUFSIZE) { // mientras reciba algo superior a 0 por el puerto serie
serial_char = miSerial.read();
Dentro del Void loop, que es la función principal, se crea este trozo de código para elegir mediante un interruptor la forma de utilizar la impresora 3D Voladora V2 de Tumaker, de manera normal, es decir, controlado por ordenador o controlado por el móvil.
Se ha creado la función void get_command_bluetooth() para interpretar los datos recibidos desde el móvil y ejecutar las acciones.
Se ha creado la función void get_command_bluetooth() para interpretar los datos recibidos desde el móvil y ejecutar las acciones.
App Inventor
App Inventor es un entorno de desarrollo visual de aplicaciones para los teléfonos Android desarrollado por el MIT. Para desarrollar aplicaciones con App Inventor sólo necesitas un navegador web y un teléfono Android.
Al construir las aplicaciones para Android se trabaja con dos herramientas: App Inventor Designer y App Inventor Blocks Editor. En Designer se construye el Interfaz de Usuario, eligiendo y situando los elementos con los que interactuará el usuario. Con el Blocks Editor se define el comportamiento de los componentes de la aplicación.
Esta es la parte visual de la aplicación se ha creado utilizando la herramienta Designer, simplemente son botones, textBox (que es un texto vació para rellenar), texto.
En la imagen de abajo se aprecia el programa entero, mediante el editor de bloques conseguimos asignar acciones a los diferentes objetos de la parte visual.
Todos los bloques tienen una condición, si el modulo bluetooth esta conectado, entonces ejecuta las acciones.
Componentes
-Modulo Bluetooth
-Interruptor
-Voladora V2
-Móvil sistema operativo Android
-Tarjeta SD
Cambios en la impresora 3D Voladora V2 de Tumaker Se ha modificado la impresora 3D Voladora V2 de Tumaker físicamente para llevar a cavo este proyecto.
Utilizando un pin digital libre de la placa Megatronics V3 se ha colocado un interruptor en forma de pull-up, cuando el interruptor este levantado significa que se controla desde el ordenador y cuando el interruptor este abajo significa que se controla desde el móvil.
Aparte de colocar el interruptor es necesario conectar el modulo Bluetooth e introducir la tarjeta SD con algún G-code cargado en la tarjeta SD.
Esquema de Megatronics V3
En el esquema de arriba se aprecia el conexionado de la placa Megatronics V3, los pines del modulo Bluetooth se conectan Rx al pin 11 y Tx al pin 15 y dos mas que son 5v y 0v.
El interruptor con el sistema pull-up se conecta en el pin 2.
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
Proiektu honen helburua jendetza handiko jazoeratan iragarkiak ahalik eta jende gehienari iritsi ahal izatea da, baina baita ere ingurugiroko datuak hartu eta imaginak denbora errealean gure Android gailura bidaltzea.
Zeppelina Wifi bidez dago konektaturik Android gailu mugikorrera. Android gailuan Zeppelina kontrolatzeko sortutako aplikazio bat egozten da, aplikazio honen bidez Zeppelinarekin interaktuatu ahal izango dugu.
Aplikazio honek Zeppelinaren kontrolaz gain beste ainbat datu ere erreztuko dizkigu, horietatik garrantzitsuena denbora errealean jasotako bideoa da.
RaspZeppelinaren egituran Raspberry Pi bat dago kontrolaz arduraturik. Raspberry Pi bat, Hardware libreko SBC bat da eta Linuxen oinarrituriko sistema eragilea erabiltzen du. Sofwar hau librea denez, proiektu honentzako aproposa da gure nahietara egoki baitezakegu. Raspberriaren funtzio nagusiak ondorengoak dira: Arduino mikrokontrolatzaileari egin beharrekoa adieraztea, Acces Point bezela jokatzea gailu mugikorrarekin wifi konexioa lortzeko eta kamararen kontrolaz arduratzea. Wifi konexia lortzeko Wi-Pi wifi moduloa erabili da.
Raspberry Piaren aginduak Arduino Mega plakara doaz. Arduino Mega ATmega2560 mikrokontrolagailu batetan oinarrituriko plaka bat da. Plaka honek agindu bakoitzeko irteera bat edo beste aktibatuko du bere barnean duen programari esker.
Arduino plakak azkenik aktuadoreei bidaliko die agindua. Aktuadoreak RaspZeppelinaren norabidea eta kameraren kontrola erregulatuko dute. 5V-ko bi servomotorek kameraren angelua eta propultsio servoen angelua kontrolatuko dute. 5V-ko ak direnez zuzenean lotu daitezke Arduino Megarekin. Beste bi brushless motore RaspZeppelinaren propulsioaz arduratuko dira. Hauek Arduino plaka eta beraien artean control etapa bat dute, ESC zirkuito elektroniko bat. Azkenik RaspZeppelinaren norabidea kontrolatzeko DC-ko 5v-ko motore bat hau isatsan dagoenez RaspZeppelina altuera konstate batean geldirik egonik bere Z ardatzarekiko biratzea ahalbidetzen du. Zuzenki polarizatzen denean zentzu batean biratzen du eta alderantziz polarizatzean beste alderuntz biratzen du.
Hurrengo lerroetan proiektua gartzeko eman ditugun pausuak:
1. Eskemaren edizioa eta Zirkuituaren simulazioa:
RaspZeppelinaren Arduinoko programa simulatzeko, Isis-en sortutako eskema bat beharrezkoa da programan egon daitezkeen akatsak aurrez topatzeko. Isis-eko programak serboak zuzenean konektatzea onartzen duen arren, brushless motoreen eta Arduinoaren artean, ESC etapa bat beharrezkoa da.
2. PCB-aren fabrikazioa:
Areseko PCB-a método mekaniakoren bidez eraiki da. Areseko artxiboa, .LYT izeneko extensioa dauka, baina extensio hau irakurezina da Board Master programan. Artxiboa egokitzeko CircuitCam-en .LMD extensiora pasa da, Board Master-ek irakur ahal dezan. Board Masterren LPKF-aren lan sistema konfiguratzen da eta fresatu beharrekoa adierazten zaio LPKF-ari.
Lehenik eta behin zuloak egiten dira metalizatu ahal izateko, metalizatu prosezua pasa eta gero, berriz LPKF-ra eramaten dugu plaka, bi aldeetako pistak egiteko.
3. Konponenteen kokapena eta soldadura:
Behin PCBaren plaka eraikita, konponenteak jarri eta soldatu dira, ondorengo argazkian eraikitako Shiedaren irudi bat.
4. Arduinoren programazioa:
#include <Servo.h>
Servo servokamera; //altuera kontrolatzeko servoa
Servo servoaltuera; //kamera kontrolatzeko servoa
Servo esc7; //nombramos el esc7. Aurrera
Servo esc8; //nombramos el esc8. Aurrera
int motor1=6; //Direccion
int motor2=5; //Direccion
float bateria=A1; //asignamos al pin A1 la entrada de la bateria
int estadobateria=0;
int ledbateriabaja=4; //asignamos el pin 4 a los led bateriabaja
float estadobateriav;
int F=’J’;
int kamerakontrol =500; //Poner servo de camara en posición «0»
void setup (){
servoaltuera.attach(10); //asignamos el pin 10 al servoaltuera
servokamera.attach(9); //asignamos el pin 9 al servokamera
esc7.attach(7); //asignamos el pin 7 al esc11
esc8.attach(8); //asignamos el pin 8 al esc12
pinMode(motor1, OUTPUT); //Direccion
pinMode(motor2, OUTPUT); //Direccion
pinMode (A1,INPUT); //pin analogico para control bateria
pinMode (4,OUTPUT); //pin para encender leds de aviso
esc7.write(0); //Armamos el esc11 enviandole «0»
esc8.write(0); //Armamos el esc12 enviandole «0»
delay (1000);
esc7.write (20); //Le enviamos «20» y se escucha un pitido
esc8.write (20); //Le enviamos «20» y se escucha un pitido
delay(1000);
Serial.begin (9600);
digitalWrite(ledbateriabaja,LOW);
}
void loop(){
estadobateria = analogRead(bateria); //leer bateria y escribir en estadobateria
estadobateriav = estadobateria * (5.0 / 1023.0); //conversión de lectura
if(estadobateriav < 4.18){
digitalWrite(ledbateriabaja,HIGH);
//mandar informacion a raspi
}
else{
digitalWrite(ledbateriabaja,LOW);
}
Serial.print( » «);
Serial.println( » «);
Serial.print(estadobateriav); //escribe en purto serial valor de la bateria
if (Serial.available() > 0) {
F = Serial.read();
}
switch(F){
case ‘A’:
mover(90,40,40,0,0); //A letra ASCII, gora juteko
break;
case ‘B’:
mover(180,40,40,0,0); //B letra ASCII, behera juteko
break;
case ‘C’:
mover(45,40,40,0,0); //C letra ASCII, aurrera juteko
break;
case ‘D’:
mover(135,40,40,0,0); //D letra ASCII, atzera juteko
break;
case ‘E’:
mover(0,20,20,255,0); //E letra ASCII, eskubira juteko
break;
case ‘F’:
mover(0,20,20,0,255); //F letra ASCII, ezkerrera juteko
break;
case ‘G’:
mov_camara(1,50); //G letra ASCII, kamera behera juteko
break;
case ‘H’:
mov_camara(0,50); //H letra ASCII, kamera gora juteko
break;
case ‘I’:
mov_camara(1,0); //I letra ASCII, kamera GERATU
break;
case ‘J’:
mover(0,20,20,0,0); //J letra ASCII, dena gelditzeko
break;
}
}
/************************************************************
funcion para control del movimiento del Zepellin
Le pasamos 5 parametros:
ang_motores (0-180)
vel_esc7 (20-180)
vel_esc8 (20-180)
motor_cola_izq (0-255)
motor_cola_dch (0-255)
***********************************************************/
servoaltuera.write(ang_motores);
esc7.write(vel_esc1); //Damos marcha al motot a «90»
esc8.write( vel_esc2); //Damos marcha al motot a «90»
analogWrite(motor1, motor_cola_izq); //Direkzioa 0ra
analogWrite(motor2, motor_cola_dch); //Direkzioa 0ra
}
/***********************************************************
función para control del movimiento de la camara
Le pasamos dos parametro:
direccion (1 –> suma , 0 –> resta)
var_angulo (0 a 50)
************************************************************/
void mov_camara (int direccion, int var_angulo) {
Eclipse programa erabiliz, edozein mugikor edo tabletekin Zeppelina guidatu ahal izateko aplikazio bat garatu dugu. Tablet bertatik Zeppelina guztiz gidatzeaz gain, bideoa ikusi daiteke eta argazkiak atera ere bai.
5. Materialen metaketa: • Arduino mega 2560
• Raspberry-py
• Raspberry-ren kamera
• 2xBrushless motore
• 2xESC
• Servo Motor
• Micro Servo
• Arduino megarentzat Shield-a
• 3xDiodo led
• 1xInterruptore
• 1xResistencia 10K
• 3xResistencia 330 ohm.
• 2xBaterias lipo de tres celdas y 2200mA
• H Zubia
6. Prototipoaren kableaketa eta froga: Behin servo guztiak eta korronte zuzenezko motorea kontrolatutak dauzkagunean, denak elkarrekin frogatzera pasako gara.
7. 3D Osagaien diseinu eta fabrikazioa:
3D inpresoran sortutako konponenteak asko izan dira RaspZeppelinean. Serboen kontrolarako engranaiak, brushlessak eje transmisorera lotzeko piezak, zeppelinaren hegalak, isatseko motorraren gurutze hegalak, elektronika sartzeko gondola, gondolaren ankak eta kamera lotzeko kutxa.
Diseinatu ditugun pieza guztien .stl artxiboak blog-aren bukaerako link-aren barruan daude.
8. Heliorekin betetzea: Heliorekin puzteko orduan, kontuz ibili behar da helio botilak presio handia duelako barruan eta gaizki erabiltzea oso arriskutsua delako.
9. Lehenengo hegalaldiak: Azkenik, frogatzeko hegalaldi frogak egin ditugu funtzionamendua ona delako bermatzeko.
Este proyecto nace de una idea : la idea de unificar lo físico y lo virtual.
Para ello se ha creado un perchero electrónico el cual, mediante la nube, se conecta a Facebook (Ver ilustración I). La percha consta de una parte mecánica para sostener la ropa y una parte electrónica en forma de pantalla LED que refleja el número de “Me gusta” que tiene una prenda concreta en la red social Facebook de una tienda.
La parte electrónica de las perchas va conectada a una centralita, la cual ha sido programada mediante Arduino. Esta se conecta a la nube y obtiene el número de “Me Gusta” de los productos que se deseen visualizar en la percha. Estos productos se habrán tenido que introducir con antelación en la red social Facebook de la tienda en cuestión.
El número de “Me Gusta” obtenido por la centralita es mandado mediante el protocolo I2C a cada percha electrónica y esta mediante varios displays led de 7 segmentos muestra dicho número de una forma en la que el cliente lo pueda ver. De esta manera se ha logrado trasladar el mundo virtual al mundo físico.
.
.
.
1.- Edición del esquema
.
.
En este caso se ha de diseñar un circuito que se puede dividir en dos partes: (véase diagrama de flujo)
1.- La parte del micro-controlador (ATMEGA328P) que se va a encargar de contabilizar el numero de “Me Gusta” y va a realizar la gestión de recibirlos y mandarlos a una segunda parte del circuito, que se incluirá en la percha.
2.- La segunda parte a la que podemos llamarla “receptor”, se encargará de recibir las señales emitidas por el micro controlador a través de los cables SDA y SDL y serán recibidas en otro microchip mediante bus I2C (SAA1064) que controlará y alimentará los displays en los que se verá el número de “Me Gusta”.
Para este proyecto se utilizarán 4 perchas con sus correspondientes displays. Para que el micro controlador (ATMEGA328P) sepa diferenciarlos, los circuitos de cada percha trabajarán con tensiones diferentes en el pin de direcciones (pin1). Un circuito llevará ese pin a masa, otro a positivo y los otros dos funcionaran mediante un divisor de tensión en cada placa, uno de 3/5 y el otro de 5/8.
.
2.- Programación
DIAGRAMA DE FLUJO del programa
.
.
A la hora de programar el Arduino para que se conecte a Facebook y muestre el numero de “Me Gusta” en los displays, lo que ha hecho es dividir el programa en dos partes: una parte se encargaría de mostrar el numero de “Me Gusta” en los displays mediante el Bus I2C y la otra parte se encarga de realizar una petición a Facebook mediante la API de esta, llamada Facebook Graph, en la que se muestra el numero de “Me Gusta” de una foto de la red social y a continuación poder guardar este número en una variable numérica con la que poder trabajar.
. 3.- Simulación (ISIS)
En este apartado se ha cargado el programa anteriormente explicado en el micro controlador (ATMEGA328P) en Proteus y así se ha podido comprobar el correcto funcionamiento del circuito.
Este software es de gran utilidad para la realización de este proyecto, ya que haciendo la simulación, se da un gran paso ante la fabricación posterior, depurando los posibles fallos que pudieran surgir.
La visualización se hace de forma automática, sin la necesidad de pulsar ningún botón o interruptor. Basta con darle al “Play” en el ISIS y los números establecidos en el programa se ven reflejados en los displays.
Se puede apreciar que los leds parpadean en la simulación, pero a la hora de hacer la prueba en una protoboard, se puede comprobar que todo funciona perfectamente. Este parpadeo se debe a que esta programado para que encienda los displays de dos en dos alternativamente, a tal velocidad que el ojo humano no es capaz de apreciar dicha multiplexación. Mediante este método se consigue ahorrar energía y se mejora la temperatura del dispositivo.
Un aspecto muy a tener en cuenta a la hora de simular en el ISIS es que el integrado SAA1064 no dispone del pin de dirección, pin muy importante, ya que es el pin que establece la dirección que va a tener el SAA1064 a la hora de recibir los datos.
.
.
Una vez hecha la simulación y comprobar su buen funcionamiento, se tiene que hacer la recopilación de los componentes a utilizar.
Para este proyecto se han recopilado los siguientes materiales:
1x Arduino UNO Rev3
1x Arduino WifiShield
1x Fuente de alimentación 5v-1A
4x SAA1064
16x SA39 (Display 7 seg)
10x Resistencia 4k7
2x Resistencia 8k2
4x Condensador de desacoplo (100KpF)
4x Condensador de filtro (1.5 KpF)
16x Zocalo 10 pines
4x Zocalo 24 pines
Diseño y fabricación de la PCB
En el diseño original, el integrado SAA1064 no disponía de huella, por lo que se le ha tenido que añadir una huella de un DIL24. Se han cambiado también los displays por unos displays individuales y añadido un par de condensadores más un conector molex de 4 pines.
De este modo, al utilizar el ARES, este reconoce automáticamente los componentes utilizados en el ISIS y se hace más fácil trabajar con ellos.
.
.
PCB (ares-circuitcam)
Éste es otro paso clave para la fabricación del proyecto, ya que hay varios factores a tener en cuenta, como el ancho de pistas, colocación de los componentes para su posterior soldadura e interferencias posibles que pueda haber entre ellos, vías, etc…
Se han realizado tres placas diferentes. Una para cada dirección del SAA1064. Una de ellas tiene el pin1 conectado a masa, otra conecta el pin1 a 5V y otras 2 comparten diseño. Estas 2 últimas son las que llevan el pin1 a un divisor de tensión.
La placa se ha diseñado en dos caras para que ocupe el menor espacio posible. Se han respetado en todo momento las recomendaciones establecidas para las distancias entre componentes y la anchura de las pistas, ya que de ser estas demasiado delgadas, pueden llegar a ocasionar problemas.
Se ha tenido que poner manualmente la alimentación y conectar el pin1 del SAA1064 a su correspondiente dirección, ya que no la conectaba automáticamente.
Placa divisor:
.
Placa positivo:
Placa negativo:
.
Fresado de la placa
Para la fabricación de nuestras placas se han introducido los esquemas en el ordenador conectado a la LPKF. Una vez cargados estos archivos se le tiene que ordenar a la maquina que comience a hacer los agujeros de los componentes en la placa, para a continuación, comenzar con el proceso de metalización, el cual se explica en el siguiente punto.
Una vez la placa este metalizada, se vuelve a poner en la LPKF, se procede a realizar la primera cara de esta y a continuación el vaciado. Tras terminar la primera cara, se voltea la placa y se repite la misma operación.
.
.
Al terminar las dos caras y comprobar que la placa ha salido bien, se procede al lacado de esta. Este lacado sirve para que la placa no se vea afectada por la corrosión o factores externos debidos a la intemperie y alargue su vida útil sin que sufra desperfectos. .
Metalización de la placa
La placa que se ha fabricado, al ser de doble cara, requiere una metalización de las vías para crear una comunicación entre una cara de la placa y la otra. Este proceso ahorra mucho tiempo a la hora de fabricar la placa, ya que de otro modo, se tendrían que hacer todos los metalizados de forma manual y seria un proceso excesivamente largo y laborioso.
La metalización de las vías es un proceso químico en el cual la placa va pasando por una serie de cubetas, las cuales contienen diferentes soluciones químicas que reaccionan con la placa preparándola para la última fase que es la de metalización en la que mediante una corriente galvánica, hace desprender el cobre de los ánodos y los adhiere a las zonas ausentes de cobre.
.
.
Construcción del prototipo
Posicionamiento y soldadura
Todos los integrados susceptibles de fallar han sido colocados con sus correspondientes zócalos para que a la hora de soldarlos no se deterioren, y para que en caso de que alguno se estropee, sea sencillo poder cambiarlo sin tener que realizar ninguna soldadura.
Para las soldaduras, se ha utilizado una estación de soldadura, la cual dispone de estañadores de punta fina para poder realizar un trabajo más detallado. También se ha aplicado Flux en cada soldadura realizada.
.
.
Construcción de la maqueta
Para la construcción de este proyecto se ha utilizado un perchero comercial normal de estructura tubular para conducir el cableado por su interior de forma que quede protegido.
Se han pasado un total de cuatro cables por el interior del tubo desde la parte inferior hasta la parte superior repartiéndolos en cuatro salidas para cada percha, unidos en paralelo entre sí. Los cables colocados comunican la parte del circuito controlador con los displays. También se ha hecho en el tramo medio un conector por si hay que realizar el transporte para que se pueda desmontar.
.
.
La construcción de las cajas de plástico que sustentan las placas de las perchas y del conjunto Arduino-Wifishield se han diseñado con el software “Solid-Edge” y la fabricación de las mismas se ha realizado con impresoras 3D . Una vez construidas las cajas se les ha colocado una pieza de metacrilato de color rojizo para optimizar su diseño. En la cajera del conjunto Arduino-Wifishield también se ha colocado una pieza rectificada manualmente de metacrilato transparente para la visualización del interior de la caja y así poder ver las luces indicadoras de conexión y las conexiones eléctricas.
.
Tapas delantera y trasera de los displays con solidedge.
.
Caja y tapa para arduino + wifishield (thingiverse)
.
Caja de thingiverse y tapa de metacrilato
.
La unión de las cajas a las perchas se ha hecho mediante un velcro para facilitar el anclaje y el desmontaje de la misma para poder manipular las perchas de una forma más sencilla.
