Video Final 2a Parte

Video Final 1a Parte

Interfaz de obtención de imágenes

Avances al dia de hoy

Presentación Parcial

Adquisición de la tarjeta EYE-FI

En esta semana nos llegó la tarjeta SD EYE-FI para la cámara. Las pruebas han sido exitosas, y gracias a esta nueva tecnología inalámbrica y al esfuerzo de nuestro compañero Diego, ya podemos tomar fotografías y subirlas automáticamente al facebook.

Más pruebas con la transmisión

Primeras pruebas con la transmisión

Primera transmisión

Un avance más en esta semana fue el terminar la primera transmisión. El diseño de la misma fue realizado por nuestro compañero Oscar. A continuación una fotografía de la misma. En la siguiente entrada se mostrará un video de sus primeras pruebas.

Cambios realizados a la estructura

Con el fin de aprovechar mejor el espacio y quitarle peso a nuestro robot, nuestro equipo optó por utilizar una estructura con acrílico y tornillos sin fin para el mismo.

Consideramos que esto fue una muy buena decisión pues además de eliminar peso innecesario, resultó ser más estético que el bote de basura que habíamos pensado utilizar.

Los circuitos, así como la cámara y la batería serán acomodados en los diferentes niveles de la estructura. En la parte inferior atornillaremos las transmisiones.

Cambio de batería

Uno de los problemas con los que nos habíamos enfrentado era el peso de la batería con la que contábamos. Creíamos que la transmisión realizada no aguantaría el peso de la misma, más el resto de la circuitería.


Afortunadamente, mientras trabajábamos en el laboratorio de Redes nos encontramos una batería de un tercio del peso de la anterior. Esta batería es de 12V y 4A. Agradecemos al Ing. Raime Bustos el préstamo de la batería para la realización de este proyecto. Ha sido montada en la estructura de la siguiente manera.

Demostración del módulo de sensores

Este módulo fue creado como parte del robot vigilante. Se encargará del control de los sensores ultrasónico (SRF08) e infrarrojos (GP2D15). Para el control de los mismos se utilizó un microcontrolador PIC18F452. La programación se realizó en C en el compilador CCS. Este módulo se comunicará con el módulo central, quien se encargará de realizar las modificaciones pertinentes a la ruta.

Módulo de sensores

En esta semana se terminó con éxito el módulo de los sensores. Como ya se ha mencionado, decidimos utilizar un sensor infrarrojo más, para controlar el movimiento de detección de obstáculos ya fuera hacia la izquierda, o hacia la derecha.

El PCB fue terminado y probado con éxito, como se pudo ver en las imágenes.

Trabajo arduo en semana santa

El equipo aprovechó las esperadas "vacaciones" de semana santa para trabajar día y noche en el proyecto.

Algunos de los avances realizados en esta semana fueron el desarrollo del sistema de sensores y detección de obstáculos.

Decidimos ordenar un nuevo sensor infrarrojo, para hacer más completo nuestro sistema.

El sistema de programación de trayectoria y movimiento fue completado, así como un módulo inalámbrico para que no fuera necesario conectarse directamente a una PC para programarla.

En cuanto al diseño de la transmisión, se realizaron avances considerables, los cuales serán mostrados en entradas posteriores del blog.

La estructura sufrió modificaciones para la conveniencia del equipo. Seguiremos una estructura semejante a la del robot EOS. Esta estructura se encuentra aún en proceso.

Sistema de control.

Los motores y trayectorias son controlados por un microcontrolador PIC16F877A el cual recibirá la distancia a recorrer por el microcontrolador principal y este almacenara la distancia e ira midiendo la distancia por un conjunto de encoders colocados en los ejes de las ruedas para poder midiendo la cantidad de vueltas que dan las ruedas, con este mismo sistema se controlara que el robot mantenga la trayectoria en el sentido que se desea y compensando cualquier inclinación en la misma que se pudiera tener.

Con el microcontrolador también se controlara el sentido que deben tener las ruedas, mediante un driver para motores de DC L293, el cual tiene la capacidad de controlar el sentido de dos motores, después del driver se colocara una etapa de potencia para evitar quemar el driver y alimentar la corriente necesaria para mover los motores.

Estructura, Sistema de tracción y control de trayectoria.

La estructura del robot se basara en la forma de un bote de plástico con tapa esférica. La cámara se posicionara en la tapa del bote, la cual tendrá la capacidad de girar 360 grados.

En el interior de la estructura, se colocaran dos niveles los cuales tendrán almacenado la batería y circuitería de control del robot.

El sistema de tracción estará conformado por dos motores de DC de 12v, los cuales dan la tracción al robot junto con una rueda loca para darle estabilidad y facilidad de movimiento al mismo.

Ya que el peso aproximado del robot es de 5.5Kg se colocara una transmisión reductora para reducir las revoluciones de los motores y aumentarles el torque que será transmitido a las ruedas de tracción del robot.

Al principio se propuso utilizar una transmisión compuesta por poleas y bandas para hacer la reducción de revoluciones, y fabricada de polietileno, pero se encontró que en algunos caso al momento de llevar a la transmisión a trabajos forzados y encontrar puntos de quiebre o derrape del material, la transmisión tendía a que las bandas se patinaran en las poleas y por lo tanto el robot dejaría de moverse o hasta llegar a reventar las bandas de plástico. Por esta razón optamos por la implementación de una transmisión compuesta por engranes, de esta manera evitamos derrapes entre componentes dentro de la transmisión.

Las primeras pruebas de transmisiones que se hicieron fueron hechas con transmisiones de 3 engranes, con el propósito de tener un engrane que fuera el productor del movimiento de la transmisión, el cual va directamente al rotor del motor de DC, otro engrane es el engrane de salida de la transmisión el cual va conectado al eje de giro de las ruedas, entre ellos se colocaría un tercer engrane el cual seria el transmisor de energía entre el engrane de salida y el de entrada, además de tener la función de transmisor de energía, tendría la función de engrane fusible, el cual, en caso de que el robot estuviera en un momento en el que entro en una parte donde la rueda quedara atorada y el robot quisiera seguir avanzando, se quebrara así evitando que el motor se sobrecalentara pudiendo llegar a quemar el motor o la circuitería misma.

Debido a la complejidad de este sistema ya que los engranes requieren de estar muy bien alineados y la estructura debe ser lo suficientemente solida para soportar las fricciones y peso del robot, se opto por hacer una transmisión simple de dos engranes con una relación de 3 a 1, siendo el sistema final, un engrane en el eje de rotación de la rueda y otro en el rotor del motor de DC, esto quiere decir que el engrane que va en el eje de las ruedas es 3 veces aproximadamente mas grande que el que va en el rotor del motor.

Los engranes de las transmisiones, fueron moldeados con plásticos macizos para evitar que sufrieran fracturas causadas por la fricción al momento de estar en movimiento el robot, ya que los engranes van a estar interactuando directamente entre si, el engrane del rotor del motor de DC esta fabricado de plástico resistente al calor, con un total de 19 dientes en su circunferencia, el engrane que va colocado en el eje de la llanta esta hecho de plástico ligero para hacer mas fácil el giro de las ruedas, con un total de 60 dientes en su circunferencia.
Las ruedas del robot son de plástico duro de 2.5 pulgadas de diámetro, serán recubiertas de plástico blando para amortiguar el rebote que tenga el robot causada por las irregularidades del terreno por el que pueda transitar el robot.

Interfaz Para Grabar la Trayectoria

Este segundo código es el de la interfaz en la cual el usuario puede predefinir la trayectoria y mandar la señal al microcontrolador para que éste la reproduza, este programa esta hecho en LabWindows CVI.

Interfaz de Usuario

Código

#include "Trayectoria.h"

static int panelHandle;

int SendAsciiString (int comport, char *send_ASCII);
int GetSerialMessage (int comport, char *readdata);

char readBuffer[256];

int main (int argc, char *argv[])
{
if (InitCVIRTE (0, argv, 0) == 0)
return -1; /* out of memory */
if ((panelHandle = LoadPanel (0, "Trayectoria.uir", PANEL)) < loopexit =" 0;" x="0;" error =" -1;" x="0;" begin =" Timer();" seconds =" 0.003;" inbuffer =" GetInQLen"> 2) {
ComRd (comport, readdata, InBuffer);
LoopExit = 1;
error = 0;
break;
}
SyncWait (Begin, Seconds);
}
if (x == 500)
break;
} while (LoopExit == 0);
return error;
}

Primera Fase del Programa para la Planeacion de la Trayectoria

EL siguiente código es la primera etapa del programa base para el control del robot, éste corre en el microcontrolador y está hecho en CodeWarrior para la tarjeta DEMOQE128. En esta primera fase el programa permite grabar una trayectoria predefinida por el usuario para después reproducirla, además en la trayectoria se pueden establecer puntos específicos dónde se desean tomar fotografías.

/*********************************************************************/
/* Project Name: Treyectory */
/* Source fle name: RTC.c */
/*********************************************************************/
/* Robotecnicos */
/*********************************************************************/
/*********************************************************************/
/* Code for QE128 MCU's */
/* Module: Trayectory */
/* The code was developed and tested on CodeWarrior 6.0 version */
/* */
/* Description: To learn the trayecory to be followed */
/* */
/*********************************************************************/
/* */
/* Date: 07/03/2009 */
/* Robotecnicos */
/* ITESM */
/*********************************************************************/

#include /* for EnableInterrupts macro */
#include "derivative.h" /* include peripheral declarations */

/*********************************************************************/
/* Globals */
/*********************************************************************/

#define RECORDING 1
#define LOOP 2
#define RESET 3

#define UP 1
#define DOWN 2
#define RIGHT 4
#define LEFT 8
#define PHOTO 16

typedef unsigned char UINT8;

unsigned char edo_past = 0;

unsigned char begin= 0;
unsigned char finish = 0;

unsigned char in = 0;

unsigned int count = 0;
unsigned int direction = 0;
unsigned int elements = 0;

unsigned int i = 0;

unsigned char state = RECORDING;

unsigned int trayectory[5][2];


/*********************************************************************/
/* Function declarations */
/*********************************************************************/

void MCU_Init(void) {

SOPT1 = 0x23; /* Watchdog disable. Stop Mode Enable. Background Pin enable. RESET pin enable */
SCGC1 = 0x01; /* Bus Clock to the SCI1 module is enable */
SCGC2 = 0x04; /* Bus Clock to the RTC module is enable */
}

void GPIO(void) {


PTAPE = 0x0C;
PTADD = 0x00; // Configure Port A as inputs

PTDPE = 0x0C;
PTDDD = 0x00; // Configure Port D as inputs

PTCDD = (PTCD 0x3F); /* Configure PTC0-PTC5 as outputs */
PTEDD = (PTED 0xC0); /* Configure PTE6 and PTE7 pins as outputs */
PTCD = 0x3F; /* Put 1's in port C in order to turn off the LEDs */
PTED = 0xC0; /* Put 1's in port E port in order to turn off the LEDs */


}

// To print data in the LEDs of DEMOQE

void display(byte x){ /* LEDS low power active */

x = ~x;
PTED = (x & 0xC0); /* Move the adquired ADC value to port E */
PTCD = (x & 0x3F); /* Move the adquired ADC value to port C */
}


void RTC_configuration (void) {

RTCSC = 0x08; /* RTCPS configure prescaler period every 1s */
RTCMOD = 0x00; /* RTCMOD configure to interrupt every 1s */
}

void SCI_configuration (void) {

SCI1C1 = 0x00; /* 8-bit mode. Normal operation */
SCI1C2 = 0x2C; /* Receiver interrupt enable. Transmitter and receiver enable */
SCI1C3 = 0x00; /* Disable all errors interrupts */
SCI1BDL = 0x1A; /* This register and the SCI1BDH are used to configure the SCI baud rate */
SCI1BDH = 0x00; /* BUSCLK 4MHz */
/* Baud rate = -------------------- = ------------ = 9600bps */
} /* [SBR12:SBR0] x 16 26 x 16 */

/*********************************************************************
* Main Function *
*********************************************************************/

void main(void) {


MCU_Init(); /* Function that initializes the MCU */
GPIO(); /* Function that initializes the Ports of the MCU */
RTC_configuration(); /* Function that initializes the RTC module */
SCI_configuration();

EnableInterrupts; /* enable interrupts */

/* Enable RTC interrupt */
for(;;) {

// in = ((~PTAD) & 0x0C);
// in = in >> 2;
// in = in ((~PTDD) & 0x0C);

switch (state){

case RECORDING:



if (finish == 0x01){

finish = 0x00;
begin = 0x00;
trayectory[elements][0] = direction;
trayectory[elements][1] = count;
count = 0;
elements ++;
//if (elements == 5) state = LOOP;
}

if(begin == 0x00) {

edo_past = in;
switch(in){
case 1 : PTCD_PTCD0 =0; RTCSC_RTIE = 1; begin = 0x01; direction = UP; break;
case 2 : PTCD_PTCD1 =0; RTCSC_RTIE = 1; begin = 0x01; direction = DOWN; break;
case 4 : PTCD_PTCD2 =0; RTCSC_RTIE = 1; begin = 0x01; direction = RIGHT; break;
case 8 : PTCD_PTCD3 =0; RTCSC_RTIE = 1; begin = 0x01; direction = LEFT; break;
case 16: PTCD_PTCD4 =1; RTCSC_RTIE = 1; begin = 0x01; direction = PHOTO; break;
default: PTCD = 0xEF; RTCSC_RTIE = 0;

}
}


break;

case LOOP:

PTED_PTED6 = 0;
RTCSC_RTIE = 1;


break;

case RESET:

elements = 0;

PTCD_PTCD0 =1;
PTCD_PTCD1 =1;
PTCD_PTCD2 =1;
PTCD_PTCD3 =1;
PTCD_PTCD4 = 0;


break;


}



} /* loop forever */
/* please make sure that you never leave this function */
}


/*********************************************************************
* Interrupt Service Routines *
*********************************************************************/

void interrupt VectorNumber_Vsci1rx SCI_RX_ISR(void) {

SCI1S1_RDRF = 0; /* Receive interrupt disable */

// display (SCI1D); /* Display on PTE the received data from SCI */

switch (SCI1D){

case '0': in = 0; break;
case '1': state = RECORDING; break;
case '2': state = LOOP; break;
case '3': in = 1; break;
case '4': in = 2; break;
case '5': in = 4; break;
case '6': in = 8; break;
case '7': in = 16; break;
case '8': state = RESET; break;

}



while (SCI1S1_TDRE == 0); /* Wait for the transmitter to be empty */
//SCI1D = '1'; /* Send a character by SCI */
}

void interrupt VectorNumber_Vrtc RTC_ISR(void) {

RTCSC = RTCSC 0x80; /* Clear the RTC flag */
PTED_PTED7 ^= 1; /* Toggles PTE7 pin */


// in = ((~PTAD) & 0x0C);
// in = in >> 2;
// in = in ((~PTDD) & 0x0C);

switch(state){

case RECORDING:
count++;
if(edo_past != in){

finish = 0x01;
RTCSC_RTIE = 0;

}

break;

case LOOP:



if (count == trayectory[i][1]){ PTCD_PTCD0 =1; PTCD_PTCD1 =1; PTCD_PTCD2 =1; PTCD_PTCD3 =1; PTCD_PTCD4 = 0; i++; count = 0;}
count ++;

if(i == elements) i = 0;

direction = trayectory[i][0];

switch(direction) {
case UP : PTCD_PTCD0 =0; break;
case DOWN : PTCD_PTCD1 =0; break;
case RIGHT : PTCD_PTCD2 =0; break;
case LEFT : PTCD_PTCD3 =0; break;
case PHOTO : PTCD_PTCD4 =1; break;
default: PTCD = 0xFF;
}



break;
}

}

Disparador externo CHDK

Gracias al CHDK es posible usar un programa que detecte una diferencia de voltaje en el puerto usb de la cámara para así poder tomar fotografías o realizar acciones que sean indicadas desde el micro.
El diagrama que se usa es muy simple

Se requiere un puerto USB con la entrada mini B que se conecta a la cámara, mientras que del otro extremo se puede conectar a un hembra que este conectado al micro o podemos cortar directamente el cable y aplicar la diferencia de voltaje ahí.
El programa que usamos para detectar el puerto usb es muy simple

@title Remote button
while 1
wait_click 1
if is_key "remote" then shoot
wend

end

Es un ciclo infinito (while 1) que espera por algún botón para ser presionado (wait_click 1). Si el “botón” es en realidad la diferencia de voltaje en el usb (remote) entonces realiza un disparo y repite el ciclo, si es algún otro botón repite el ciclo sin disparar.
El voltaje que se aplica en la cámara depende de cada modelo en nuestro caso es suficiente con 3.75, sin embargo otros modelos requieren mas voltaje mientras que otros requieren menos.

El CHDK detecta al puerto USB como otro botón mas, es decir que se puede usar para alterar el comportamiento del programa y no solo para disparar la cámara., el día de hoy en clase trataremos de hacer que la cámara tome fotos en intervalos, y que cuando reciba una señal del micro tome fotos al detectar movimiento.

Estructura del Robot

Estas son algunas imágenes de cómo se ve la estructura del robot, hecha a partir de un bote de basura, cortesía de nuestro compañero Oscar.

Programación del pic 16f877a / CCS

Programming PIC16F877A Using CCS C Compiler and US-Burn

Publish at Scribd or explore others: Academic Work ebook programming

Eye-fi baja de precio

Hoy nos enterramos de que la tarjeta que pensamos comprar para pasar las fotos de manera inalámbrica ha bajado de precio. Ahora cuesta solo 50 dólares el modelo mas económico, esto es debido a que se introdujo una nueva versión que soporta el poder subir videos a youtube. Esperamos que ahora el robot sea de un precio mas accesible y poder invertir el dinero en otras partes del robot.

Inauguración del blog en INGLÉS

Esta semana nos complace el anunciar que los contenidos de nuestro blog serán agregados a un blog en inglés. En el mismo encontraremos toda la información que hasta la fecha encontramos en este blog.

Para visitar el blog, clic en el siguiente link

BLOG EN INGLÉS - ENGLISH VERSION OF THE BLOG

Primer programa de prueba para el PIC16F877A

Acudimos a la página de ayuda en materia de robótica:

ROBOT ELECTRONICS - 1st rule of Robotics: Have fun!

En ella pudimos encontrar una variedad de ejemplos para controlar el SRF08. Cabe mencionar que se permite que estos ejemplos se utilicen para fines educativos, más no comerciales.

Encontramos el siguiente código, que será el precursos de nuestras pruebas con el PIC16F877A.

'****************************************************************
'* Name : UNTITLED.BAS *
'* Author : [Vladimir Kornienko] *
'* Notice : Copyright (c) 2006 [ARMORED DOLPHIN] *
'* : All Rights Reserved *
'* Date : 12/1/2006 *
'* Version : 1.0 *
'* Notes : *
'* : *
'****************************************************************

'PIC16f872

'---------------- Definitions---------------------------------------------

define OSC 20

'------------- Define LCD registers and bits------------------------------

DEFINE I2C_HOLD 1
define I2C_SLOW 1

Define LCD_DREG PORTB 'Set LCD data port
Define LCD_DBIT 0 'Set starting data bit
Define LCD_RSREG PORTB 'Set LCD register select port
Define LCD_RSBIT 4 'Set LCD register select bit
Define LCD_EREG PORTB 'Set LCD enable port
Define LCD_EBIT 5 'Set LCD enable bit
define DEBUG_REG PORTC 'Set DEBUD port
DEFINE DEBUG_BIT 1 'Set DEBUG pin
DEFINE DEBUG_BAUD 2400 'Set DEBUG baud rate
DEFINE DEBUG_MODE 0 'Set DEBUG mode

DPIN var PORTc.4 ' I2C data pin
CPIN var PORTc.3 ' I2C clock pin

bearing var word ' word size bearing value 0 - 359
bearing1 var byte ' byte size bearing value 0 - 254

Main:

i2cread dpin,cpin,%11000000,2,[bearing.Highbyte,bearing.lowbyte]
lcdout $fe, 1,"BEARING ",DEC BEARING/10
i2cread dpin,cpin,%11000000,1,[bearing1]
lcdout $fe, $c0,"Bearing ", dec bearing1
DEBUG " Compass Bearing ", # bearing,13,10
pause 20

goto main

Microcontrolador PIC16F877A (para manejo de sensores)

El microcontrolador a usar para el manejo de sensores es el PIC16F877A, este tiene la particularidad de contar con los pines necesarios para comunicación a través del protocolo I2C, haciéndolo la mejor opción en este caso, a continuación se describen las principales características de este modelo:

• Velocidad de operación: 20Mhz
  
• Mas de 8K x 14 palabras de memoria FLASH
  
• Más de 368 x 8 bytes de memoria de datos (RAM)
  
• Más de 256 x 8 bytes de memoria de datos EEPROM
  
• Bajo consumo de energía.
  
• Puerto serial síncrono (SSP) con SPI (Modo maestro)
  
• I2C (Maestro/Esclavo)
  

Para mas informacion:

DATASHEET del microcontrolador PIC16F877A

Especificaciones del sensor ultrasónico SRF08

El SRF08 es uno de los sensores con los que equiparemos a nuestro robot vigilante. Gracias a el mismo podremos detectar los obstáculos con los que se encuentre y poder evitarlos, siguiendo en la misma ruta.

Éste es un sensor de alto desempeño para detectar rangos de distancia. Se comunica a través del protocolo I2C, el cual se encuentra disponible en el microcontrolador PIC que utilizaremos para su control.

El SRF08 se comporta de la misma forma que eeprom's serie 24XX, a excepción de que el direccionamiento en I2C es diferente.

Algunas especificaciones:

Voltaje: 5v
Current: 15mA Typ. 3mA Standby.
Frecuencia: 40KHz
Rango: 3cm -6m.
Conexión Standard I2C Bus.
Sensor de luminosidad
Rango de unidades reportadas en uS, mm o pulgadas.
Dimensiones: 43 x 20 x 17mm altura
Peso: 11 g.

Guía para instalar el CHDK

El CHDK es un programa que corre sobre el firmware de fabrica de varios modelos de cámaras canon. Por su naturaleza el CHDK no es destructivo y en caso de que no se quiera mas en la cámara que se instalo es fácil desinstalarlo.
Los materiales para instalar el CHDK son:
Φ Tarjeta SD
Φ Cámara Canon powershot compatible. (aqui)
Φ Lector de tarjetas SD
Φ El programa CARDTRIKS para usuarios Windows
Φ El editor hexadecimal de tu preferencia
Lo primero que se tiene que hacer es checar la versión de FIRMWARE que tiene nuestra cámara. Para esto creamos un archivo Dummy llamado vers.req el cual no necesita ningún contenido especial (es decir puede ser un archivo de 0kb). Es importante que para este paso como todos los demás se útiles un lector de tarjetas que nos reconozca nuestra memoria como un disco externo (o como una memoria usb estandar) pues si se usa el cable usb que trae la cámara no se tiene acceso al directorio de mas alto nivel de la tarjeta, solo a la carpeta de fotos.
El archivo vers.req se copia a la tarjeta y después colocamos la tarjeta en la cámara. Prendemos la cámara en el modo de reproducción de fotografías y presionamos el botón de SET por un segundo. Después de esto se presiona el botón de DISP sin haber soltado el de SET, esto provocara que se despliegue una pantalla con la versión de FIRMWARE que tenemos, en nuestro caso es el GM1.00A.
Una vez que se conoce la versión de firmware bajaos el CHDK para nuestra cámara bajamos la versión adecuada del CHDK (http://mighty-hoernsche.de/)
Antes de instalar el CHDK en la tarjeta tenemos que prepararla como un disco de arranque. Los usuarios Windows deberán usar el programa que se menciono al principio. Los usuarios de mac y linux (entre otros OS basados en unix) pueden usar la línea de comandos para realizar el procedimiento. En este caso se formatea la tarjeta como FAT16 (es importnate notar que esto solo es para tarjetas menores a 4 gigas),.
Después en la línea de comandos de la terminal (para usuarios mac) usas el comando de dd if=/dev/diskXsX of=BootSector.bin bs=512 count=1 donde diskXsX se cambia por el identificador de la tarjeta (algo como disk1s1) y esto copia a tu computadora el sector de arranque de la tarjeta. El comando en ubuntu seria dd if=/dev/sdx1 of=BootSector_G9.bin bs=512 count=1 donde sdx1 es el identificador de la tarjeta. Esto crea el archivo Bootsector.bin en la carpeta “home” del usuario que estés usando en ese momento.



Después de este paso se abre el archivo que se copio al disco duro con un editor hexadecimal y en el sector 40 hexadecimal (64 decimal) agregas la palabra BOOTDISK, salvas el archivo y ahora realizas el procedimiento inverso, copias el archivo a la memoria (al sector de arranque) en Windows se puede usar un programa para esto, en mac se usa una línea de comando en terminal muy parecida a la anterior. dd if=BootSector.bin of=/dev/diskXsX bs=512 count=1 donde diskXsX se remplaza por el identificador del disco como es disk1s1. La línea de comando en ubuntu dd if=BS.bootable of=/dev/sdx1 bs=512, donde sdx1 es el identificador de la tarjeta.
IMPORTANTE en caso de que alguno de los comandos de terminal te marque un error como “dd: /dev/disk1s1: Resource busy” significa que la tarjeta esta siendo usada por el sistema operativo, así que debes “desmontarla”, en UBUNTU se puede hacer desde la línea de comandos, en MAC entras a DiskUtility y seleccionas UNMOUNT, es importante notar que esto no es lo mismo que expulsar el disco, si se expulsa la tarjeta esta pierde toda conexión con la computadora, en este caso lo que hacemos es solo desconectar el controlador que permite que el sistema operativo realice acciones sobre la tarjeta (como copiar archivos o explorar el contenido de la tarjeta) pero la tarjeta sigue teniendo comunicación con la computadora.

Una vez que nuestra tarjeta esta lista se puede instalar el CHDK, lo primero que se hace es descomprimir el archivo que se descargo y lo colocamos en la tarjeta, todo el programa va dentro de una tarjeta conocida como CHDK en el root de la tarjeta. Una vez que se hizo esto se inserta la tarjeta a la cámara pero teniendo cuidado de que el switch de LOOK este activado, este switch indica que no se permite escribir archivos en la tarjeta y es necesario pues en teoría no se puede escribir sobre el disco que usas como arranque, pero el CHDK sobrescribe por software esta función para que la tarjeta se puede usar para tomar fotos.

Finalmente solo nos queda prender la cámara y disfrutar las funciones del CHDK.
Si se quiere usar un programa extra se puede ir a
http://chdk.wikia.com/wiki/UBASIC/Scripts
donde existe una serie de fundones extras programadas para el CHDK. Uno muy interesante es el script que detecta movimiento, la demostración del mismo se hará en clase.
http://chdk.wikia.com/wiki/UBASIC/Scripts:_Multipurpose_Motion_Detection
Para usar estos scripts solo basta copiarlos a la tarjeta y cargarlos desde el menú del CHDK.

PPT sensores

Sensores De Distancia

View more presentations from diego5wh.

Resumen de Protocolo I2C

Cuando se conectaban múltiples dispositivos a un microcontrolador, la dirección y las líneas de datos de cada dispositivo se conectaban por convención individualmente. Esto quitaba pines útiles del microcontrolador, que resultaba en muchas pistas en el PCB y requerían que más componentes se conectaran. A su vez, esto hacía que los sistemas fueran costosos y susceptibles a interferencia y ruido.

Para resolver este problema, Phillips desarrolló Inter-IC o I2C en la década de los 80s. I2C es un protocolo de distancias cortas y bajo ancho de banda. Todos los dispositivos se conectan mediante dos cables. Como ya hemos mencionado anteriormente, ell sensor ultrasónico SRF08 con el que cuenta nuestro equipo está diseñado para trabajar con el protocolo I2C.

A continuación se mencionan algunas de las características más importantes de este protocolo.

•Se necesitan solamente dos líneas, la de datos (SDA) y la de reloj (SCL).
•Cada dispositivo conectado al bus tiene un código de dirección seleccionable mediante software. Habiendo permanentemente una relación Maestro/Esclavo entre el micro y los dispositivos conectados
•El bus permite la conexión de varios Maestros, ya que incluye un detector de colisiones.
•El protocolo de transferencia de datos y direcciones posibilita diseñar sistemas completamente definidos por software.
•Los datos y direcciones se transmiten con palabras de 8 bits.

Las líneas SDA y SCL transportan información entre los dispositivos conectados al bus. Cada dispositivo es reconocido por su código (dirección) y puede operar como transmisor o receptor de datos. Además, cada dispositivo puede ser considerado como maestro o esclavo. El maestro es el dispositivo que inicia la transferencia en el bus y genera la señal de reloj. El esclavo es el dispositivo direccionado.

Las líneas SDA (serial Data) y SCL (serial Clock) son bidireccionales, conectadas al positivo de la alimentación a través de las resistencias de pull-up. Cuando el bus está libre, ambas líneas están en nivel alto.

La transmisión bidireccional serie (8-bits) de datos puede realizarse a 100Kbits/s en el modo estándar o 400 Kbits/s en el modo rápido.
La cantidad de dispositivos que se pueden conectar al bus está limitada, solamente, por la máxima capacidad permitida: 400 pF.

Presentación Primer parcial

Primer Parcial

View more presentations from diego5wh.

Controladores

Módulos del Robot Vigilante

Descripción de los módulos del robot vigilante

Módulo 1. Cámara y procesamiento de imágenes: en este módulo se va a realizar todo lo referente a la programación de la cámara, tal como intervalos de tiempo entre fotografías, o toma de fotografías cuando se detecta movimiento, el almacenamiento de las mismas en una PC, así como el procesamiento de imágenes requerido para lograr los objetivos del proyecto.
Módulo 2. Estructura Física: este módulo se va a encargar de diseñar y crear la estructura donde se van a montar todos los módulos, la cámara, los controladores, motores, la batería, etc.

Módulo 3. Sensores: es el encargado de adquirir las señales de los distintos sensores, para detectar obstáculos, calibrar trayectoria y determinar posición actual del robot, además de determinar si el robot es levantado.


Módulo 4. Movimiento y Trayectoria: módulo encargado del control de los motores, así como también de la programación de la trayectoria.


Módulo 5. Documentación: encargado de evidenciar el proceso de elaboración del robot, así como de elaborar las descripciones detalladas de cada uno de sus módulos y las especificaciones para el usuario.

EYE FI

Encontramos unas fotos en Flickr donde abrieron la tarjeta EYE FI, de esta forma podemos apreciar mejor como esta la tarjeta por adentro. vemos que tenemos un chip de memoria SAMSUNG, el chip para el inalámbrico es ATHEROS (el ROCm que es usado en celulares con WI-FI). Además esta el chip de GPS que solo se encuentra la versión mas cara de la misma. .
http://www.flickr.com/photos/sniperninja123/3245581254/in/photostream/

También esta otra página donde explican a fondo que es cada chip y sus especificaciones. (http://www.ikontools.com/articles/eyefi-dissected)

Alternativa de Camara

Esta es una alternativa a la camara que podmeos usar

Alternativa de Camara

Esta es una alternativa a la camara que podmeos usar

Presentación de Actuadores Eléctricos

Actuadores Electricos

View more presentations or upload your own.

WIFIBOT

WIFIBOT es una compañía que se dedica ha hacer robots con cámaras y conexiones WiFi, la compañía se encuentra en Francia y aun que no es muy grande tiene robots muy interesantes, incluyendo algunos que además de cámaras tienen brazos robóticos.
En el video vemos como alguien creo un cliente para la consola portátil de Sony (PSP) para mandar el video del robot de forma inalámbrica, aun que por las limitaciones de procesamiento la trasmisión tiene un serio retardo y son muy pocos los cuadros que se reciben por segundo es un video interesante que muestra el potencial de las tecnologías existentes.

Con ustedes … Los técnicos.

El equipo de los técnicos se conforma por 8 miembros curiosos y con un espíritu libre.

Areacely – una líder por naturaleza, sabe como motivar al equipo para cumplir los objetivos además de amplios conocimientos en el área de electrónica de potencia.

Leslie-Bella y peligrosa, cuando no esta manejando un cautín se encuentra desafiando las leyes de la gravedad construyendo péndulos invertidos.

Michell- Experta en matemáticas y algoritmos, realizo estudios avanzados en la universidad de san Angelo en el área de matrices, incluyendo la resolución de matrices jacobinas de mas de 2 dimensiones.

Adrián-Experto programador, domina tanto ensamblador como C. galardonado a nivel nacional en concursos de electrónica.

Oscar-Con amplia experiencia en la industria tiene un enfoque practico y habilidades poco comunes, un amplio conocimiento del diseño de piezas y modelado computacional

Tito-Experto en el manejo de sensores, tiene estrecha relación con diferentes proveedores de componentes electrónicos a nivel nacional e internacional.

Julio- Guru en el área de electrónica analógica. Conoce mejor que nadie el manejo de filtros y el funcionamiento de amplificadores operacionales.

Diego- Con un gran dominio del área de procesamiento digital de señales y una implacable curiosidad puede programar transformadas rápidas de fourier incluso en los micros mas básicos.



#algunas de las habilidades fueron exageradas con motivo humorístico.

Pila

Entre los avances al robot se encuentra la adquisición de una Batería recargable sellada, que nos ofrece 12 volts además de una capacidad de trabajo de 7 ampers-hora, con un peso de 1.7 kilogramos, esta pila fue donada por un profesor y comenzaremos ha hacer pruebas es probable que el modelo final tenga una pila mas ligera aun que de menos capacidad.

Robot Vigilante Eos

Comenzamos

Esta es la primer entrada de nuestro blog, en la cual describiremos nuestros avances en el proyecto de la materia de robótica aplicada con el profesor Javier Rubio.
Nuestro proyecto consiste en un robot vigilante que tomara fotografías en intervalos de tiempos y va a seguir una ruta definida durante la noche.