Hola a todos los que ven mi blog, de una forma ocacional o que lo visitan frecuente mente, es esta vacaciones navideñas, colocare algunos artículos y proyectos que he hecho en este tiempo, por mis estudios no he tenido mucho tiempo.
gracias
Jaime
sábado, 19 de noviembre de 2011
viernes, 26 de agosto de 2011
Reinstalando el Bootloader de tu Arduino
Reinstalando el Bootloader de tu Arduino
¿Cómo reprogramar el bootloader en un Arduino Uno?
Lo que necesitas (Opción 1):- Tu Arduino Uno (para programar)
- Un Arduino Funcional.
- Algunos cables para el interconectado.
Lo que necesitas (Opción 2):
- Tu Arduino Uno (para programar).
- Un Programador AVR como el AVR Pocket Programmer o el AVR-ISP500.
- Un Cable para Programar el AVR (el pocket programmer viene con uno).
- El Arduino Optiboot Bootloader
- WinAVR (Windows) o Crosspack for AVR Development (Mac) - Este software contiene elavrdude, el cual es necesario! (Nota: podrías obtenerlo bajándolo o usando una copia del avrdude que viene con el Arduino, sin embargo, instalando la versión con el WinAVR, éste agregará las rutas a Windows Environment Variables lo cual lo hace mucho más fácil de usar por medio de comandos (prompt).
- Arduino 0018 (o más nuevo) si es que estás usando la opción 1.
Programando el Arduino para que funcione como programador (para la Opción 1)
Primero debemos tener el Arduino programado para trabajar como programador. Esto es muy simple, con el Arduino IDE, abrir el ArduinoISP realizando lo siguiente:
File->Examples->ArduinoISP.
Lo anterior hará que el Arduino actúe como un programador ISP. Selecciona tu tarjeta en menú de herramientas (Tools), y luego asegúrate de seleccionar el puerto COM correcto (anota el puerto seleccionado, porque se volverá a usar más adelante). Luego sólo sube el programa al Arduino.
Por ahora, el Arduino se programó para funcionar como un programador ISP, y se encuentra conectado al computador por medio de un cable USB. Lo siguiente que necesitamos es que este Arduino se conecte a la tarjeta objetivo (la que queremos reinstalar el Bootloader), para luego poder cargar los archivos *.HEX a esta tarjeta.
Conexionado de tu Tarjeta
| Arduino | Programador AVR | Arduino al que se le reinstalará el bootloader |
|---|---|---|
| VCC / 5V | 5V | VCC / Pin2 |
| GND | GND | GND / Pin 6 |
| MOSI / D11 | MOSI | MOSI / Pin 4 |
| MISO / D12 | MISO | MISO / Pin 1 |
| SCK / D13 | SCK | SCK / Pin 3 |
| D10 | RESET | RESET / Pin 5 |
Nota: Puedes usar el cable que viene con el programador. El lado que se conecta al Pocket Programmer sólo se puede conectar de una forma. El lado que se conecta al Arduino va con la muesca de frente al botón Reset.
Programando la Tarjeta a Reinstalar
Lo único que queda por hacer es enviar el archivo *.hex desde el computador al Arduino Programador (el que se encuentra conectado al PC) para que éste pueda luego pasarle el programa al Arduino objetivo (al que se le reinstalará el Bootloader). AVRdude es un programa incluido con WinAVR (o Crosspack) que puede enviar un archivo *.hex a un programador ISP. Una vez que tengas el AVRdude instalado (vía WinAVR o Crosspack) sólo necesitas un comando para llevar el archivo *.hex a la tarjeta objetivo. Instalar este programa es simple, sólo sigue las indicaciones e instala el programa usando los valores por defecto.
AVRdude en un programa que funciona por línea de comando, por lo que debes abrir la línea de comandos de Windows (Inicio-Ejecutar- "cmd") para poder usarlo. Una vez abierto el "cmd", escribe "avrdude" y presiona Enter. Si la instalación está correcta entonces se mostrará una lista de opciones disponibles. Con esto estamos listos para enviar comandos que programarán la tarjeta. Comienza por dirigirte hacia el directorio en el cual se encuentra el archivo *.hex.
Primero vamos a configurar los Fuse Bits (bits de memoria que según su valor, ´0´ o ´1´, permiten configurar a muy bajo nivel un microcontrolador, el cual corresponde en este caso al chip que controla el Arduino, un ATMega328). Te permiten controlar cosas como si vas a usar o no un reloj externo, la velocidad del reloj interno, habilitar el Reset externo, y así muchas otras opciones las cuales aparecen detalladas en la hoja de datos del chip. Como una forma de asegurarse del correcto funcionamiento del chip, se van a configurar todos los fuse bits de éste.
Opción 1: avrdude -P comport -b 19200 -c avrisp -p m328p -v -e -U efuse:w:0x05:m -U hfuse:w:0xD6:m -U lfuse:w:0xFF:m
Opción 2: avrdude -b 19200 -c usbtiny -p m328p -v -e -U efuse:w:0x05:m -U hfuse:w:0xD6:m -U lfuse:w:0xFF:m
Ahora ingresa el comando, reemplazando comport (com5 por ejemplo) por el puerto COM al cual tu Arduino fue conectado (para la opción 1), y hexfilename por el nombre de tu archivo. No olvides que el comando es sensible a mayúsculas y minúsculas, por lo que ten cuidado al escribir o algún error podría ocurrir. El comando utiliza 7 parámetros: -P es el puerto usado, -b es el baudrate, -c es el tipo de programador, -p es el microprocesador que está siendo programado, y -v le dice al Avrdude que utilice una salida verbal, es decir, para cada respuesta de un comando o algún error, entonces se mostrará la descripción del error en vez de sólo el código, lo cual es útil si una persona está viendo la salida y no un programa. El resto indica: -e le dice al Avrdude que borre el chip antes de programarlo, y -U le dice al Avrdude dónde colocar el archivo *.hex. Además escribimos los Lock Bits en tu chip. Estos bits son similares a los Fuse Bits, con la excepción de que los Lock Bits controlan la seguridad de acceso en el chip. En este caso esto es importante, ya que evita que se sobreescriba accidentalmente en el Bootloader al instalar por ejemplo un programa demasiado grande.
Opción 1: avrdude -P comport -b 19200 -c avrisp -p m328p -v -e -U flash:w:hexfilename.hex -U lock:w:0x0F:m
Opción 2: avrdude -b19200 -c usbtiny -p m328p -v -e -U flash:w:hexfilename.hex -U lock:w:0x0F:m
Nota: recuerda que Arduino es sólo una tarjeta de desarrollo AVR que ejecuta el Arduino Bootloader. Por lo tanto, puedes usar este método para cargar cualquier archivo *.hex a un chip ATMega328. Para más información ingresa a este tutorial para usar tu Arduino para programar un AVR. (http://www.sparkfun.com/tutorials/200)
Nota: también puedes saltar la opción de usar la línea de comandos de Windows y usar el Arduino IDE para reprogramar el Bootloader. Asegúrate de tener la tarjeta correcta y el puerto seleccionado, luego dirígete a Tools-Burn Bootloader-(selecciona tu ISP) y selecciona "w/USBtinyISP" para el Pocket Programmer. La desventaja de usar este método es que no tienes ningún control sobre cual Bootloader estás cargando en tu tarjeta.
miércoles, 24 de agosto de 2011
Mi Canal de Youtube
Hola, este es mi canal de youtube, donde tengo mis vídeos, se los dejo para que los mires.
http://www.youtube.com/user/jarain78?feature=mhee
http://www.youtube.com/user/jarain78?feature=mhee
domingo, 21 de agosto de 2011
Polémica por la creación de embriones híbridos entre animales y humanos
Un organismo regulador británico se dispone a autorizar hoy la creación de embriones híbridos de animales y seres humanos como primer paso para el desarrollo de terapias destinadas al tratamiento de enfermedades como el Alzheimer o el mal de Parkinson.
Tras varios meses de consultas, la llamada Autoridad para la Fecundación y Embriología Humanas, dará este viernes su esperado visto bueno a esas prácticas, según adelanta el diario The Guardian.
Los investigadores quieren crear embriones híbridos insertando células humanas en óvulos de vacas muertas y esperan extraer de ellos valiosas células embrionarias con las que combatir enfermedades neurodegenerativas e incluso graves lesiones de la médula espinal.
La publicación, hoy, de la decisión oficial, que deberá pasar antes de fin de año el trámite parlamentario, viene precedida de meses de reflexión a cargo de los científicos interesados, por un lado, y grupos religiosos y otros que se oponen al uso de células madre embrionarias para fines médicos. Los científicos argumentan que la utilización de óvulos de animales permitirá resolver el problema que presenta la escasez de óvulos humanos.
Legislación
De acuerdo con la legislación actual, los embriones deben destruirse al cabo de catorce semanas, cuando no han alcanzado el tamaño de una cabeza de alfiler, y no pueden implantarse en el útero.
Quienes se oponen a esas prácticas señalan que difuminan la distinción entre el ser humano y el animal y crean además embriones destinados a ser destruidos una vez que se extraigan de ellos las células troncales.
Sendos equipos de investigadores del King´s College de Londres y la Universidad de Newcastle solicitaron el pasado noviembre autorización al organismo regulador para crear esos embriones.
Si la Autoridad para la Fecundación y Embriología Humana da su aprobación, según se espera, el tema pasará a otro comité gubernamental, que deberá decidir en un plazo máximo de tres meses.
Ian Wilmut, jefe del equipo creador de Dolly, la primera oveja clonada, espera la decisión favorable de esa autoridad para crear embriones híbridos que le permitan estudiar la enfermedad de la neurona motriz junto a Chris Shaw, del Instituto de Psiquiatría de Londres.
Consultas y sondeos
Antes de comunicar su decisión definitiva, el organismo regulador ha llevado a cabo durante tres meses consultas, sondeos de opinión y debates públicos.
Según la autoridad gubernamental, los consultados se mostraron mayoritariamente favorables a la creación de embriones híbridos citoplásmicos, en los que una célula humana se inserta en un óvulo animal previamente vaciado.
Gozan, por el contrario, de menos favor otro tipo de embriones híbridos: los creadosfecundando un óvulo animal con esperma humano o viceversa.
El pasado diciembre, el Gobierno de Londres provocó el rechazo de la comunidad científica, de grupos de pacientes e investigadores médicos al publicar un libro blanco que proponía ilegalizar prácticamente todas las investigaciones que utilizasen embriones híbridos.
En mayo, las autoridades, sin embargo, flexibilizaron su postura inicialmente negativa con la publicación de un nuevo borrador de proyecto de ley sobre fecundación y ahora sólo seguirán prohibidos los embriones híbridos del segundo tipo: los creados con óvulo animal y esperma humano o esperma animal y óvulo humano.
sábado, 20 de agosto de 2011
Como hacer comunicacion serial: Ubuntu-Arduino
Progrma para hacer comunicacion serial entre Ubuntu y arduino, proramado en C++ con CodeBlocks IDE:
Porgrama CodeBlocks:
#include <stdio.h> // standard input / output functions
#include <string.h> // string function definitions
#include <unistd.h> // UNIX standard function definitions
#include <fcntl.h> // File control definitions
#include <errno.h> // Error number definitions
#include <termios.h> // POSIX terminal control definitionss
#include <time.h> // time calls
#include <sys/signal.h>
#include <sys/types.h>
//#include <cv.h>
char buf[255];
int res;
int open_port(void);
int configure_port(int fd);
int query_modem(int fd);
int main(void)
{
int fd = open_port();
configure_port(fd);
while(true){
query_modem(fd);
}
return(0);
}
int open_port(void)
{
int fd; // file description for the serial port
fd = open("/dev/ttyUSB0", O_RDWR | O_NOCTTY | O_NDELAY);
if(fd == -1) // if open is unsucessful
{
perror("open_port: Unable to open /dev/ttyS0 - ");
}
else
{
fcntl(fd, F_SETFL, 0);
}
return(fd);
}
int configure_port(int fd) // configure the port
{
struct termios port_settings; // structure to store the port settings in
cfsetispeed(&port_settings, B9600); // set baud rates
cfsetospeed(&port_settings, B9600);
port_settings.c_cflag &= ~PARENB; // set no parity, stop bits, data bits
port_settings.c_cflag &= ~CSTOPB;
port_settings.c_cflag &= ~CSIZE;
port_settings.c_cflag |= CS8;
tcsetattr(fd, TCSANOW, &port_settings); // apply the settings to the port
return(fd);
}
int query_modem(int fd) // query modem with an AT command
{
int n;
fd_set rdfs;
struct timeval timeout;
// initialise the timeout structure
timeout.tv_sec = 10; // ten second timeout
timeout.tv_usec = 0;
write(fd, "1", 3); // send an AT command followed by a CR
res = read(fd,buf,255);
buf[res]=0;
printf("%s", buf, res);
// do the select
//n = select(fd + 1, &rdfs, NULL, NULL, &timeout);
// check if an error has occured
/*if(n < 0)
{
perror("select failed\n");
}
else if (n == 0)
{
puts("Timeout!");
}
else
{
printf("\nBytes detected on the port!\n");
}
*/
}
Programa Arduino:
void setup(){
Serial.begin(9600) ;
}
void loop(){
word Adc = analogRead(0);
delay(5);
Serial.println(Adc);
if(Serial.available()){
int Rd = Serial.read();
if(Rd==49){
digitalWrite(13,HIGH);
Serial.print("dato:" );
Serial.println(Rd);
}
}
delay(200);
}
Porgrama CodeBlocks:
#include <stdio.h> // standard input / output functions
#include <string.h> // string function definitions
#include <unistd.h> // UNIX standard function definitions
#include <fcntl.h> // File control definitions
#include <errno.h> // Error number definitions
#include <termios.h> // POSIX terminal control definitionss
#include <time.h> // time calls
#include <sys/signal.h>
#include <sys/types.h>
//#include <cv.h>
char buf[255];
int res;
int open_port(void);
int configure_port(int fd);
int query_modem(int fd);
int main(void)
{
int fd = open_port();
configure_port(fd);
while(true){
query_modem(fd);
}
return(0);
}
int open_port(void)
{
int fd; // file description for the serial port
fd = open("/dev/ttyUSB0", O_RDWR | O_NOCTTY | O_NDELAY);
if(fd == -1) // if open is unsucessful
{
perror("open_port: Unable to open /dev/ttyS0 - ");
}
else
{
fcntl(fd, F_SETFL, 0);
}
return(fd);
}
int configure_port(int fd) // configure the port
{
struct termios port_settings; // structure to store the port settings in
cfsetispeed(&port_settings, B9600); // set baud rates
cfsetospeed(&port_settings, B9600);
port_settings.c_cflag &= ~PARENB; // set no parity, stop bits, data bits
port_settings.c_cflag &= ~CSTOPB;
port_settings.c_cflag &= ~CSIZE;
port_settings.c_cflag |= CS8;
tcsetattr(fd, TCSANOW, &port_settings); // apply the settings to the port
return(fd);
}
int query_modem(int fd) // query modem with an AT command
{
int n;
fd_set rdfs;
struct timeval timeout;
// initialise the timeout structure
timeout.tv_sec = 10; // ten second timeout
timeout.tv_usec = 0;
write(fd, "1", 3); // send an AT command followed by a CR
res = read(fd,buf,255);
buf[res]=0;
printf("%s", buf, res);
// do the select
//n = select(fd + 1, &rdfs, NULL, NULL, &timeout);
// check if an error has occured
/*if(n < 0)
{
perror("select failed\n");
}
else if (n == 0)
{
puts("Timeout!");
}
else
{
printf("\nBytes detected on the port!\n");
}
*/
}
Programa Arduino:
void setup(){
Serial.begin(9600) ;
}
void loop(){
word Adc = analogRead(0);
delay(5);
Serial.println(Adc);
if(Serial.available()){
int Rd = Serial.read();
if(Rd==49){
digitalWrite(13,HIGH);
Serial.print("dato:" );
Serial.println(Rd);
}
}
delay(200);
}
sábado, 13 de agosto de 2011
Life is Infinty: Robot con Cerebro de Rata
Life is Infinty: Robot con Cerebro de Rata: "Los científicos están derribando las barreras que separan diferentes disciplinas, aparentemente incompatibles entre sí. En la actualidad,..."
jueves, 11 de agosto de 2011
domingo, 31 de julio de 2011
DARPA Arm Robot Controlled via LabVIEW
DARPA Arm Robot Controlled via LabVIEW: "
"
By now, you’ve all heard of one of DARPA’s latest robotics projects, but just in case:
DARPA is introducing its Autonomous Robotic Manipulation (ARM) program. The goal of this 4 year, multi-track program is to develop software and hardware that allows an operator to control a robot which is able to autonomously manipulate, grasp and perform complicated tasks, given only high-level direction. Over the course of the program in the Software Track, funded performers will be developing algorithms that enables the DARPA robot to execute these numerous tasks. DARPA is also making an identical robot available for public use, allowing anyone the opportunity to write software, test it in simulation, upload it to the actual system, and then watch, in real-time via the internet, as the DARPA robot executes the user’s software. Teams involved in this Outreach Track will be able to compete and collaborate with other teams from around the country.
One of NI’s R&D engineers, Karl, has developed a LabVIEW wrapper for the DARPA arm simulator in his spare time and has graciously shared it on the NI Robotics Code Exchange (ni.com/code/robotics).
Using Karl’s code, you can directly control the arm simulator using LabVIEW. This means you develop your own control code and easily create UIs using LabVIEW’s graphical programming environment (two of the things LabVIEW is best for).
Check out Karl’s blog to request the code:
DARPA Arm Robot Controlled via LabVIEW
"
More LabVIEW Development for the Xbox Kinect
More LabVIEW Development for the Xbox Kinect: "
"
So remember when I said the Xbox Kinect was going to revolutionize robotics (at least from a sensor-hardware point of view)?
Well, when it rains, it pours: More and more LabVIEW developers are uniting, creating and sharing drivers that allow you to communicate with the Xbox Kinect hardware using LabVIEW software.
An NI Community member, anfredres86, has published his VI driver library, making it easy to download and install the necessary files for you to start developing robotics applications in LabVIEW that utilize the Kinect hardware for robot sensing.
Here is a video of the 2D occupancy grid mapping example he put together using LabVIEW and the Kinect:
I encourage everyone to check out (and download) his code:
Kinect Drivers for Labview: http://decibel.ni.com/content/docs/DOC-15655
And be sure to share your examples on the NI Robotics Code Exchange as well!
"
Kinect 6D Visualization in LabVIEW
Kinect 6D Visualization in LabVIEW: "
"
The LabVIEW Kinect code keeps rolling in. I am happy to share yet another example that is available for free download.
This one is very similar to John Wu’s LabVIEW + Kinect example I shared awhile back. Karl Muecke, NI R&D engineer, shares his 6D visualization example on the NI Robotics Code Exchange.
You can view a video screen capture of the demo and download his open source code here:
https://decibel.ni.com/content/blogs/MechRobotics/2011/04/19/kinect-6d-visualization-in-labview
"
Open Source Code: Using XBox Kinect with the LabVIEW Robotics Starter Kit
Open Source Code: Using XBox Kinect with the LabVIEW Robotics Starter Kit: "
"
This example features sensor fusion, using the Kinect to gather the 3D image of the world and a scanning sonar to help avoid obstacles that get too close for the Kinect to see.
Check out the full recipe on the NI Robotics Code Exchange, including hardware lists, software and setup requirements, as well as code descriptions and downloads.
Download: Using the XBox Kinect with LabVIEW Robotics Starter Kit
"
U.S. Military Insect Drones (powered by LabVIEW?)
U.S. Military Insect Drones (powered by LabVIEW?): "
"
Do the screens of any of the monitors look familiar?
Read the news coverage of this robots here:
Micro-machines are go: The U.S. military drones that are so small they even look like insects
"
Suscribirse a:
Entradas (Atom)