It’s basically a 1:28 scale RC car hacked with a servo for direction and an home-made arduino based board. In the front there can be seen 5 x CNY70 line sensors (IR reflection), shielded from light and crashes with foam. The rest of the car is described in the pdf below.

This has been the first competition robot we have made, and OK, I can say that I have learned a lot with it… Now I know that EVERYTHING can fail if you are sufficiently close to the challenge date. As any of my projects, the main reason to our partial failure was the lack of time (and planning). Apart from this, we had a very crude fight with some noise created by the DC motor, which interacted with the electronics of the servo. Eventually noise won, and we had to divide our power sources in two separate ones. Huge botch…

So, the competition day we met at 7:00 AM and tried to make some adjustments on the software, and we achieved speeds over 1m/s, what seemed a good value (although usually competition level line-followers reach up to 2.5m/s). But the funny part was this: We used to test the robot in a concrete, even surface; but the competition track was made from a soft foam, which was deformed by the weight of the robot, making the sensor array touch the ground and brake the entire car… Although this technical problem, we got the 12th position out of 40, and we spent a quite good time.

This is the document we attached to our inscription:

Any blogger will agree with me: There are a LOT of situations in which you think about writing a new post and, after some time, you realize that the article is not interesting enough to finally publish it. This happens to me everyday, and yesterday I reached the conclusion that I had to create a place to keep all this “small projects” together, and share them with the world (Ok, the vast majority of them are unlikely to be interesting, but this is better than leaving them unpublished)

With this in mind, yesterday I re-opened my Flickr account and I created a new set called “Tinkering Today…” in which I will try to upload one picture a day summarizing what I’ve spent my time in. So this is going to be quite strange because this Flickr set is more similar to a blog than this site, which I will keep for publishing finished projects. You can find the latest updates at the right of this page or the full set in the “Tinkering Today…” page of the blog.

This morning I was trying to tidy up my workbench when I found an old PS2 keyboard that I was keeping for disassembly. After removing some screws I realized that, as usual, the electronics of the keyboard were substituted by a black blob of epoxi, so few things apart from some connectors and some meters of AWG26 cable could be savaged.

But then I remembered that I had a tiny USB broken pendrive with a metal enclosure. I opened it and found that the only problem with it was that the crystal was desoldered, something quite easy to fix.

After that, the only remaining thing to do was to find a new enclosure for the pendrive, so I took a Ctrl key from the keyboard, hollowed it and cut it in a shape that could allow the “naked” pendrive to fit in it. In the bottom part it is covered with a piece of plastic from a VHS tape box.

Excuse me for the silly post!

But this is not a very graphical way to see a signal, so I wanted something similar to an oscilloscope, to to see the data I was pushing through the serial port in a comfortable way. So with only some lines of code I have created a nice arduino voltage visualizer, in the Old School way: It just prints to the Arduino serial console a real time bar chart with the readings of your input, with a refresh frequency of about 350 samples per second (When using 115200 bauds). No comparison with an oscilloscope, but useful when measuring inputs from potentiometers or LDRs…

Watch it in action after the break!

Here is an example of the output of the program:

--------------------------
Extremely Simple Voltage
visualizer for Arduino
-------------------------- 

Created by Sergio Vilches
vlxs.wordpress.com
--------o                 1.67 V
--------o                 1.50 V
-------o                  1.38 V
------o                   1.26 V
------o                   1.11 V
-----o                    0.92 V
----o                     0.72 V
---o                      0.55 V
--o                       0.42 V
--o                       0.37 V
-o                        0.37 V
-o                        0.39 V
-o                        0.73 V
--o                       1.46 V
-----o                    2.39 V
--------o                 3.06 V
-----------o              3.46 V
--------------o           3.68 V
----------------o         3.93 V
-----------------o        4.22 V
-------------------o      4.45 V
--------------------o     4.55 V
---------------------o    4.50 V
---------------------o    4.12 V
--------------------o     3.59 V
------------------o       2.94 V
----------------o         2.35 V
-------------o            1.70 V

And here is the sketch:

/*
                          Ard_o_Scope
                          
      Extremely Simple Voltage Visualizer (oscilloscope) for Arduino
  
  This program shows the (smoothed) reading of analog input (0) as an horizontal bar chart in the Serial Monitor of Arduino.

  The circuit:
  Analog sensor (potentiometer will do) attached to analog input 0

  Created 12 July 2010
  By Sergio Vilches  

  http://vlxs.wordpress.com
  
  This sketch is in the public domain. Feel free to modify or distribute it. Have fun!

*/

int val;
int ScreenWidth = 25;  // Use this parameter to choose the maximum number of characters that will be sent for each reading
                       // (the number of "-"). Please note that the sampling frequency will decrease when using a large value.

float smoothingFactor = 0.5; //Vary this value from 0 (no smoothing of the signal) to 0.99 (a lot of smoothing). 0.8 works well

void setup()
{
  Serial.begin(9600);
  val = analogRead(0) * ScreenWidth / 1024.0;

  //Let's print a heading
  delay(500);
  Serial.println("--------------------------");
  Serial.println("Extremely Simple Voltage");
  Serial.println("visualizer for Arduino");
  Serial.println("--------------------------");
  Serial.println();
  Serial.println("Created by Sergio Vilches");
  Serial.println("vlxs.wordpress.com");
  delay(1500);
}

void loop()
{
  val = (smoothingFactor * val + (1-smoothingFactor) * analogRead(0) * ScreenWidth / 1024.0) ;  //This line smooths the data

  for (int i = 0 ; i < val ; i++)    //We print as many "-" as val
    Serial.print("-");

  Serial.print("o");    //We print the marker

  for (int i = 0 ; i < ScreenWidth - val ; i++)
    Serial.print(" ");

  Serial.print(analogRead(0)*5/1024.0);  //And the voltage of the reading
  Serial.println(" V");
  }

Here is the result of measuring the voltage output from a slider, using a serial speed of 9600 bauds. You can improve the sampling speed by changing this value in void setup, setting Serial.begin(115200).

LEDs… The beauty of electronics, the soul of a project. What can I say, I love LEDs!! Each time I see a project involving RGB LEDs, several ideas come to my mind and I’ve always wondered I had a good hardware platform to mess around with them!

So, after some days surfing through datasheets, online shops and tech documents, I reached one conclusion: Controlling several High-intensity RGB LEDs IS DIFFICULT. You need to supply the correct voltage to each one of the LEDs (without using resistors: when you are dealing with a 3A current, each tiny resistor can dissipate more energy in heat that your LED does, what is not very efficient…), you need a very good heatsink and an amplifier stage to control them using your Arduino. Dealing with these handicaps can be very though, or it can be just expensive. Guess which is the option that I chose…

MegaBrite, from Macetech Industries

This tiny piece of hardware simplifies a LOT your life if you want to make some microcontroller-driven illumination project. It is composed by three high-intensity LEDs (Actually inside each one of the encapsulations there are 5 small dyes, totalling 15 x 20mA LEDs = 300mA of pure colour in each MegaBrite). But the cool thing about this component is that each MegaBrite has an Allegro A6281 chip that does all the hard work in your project if you want to light a huge strip of RGB LEDs. You can find more about ShiftBrites and MegaBrites at Macetech, but roughly they work like this: Your microcontroller passes an binary word containing the values you want for each R, G and B LED to the first MegaBrite. Then, toggling one pin you can shift this information to the next MegaBrite of your strip, and so on, setting each one of the LEDs the colour you want. Easy enough for me!!

I ordered 5 MegaBrites from the Macetech online store for 10$ each one (yes, this hobby is expensive, and more if you are a beginner in electronics like me…) and then I was ready to start the interesting thing.

Making them to work with Arduino was as easy as looking for the libraries at Macetech, and after modifying some examples, I was confident enough to start doing some maths. The problem that appears when using any RGB space (yes, the color space is an R³ space, like points in space) is that it is not human-friendly: If you want to change frome a bright blue (ie R86 G30 B229) to a darker one (R50 G14 B140) you have to change all RGB coordinates, what is not very intuitive. In order to solve this problem, some decades ago the HSV space was developed. In it, the RGB coordinates are transformed into a kind of distorted polar coordinates, where you can determine a colour by its Hue (tone), Saturation (more or less colourful) and Value (brightness). This is quiiite more human-friendly, and it is widely used in colour pickers for computer graphic programs as GIMP.

Which is the next step? Of course, creating a real-world color mixer for interfacing ShiftBrite LEDs with Arduino in an easy way!

So, as I really avoid as far as possible using the protoboard (wires messing around, false contacts, noise, fragility…), soon I was designing a PCB in Eagle (I have to say that I have installed Kicad, an open-source alternative for creating PCBs, but I’m too lazy to learn how to use it now, although sooner or later I will try to use it).

I decided to create this board without going to the electronic components shop, using only recycled components that I’ve savaged from different sources. This means that I had to create my own library for Eagle, what is really easy following the Sparkfun’s tutorial.

At the end, this is what I achieved:

· Schematic

· Board

And the Arduino code:

#define clockpin 13 // CI
#define enablepin 10 // EI
#define latchpin 9 // LI
#define datapin 11 // DI

#define NumLEDs 1

void hsv2rgb(float h, float s, float v, int &R, int &G, int &B);
void SB_SendPacket();
void WriteLEDArray();

int LEDChannels[NumLEDs][3] = {
  0};
int SB_CommandMode;
int SB_RedCommand;
int SB_GreenCommand;
int SB_BlueCommand;
float hue, sat, val;
int R, G, B;

void setup() {

  pinMode(datapin, OUTPUT);
  pinMode(latchpin, OUTPUT);
  pinMode(enablepin, OUTPUT);
  pinMode(clockpin, OUTPUT);
  SPCR = (1<<<<digitalWrite(latchpin, LOW);
  digitalWrite(enablepin, LOW);
  Serial.begin(9600);
}

void loop() {

  hue = (analogRead(0)/1024.0);
  sat = (analogRead(1)/1024.0);
  val = (1-analogRead(2)/1024.0);

  //sat = 1 - (0.58198*(exp(sat*sat)-1));    // This transformation intends to make saturation more linear, although it doesn't seem to really work

  Serial.println(sat);

  hsv2rgb(hue, sat, val, R, G, B);

  R = R*4;
  G = G*4;
  B = B*4;

  LEDChannels[0][0] = R;
  LEDChannels[0][1] = G;
  LEDChannels[0][2] = B;

  WriteLEDArray();
  //delay(100);

}

void SB_SendPacket() {

  if (SB_CommandMode == B01) {
    SB_RedCommand = 120;
    SB_GreenCommand = 100;
    SB_BlueCommand = 100;
  }

  SPDR = SB_CommandMode << 6 | SB_BlueCommand>>4;
  while(!(SPSR & (1<>6;
  while(!(SPSR & (1<>8;
  while(!(SPSR & (1<while(!(SPSR & (1<void WriteLEDArray() {

  SB_CommandMode = B00; // Write to PWM control registers
  for (int h = 0;hdelayMicroseconds(15);
  digitalWrite(latchpin,HIGH); // latch data into registers
  delayMicroseconds(15);
  digitalWrite(latchpin,LOW);

  SB_CommandMode = B01; // Write to current control registers
  for (int z = 0; z < NumLEDs; z++) SB_SendPacket();
  delayMicroseconds(15);
  digitalWrite(latchpin,HIGH); // latch data into registers
  delayMicroseconds(15);
  digitalWrite(latchpin,LOW);

}

void hsv2rgb(float H, float V, float S, int& R, int& G, int& B) {

  int var_i;
  float var_1, var_2, var_3, var_h, var_r, var_g, var_b;

  /*if ( S == 0 )                       //HSV values = 0 ÷ 1
    {
     R = V * 255;
     G = V * 255;
     B = V * 255;
     }
     */

{
  var_h = H * 6;
  if ( var_h == 6 ) var_h = 0;      //H must be < 1
  var_i = int( var_h ) ;            //Or ... var_i = floor( var_h )
  var_1 = V * ( 1 - S );
  var_2 = V * ( 1 - S * ( var_h - var_i ) );
  var_3 = V * ( 1 - S * ( 1 - ( var_h - var_i ) ) );

  if      ( var_i == 0 ) {
    var_r = V     ;
    var_g = var_3 ;
    var_b = var_1 ;
  }
  else if ( var_i == 1 ) {
    var_r = var_2 ;
    var_g = V     ;
    var_b = var_1 ;
  }
  else if ( var_i == 2 ) {
    var_r = var_1 ;
    var_g = V     ;
    var_b = var_3 ;
  }
  else if ( var_i == 3 ) {
    var_r = var_1 ;
    var_g = var_2 ;
    var_b = V     ;
  }
  else if ( var_i == 4 ) {
    var_r = var_3 ;
    var_g = var_1 ;
    var_b = V     ;
  }
  else                   {
    var_r = V     ;
    var_g = var_1 ;
    var_b = var_2 ;
  }

  R = (1-var_r) * 255;                  //RGB results = 0 ÷ 255
  G = (1-var_g) * 255;
  B = (1-var_b) * 255;
}
}

Videos soon!!!
(Here I don’t have enough 3G signal to upload them!)

LAST HOUR!!!!
I’ve been published in PCB Heaven!! Thanks very much for your attention!

Some days ago, I received a very weird and exciting SMS from a friend asking me if I wanted the pieces from a “meteorological balloon”. The only words that came to my mind were “What the hell!!??”, so I took my bike and cycled quickly to my friend’s home.

Do you want the pieces from a meteorological balloon?

From the outside of the house I was able to distinguish some pieces of a huge latex balloon in the floor. From it, a thin rope climbed to the roof. Mmmm, interesting…

At last, my friend explained me that while he was eating in its garden, a strange thing tied to a parachute hit the floor few meters from him, crashing with violence and breaking into pieces instantaneously. When I went into its garden, I could see what he said to me: A little white box (100x60x150mm approx.) tied to the rope, and pieces of dry carbon batteries everywhere.

Of course, I managed to get it to my home in order to inspect it carefully. First of all I search the Internet for some information: The company is called Vaisala, and makes meteorological sensors and radiosondes. In their web page there was a little note with instructions in case you found a sonde: just throw it in the right place. But that’s not fun!

This model is a Pressure, Humidity and Temperature sensor. It has an autonomy of 1h40′ and may have GPS (I don’t know yet, there are very similar models with and without GPS)

In the first picture you can see the PCB of the sonde: a lot of smd components, a cool antenna (I don’t know what’s its use), an FM antenna and a strap with some sensors. The only one I’ve recognized is the one at the middle.

Thin film capacitor heated twin sensor

So, the datasheet says that it’s a Thin film capacitor heated twin sensor, used to measure relative humidity (rH). During the next days I’ll try to get it working (although it seems quite difficult, I don’t like capacitive sensors, too complex for me!)

Inspecting the PCB, I got disappointed when I saw that ALL the big chips were property of Vaisala, and therefore, useless for me. I think that the only components I’m going to reuse are some SMD passives, an LM1117 adjustable power supply and this beauty chip:

M95256W: 256 Kbit serial SPI bus EEPROM with high-speed clock

As the legend of the picture says, it’s a serial EEPROM 256Kbit memory that can be interfaced with Arduino (link). That is veeery useful combined with some Universal Time Chip, as you can create very cool dataloggers.

Un grupo de colegas estamos desarrollando un robot velocista (siguelíneas) para presentar a varias competiciones de robótica. Como base estoy utilizando un pequeño coche RC que tenía cogiendo polvo desde hace 4 años, y que ahora estoy intentando que responda a las ordenes de mi Arduino. Eso lleva un proceso bastante complicado, que va desde meter osciloscopio y voltímetro en la electrónica del coche para ver cómo controlar motores y dirección, aislar los componentes necesarios para su funcionamiento, emular el resto con el Arduino, y luego… quemarlos al conectarlos a un voltaje no muy adecuado (hice hervir un FET al conectarlo a 9V en vez de 6).

Lo que se ve en la imágen es el Arduino con mi LCD shield enviando una señal PWM para controlar la velocidad del motor del coche (el cual está conectado a través de un transistor de 3 amperios). Esta señal se vigila con el osciloscopio, y mientras el polímetro me asegura que no está pasando demasiada corriente por el transistor o motor.

Vamos, que hacer bién las cosas cuesta su trabajo, pero al final arroja resultados.

En el desarrollo de nuestro robot siguelíneas FET_0x08 nos hemos visto obligados a reutilizar componentes SMD de la electrónica del coche RC que estamos usando como base. Para hacer pruebas, no hay nada más cómodo que usar una breadboard, así que he creado esta pequeña PCB para poder usar componentes SOIC8 de 3.8mm de ancho como si fuesen integrados normales (DIP).

Imágen de la PCB y fichero Eagle tras la pausa.

Tenéis a vuestra disposición el fichero de Eagle con la PCB aquí y PDF listo para imprimir aquí.

Señal de vídeo compuesto (TV)

El osciloscopio: el mejor amigo del ingeniero. Tarde o temprano, todo electrónico que se precie tiene que conseguir uno de estos cacharros, y yo no iba a ser menos…
Desde que comencé a manejar estos aparatos en el instituto, siempre he tenido ganas de comprar uno, pero normalmete, problemas de espacio y presupuesto me lo impedían. Hasta que vi esta maravilla en internet: El osciloscopio de almacenamiento digital de Jyetech.
Es un pequeño osciloscopio con pantalla LCD, bajo coste (unos 40€) y que se puede comprar en kit.

Características:

Kit osciloscopio

Yo pedí el kit con componentes SMD pre-soldados (no me atrevía a soldar cientos de patillas sin un solo error), y me llevó menos de 2 horas ponerlo en funcionamiento y aprender a manejarlo, y hay que decir que te mejora bastante la vida, a la vez que te abre las puertas al interesantísimo mundo de la ingeniería inversa.

Interpretando señales en la electrónica de un coche RC escala 1:28 con fin de poder manejarlo usando Arduino

Enlace a la página del fabricante (Puede encontrarse en BricoGeek y en SeedStudio)

Con esto me he encontrado hoy en el hipermercado de turno (Alcampo), y no he podido resistir a la tentación. Lo que no sabía era la cantidad de piezas que iba a poder obtener de ella…

Esta entrada es una reflexión al poder que tiene la producción en masa. Cada vez que veo los juguetes que regalan en McDonalds, me paro a pensar en los meses que me hubiese llevado a mí construirlos: regalan “videoconsolas” con pantalla LCD con un  Happy Meal de 3€!! Me imagino las partes que yo tendría que utilizar: microcontrolador de 5€, una LCD de 80×80 píxels, driver para la LCD, 4 pulsadores, pilas, y unas cuantos cientos de líneas de código… increíble que el precio de producción en masa no llegue a los 0.5€.

Pues con esta linterna lo mismo. Esta misma tarde voy a comprar unas cuantas más, ya que por 1€ te llevas a casa una linterna con cuerpo de aluminio, 4 LEDs blancos (me cobran el la tienda de electrónica 0.8€ por cada uno…), 4 placas solares, una batería de Ni-Mh de 1.2V, un transformador DC-DC que pasa de 1.2V de la batería a los 4V que necesitan los LEDs y un interruptor. ¿Qué mas puede pedir un Maker?

Ya iré comentando para qué voy a utilizar cada cosa…