Knoppix remasterizada para desarrollo con Arduino

Uno de los problemas con los que me he topado al intentar realizar prácticas con Arduino en el aula es la instalación del IDE de desarrollo en los ordenadores. Este curso disponía de varios miniportátiles para trabajar que tenían instalado en una partición Windows 7 y en otra una Edubuntu obsoleta y poco funcional. Al final, en ambas particiones, la comunicación por USB con Arduino daba problemas lo que suponía ser muy poco productivos y tener dedicarle más tiempo al mantenimiento de los ordenadores que al propio aprendizaje de Arduino y las prácticas con Edubásica que era el principal objetivo.

Se me ocurrió que, para sucesivos cursos, tenía que customizar un gnu/linux con las herramientas que necesitara para el aula, de forma que los alumnos llevaran su Live USB y trabajaran únicamente con él, así nos ahorraríamos el problema del mantenimiento del software de los ordenadores.  Pues bien, aquí está la primera remasterización. He decidido basarla en Knoppix (7.2) por ser la que mejores resultados me ha dado para el funcionamiento en modo "Live". Las modificaciones incluyen: teclado en español, IDE de Arduino, Fritzing y el manual de prácticas. No es gran cosa pero lo considero muy útil como herramienta docente.
Cuelgo el enlace para su descarga y hago un llamamiento: "Frikis, linuxeros y arduineros de todo mundo pruébenla y pónganme todas las pegas que se les ocurran". El objetivo es que desde el pendrive se pueda programar Arduino, cargar los programas en la tarjeta, salvar datos y trabajar con internet de forma productiva, principalmente.

Descarga: http://t.co/E2D14rkKS7


 He incluido en el escritorio una carpeta con los capítulos del manual de prácticas con Arduino para 4º de Educación Secundaria (ESO) que se pueden abrir con el programa XPdf.
Supongo que iré añadiendo paquetes a la distribución en función de las necesidades que vayan surgiendo.
Para crear un LiveUSB puedes utilizar varias herramientas, por ejemplo:
http://unetbootin.sourceforge.net/


Como no puede ser de otra manera, este derivado de gnu/linux sólo lleva software libre, por lo que no podrás ver vídeos de Youtube directamente (no lleva el flashplayer para mozilla) ni otros formatos multimedia no libres, a día de hoy. La verdad es que yo en mis clases utilizo Youtube como otra herramienta más para el autoaprendizaje de los alumnos. Para poder utilizarlo, simplemente habrá que activar los repositorios Multimedia e instalar los paquetes necesarios. Al hacerlo desde un Live USB todo lo que se instale quedará guardado de forma permanente.

Para ello, una vez hecha la LiveUSB, se arranca desde ella el ordenador y, cuando se cargue el entorno gráfico, se abre un terminal de root: Accesorios -> Terminal de "Root"

Sobre el terminal hay que teclear:

#nano /etc/apt/sources.list

Se lleva el cursor hasta el final del archivo y en la última línea:

 #deb http://deb-multimedia.org squeeze main non-free

 se quita la # (almohadilla), quedando:

deb http://deb-multimedia.org squeeze main non-free

 Después se salvan los cambios CTRL+O y se sale con CTRL+X
, en la terminal hay que escribir:

#apt-get update

#apt-get install flashplayer-mozilla

y, de la misma manera, se instalarán el resto de paquetes que se necesiten para visualizar otros formatos.

Pues nada, a probar y a poner pegas.

Gracias.

Cilindro neumático con Arduino y Edubásica

Os pongo un adelanto de la nueva unidad que estamos preparando para el manual de www.practicasconarduino.com
Se trata de realizar un simple movimiento de vaivén de un cilindro de doble efecto con dos finales de carrera.

Aquí va el vídeo:

Prácticas con Arduino

Hace unos meses publiqué junto a tres compañeros profesores de Tecnologías un manual de prácticas con la controladora Arduino para 4º curso de ESO. Todo surgió de un grupo de profesores y amigos interesados por la electrónica, la informática y la docencia; básicamente compañeros de tertulias animadas con cerveza, mucha moral y buen humor.
 Nuestra experiencia docente nos hizo ver que los conceptos que se estudian durante el curso no se aprenden sin un enfoque fundamentalmente práctico de la asignatura. Por ello surgió la idea de plantear el curso mediante un currículo integrado sustentado en la controladora libre Arduino. De esta manera los alumnos podrían aprender los conceptos reglados del currículo de 4º curso de secundaria mediante la realización de prácticas y proyectos. Fruto de un intenso trabajo y apoyado en nuestra experiencia docente publicamos el manual de prácticas.
 Para facilitar la iniciación a esta magnífica controladora libre, se diseñó una tarjeta cuya finalidad era la de extender las capacidades de Arduino o "Shield" bautizada como Edubásica que ofrece la posibilidad de manejar motores DC, activar relés, encender LEDs, leer LDR sin necesidad de realizar montajes externos.
En el manual los capítulos están organizados por áreas temáticas y, aunque el tema de Arduino está muy manido en internet, hemos intentado seleccionar y recopilar proyectos que fueran fáciles de asimilar por los alumnos. Algunos de ellos requieren la tarjeta Edubásica y otros simplemente una Arduino y unos cuantos componentes electrónicos.

El manual está disponible libremente para su descarga en la web http://www.practicasconarduino.com/ y se puede obtener en formato pdf o en versión para iPad (cosas del guión) desde iTunes.
El manual es un documento vivo al que iremos añadiendo capítulos mejorando los existentes y, poco a poco, lo iremos implementando para todo tipo de formatos.

Si os gusta el tema de Arduino, la investigación y el cacharreo no dudéis en descargarlo, ¡no tiene desperdicio!
¡Ah! y no os olvidéis de contarme vuestras experiencias.  

http://www.practicasconarduino.com/

Tacómetro para proyecto de aerogenerador (Arduino y Tecnologías para educación secundaria).

Hace tiempo que quería hacer un proyecto que integrara y reutilizara algún tipo de maqueta con partes móviles, la placa Arduino y algún elemento transductor sencillo para alumnos de ESO y no se me fuera mucho tiempo en ello. En casa tenía una maqueta didáctica distribuida por CEBEK y en el aula una compañera estaba haciendo un proyecto con los alumnos para trabajar el tema de mecanismos que consistía en la fabricación de un aerogenerador con distintos elementos mecánicos. Así decidí montar un tacómetro para medir las revoluciones por minuto del rotor utilizando un relé Reed, la controladora Arduino y uno de los programas de ejemplo que vienen en el IDE de Arduino que detectan el cambio de estado en una entrada digital... así de sencillo. Paso a describir e ilustrar el proyecto por si alguien le interesa montárlo en casa o en el aula:

PROYECTOS DE TECNOLOGÍAS CON ARDUINO:
"Tacómetro para maqueta con elementos rotativos de bajas revoluciones"

Aprenderás a : 

Medir las revoluciones por minuto de tus proyectos de Tecnologías que incluyan partes rotatorias. Como ejemplo de esta práctica se ha utilizado un aerogenerador pero el principio de funcionamiento hace que sea aplicable a cualquier otro proyecto similar como norias, tiovivos, etc…


Necesitarás: 

• Placa Arduino.
• Placa protoboard.
• Imán ligero y de pequeño tamaño (similar a los que se adhieren en las neveras).
• Relé Reed. 
• Resistencia 10 K. Cable rígido de conexión protoboard.
• Ordenador personal para monitorizar la salida.
• Proyecto de tecnologías ya montado y funcional (en nuestro caso la maqueta de un aerogenerador). 

Descripción del proyecto: 

 Mediante esta práctica se pretenden medir las revoluciones por minuto (RPM) del rotor de una maqueta que simula el movimiento de un aerogenerador. Se han utilizado dos modelos para realizar las pruebas. Uno es el modelo didáctico comercial de CEBEK y el otro aerogenerador corresponde a un modelo construido por alumnos de tercero de ESO con materiales del aula taller. Hay que tener en cuenta que la maqueta no realiza la función de generación de energía mediante la fuerza de viento, como corresponde a un aerogenerador, sino que simplemente provoca el movimiento del rotor para simular el efecto del viento. Para ello se suministra la corriente necesaria al motor eléctrico bien mediante una una placa solar o bien mediante una pila en cada caso. Para realizar la detección de cada vuelta se utiliza un imán adherido a una de las palas que gira solidario a ella y un detector magnético, en este caso un relé Reed. Cada vez que el imán se posiciona frente al relé, debido a su campo magnético, provoca el contacto de los terminales del relé poniendo en conexión un canal de lectura digital de la tarjeta Arduino con una tensión de 5 voltios. Esta acción provoca que la tarjeta reconozca un nivel lógico alto que, mediante la un sencillo programa, realizará un conteo de vueltas y la medida de las revoluciones por minuto del rotor.

 Montaje:

 Se ubica el relé Reed sobre la parte superior y el imán se pega a una de las palas del aerogenerador, de forma que cuando pase la pala por la parte superior del aerogenerador, imán y relé queden enfrentados. Así el campo magnético del imán permite cerrar los contactos del relé Reed.

Figura 1 (detalle cabeza aerogenerador relé -imán)

Las conexiones eléctricas se realizarán con el apoyo de la placa protoboard según el esquema que se adjunta. Se conecta la resistencia en configuración “pull-down”, es decir, cuando el imán está enfrentado al relé éste se cierra (ON) y conecta la entrada digital a una tensión de +5 V. En ausencia de imán el relé permanece abierto (OFF) y la entrada digital quedará conectada a masa (GND) a través de la resistencia de 10K.

 Figura 2 (esquema eléctrico - www.circuitlab.com )

Figura 3 (detalle conexiones protoboard)

 Programa:

Una vez configurados el pin 2 como entrada digital y la comunicación serie para poder monitorizar la salida, realiza de forma cíclica una lectura del puerto de entrada. Mediante una sentencia condicional comprueba si el estado ha cambiado. En el caso de que el cambio sea a un nivel alto (HIGH) incrementa en una unidad la variable que cuenta las vueltas. Con el apoyo de la instrucción millis() se puede calcular el tiempo que trascurre el rotor en dar una vuelta completa (tiempo_una_rev), por lo que mediante un sencillo cálculo podremos conocer la velocidad en revoluciones por minuto, como se indica en la siguiente línea del programa: rpm = 60000 / tiempo_una_rev;
A continuación se incluye el programa completo:

  /*
Programa basado en http://arduino.cc/en/Tutorial/ButtonStateChange (Examples ->; Digital ->; StateChangeDetection).
Tildes omitidas.
Detecta la conexion de los terminales de un rele Reed.
Se aplica para contar las vueltas de una maqueta aerogenerador mediante un
iman ubicado en una de las palas.
Circuito:


+5 V
o
|
|
|
o
  /
/ Reed Rele
|
|
|------> Pin 2 (Digital)
---
| |
| |  R = 10 KOhmios
| |
---
|
|
|
GND


created  27 Sep 2005
modified 30 Aug 2011
by Tom Igoe
modificado por Jorge Muñoz 15 Mayo 2012

This example code is in the public domain.

http://arduino.cc/en/Tutorial/ButtonStateChange

*/

const int  releReedPin = 2;
int vueltas = 0;
int estadoRele = 0;        
int ultimoEstadoRele = 0;  
long tiempo_anterior = 0;
long tiempo_una_rev = 0;
unsigned long tiempo_ahora;
long rpm;
void setup()
{
  pinMode(releReedPin, INPUT);
  Serial.begin(9600);
}


void loop() {
  // Lee el estado del rele
  estadoRele = digitalRead(releReedPin);
  // Compara el estado del rele con el estado previo
  if (estadoRele != ultimoEstadoRele) {
    // Si el estado ha cambiado incrementa el contador
    if (estadoRele == HIGH)
    {
      vueltas++;
      tiempo_ahora =millis();
      tiempo_una_rev = tiempo_ahora - tiempo_anterior;
      rpm = 60000 / tiempo_una_rev; // 1 minuto = 60000 ms
      Serial.println("Rele ON");
      Serial.print("vuelta ");
      Serial.println(vueltas);
      Serial.print("Tiempo por revolucion: ");
      Serial.println(tiempo_una_rev);
      Serial.print("Revoluciones por minuto: ");
      Serial.println(rpm);
    }
    else {
      // Si el estado actual es LOW pasa de ON a OFF
      Serial.println("Rele OFF");

      tiempo_anterior = tiempo_ahora;
    }
  }
  // Guarda el estado actual como ultimo estado
  ultimoEstadoRele = estadoRele;

}




 Práctica en funcionamiento:

Botonera para servos con Arduino UNO

Trasteando de nuevo con Arduino he hecho un montaje casero para almacenar y reproducir con sendos pulsadores la posición de un servo que se maneja o, mejor dicho, sigue a un potenciómetro. Esto me ha permitido jugar un poco con la librería Servo.h y las instrucciones para escribir y leer datos en la EEPROM de 1Kb que lleva el modelo Arduino UNO.

Ahí va la inmortalización del evento de pruebas:

El código fuente:

 
/*
Potentiometer-Servo-button-command
Author: Jorge Muñoz Rodenas jorgeroden1@gmail.com
License: GPL v.3
Date: 14/7/2011
Version: 0.2 (alpha)
Description: to do
 */

#include <eeprom.h>
#include <servo.h>

Servo myservo1;  
Servo myservo2;

// Constants

const int buttonPinMem1 = 2;               // digital pin Mem button1
const int buttonPinAct1 = 3;               // digital pin Act button1
const int buttonRelease = 12;              // digital pin RELEASE button
const int servo1Pin = 10;                  // Servo1 PWM pin
const int servo2Pin = 11;                  // Servo2 PWM pin
const int ledPin =  13;                    // the number of the LED pin (soldered on board)
const int potpin1 = 0;                     // analog pin used to connect the potentiometer1
const int potpin2 = 1;                     // analog pin used to connect the potentiometer2
const int addr0 = 0;                       // EEPROM 1st address  (Mem1-servo 1)
const int addr1 = 1;                       // EEPROM 2nd address  (Mem1-servo 2)

// Variables  

int val1 = 0;
int val2 = 0; 
int posPot1 = 0;
int posPot2 = 0;
byte pos1, pos2;                             //Servo position
int buttonStateMem1 = LOW;                   // memory pushbutton1 status
int buttonStateAct1 = LOW;                   // action pushbutton1 status
int buttonStateRelease = LOW;
boolean running = true;

void setup() {
  
   myservo1.attach(servo1Pin);                     // attaches the servo on pin 9 (digital) to the servo object 
   myservo2.attach(servo2Pin);                    // attaches the servo on pin 10 (digital) to the servo object 
   pinMode(ledPin, OUTPUT);          
   pinMode(buttonPinMem1, INPUT);  
   pinMode(buttonPinAct1, INPUT);  
}

void loop(){
    
  //Reads analog input
  
  val1 = analogRead(potpin1);              // reads the value of the potentiometer (value between 0 and 1023)   
  val1 = map(val1, 0, 1023, 0, 179);       // scale it to use it with the servo (value between 0 and 180) 
  val2 = analogRead(potpin2);              // reads the value of the potentiometer (value between 0 and 1023) 
  val2 = map(val2, 0, 1023, 0, 179);       // scale it to use it with the servo (value between 0 and 180)   
  
  //Reads digital input
  
  buttonStateMem1 = digitalRead(buttonPinMem1);
  buttonStateAct1 = digitalRead(buttonPinAct1);
  buttonStateRelease = digitalRead(buttonRelease);
  
  //Servo 1 and 2
  
  if (running == true)
  {
    myservo1.write(val1);
    myservo2.write(val2);
  }
 
 // Program 1
 
  if (buttonStateMem1 == HIGH) {    
    
    digitalWrite(ledPin, HIGH);          //LED 13 on
    EEPROM.write(addr0, val1);
    EEPROM.write(addr1, val2);
    digitalWrite(ledPin, LOW);           //LED 13 off
          
  } 
  
  if (buttonStateAct1 == HIGH) {     
 
    running = false;
    digitalWrite(ledPin, HIGH);                 //LED 13 on
    pos1 = EEPROM.read(addr0);
    pos2 = EEPROM.read(addr1); 
    myservo1.write(pos1);                       // sets the servo position according to the scaled value 
    myservo2.write(pos2);                       // sets the servo position according to the scaled value 
    digitalWrite(ledPin, LOW);                  //LED 13 off

    } 
 
    // Release button
  
  if (buttonStateRelease == HIGH) {    
    digitalWrite(ledPin, HIGH);                 //LED 13 on
    running = true;   
    delay(40);
    digitalWrite(ledPin, LOW);                 //LED 13 off      
  } 
   
}

Sobre el tema de las conexiones, los pines vienen en el software aunque si alguien lo quiere montar, y tiene dudas de cómo se conectan los servos, pulsadores y potenciómetros aquí dejo unos garabatos a mano (hoy paso del Eagle) a modo de recordatorio.

Ciao!

Arreglar Arduino UNO para Ubuntu (10.10)

Hace unos días me compré una nueva Arduino para jugar con ella. Es el modelo Arduino UNO y, paradojas de la vida, a pesar de ser un proyecto MUY libre, no tiene buen soporte para gnu/linux (Ubuntu que es mi caso a día de hoy). Hay un bug en el firmware para la comunicación serie-USB.
La solución está en cargar un nuevo firmware, siguiendo los siguientes pasos (bajo la responsabilidad de cada uno, que todo esto es gratis ):

Paso 1:
Ir a https://github.com/arduino/Arduino/tree/master/hardware/arduino/firmwares/arduino-usbserial/   y descargar la última versión de Arduino-usbserial-uno.hex 
Ojo, hay que descargarse el código hexadecimal tal cual (no el html). Para ello hacemos click sobre el archivo y después click derecho en la opción "raw" (guardar enlace como).

Paso 2: Instalar Device Firmware Update para chips Atmel:

 $sudo dpkg -i linux-headers-2.6.38-020638_2.6.38-020638.201103151303_all.deb  

Paso 3: Poner el chip en modo programación conectando los siguientes cables:

Con el cable USB conectado:

• Mantén el primer cable en la posición indicada.

• Mantén el segundo cable en la posición indicada.

• Desconecta el segundo cable.

• Desconecta el primer cable.

Paso 4: Reprogramar el firmware:

 $sudo dfu-programmer at90usb82 erase  
 $sudo dfu-programmer at90usb82 flash --debug 1 Arduino-usbserial-uno.hex  
 $sudo dfu-programmer at90usb82 reset  

Paso 5:

Desconectar y volver a conectar el cable USB...y a rular.

Fuentes:

http://arduino.cc/forum/index.php?topic=55736.0
http://es.scribd.com/doc/45913857/Arduino-UNO
http://www.strangeparty.com/2010/12/13/fix-your-arduino-uno-for-linux/