El martes pasado, fue la presentación de los proyectos, y la nuestra fue todo un desastre. Nervios + tocar cosas que funcionan a ultima hora = desastre. Aunque al final acabamos con nota aceptable (6,7 de la clase, y 9 del profesor) decidí que esto no podía quedar así y debía mostrar al resto como funcionaba de verdad el brazo. A si que he decidido poner aquí los videos del brazo. Pero no, no son del brazo terminado, si no de algunas pruebas hechas antes terminarlo. Cuando me lleguen los dos servos que me faltan (uno se rompio y otro era del Kit de arduino que nos prestó el profesor y que ya se lo hemos devuelto) grabaremos un vídeo en condiciones y lo mostraré… mientras tanto…

Si, lo se, se me da muy mal editar vídeos…

El otro día un amigo me dejo una pequeña placa (PCB) que se había encontrado. Seguramente sea de una maquina de vending o algo por el estilo ya que tiene 4 displays de 7 segmentos y otros 4 pulsadores. Venía con un cable plano de 16 hilos, y trae en soldado a la placa un chip MC14499P. Obviamente lo primero que hice, fue buscar en internet el datasheeet del chip. Este es un driver para 4 displays de 7 segmentos que se puede enlazar en cascada a otros drivers para controlar mas displays. La forma de comunicarnos con el es a traves de tres señales: DATA, CLOCK y ENABLE. Al no haber libreria de arduino para este chip, tuve que pensar como comunicarme con el, y como su interfaz es tán parecida a la de los registros de desplazamiento (Shift Registers ->74HC595) pues probé con el mismo método. La función ShiftOut, y con un poco de prueba y error saque las posiciones de cada digito. Aquí dejo el vídeo:

Y el código:

#define LATCH   6
#define CLK     7
#define DATA    8

// 128.64.32.16.8.4.2.1 // 0 0 0 0 1 1 1 1

void setup() {
  Serial.begin(9600);
  Serial.println("startup");

  pinMode(LATCH,OUTPUT);
  pinMode(CLK,  OUTPUT);
  pinMode(DATA, OUTPUT);
}

void loop(){
    digitalWrite(LATCH, LOW);
    shiftOut(DATA, CLK, MSBFIRST, 80);   //80 = 0 1 0 1 | 0 0 0 0  [ 5 | 0 ]

    shiftOut(DATA, CLK, MSBFIRST, 233);  //229= 1 1 1 0 | 1 0 0 1 [ - | 9 ]

//Resultado 9 - 0 5

    digitalWrite(LATCH, HIGH); // Activando el latch indicamos de que ya están todos los datos
    delay(1000);   // Lo mostramos durante un segundo
    digitalWrite(LATCH, LOW);  // Bajamos el latch para introducir mas datos. 
    shiftOut(DATA, CLK, MSBFIRST, 33);  //33 = 0 0 1 0 | 0 0 0 1 [ 2 | 1 ]
    shiftOut(DATA, CLK, MSBFIRST, 2);   //2 = 0 0 0 0 | 0 0 1 0 [ 0 | 2 ]

// Resultado : 2 0 1 2

    digitalWrite(LATCH, HIGH);
    delay(1000);
}

CAN (acrónimo del inglés Controller Area Network) es un protocolo de comunicaciones desarrollado por la firma alemana Robert Bosch GmbH, basado en una topología bus para la transmisión de mensajes en entornos distribuidos.

Can Sniffer

Lee la entrada completa

Y para que quiero yo esto? Pues desde hace unos cuantos años, el aumento de electrónica en los coches ha obligado a los fabricantes a implantar una red dentro del vehículo para poder comunicar todos los sensores, actuadores y cpus del coche sin tener que tirar metros y metros de cables para conectarlos todos. Con este bus, podemos comunicar toda la electrónica del coche ¡¡¡con solo dos hilos!!! (Cosas de la transmision diferencial y el CSMA). Aunque en la realidad, por ejemplo en los coches del grupo Volkswagen cada vehículo tiene tres buses, el de Tracción, el de Confort, y el de “Infotaiment”. Como es de esperar, las comunicaciones mas vitales del coche van por el de tracción, lo referente a los asientos, el climatizador, puertas, ventanas luces etc va por el de confort, y por último la información del cuadro de instrumentos (a.k.a Cockpit) la radio, el navegador … va por el de “infotaiment”. Y aquí es donde me interesa el sniffer, ya que en mi coche, la radio se puede comunicar con el Cockpit para mostrar información en el FIS, incluso en coches con mandos en el volante (manos libres, control de la radio…) puedes a través de este bus saber cuando se pulsa un botón. Todo esto enfocado a algún día llevar en el coche un CarPC/TabletPC y dotarlo de funcionalidades añadidas.

El cacharro en si es bien sencillo.

• Un controlador del CAN-BUS
• Arduino
• Software adecuado (Do It Yourself)

En principio solo vamos a analizar una parte de las comunicaciones, ya que por el bus viaja mucha información, y solo una parte nos interesa, ademas esta va codificada (que no cifrada) a su manera, ya que aunque el CAN es un estándar, cada fabricante pone los datos en el bus como le da la gana.

Una vez tengamos la información que necesitemos, podemos reprogramar arduino para que simplemente conecte el pc con el CAN-BUS.

Aquí dejo la foto del caos-cableado que une todo. La idea es que también lleve su tarjeta SD/microSD para que almacene todos los mensajes durante los viajes y después analizarlos sin necesidad del PC siempre en el coche.

CAN Sniffer sin LCD

Está hecho con Arduino, un array de pares darlington (ULN2003A) y un shift register 74HC595. Solo falta montarlo en una placa, soldarlo con unos cuantos mas shift registers y tendremos una marquesina. Esuqema de conexion de la matriz de 8×8:

Las resistencias que hay entre los integrados y la matriz, a mi me ha funcionado con resistencias de entre 0,5K Ohm y 1k Ohm
El codigo está aquí.

// 8*8 LED matrix with ULN2003A & 74HC595
// Made by Vadim S.
//On 25.06.2009
// Mod by Alwar
//On 13.06.2010
///Pin connected to ST_CP of 74HC595
int latchPin = 8;
//Pin connected to SH_CP of 74HC595
int clockPin = 12;
////Pin connected to DS of 74HC595
int dataPin = 11;
int x;
int y;
// here the definion of all the letter(big ans small) and numbers
#define A     {B00111100,B01000010,B01000010,B01000010,B01111110,B01000010,B01000010,B01000010}
#define B     {B01111100,B01000010,B01000010,B01111100,B01000010,B01000010,B01000010,B01111100}
#define C     {B00111110,B01000000,B01000000,B01000000,B01000000,B01000000,B01000000,B00111110}
#define D     {B01111100,B01000010,B01000010,B01000010,B01000010,B01000010,B01000010,B01111100}
#define E     {B01111110,B01000000,B01000000,B01111100,B01000000,B01000000,B01000000,B01111110}
#define F     {B01111110,B01000000,B01000000,B01111100,B01000000,B01000000,B01000000,B01000000}
#define G     {B00111100,B01000010,B01000010,B01000000,B01000111,B01000010,B01000010,B00111100}
#define H     {B01000010,B01000010,B01000010,B01111110,B01000010,B01000010,B01000010,B01000010}
#define I     {B00111000,B00010000,B00010000,B00010000,B00010000,B00010000,B00010000,B00111000}
#define J     {B00011100,B00001000,B00001000,B00001000,B00001000,B01001000,B01001000,B00110000}
#define K     {B01000100,B01001000,B01010000,B01100000,B01010000,B01001000,B01000100,B01000010}
#define L     {B01000000,B01000000,B01000000,B01000000,B01000000,B01000000,B01000000,B01111110}
#define M     {B01000100,B10101010,B10010010,B10010010,B10000010,B10000010,B10000010,B10000010}
#define N     {B01000010,B01100010,B01010010,B01001010,B01001010,B01001010,B01000110,B01000010}
#define O     {B00111100,B01000010,B01000010,B01000010,B01000010,B01000010,B01000010,B00111100}
#define P     {B00111100,B01000010,B01000010,B01000010,B01111100,B01000000,B01000000,B01000000}
#define Q     {B00111100,B01000010,B01000010,B01000010,B01000010,B01000110,B00111110,B00000001}
#define R     {B00111100,B01000010,B01000010,B01000010,B01111100,B01000100,B01000010,B01000010}
#define S     {B00111100,B01000010,B01000000,B01000000,B00111100,B00000010,B01000010,B00111100}
#define T     {B11111110,B00010000,B00010000,B00010000,B00010000,B00010000,B00010000,B00010000}
#define U     {B01000010,B01000010,B01000010,B01000010,B01000010,B01000010,B01000010,B00111100}
#define V     {B01000010,B01000010,B01000010,B01000010,B01000010,B01000010,B00100100,B00011000}
#define W     {B10000010,B10000010,B10000010,B10000010,B10010010,B10010010,B10101010,B01000100}
#define X     {B01000010,B01000010,B00100100,B00011000,B00011000,B00100100,B01000010,B01000010}
#define Y     {B10000010,B01000100,B00101000,B00010000,B00010000,B00010000,B00010000,B00010000}
#define Z     {B01111110,B00000010,B00000100,B00001000,B00010000,B00100000,B01000000,B01111110}
#define lit_a {B00000000,B00000000,B00000000,B00111000,B01000100,B01000101,B01000101,B00111010}
#define lit_b {B00000000,B00100000,B00100000,B00100000,B00111100,B00100010,B00100010,B00111100}
#define lit_c {B00000000,B00000000,B00000000,B00111100,B01000000,B01000000,B01000000,B00111100}
#define lit_d {B00000000,B00000100,B00000100,B00000100,B00111100,B01000100,B01000100,B00111100}
#define lit_e {B00000000,B00000000,B00111000,B01000100,B01000100,B01111000,B01000000,B00111100}
#define lit_f {B00011000,B00100100,B00100000,B00100000,B01110000,B00100000,B00100000,B00100000}
#define lit_g {B00011100,B00100010,B00100010,B00011110,B00000010,B00000010,B00010010,B00001100}
#define lit_h {B01000000,B01000000,B01000000,B01000000,B01111000,B01000100,B01000100,B01000100}
#define lit_i {B00000000,B00010000,B00000000,B00010000,B00010000,B00010000,B00010000,B00010000}
#define lit_j {B00000000,B00010000,B00000000,B00010000,B00010000,B00010000,B01010000,B00110000}
#define lit_k {B00000000,B00000000,B01001000,B01010000,B01100000,B01100000,B01010000,B01001000}
#define lit_l {B01000000,B01000000,B01000000,B01000000,B01000000,B01000000,B01000000,B01000000}
#define lit_m {B00000000,B00000000,B00110100,B01001010,B01001010,B01001010,B01001010,B01001010}
#define lit_n {B00000000,B00000000,B01111000,B01000100,B01000100,B01000100,B01000100,B01000100}
#define lit_o {B00000000,B00000000,B00000000,B00011100,B00100010,B00100010,B00100010,B00011100}
#define lit_p {B00000000,B00000000,B00011100,B00100010,B00100010,B00111100,B00100000,B00100000}
#define lit_q {B00000000,B00000000,B00111000,B01000100,B01000100,B00111100,B00000100,B00000100}
#define lit_r {B00000000,B00000000,B00111000,B01000000,B01000000,B01000000,B01000000,B01000000}
#define lit_s {B00000000,B00111000,B01000100,B01000000,B00111000,B00000100,B01000100,B00111000}
#define lit_t {B00100000,B00100000,B00100000,B01111000,B00100000,B00100000,B00100010,B00011100}
#define lit_u {B00000000,B00000000,B00000000,B01000100,B01000100,B01000100,B01000100,B00111000}
#define lit_v {B00000000,B00000000,B01000100,B01000100,B01000100,B01000100,B00101000,B00010000}
#define lit_w {B00000000,B00000000,B00000000,B01000100,B01000100,B01010100,B01010100,B00101000}
#define lit_x {B00000000,B00000000,B00000000,B00000000,B00100100,B00011000,B00011000,B00100100}
#define lit_y {B00000000,B01000100,B01000100,B00111100,B00000100,B00000100,B00000100,B00111000}
#define lit_z {B00000000,B00000000,B00000000,B01111100,B00001000,B00010000,B00100000,B01111100}
#define space {B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000}
#define num_0 {B00111100,B01000110,B01001010,B01001010,B01001010,B01010010,B01100010,B00111100}
#define num_1 {B00001000,B00011000,B00001000,B00001000,B00001000,B00001000,B00001000,B00011100}
#define num_2 {B00111100,B01000010,B00000100,B00001000,B00010000,B00100000,B01000000,B01111110}
#define num_3 {B01111110,B00000010,B00000010,B00011100,B00000010,B00000010,B01000010,B00111100}
#define num_4 {B00000100,B00001100,B00010100,B00100100,B01000100,B01111110,B00000100,B00000100}
#define num_5 {B01111110,B01000000,B01000000,B00111100,B00000010,B00000010,B00000010,B01111100}
#define num_6 {B00111100,B01000000,B01000000,B01111100,B01000010,B01000010,B01000010,B00111100}
#define num_7 {B01111110,B00000010,B00000100,B00001000,B00010000,B00010000,B00010000,B00010000}
#define num_8 {B00111100,B01000010,B01000010,B00111100,B01000010,B01000010,B01000010,B00111100}
#define num_9 {B00111100,B01000010,B01000010,B01000010,B00111110,B00000010,B00000010,B00111100}
#define times {B00000000,B01000010,B00100100,B00011000,B00011000,B00100100,B01000010,B00000000}
// Signals for shift register, go over al cols, one each time
byte barrido[8] = { B00000001,B00000010,B00000100,B00001000,B00010000,B00100000,B01000000,B10000000 };
const int numPatterns = 15;//this is the number of patterns you want to display
// the patterns order
byte patterns[numPatterns][8]={space,M,A,D,E,space,B,Y,space,A,L,W,A,R,space};
void setup(){
  // this is a commed that makes pins 0-7 outputs(see more on the arduino site)
  DDRD=B11111111;
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
}
// int loop acts like a delay, it take 8 mSecands to scan all of the rows so int
// loops = 15 is a good time for it
void display_pattern(int loops)
{
   for(x=0;x
   { // loop over the patterns
      for (int z=0;z<8;z++)
      { //scrolls one bite at a time
         for(int t=0;t
         {// the delay we get with loops
            for(y=0;y<8;y++)
            {
               // loops over the array of bytes
               byte temp = patterns[x][y];
               byte temp_2=patterns[x+1][y];
               //writes digital outputs, Z is for how much bites it need to scroll
               PORTD = (temp<>7-z);
               delayMicroseconds(800);// the time every row is one
               PORTD=B00000000;// all pins are low, fixes the ghosting effect
               digitalWrite(latchPin, LOW);
               shiftOut(dataPin, clockPin, LSBFIRST, barrido[y]);
               //return the latch pin high to signal chip that it
               //no longer needs to listen for information
               digitalWrite(latchPin, HIGH);
            }
         }
      }
   }
}
void loop(){
// calls for the display_pattern function and says that int loop = 15
// (if you do more loop the pattern whould scrrol slower).
display_pattern(15);
}

Para hallar el valor de salida en relación al de entrada debemos aplicar la siguiente formula:

¿Y para uqe nos vale esto? Pues porque el “convertidor analógico digital” que trae Arduino solo acepta hasta 5 voltios, pero si por ejemplo en mi caso queremos utilizar el circuito para comprobar baterías de 8,4 voltios, y puede que también de 9,6 voltios necesitamos reducir el voltaje de entrada para no churruscar nuestra placa de prototipado. Entonces con el divisor de tensión el ADC de arduino ahora acepta hasta 10v con una resolución de 10bits lo que no da una precisión de 9,77 mV. Si quisiéramos baterías mas grandes deberíamos añadir resistencias al divisor de tensión para que en Vout cuando Vin es máximo solo hubiese 5 voltios. No vale poner una resistencia muy grande, necesitamos varias, ya que en mi ejemplo cada resistencia tiene una caída de potencial del 50%. Si po ejemplo quisiéramos medir baterías de hasta 20 voltios, necesitaríamos dividir por 4 la tensión, y lo conseguríamos conectando en vez de dos resistencias, cuatro. Y conectaríamos Vout entre la penúltima y la última resistencia. Como las 4 resistencias serán iguales, pues cada una tendrá una caída de potencial de 1/4 del voltaje de entrada, lo que nos daría como máximo 5 voltios.

Este es el circuito. Donde el simbolo del voltimetro es la placa arduino usando cualquiera de sus pines de entrada analogicos (A0~A5). La batería de 9 voltios es la que queremos probar. Las resistencias según pueden ser de entre 1K y 10K, yo uso un valor intermedio de 4,7K.


El código
Es muy sencillo, creo que no hace falta explicarlo.

int sensorPin = 3;
int sensorValue = 0;
float voltaje = 0.0;

void setup()
{
  Serial.begin(9600);
  Serial.println("Battery Tester");
} 

void loop()
{
  sensorValue = analogRead(sensorPin);
  Serial.println(sensorValue);
  voltaje = ((5*float(sensorValue))/1024);
  Serial.print("Divisor de Tension (Vout): ");
  Serial.println(voltaje,3);
  Serial.print("Voltaje estimado (Vin): ");
  Serial.println(voltaje*2,3);
  delay(1250);

}

xkcd.com - Harto con Internet

Exceptuando lo de LiveJournal, ya que yo escribo mi propio blog, me siento identificado con este comic encontrado en xkcd.com. Tiene muchos, y buenos, pero solo algunos soy capaz de entenderlos. Otro muy bueno es este, ademas romantico y friki a la vez.

Esto de que te cansas de internet ya me paso una vez, y ahora otra, normalmente viene dado por la falta de creatividad, ya que no sabes nada nuevo que hacer, que proyectos emprender o como es en este caso, que lo que quieres hacer eres incapaz por tu falta de conocimientos, o tu poca habilidad para programar en C un programa para arduino que controle un LCD de 16×2 caracteres y un teclado 4×4. Haber si cojo fuerzas y consigo hacerlo funcionar (aunque 2º de bachillerato no me da muchas fuerzas, tampoco creo que tenga cuando llegue a la carrera o tenga que trabajar).

Purely Booooooring.

Ya por fin conseguí hacerme con unas cuantas matrices de LEDs y así me ahorro soldar centenares de leds.

Por falta de previsión no me he hecho con un convertidor serie paralelo (shift register) y no he podido probar como mostrar caracteres en una matriz de 8×8 como la de la fotografía, a sí que me he tenido que conformar con  hacer un pequeño efecto de cortinilla con un modulo para ir probando. Es bastante sencillito.  Tras localizar cada pin (que es bastante laborioso y no he encontrado un datasheet decente) conectamos los negativos al GND de la placa arduino, y los 8 positivos a 8 entradas de la placa arduino. Y después con un bucle encendemos las columnas que queremos…

Este es el resultado:

Ir a MetaCafe

Y aquí otra forma:

Ir a MetaCafe

El esquema de conexión es el siguiente:

Es una putada que los positivos no estén en un lado y los negativos en otro, sería bastante mas fácil.

Ahora abrimos el IDE de arduino y pegamos el codigo:

Ahora dependiendo del efecto que queramos tenemos un bucle o dos dentro del “void loop”:
El mas simple es el que esta dando vueltas de un lado a otro (se encienden las columnas por este orden: 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8…):

void setup() {
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
}

void loop() {
for (int i=2; i <= 9; i++){
digitalWrite(i, HIGH); //Encendemos
delay(100); //Esperamos
digitalWrite(i, LOW); //Apagamos y vamos a la siguiente
}
}

Pero tambien podemos hacer uno que valla de un lado al otro (las columnas se encienden 1, 2, 3, 4, 5, 6, 7, 8, 7, 6, 5, 4, 3, 2, 1...):
void setup() {
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
}

void loop() {
for (int i=2; i <= 9; i++){
digitalWrite(i, HIGH); //
delay(100);
digitalWrite(i, LOW); //
}
for (int i=9; i >= 2; i--){
digitalWrite(i, HIGH); //
delay(100);
digitalWrite(i, LOW); //
}
}

Pero esto solo son dos ejemplos, deja volar la imaginación, experimenta con el código y observa que obtienes!

Si buscáis en internet, encontrareis por ejemplo muy buenos instructables como este o como este otro

Bueno y una vez tengamos varios "shift registers" habrá que avanzar algo mas no?

PD: En un articulo anterior tenéis una mas información sobre esto.

El caso es que se puede. Al principio pensaba que no, porque la pda no tiene una conexion rs232 que nos permita enviar datos por un puerto serie, pero tiene un conector usb… a si que me puse a ver como conectaban arduino al ordenador y llegué a la pagina de FTDI, un chip que utiliza arduino en su version USB para poder comunicarse por el usb y no usar el rs232… viendo la pagina de drivers veo que hay para todas las plataformas, incluida esta Windows CE 4.2 y 5.0, es verdad que la pda usa Windows Mobile 5, pero espero que funcione el driver (por eso de la compatibilidad con versiones anteriores…. 8-))

A ver si esta noche puedo programar ya, y pruebo el driver… y si funciona pues tendre que buscar un cable USB de miniUSB a USB tipo B, ???