La idea es implementar un circuito regulador de corriente constante con el LM317 segun el siguiente esquema:
Tras la realizar la primera prueba de iluminacion del luxeon, con el integrado LM317, en el transcurso se aprecian una serie de cosas:
- es un poco costoso de soldar ya que el propio disipador de aluminio se come el calor del soldador, con un poco de flux, se soluciona el problema
- hay una caida de tension en el LM317 de 3 voltios, eso sumado a los 3,5 del luxeon, hace que se requieran 6,5 voltios de entrada minimo para conseguir los 620ma como se ve en la imagen.
este es el primer prototipo del invento, se requiere una resistencia de 2ohm y 2W para una corriente de 620ma, he puesto 2 en serie de 1ohm 2W que es lo que tenia en el cajon
y aqui un video el asunto funcionando donde se aprecia como se mantiene la corriente estable a 620mah
TODO:
- controlar y medir la temperatura para adaptar un disipador de aluminio acorde, tanto en el led, como en el integrado
El chisme trata de usar una cámara de fotos digital vieja que tenía por ahí para montar un sistema de capturas de fotos automático para grabar efectos atmosféricos y su posterior colocación en el UAV.
La cámara en cuestión es una cámara BenqDC630 que tenia por ahí. Un poco vieja, pero con posibilidad de fotografías de hasta 6MPx. Todo el sistema estará alimentado por una batería lipo de 2450 maH, asi que utilizaremos un circuito divisor de tensión para controlar el voltaje de la batería y un relé para cortar la corriente a la cámara cuando tengamos poca tensión, para no dañarla. Para este divisor de tensión usaremos dos resistencia iguales porque la lipo que utilizaremos es de 2 celdas. Si usáramos de 3 tendríamos que hacer la proporción y una seria el doble de la otra. Para adaptar la camara a los 3v que le hace falta usaremos otro circuito divisor de tensión. Este con regulador que nos cede King.
Usaremos un sensor de temperatura para controlar la temperatura de la lipo (por si las moscas) y cortar la corriente y una pantalla LCD en la que mostraremos información sobre temperatura, tensión de la lipo, y tiempo entre disparos.
Así pues tenemos como componentes:
- Arduino Duemilanove (En este caso uso una ProtoShield para un conexionado mas simple).
- Camara Digital BENQDC630
- Lipo Turnigy 2450 mah 7,4v
- Variador Brushless ZTV 30A
- Dallas 18b20
- LCD GDM1602A
- 2 Relés de 5v Finder 30.22.7.005.0010 (Cualquier otro valdría también. Uno para la camara y otro para cortar la tensión).
- 2 diodos, uno rojo y otro verde para alertar del corte de tensión.
- 2 resistencias del mismo valor para el divisor de tensión de control de carga de la lipo.
Modificación de la cámara digital
Le quitamos la carcasa y se ve el pulsador del botón con espacio suficiente para trabajar. Así pues soldamos 2 parejas de cables a cada una de las dos parejas de pines que tiene el pulsador. Una para el contacto en la posición central y otra para el contacto de la posición inferior. Nosotros pulsaremos los dos a la vez asi que bien podemos hacer las dos parejas de cables o hacerle corto a la pareja de la posición central. En nuestro caso como con el relé podemos activar los dos a la vez lo haremos con las dos parejas de cables.
Para la alimentación utilizaremos el divisor de tensión ajustable que comentamos anteriormente. Este nos convertirá los 5v que obtenemos de la lipo a 3v.
Preparando el divisor de tensión y los relés.
Para el divisor de tensión utilizaremos dos resistencias de 4,7K ohmnios que son las que tengo a mano. Para aprovechar colocare también en la misma placa el relé para el control de tensión a la cámara y los diodos. Para disparar la cámara utilizare otro relé que ya tenia montado de antemano independiente.
De momento lo montaremos todo provisionalmente sobre la misma placa de prototipo nada mas que por manejabilidad. Conectamos el relé de disparo al pin digital 2 del arduino. La pantalla lcd la pinchamos en los pines 8,11 y 12 y la salida del divisor de tensión la enganchamos a la salida analógica 0 para leerla. El sensor de temperatura lo pinchamos en el pin digital 10.
Le cargamos el código y probamos a ver si todo funciona correctamente.
Bueno, todo esto y lo que queremos es echar fotos así que vamos manos a la obra. En principio hay que configurar en la cámara algunas opciones como la desactivación del balance de blancos automático y casi que cualquier opción que nos venga como automática. Le damos ya para ir haciendo la primera prueba. Me la llevo a la ventana de mi casa un día tal como el de hoy, soleado con nubes. Ideal para el efecto que queremos conseguir.
Hacemos la primera prueba. Capturamos unas 275 fotos. Las fotos no han sido muy buenas, se ve que algo se me ha pasado en las opciones de configuracion de la cámara, pero son suficientes para hacer el nuestro primer efecto de timelapse con nubes. Primero las mejoro un poco con iphoto y luego creo la película con mencoder. Le pongo un bitrate de 5000, un tamaño de 1280×720 y 25 fps.
Lo que tenemos aqui es un receptor IR 38khz TSOP4838 y la idea es programar el Arduino para que reciba los codigos IR de mandos a distancia, en concreto los mandos que he probado parecen usar el protocolo NEC que esta bastante extendido
El primer paso es conectar el receptor IR como se ve en la foto, con el positivo a una resistencia de 220 ohm, aqui abajo se muestra el esquema de conexionado del datasheet, pero voy a obviar algunos componentes por simplificar la tarea.
Podemos cargar el ejemplo que viene con la libreria pero hay que añadir un include al principio para que la compilacion no de errores, quedaria como lo siguiente:
// look for IR codes and print them as they are received #include <WProgram.h>
#include <NECIRrcv.h>
#define IRPIN 8 // pin that IR detector is connected to
Para hacer que un servo futaba funcione en rotacion continua tenemos que modificarle una de sus piezas. Abrimos el servo y sacamos el engranaje principal.
Luego le raspamos el tope que tiene en la parte exterior y luego el que lleva en la parte interior.
Una vez eliminados, ya esta preparado para rotar indefinidamente y podemos cerrarlo.
Para usarlo con arduino es bien sencillo. Como dijimos en el post del servo cada servo tiene un intervalo que define su posicion (0.5 a 2,5 ms). Pues cuando le damos un tiempo fuera de este intervalo rotara indefinidamente en un sentido o en otro.
Vamos a probar una conexion serie con db9 contra un pc usando la libreria softwareserial. Necesitaremos convertir los niveles logicos que nos proporciona arduino a niveles RS232 y para ello utilizaremos un MAX232N.
Como podemos ver en su datasheet, el conexionado es bastante sencillo.
Basicamente: pin1 con (+) condensador (-) 1uF a pin3; pin4 con (+) condensador 1uF (-) a pin5; pin2 con (+) condensador 1uF (-) a tierra; pin6 con (-) condensador 1uF (+) a tierra; pin16 con (+) condensador 1uF (-) a tierra; pin16 tambien conectado a 5v; pin 15 a tierra; pin7 a RX en DB9 (su pin2); pin8 a TX en DB9 (su pin 3); pin9 a RX en arduino; pin10 a TX en arduino; pinGND del DB9 (su pin 5) a tierra tb.
Nos deberia de quedar algo asi:
Para hacer la prueba cargaremos el siguiente codigo al arduino. En vez de la libreria softwareserial que viene con arduino en el ejemplo utilizamos la libreria NewSoftSerial adaptada por David A. Mellis que posee varias mejoras y funcionalidades, pero la que viene por defecto funciona tambien perfectamente.
// set the data rate for the NewSoftSerial port
mySerial.begin(9600);
mySerial.println(“Hello, world?”);
}
void loop() // run over and over again
{
if (mySerial.available()) {
Serial.print((char)mySerial.read());
}
if (Serial.available()) {
mySerial.print((char)Serial.read());
}
}
En el ejemplo lo que hacemos es mandar primero una cadena de texto al serial del arduino y otra al nuevo serial creado contra el db9 (pc con minicom o hiperterminal por ejemplo) y a continuacion mandar caracteres desde un lado a otro de la conexion db9.
Este sensor de ultrasonidos es compacto y facil de utilizar con nuestro arduino. Con tan solo 3 de sus pines (vcc, gnd y an) podremos tener una idea aproximada de la distancia de los objetos. Tambien posee otros dos metodos de medir las distancia que veremos mas adelante (por serie en RS232 y por pulsos pwm).
En esta primera practica usamos la salida analogica. Segun arduino el valor que nos devuelve la entrada analogica es un valor comprendido entre 0 y 1023 que representa la tension de 0 a 5v. A su vez el datasheet del sensor nos indica que que para una tension de 5v aplicada al mismo nos devolvera 9.8mv por pulgada. Con lo cual tan solo tenemos que medir el valor que nos devuelve arduino y hacer unos simples calculos.
La practica
En nuestro ejemplo daremos tension a los pines vcc y gnd y el pin de salida analogica (an) lo conectaremos al pin analogico 0 del arduino.
Una vez que lo tenemos conectado cargamos el siguiente codigo de prueba al arduino:
void setup()
{
Serial.begin(9600);
}
void loop()
{
int x = 0;
int inches = 0;
int cm=0;
x = analogRead(0);
inches = ((x*0.0049)/0.0098);
cm= inches * 2.54;
Serial.print(“Read: “);
Serial.print(x);
Serial.print(” Inches: “);
Serial.print(inches);
Serial.print(” CM: “);
Serial.println(cm);
delay(1000);
}
Este ejemplo nos sacara por puerto serie cada segundo el valor medido en la entrada analogica y su correspondecia con con pulgadas y centimetros.
Este sensor de temperatura tiene dos modos de funcionamiento. Modo normal, y modo parasito. En el modo normal tenemos que alimentar el sensor por sus pines VCC y GND, mientras que en modo parasito el pin VCC va a tierra tambien y la alimentacion la toma del pin de control.
El metodo que utilizaremos sera el modo parasito. Lo bueno de utilizar este metodo es que podemos poner en serie unos pocos de sensores utilizando unicamente un pin del arduino (el pin de datos en el sensor ). Para usar el modo parasito debemos colocar una resistencia de 4,7 k entre el pin de datos y la tension como indica el datasheet.
La practica
Para utilizar el modo parasito utilizaremos la libreria OneWire. Conectamos el sensor al arduino (en nuestro caso utilizaremos el pin 10 del arduino) y cargamos el siguiente codigo de ejemplo:
#include <OneWire.h>
/* DS18S20 Temperature chip i/o
*/
OneWire ds(10); // on pin 10
void setup(void) {
// initialize inputs/outputs
// start serial port
Serial.begin(9600);
}
void loop(void) {
byte i;
byte present = 0;
byte data[12];
byte addr[8];
int Temp;
if ( !ds.search(addr)) {
//Serial.print(“No more addresses.\n”);
ds.reset_search();
return;
}
Serial.print(“R=”); //R=28 Not sure what this is
for( i = 0; i < 8; i++) {
Serial.print(addr[i], HEX);
Serial.print(” “);
}
if ( OneWire::crc8( addr, 7) != addr[7]) {
Serial.print(“CRC is not valid!\n”);
return;
}
if ( addr[0] != 0×28) {
Serial.print(“Device is not a DS18S20 family device.\n”);
return;
}
ds.reset();
ds.select(addr);
ds.write(0×44,1); // start conversion, with parasite power on at the end
delay(1000); // maybe 750ms is enough, maybe not
// we might do a ds.depower() here, but the reset will take care of it.
present = ds.reset();
ds.select(addr);
ds.write(0xBE); // Read Scratchpad
Serial.print(“P=”);
Serial.print(present,HEX);
Serial.print(” “);
for ( i = 0; i < 9; i++) { // we need 9 bytes
data[i] = ds.read();
Serial.print(data[i], HEX);
Serial.print(“-”);
}
Temp=(data[1]<<8)+data[0];//take the two bytes from the response relating to temperature
Temp=Temp>>4;//divide by 16 to get pure celcius readout
//next line is Fahrenheit conversion
//Temp=Temp*1.8+32; // comment this line out to get celcius
Serial.print(” Temp=”);//output the temperature to serial port
Serial.print(Temp);
Serial.print(” C”);
Los servos estandar llevan 3 cables : tension, tierra y control. Se mueven en funcion de pulsos que le enviamos a traves del cable de control y estos pulsos que le enviamos son los que establecen la posicion del servo. El servo espera pulsos cada 20 milisegundos para tener una idea correcta de la posicion que ha de tener. La mayoria de los servos giran unos 180 grados y tienen una amplitud de pulsos de entre 0.5 y 2.5 milisegundos para establecer la posicion. Esta amplitud de pulsos puede variar en funcion del servo, e incluso entre mismos modelos de servos.
La practica
Conectaremos los pines del servo al arduino. En nuestro caso utilizaremos el pin digital 2 del arduino.
int servoPin = 2; // control pin for servo motor
int minPulse = 600; // minimum servo position
int maxPulse = 2400; // maximum servo position
int turnRate = 100; // servo turn rate increment (larger value, faster rate)
int refreshTime = 20; // time (ms) between pulses (50Hz)
/** The Arduino will calculate these values for you **/
int centerServo; // center servo position
int pulseWidth; // servo pulse width
int moveServo; // raw user input
long lastPulse = 0; // recorded time (ms) of the last pulse
void setup() {
pinMode(servoPin, OUTPUT); // Set servo pin as an output pin
centerServo = maxPulse – ((maxPulse – minPulse)/2);
pulseWidth = centerServo; // Give the servo a starting point (or it floats)
Serial.begin(9600);
Serial.println(“ Arduino Serial Servo Control”);
Serial.println(“Press < or > to move, spacebar to center”);
Serial.println();
}
void loop() {
// wait for serial input
if (Serial.available() > 0) {
// read the incoming byte:
moveServo = Serial.read();
// ASCII ‘<’ is 44, ASCII ‘>’ is 46 (comma and period, really)
if (moveServo == 44) { pulseWidth = pulseWidth – turnRate; }
if (moveServo == 46) { pulseWidth = pulseWidth + turnRate; }
if (moveServo == 32) { pulseWidth = centerServo; }
// stop servo pulse at min and max
if (pulseWidth > maxPulse) { pulseWidth = maxPulse; }
if (pulseWidth < minPulse) { pulseWidth = minPulse; }
}
// pulse the servo every 20 ms (refreshTime) with current pulseWidth
// this will hold the servo’s position if unchanged, or move it if changed
if (millis() – lastPulse >= refreshTime) {
digitalWrite(servoPin, HIGH); // start the pulse
delayMicroseconds(pulseWidth); // pulse width
digitalWrite(servoPin, LOW); // stop the pulse
lastPulse = millis(); // save the time of the last pulse
}
}
// print pulseWidth back to the Serial Monitor (uncomment to debug)
Serial.print(“Pulse Width: “);
Serial.print(pulseWidth);
Serial.println(“us”); // microseconds
En el ejemplo lo que hacemos es esperar por serie que presionesmos las teclas “,” o “.” para ampliar el pulso que le mandamos al servo en rangos de 100 ms hacia derecha o izquierda.
El resultado
Manejando multiples servos
Cuando tenemos mas de un servo el proceso es practicamente identico. Solo tenemos que contemplar las longitudes de pulso de todos los servos y restarselos a los 20 milisegundos.
Dicho con codigo.
int servoPinL = 2; // Control pin for servo motor – L
int servoPinR = 3; // Control pin for servo motor – R
int minPulse = 500; // Minimum servo position
int maxPulse = 2500; // Maximum servo position
long adjustedAV = 0; // Analog value adjusted for determining pulse values
int pulseL = 0; // Amount to pulse the servoL
int pulseR = 0; // Amount to pulse the servoR
int delayValueMax = 20000; // the 20 microsecond maxiumum pulse range for the servo
int delayValue = 20000; // the actual value the code should wait, determined later
int analogValue = 0; // the value returned from the analog sensor
int analogPin = 0; // the analog pin that the sensor’s on
void setup() {
pinMode(servoPinL, OUTPUT); // Set servo pins as an output pins
pinMode(servoPinR, OUTPUT);
pulseL = minPulse; // Set the motor position values to the minimum
pulseR = maxPulse;
}
void loop() {
analogValue = analogRead(analogPin); // read the analog input (0-1024)
adjustedAV = (analogValue / 10) * 19; // convert the analog value to a number
// between 0-2000 (difference between min and max)
pulseL = adjustedAV + minPulse; // set value for left motor
pulseR = maxPulse – adjustedAV; // and the inverse for the right
digitalWrite(servoPinL, HIGH); // Turn the L motor on
delayMicroseconds(pulseL); // Length of the pulse sets the motor position
digitalWrite(servoPinL, LOW); // Turn the L motor off
digitalWrite(servoPinR, HIGH); // Turn the R motor on
delayMicroseconds(pulseR); // Length of the pulse sets the motor position
digitalWrite(servoPinR, LOW); // Turn the R motor off
delayValue = (delayValueMax – pulseL) – pulseR; // determine how much time you have before the 20 ms is over…
delayMicroseconds(delayValue); // 20 millisecond delay is needed between pulses
// to keep the servos in sync
}
Aqui lo que vamos a hacer es utilizar el shift register para para convertir los datos en paralelo que hemos de pasarle al LCD en serie que pasaremos al shift register.
Para ello se ha creado una nueva libreria basada en LiquidCrystal.h. Realmente lo unico que hacemos con ella es añadir una nueva funcion envia que sera la encargada de enviar los datos cumpliendo el protocolo de comunicacion del LCD.
La libreria de momento esta adaptada solo para usar el modo de 4 bits. Lo hacemos asi porque de esta forma los pines necesarios en el LCD son 7 (4 datos y 3 de control). permitiendonos hacerlo todo con un solo shift register. El pin q0 del shift lo utilizaremos, siempre en on ,para encender un led que nos indique que esta funcionando el sistema.
Funcionamiento
Basicamente lo que hacemos es pasarle los 8 bits de datos que queremos hacer llegar al LCD al shiftter uno a uno (serie) y a continuacion los enviamos por las patas del mismo hacia el LCD (paralelo).
La librearia se ha escrito preparada para controlar dicha comunicacion con un conexionado determinado.
q0 – > diodo led (siempre estara on)
q1 -> pin S/R
q2 -> pin R/W
q3 -> pin enable
q4-> d4 (pin 11)
q5-> d5 (pin 12)
q6 ->d6 (pin 13)
q7 ->d7 (pin 14)
Esto es importate mantenerlo asi pues los datos se enviaran cumpliendo el protocolo y si lo cambiamos al LCD le llegaran de otra forma los datos interpretandolos como bytes distintos.
La practica
Una vez que lo tenemos conectado subiremos el siguiente codigo al arduino:
//Print some characters
lcd.print(” Sucess!”);
delay(3000);
//lcd.send(0×01,LOW); //Clear
lcd.setCursor(0,1);
lcd.print(“OK”);
}
void loop()
{
}
Primero creamos el objecto y a continuacion en el metodo setup inicializamos el LCD. Los comandos para inicializar el lcd son variados y pueden encontrarse en el datasheet del lcd.
LCD paralelo capaz de trabajar tanto con 8 como con 4 bits. Las librerias para controlarlo vienen con el core de arduino (LiquidCrystal.h).
Funcionamiento
La forma de controlarlo es bien sencilla. En el modo de 8 bits necesitaremos conectar los 8 pines de datos al arduino (6-14). Ademas de estos 8 pines necesitaremos tambien los pines 3, 4 y 5 para controlar cuando le mandamos los datos al LCD.
El pin rs (3) lo utilizaremos para marcar si lo que estamos enviando es un comando o es un caracter a dibujar. El pin r/w (4) lo utilizamos para escribir o leer del LCD. El pin Enable (5) se usa para que el display sepa cuando tiene listo los 8 bits de datos que le vamos a enviar. Abriendo el pin enable, metiendo las tensiones en los pines de datos y cerrando a continuacion el pin enable.
En el modo de 4 bits los pines que se usan en el lcd son del 10 al 14. Para pasar los datos al lcd en este modo es parecido al anterior solo que en vez de abrir el pin enable y cerrarlo una vez, lo abririamos, enviariamos los 4 primeros bits (los mayores), cerrariamos el pin enable, y volviendo a abrirlo y cerrarlo de nuevo con los otros 4 bits (los menores).
La practica
El modo que utilizamos es el modo de 4 bits, que la cosa de pines esta corta. Una vez que lo tenemos conectado de la forma que hemos dicho antes (habiendole dado tb tierra y tension en los pines 1 y 2 respectivamente) le cargamos el siguiente codigo al arduino.
#include <LiquidCrystal.h>
// LiquidCrystal display with:
// rs on pin 12
// rw on pin 11
// enable on pin 10
// d0, d1, d2, d3 on pins 5, 4, 3, 2
LiquidCrystal lcd(12, 11, 10, 5, 4, 3, 2);
void setup()
{
// Print a message to the LCD.
lcd.print(“hello, world!”);
}
void loop()
{
}
Lo que hace el codigo es sencillo. Inicializamos el objeto que lo que realmente hace es mandarle al LCD los comandos de set a 4 bits, entry mode, y clear display, para que a continuacion podamos empezar a escribir en el con la funcion print.
