Luz de atril

Para un concierto en el que toqué recientemente nos hacía falta tener luces en los atriles ya que en algunas piezas se proyectaban vídeos mientras tocábamos y la luz era insuficiente para poder leer la partitura.

Así que decidí construirme una luz de atril, con batería recargable por USB.

Para fijar la lámpara (realmente, tres lámparas LED) al atril, preví un par de imanes de neodimio, que se pegan a cualquier superficie metálica (la mayoría de los atriles) de forma muy fuerte.

Material necesario:

  • Una percha
  • 3 leds cortados de una tira led
  • Una batería de ion litio 18650 (sacada de la batería de un portátil)
  • Módulo cargador TP4056
  • 2 imanes de neodimio (sacados de un disco duro)
  • Interruptor
  • Potenciómetro

Realmente no hay mucho que contar. Con unos alicates enderecé y di forma al bastidor. Ojo, que el alambre de esta percha era muy grueso y por tanto excesivamente rígido y difícil de doblar.

Luego soldé los cables correspondientes entre la batería y el módulo de carga, con la precaución de meter un tiempo antes la batería en el congelador, para que el calor de la soldadura no afectase al ión litio (estas baterías se llevan mal con el calor, y en algún sitio leí este truco).

Del módulo de carga soldé los cables al interruptor, y de este al potenciómetro, que alimentaba en serie a los tres leds.

En total unas 2 horas de una tarde de domingo.

Altavoz Bose SoundDock + entrada de línea + bluetooth

Hace tiempo cayó en mis manos un altavoz Bose SoundDock de primera generación. Es un altavoz magnífico (y muy caro, unos 500 €), que se empleaba para reproducir música de un iPod o de un iPhone de las primeras generaciones (los que tienen conexión alargada, de 30 pines). El problema es que solo permite conectar uno de esos aparatos, ya antiquísimos, y que a ver quién usa aún uno… Además, en mi caso, la base estaba rota y ya ni siquiera tenía la clavija, por lo que estaba totalmente inservible. Pero, salvo que no había forma de conectarle un iPod o ningún otro dispositivo, el altavoz en sí parecía en perfecto estado…

Bose Sounddock

Así que me propuse arreglarlo. A continuación cuento todas las trastadas que le he hecho al altavoz, y cómo he llegado al resultado final, en el que tengo un altavoz perfectamente funcional, al que he añadido una entrada de audio por medio de una clavija de 2.5 mm, le he añadido bluetooth y un potenciómetro para regular el volumen. Ojo, que los primeros procedimientos que intenté no me funcionaron, pero los cuento también por si alguien se encuentra con los mismos problemas. Más adelante contaré cómo le he añadido una Raspberry Pi en la que he instalado el Google Assistant.

Pero antes, este es el resultado final:

 

Esta es la etiqueta que aparece en la base:

El frontal se demonta por medio de tres tornillos tor.

Podemos desconectar la banda, y luego hay que despegar el plástico negro:

Buscando por internet hay varias personas que han “hackeado” este altavoz con el mismo propósito, bien por rotura de la clavija como es mi caso, o para añadirle una entrada auxiliar. Mike Kruckenberg parece que fue el primero en explicar cómo lo hizo. Hay también varios vídeos en Youtube. Tengo que decir de antemano que el procedimiento de Mike Kruckenber, que es el primero a seguir (por simplicidad), no me funcionó. Por un lado mi placa parece ser una versión más antigua que todas las otras que he visto, y además sospecho que tendría algún problema más. Pero al final lo conseguí con otro procedimiento que contaré más abajo.

La idea de fondo es averiguar cuáles son los pines del iPod que mandan la señal de audio, y conectar ahí nuestra entrada. Son el pin 13 para audio izquierdo, el pin 14 para el derecho, y el 24 para tierra. Conectando ahí debería funcionar, pero hace falta un paso adicional pues solo mandando ahí audio el altavoz sigue sin funcionar. Al parecer, el iPod le indica por algún otro pin al altavoz que debe encenderse. No me entretengo a explicarlo (en el post de Mike Kruckenberg está muy bien explicado, y también en varios vídeos), pero su método no me funcionó. Aquí van las fotos de los intentos fallidos.

Otra prueba fallida:

Así que decidí dar por perdida la primera placa e ir directamente a la placa del amplificador, dentro.

Encontré otro post en el que hacían lo mismo, que lo explica muy bien. La idea es nuevamente localizar los pines de audio y “pinchar” ahí. Del encendido nos encargaremos luego.

Preparo una clavija hembra de jack de 3.5 mm y le sueldo los cables.

Como estos cables eran algo gruesos, con una pequeña broca agrandé ligeramente los agujeros donde iba a soldar en la placa. Inicialmente soldé por detrás:

Empleo blu-tack para mantener en su sitio los cables mientras sueldo. Siguiendo el mismo criterio de William Paul, realizo unos pequeños cortes al circuito, para que si hay algo más ocurriendo por ahí, no me afecte.

Al final me fue más fácil soldar directamente a las patas de la clavija, por delante:

Si probaba el altavoz con estas conexiones, escuchaba música por unos segundo nada más, y luego dejaba de sonar. Así que me quedaba arreglar el “encendido automático”. Para eso tenemos que ir un poco más adentro.

Desmonto la placa del amplificador en sí.

Hay que enviar entre 4.2 V y 5.5 V al pin 6 de este circuito integrado para que se encienda. Paul William lo hizo con un divisor de tensión con dos resistencias, pero es más fácil conectarle directamente un cable que lleve 5 V de la placa anterior, que es lo que hice yo. Soldé con mucho cuidado un cable al pin 6, que luego puse un poco de resina epoxi para que permanezca fijo eternamente.

Soldando ese cable a algún punto que tenga 5 V de la placa anterior (buscar con el multímetro), ¡funcionaba a la perfección!

Ya solo quedaba el volver a ensamblarlo todo en el interior y a hacer un poco de bricolaje para que el acabado fuese perfecto. Esto es lo que más tiempo me llevó…

Lo primero era hacer una tapa para el hueco frontal. Hice una planilla marcando el hueco en un papel.

Recorté la planilla y la pegué sobre un trozo de plástico negro de una tapa de un lector externo de DVD (que ya había usado antes en el megáfono de juguete).

Con mi Dremel casera recorto la tapa:

Tras el corte con la mini-Dremel, tuve que lijar mucho hasta que la tapa encajase perfectamente en el hueco. El resultado es perfecto, parece una tapa que viene con el altavoz nuevo…

Y ahora, a por el receptor de audio de Bluetooth. Compré este módulo de Bluetooth por 5.52 €. Le sueldo tres cables a las conexiones de audio.

Sueldo dos cables a una clavija de micro-usb, para alimentar el receptor de audio de Bluetooth a través de algún punto con 5V de la placa.

También sueldo tres cables a un conector de audio de 3.5 mm.

Los conecto en paralelo:

Pero no los conecto directamente a los tres puntos de entrada de audio en la placa, sino que como voy a querer regular el volumen conecto un potenciómetro estéreo logarítimico de 10 KΩ., que me costó 4.4 €.

El potenciómetro lo conecto así:

Y es logarítmico porque para audio tiene que ser así; el oido “no funciona linealmente”. Esta figura lo explica muy bien:

Busco un punto de tierra en la placa y le conecto un cable (blanco):

El otro cable (naranjha) lo conecto al mismo punto de 5 V que empleé para “encender” el altavoz.

Y ahora conecto un interruptor. Voy a sufrir para que me quepa todo dentro de este espacio…

Hago unos taladros en los botones originales de volumen + y – (que ya no tienen uso), que emplearé para el potenciómetro y para la clavija de audio. Fijo con pegamento epoxídico el conector de audio y con pegamento térmico el potenciómetro, que ya lleva su tuerca.

Esto parece el juego “Operación”…

¡Ya está!

Recorto un poco el fuste y le coloco el embellecedor al potenciómetro, y ya está terminado.

 

Referencias

http://mike.kruckenberg.com/archives/2006/06/add_aux_input_t.html

http://williampaulblog.blogspot.com.es/2012/11/ressurection-of-bose-sounddock-ipod-dock.html

Manejar un motor stepper con un driver DRV8825 y una Raspberry Pi

Para un proyecto que tengo entre manos (un scanner 3D por fotogrametría, ver esta entrada), quiero controlar un motor a pasos (stepper) con una Raspberry Pi. En esta entrada ya expliqué cómo hacerlo con Arduino, pero ahora lo voy a hacer con la Rapsberry Pi, y voy a emplear un driver DRV8825.

En teoría, al no ser linux un sistema de “tiempo real”, no es muy indicado para manejar directamente elementos que requieren un control preciso del tiempo. Para mis propósitos, como no necesito controlar de forma muy precisa la velocidad, sino la posición, me sirve sin problemas.

0j42241200

Características principales del driver DRV8825:

  • Para motores bipolares
  • Permite microstepping de hasta 1/32
  • 1.5  por fase o 2.2A si se dispone de ventilación forzada de aire o disipadores
  • Interfaz casi idéntica al A4988
  • 45 V máximo
  • Control de corriente máxima con un potenciómetro

El motor que tengo es un motor NEMA 17 JK42HS40-1704 13A, comprado aquí por 12.50 €.

Características:

  • Número de parte: JK42HS40-1704 13A
  • Tamaño de marco: NEMA17
  • Ángulo del paso: 1,8 grados
  • Voltaje: 3.4V
  • Corriente: 1,7 A/phase
  • Resistencia: 2,0 ohmios/fase
  • Inductancia: 3,0 mH/phase
  • Llevar a cabo el esfuerzo de torsión: 4000g-cm 58.30 OZ-IN
  • Inercia del rotor: 54 g-cm2
  • Esfuerzo de torsión de la muesca: 0,22 kilogramo-cm
  • Número de ventajas de alambre: 4
  • Peso: 0,24 kilogramos
  • Longitud: 40m m
  • Eje del motor: 5mm
  • Longitud del árbol delantero: 20 mm
  • Certificación: CE, ROHS, ISO9001

 

Para alimentar el motor empleo una fuente de alimentación de un ordenador (ver esta entrada).

Siguiendo las instrucciones de la página de Pololu, voy a emplear el siguiente modo de conexión, con paso completo (sin microstepping):

El esquema Fritzing sería así:

Manejar un motor paso a paso con DRV8825 y Raspberry Pi

La conexión de los cables del motor al DRV8825 la hago así:

  • B2: azul
  • B1: rojo
  • A1: negro
  • A2: verde

Para no dañar el motor tenemos que regular inicialmente el potenciómetro a la mínima potencia, girando el potenciómetro en sentido antihorario hasta el final, y más adelante ajustarlo hasta la capacidad del motor. En este vídeo se explica cómo regular adecuadamente la intensidad.

Empiezo con el motor desconectado. Lo primero, calculo el voltaje por cada fase. Para eso me fijo en las características de mi motor. Ahí me dicen que el motor es de 1.7 A / fase. Tendré que limitar el DRV8825 a este valor. Por encima de 1.5 A (y hasta 2.2A) el controlador DRV8825 debe tener ventilación forzada de aire o un disipador, así que le pego un disipador (me venía al comprarlo con el DRV8825), pues pretendo fijarlo en la capacidad máxima del motor.

Ahora tengo que ajustar la corriente del DRV8825 con el potenciómetro. Primero tengo que averiguar a cuánto he de limitar esa corriente. Para ello empleo la fórmula que viene en la hoja de especificaciones del driver:

Current Limit = VREF × 2

(Ojo, que por muchas páginas se ven otras fórmulas; hay que emplear la fórmula específica de nuestro driver).

Entonces:

1.7 = VREF x 2

VREF = 0.85 V

Pero ojo, este voltaje va asociado a la corriente máxima que recibirá el motor, y depende de la configuración de micropasos. Hay que consultar en la Tabla 2 de la hoja de especificaciones del DRV8825. En mi caso, con paso completo (full step), la corriente es un 71%, así que deberé multiplicar por este factor el resultado anterior:

VREF = 0.71 · 0.85 = 0.60 V

Así que el voltaje límite que debo ajustar es 0.60 V por fase.

Ahora tengo que ver dónde medir con el multímetro en el DRV8825:

Aunque es más fácil medir directamente desde el potenciómetro:

Desconecto el motor, pero alimento con 12V el DRV8825 y alimento también el Arduino a través del puerto USB. Con todo así, mido el voltaje y ajusto el potenciómetro hasta alcanzar mis VREF calculado antes (0.60 V).

Ya tengo el driver ajustado a mi motor, así que ya puedo conectarlo y empezar a utilizarlo.

 

En la Raspberry Pi voy a emplear código en Python. He conectado el pin de STEP del DRV8825 en el pin GPIO7 de la Raspberry Pi (pin 26), y el de DIR en el pin GPIO8 (pin 26). Mandando señales a estos pines podré indicar que se avance un paso (pin STEP), y cambio de dirección en en pin DIR. Por como tengo conectado todo, son pasos completos, nada de micropasos, que no me hacen falta por el momento.

Con el código siguiente en Python el motor da una vuelta completa en una dirección, y luego cambia de dirección y da otra vuelta:

# -*- coding: utf-8 -*-

import time                     #Para las pausas
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BOARD)        #Usar la numeración de pines de la placa

pinDir = 24                     #Pin DIR
pinStep = 26                    #Pin Step
numSteps = 200                  #Número de pasos del motor
microPausa = 0.005              #Número de segundos de pausa


GPIO.setup(pinDir,GPIO.OUT)
GPIO.setup(pinStep,GPIO.OUT)

while True:

        GPIO.output(pinDir,0)           #Establezco una dirección (0 o 1)

        for x in range(0,numSteps):
                GPIO.output(pinStep, True)
                time.sleep(microPausa)
                GPIO.output(pinStep, False)
                time.sleep(microPausa)

        time.sleep(microPausa)

        GPIO.output(pinDir, 1)          #Cambio de dirección

        for x in range(0,numSteps):
                GPIO.output(pinStep, True)
                time.sleep(microPausa)
                GPIO.output(pinStep, False)
                time.sleep(microPausa)

GPIO.cleanup()          #Para acabar correctamente

Y aquí un vídeo mostrando el motor en funcionamiento:

 

Referencias

https://www.pololu.com/product/2133

 

https://forum.pololu.com/t/drv-8825-stepper-motor-steps-and-delay-between-pulses/7530

Raspberry Pi Stepper Motor Tutorial

Megáfono de juguete

He terminado un megáfono para regalarle a mi sobrino de tres años y que se dedique a gritar todo lo que quiera por él.

La idea es tener un juguete al que habla o grita por un lado y se amplifica por el otro (un megáfono). También le añado un conector de audio por si se quiere poner unos auriculares, y un potenciómetro para regular el volumen. Empleará unas baterías de ión litio recuperadas de la batería de un portátil, y se podrá recargar con un conector micro USB.

Lista de la compra:

  • Tubo de PVC diámetro 40 mm, con embellecedor (acoplamiento a pared para sifones). Comprado aquí por 3.50 €, aunque hubiera valido cualquier tubo, vaso de plástico, etc.
  • Tapón PVC 40 mm, comprado aquí por 0.98 €.
  • Amplificador audio LM386. Comprado aquí por 6 € (porque tenía prisa), pero si se quiere esperar unas semanas, puede venir de China por 1.19 €.
  • Potenciómetro con embellecedor (lo tenía por ahí). Realmente no es necesario, valdría el del kit LM386.
  • Altavoz 8 ohm reciclado de algún juguete (no recuerdo)
  • 2 pilas 18650 extraídas de la batería de un portátil
  • BMS para 2 pilas 18650 en serie, comprado aquí por 2.25 €.
  • Módulo cargador de pilas de litio TP4056, comprado aquí (5 unidades por 1.99€; 0.40€ la unidad)
  • Convertidor DC-DC (Step-up) comprado aquí por 2.29 €.
  • Cables diversos, pegamento, etc…

Herramientas:

  • Soldador
  • Dremel (yo he usado uno que me fabriqué hace tiempo; ver esta entrada)

 

Algunas de las piezas antes de ponerme a montarlo todo:

El esquema de montaje es el siguiente:

Todo montado, a falta del convertidor de voltaje, que aún no me había llegado:

Hago la tapa a partir de un plástico cualquiera (de una tapa de un lector de DVD portátil que tenía por ahí), que corto del mismo diámetro que el embudo, y le hago unos agujeros para el altavoz, por medio de una plantilla:

Plantilla agujeros Megáfono

Recorto la tapa con la “Dremel” que me fabriqué:

Hago los pequeños taladros, también con la dremel:

Veo que encaja todo bien (sin pegar aún):

 

Practico los agujeros para el pulsador y el potenciómetro:

Y ahora lo complicado, a meter todo dentro:

Todavía no me ha llegado el convertidor de voltaje…

Empiezo a pegar…

Ya llegó el step-up:

Todo en su sitio, solo falta la tapa:

Hago una “plantilla” para hacer los agujeros en su sitio en la tapa:

Ya está.

Pruebo a conectar el cargador, ok.

Pruebo unos auriculares, ok.

 

Mejoras para futuros proyectos parecidos:

  • emplear cable de menor sección y más flexible, pues “maniobrar” dentro del tubo fue realmente complicado
  • aislar (acústicamente) o separar más el altavoz del micrófono, pues se acoplan con facilidad

 

Power supply de una fuente de alimentación ATX de PC

Para trabajar con todo tipo de “inventos” es muy útil tener una fuente de alimentación. Las fuentes de ordenador de sobremesa se pueden adaptar de forma muy fácil para esto, y suministran (sin necesidad de hacer nada) diferentes voltajes:

  • +3.3 V
  • +5 V
  • +12 V
  • -12 V

(Combinando los anteriores podemos obtener otros voltajes, naturalmente).

Hay inifinidad de tutoriales por internet en el que explican cómo hacer esto, aunque relamente no hace falta un tutorial porque es cortar cables y listo.

Como puntos a destacar, para que arranque la fuente es necesario puentear el cable verde a cualquier cable tierra (negro). Y en función de lo antigua que sea la fuente será necesario añadir una resistencia o no; en mi caso no fue necesario.

Para hacer los agujeros en la cargasa recomiendo empezar con pequeños taladros y luego hacerlos más grandes.

Compré unos conectores como estos y estos los que realmente compré ya no los veo, pero hay miles)

Y para la próxima que me haga, las conexiones las voy a hacer con estas horquillas, que facilitará mucho la vida.

No hice muchas fotos durante el montaje, pero es que es muy básico todo…

 

Referencias

http://www.instructables.com/id/Computer-Power-Supply-to-Bench-Power-Supply-Adapte/?ALLSTEPS

http://www.wikihow.com/Convert-a-Computer-ATX-Power-Supply-to-a-Lab-Power-Supply

 

Herramienta rotativa manual tipo Dremel

Con un motor que rescaté de una impresora rota me he construido una “dremel”: una herramienta que puede ser un taladro, una fresadora, un lija, un disco de corte…

El proyecto es muy básico, pero realmente muy útil y así nos ahorramos la compra de una de estas herramientas. Lo único que hace falta es un motor DC suficientemente rápido, o tubo o similar para sujetarlo, un pulsador, un portabrocas y luego las brocas, discos, fresas o lo que vayamos a necesitas, que tendremos que comprar.

El portabrocas tiene que poder fijarse al eje del motor, por lo que tendrá que ser de un diámetro pequeño. Yo compré uno similar a este por 5.99 €.

Este es el motor que saqué de una impresora:

Le acoplo el portabrocas:

El motor quedaba un poco holgado dentro del tubo, así que enrollé un poco de cable y con esto encajó perfectamente.

Para la tapa, corté un poco de plástico de una caja de CD:

Compré algunos accesorios, como mini brocas, discos de corte y piezas para amolar/fresar.

 

Mejoras si vuelvo a construirme uno:

  • Emplear un pulsador más grande y mejor (el que puse es muy pequeño e incómodo)
  • Añadirle un par de baterías de ion litio 18650 y cargador, y así lo hago totalmente inalámbrico.

Manejar un motor stepper con un driver A4988 y Arduino

Voy a contar cómo manejar un motor paso a paso (stepper) con Arduino a través de un driver A4988. En esta otra entrada ya expliqué cómo hacerlo con un controlador DRV8825, que es una versión mejorada del A4988 (el DRV8825 admite microstepping has 1/32, frente al 1/16 del A4988, 45V frente a 35V, y 2.5A frente a 2A).

Pololu driver A4988

 

Características principales del driver A4988:

  • Para motores bipolares
  • Permite microstepping de hasta 1/16
  • 2A
  • Interfaz casi idéntica al DRV8825
  • 35 V máximo
  • Control de corriente máxima con un potenciómetro

Nota importantísima: los datos anteriores, en especial el del límite de 2A es para los A4988 en los módulos Pololu (algo más caros). Hay una variante muy común que son los StepStick (más baratos, y seguramente es este el que tienes si lo has comprado de China). y la principal diferencia es que su límite es de 1A. Así que mucho ojito.

Stepstick driver A4988

El motor que voy a usar es un motor NEMA 17 GZGW09, comprado aquí por 13.50 €, pero valdría cualquier motor bipolar de 4 cables.

gzgw09

Características:

  • Step angle: 1.8 degree
  • Rated voltage: DC 4.83V
  • Rated current: 0.84A
  • Phase impedance: 5.75 Ohm + / – 10 degree centigrade
  • Phase inductance: 9.3 mH + / – 20 degree centigrade (1kHz 1V RMA)
  • Holding torque: 0.48Nm Min
  • Shaft diameter: 5mm / 0.188 (3/16)
  • Shaft length: 20mm
  • Motor height: 34mm
  • Number of lead wire: 4 wires
  • Driven X-axis and Y-axis movement, sprinkler wire wheel to scroll
  • Great for DIY project
  • Dimensions: 5.8 cm x 4.2 cm x 4.2 cm
  • Weight: 220 g

 

Para alimentar el motor empleo una fuente de alimentación de un ordenador (ver esta entrada).

Siguiendo las instrucciones de Pololu, voy a emplear el siguiente esquema de conexión, con paso completo (sin microstepping):

Empleo un Arduino Nano, pero valdría cualquier otro. Uso el pin 8 para la dirección y el 9 para el step. El esquema Fritzing sería así:

La conexión de los cables del motor al StepStick A4988 la hago así:

  • 1A: rojo (morado)
  • 1B: gris (gris)
  • 2A: amarillo (blanco)
  • 2B: verde (negro)

Para no dañar el motor tenemos que regular inicialmente el potenciómetro a la mínima potencia, girando el potenciómetro en sentido antihorario hasta el final, y más adelante ajustarlo hasta la capacidad del motor. En este vídeo se explica cómo regular adecuadamente la intensidad.

Lo primero es determinar el chip que realmente tenemos, pues cambia mucho si es un Pololu o un StepStick.

En la hoja de especificaciones se dice:

El Pololu tiene un valor de para la resistencia de censado SMD de 0.05 Ω (si se fabricó a partir de enero de 2017, entonces 0.068 Ω), mientras que en el StepStick es de 0.2 Ω. Lo mejor es mirarlo en la propia placa.

Así pues, en mi caso, tengo un StepStick (Rs= 0.2 Ω), y la intensidad máxima para mi motor de 0.84 A.

VREF = ItripMAX · 8 · Rs = 0.84 · 8 · 0.2 = 1.34 V

Así que debería limitar a 1.34 V.

Pero ojo, el valor de la intensidad que hemos empleado antes es la máxima. En función de qué configuración de microstepping vayamos a usar, se podrá emplear otro valor.

Así, si empleamos pasos completos sin micro pasos, vemos que la tensión va variando en cada micropaso (también se puede consultar una tabla en las especificaciones):

Si emplease pasos completos y no micro pasos, entonces la tensión máxima que se entrega al motor es de un 70.71%.

Y entonces, si voy a emplear pasos completos tendré que ajustar el voltaje a:

 

VREF= 0.7071· ItripMAX · 8 · Rs = 0.7071 · 0.84 · 8 · 0.2 = 0.95 V

Para medir este voltaje, lo hacemos con el multímetro sobre el potenciómetro y sobre tierra, y ajustamos el potenciómetro hasta la VREF calculada antes (0.95 V).

Ya tengo el driver ajustado a mi motor para pasos completos, así que ya puedo conectarlo y empezar a utilizarlo.

Cargando el siguiente código a Arduino, el motor da una vuelta completa en una dirección, y luego cambia de dirección y da otra vuelta:

const int dirPin = 8;
const int stepPin = 9;
 
const int steps = 200;
int microPausa = 1000;
 
void setup() {
 pinMode(dirPin, OUTPUT);
 pinMode(stepPin, OUTPUT);
}
 
void loop() {
 digitalWrite(dirPin, HIGH);  // Establezco una dirección

 for (int x = 0; x < steps ; x++) {
   digitalWrite(stepPin, HIGH);
   delayMicroseconds(microPausa);
   digitalWrite(stepPin, LOW);
   delayMicroseconds(microPausa);
 }
 delay(1000);
 
 digitalWrite(dirPin, LOW);  // Cambio la dirección

 for (int x = 0; x < steps ; x++) {
   digitalWrite(stepPin, HIGH);
   delayMicroseconds(microPausa);
   digitalWrite(stepPin, LOW);
   delayMicroseconds(microPausa);
 }
 delay(1000);

}

Y un vídeo mostrando el motor en movimiento con el código anterior:

Referencias

https://www.pololu.com/product/2133

Motores paso a paso con Arduino y driver A4988 o DRV8825

http://www.instructables.com/id/Drive-a-Stepper-Motor-with-an-Arduino-and-a-A4988-/

https://www.spainlabs.com/foros/tema-Ajuste-de-los-pololus-en-caliente

Manejar un motor stepper con un driver DRV8825 y Arduino

Voy a contar cómo manejar un motor paso a paso (stepper) con Arduino a través de un controlador DRV8825. En esta otra entrada explico cómo hacerlo con una Raspberry Pi, de forma muy similar, y en esta hablo de varios motores y drivers.

0j42241200

Características principales del driver DRV8825:

  • Para motores bipolares
  • Permite microstepping de hasta 1/32
  • 1.5  por fase o 2.2A si se dispone de ventilación forzada de aire o disipadores
  • Interfaz casi idéntica al A4988
  • 45 V máximo
  • Control de corriente máxima con un potenciómetro

El motor que voy a usar es un motor NEMA 17 JK42HS40-1704 13A, comprado aquí por 12.50 €, pero valdría cualquier motor bipolar de 4 cables.

Características del motor:

  • Número de parte: JK42HS40-1704 13A
  • Tamaño de marco: NEMA17
  • Ángulo del paso: 1,8 grados
  • Voltaje: 3.4V
  • Corriente: 1,7 A/fase
  • Resistencia: 2,0 ohmios/fase
  • Inductancia: 3,0 mH/phase
  • Llevar a cabo el esfuerzo de torsión: 4000g-cm 58.30 OZ-IN
  • Inercia del rotor: 54 g-cm2
  • Esfuerzo de torsión de la muesca: 0,22 kilogramo-cm
  • Número de ventajas de alambre: 4
  • Peso: 0,24 kilogramos
  • Longitud: 40m m
  • Eje del motor: 5mm
  • Longitud del árbol delantero: 20 mm
  • Certificación: CE, ROHS, ISO9001

Para alimentar el motor empleo una fuente de alimentación de un ordenador (ver esta entrada).

Siguiendo las instrucciones de la página de Pololu, voy a emplear el siguiente modo de conexión, con paso completo (sin microstepping):

Empleo un Arduino Nano, pero valdría cualquier otro. Uso el pin 8 para la dirección y el 9 para el step. El esquema Fritzing de mi montaje es así:

Manejar un motor paso a paso con DRV8825 y Arduino

 

La conexión de los cables del motor al DRV8825 la hago así:

  • B2: azul
  • B1: rojo
  • A1: negro
  • A2: verde

Para no dañar el motor tenemos que regular inicialmente el potenciómetro a la mínima potencia, girando el potenciómetro en sentido antihorario hasta el final, y más adelante ajustarlo hasta la capacidad del motor. En este vídeo se explica cómo regular adecuadamente la intensidad, que cuento a continuación.

Empiezo con el motor desconectado. Lo primero, calculo el voltaje por cada fase. Para eso me fijo en las características de mi motor. Ahí me dicen que el motor es de 1.7 A / fase. Tendré que limitar el DRV8825 a este valor. Por encima de 1.5 A (y hasta 2.2A) el controlador DRV8825 debe tener ventilación forzada de aire o un disipador, así que le pego un disipador (me venía al comprarlo con el DRV8825), pues pretendo fijarlo en la capacidad máxima del motor.

Ahora tengo que ajustar la corriente del DRV8825 con el potenciómetro. Primero tengo que averiguar a cuánto he de limitar esa corriente. Para ello empleo la fórmula que viene en la hoja de especificaciones del driver:

Current Limit = VREF × 2

(Ojo, que por muchas páginas se ven otras fórmulas; hay que emplear la fórmula específica de nuestro driver).

Entonces:

1.7 = VREF x 2

VREF = 0.85 V

Pero ojo, este voltaje va asociado a la corriente máxima que recibirá el motor, y depende de la configuración de micropasos. Hay que consultar en la Tabla 2 de la hoja de especificaciones del DRV8825. En mi caso, con paso completo (full step), la corriente es un 71%, así que deberé multiplicar por este factor el resultado anterior:

VREF = 0.71 · 0.85 = 0.60 V

Así que el voltaje límite que debo ajustar es 0.60 V por fase.

Ahora tengo que ver dónde medir con el multímetro en el DRV8825:

Aunque es más fácil medir directamente desde el potenciómetro:

Desconecto el motor, pero alimento con 12V el DRV8825 y alimento también el Arduino a través del puerto USB. Con todo así, mido el voltaje y ajusto el potenciómetro hasta alcanzar mis VREF calculado antes (0.60 V).

Ya tengo el driver ajustado a mi motor, así que ya puedo conectarlo y empezar a utilizarlo.

Cargando el siguiente código a Arduino, el motor da una vuelta completa en una dirección, y luego cambia de dirección y da otra vuelta:

const int dirPin = 8;
const int stepPin = 9;
 
const int steps = 200;
int microPausa = 1000;
 
void setup() {
 pinMode(dirPin, OUTPUT);
 pinMode(stepPin, OUTPUT);
}
 
void loop() {
 digitalWrite(dirPin, HIGH);  // Establezco una dirección

 for (int x = 0; x < steps ; x++) {
   digitalWrite(stepPin, HIGH);
   delayMicroseconds(microPausa);
   digitalWrite(stepPin, LOW);
   delayMicroseconds(microPausa);
 }
 delay(1000);
 
 digitalWrite(dirPin, LOW);  // Cambio la dirección

 for (int x = 0; x < steps ; x++) {
   digitalWrite(stepPin, HIGH);
   delayMicroseconds(microPausa);
   digitalWrite(stepPin, LOW);
   delayMicroseconds(microPausa);
 }
 delay(1000);

}

 

Y un vídeo mostrando el motor en movimiento con el código anterior:

 

Referencias

https://www.pololu.com/product/2133

Controlador de motor a pasos DRV8825

Motores paso a paso con Arduino y driver A4988 o DRV8825

https://forum.pololu.com/t/drv-8825-stepper-motor-steps-and-delay-between-pulses/7530

Acceder a la consola de una Raspberry Pi (Zero) por UART con un adaptador USB PL2303

La Pi Zero es una maravilla, si no fuera por lo complicado que es acceder a su consola, al tener un único puerto USB y no tener ni WiFi integrado ni una conexión de red: hace falta conectarse con un teclado y a una pantalla a través de HDMI, o a través de un hub USB, más una tarjeta WiFi USB, etc.

Una forma más sencilla de poder acceder a la consola de la Raspberry Pi es a través de UART, con un cable específico USB, o con un adaptador USB PL2303. Esto es válido no solo para la Raspberry Pi Zero, sino para todas las Raspberrys.

Adaptador USB – TTL PL2303 (vista delantera)

Adaptador USB – TTL PL2303 (vista trasera)

Lo primero es activar la comunicación en serie en la Raspberry Pi. Esto lo podemos hacer con sudo raspi-config
y después en Advanced Options – Serial decimos sí a permitir hacer login por serie. Otra alternativa es editar el ficher /boot/config.txt y añadir al final enable_uart=1. En cualquier caso, es necesario reiniciar tras hacer el cambio.

Ahora es necesario instalar los drivers en nuestro ordenador para que reconozca el PL2303. Para ello nos descargamos de la página oficial el driver correspondiente a nuestro sistema operativo (para Mac, para Windows, para Linux no hace falta, viene por defecto). Tras instalarlo tenemos que reiniciar el ordenador.

Como en Windows me ha dado problemas (no reconoce el módulo), al final lo he probado desde mi Mac y ha funcionado. He hecho lo siguiente.

 

Tras instalar el driver del enlace anterior y reiniciar, he conectado el adaptador (a su vez conectado a la Raspberry Pi) de la siguiente forma:

Ojo, que el TXD de la Raspberry Pi se conecta al RXD del PL2303 y viceversa.

Esquema conexión PL2303 a Raspberry Pi Zero

Tras comprobar que todo estaba bien conectado, he abierto una consola en mi Mac y he escrito el siguiente comando: screen /dev/cu.usbserial 115200. ¡Y ya está! Tras hacer eso y dar al enter, ya nos pide el usuario y contraseña y ya estamos conectados a la Raspberry Pi.

(Ojo, que a lo mejor en otros casos el dispositivo podrá tener otro nombre; entonces bastará con teclear screen /dev/cu. y darle al TAB para ver los que hay, y escogemos.)

Diseño y construcción de un arpa láser

Introducción

Hace tiempo me encontré por internet una página en la que se explicaba cómo construirse un arpa láser casera. La idea es sencilla: se tiene un láser que encendemos y apagamos a muy alta velocidad contra un espejo montado sobre un motor a pasos que va cambiando de posición de forma sincronizada con el láser, de tal manera que por persistencia de la visión da lugar a una serie de haces de luz muy espectaculares, si el láser tiene la potencia adecuada y/o la luz ambiente es apropiada. Si disponemos una célula fotoeléctrica que detecte cuándo uno de los haces de láser ha sido interrumpido y vemos en qué posición está el láser en ese momento, podemos asociar a cada posición del láser una nota musical, que se envía por MIDI a un teclado o al ordenador, o podemos también hacer sonar con un pequeño altavoz.

Arpa láser en su configuración final

Arpa láser en su configuración final

Como además estaba preparando un concierto para unos meses más tarde en el que podría quedar muy bien hacer una parte con el arpa láser, decidí construirme una.

En esta página describo todo el proceso de montaje de un arpa láser plenamente funcional, tratando de explicar las pruebas que hice y todos los pasos que seguí, así como las referencias que consulté siempre que he podido. Ojo, que muchas de las páginas de internet sobre arpas láser no son del todo funcionales, o se quedan a la mitad y no lo llevan hasta el final, o directamente cuentan cosas que no son del todo creíbles.

Para llegar al arpa que empleé en el concierto, construí varios prototipos parciales y uno completo antes del arpa definitiva. Las fotos que pongo en la página pueden corresponder a alguno de los prototipos o a la definitiva en proceso de montaje.

Aviso al navegante: si tienes intención de hacer algo parecido a las arpas láser de Jean Michel Jarre ya puedes ir preparándote para un gran desembolso económico y para dedicarle mucho tiempo…

Y el aviso más importante, y no es broma: trabajar con láseres, especialmente de alta potencia como el que empleo en este arpa, supone un riesgo muy alto y existe la posibilidad de quedarse ciego si se mira accidentalmente al láser (o un reflejo de éste en alguna superficie reflectante) ya que puedes quemarte la retina en un tiempo menor del tiempo de reacción de cerrar el ojo o apartar la mirada. Así que hay que emplear en todo momento gafas protectoras, adecuadas al láser que empleemos, evitar que haya más gente donde estemos trabajando y ser muy cuidadoso…

Material y lista de la compra

General:

  • Cables (pueden ser normales o tipo Dupont)
  • Cola térmica
  • Soldador
  • Resistencias varias
  • Madera o caja de aproximadamente 32 x 20 cm

Opcional:

  • Teclado MIDI al que conectar el arpa láser y que genere los sonidos.
  • Interfaz MIDI – USB (4.86 €) sólo necesario si no disponemos de un sintetizador o teclado MIDI que genere los sonidos.
  • Conector DC 12 V 2.1 mm x 5.5 mm (3 unidades por 2.58 €: 0.86 €) Opcional pues podemos cortar y soldar los cables directamente…
  • Jack conector hembra audio 3.5 mm (2 unidades por 1.45 €) Sólo necesario si queremos que el arpa genere sonidos por sí sola, sin
  • Altavoz piezoeléctrico: de cualquier juguete o altavoz malo
  • Transistor NPN 2N222 (10 unidades por 1.62 €: 0.16 €) Solo necesario si el láser no viene con su propio driver.
  • 1 LED
  • Módulo lector de tarjeta SD (1.99 €) y una tarjeta SD. Solo necesario si queremos que al arrancar el arpa láser se reproduzca un archovo wav con el sonido de un sable láser encendiéndose.

TOTAL: Configuración mínima: unos 150€, que podría llegar a ser unos 80 € si usamos un láser malucho (no se verían los haces salvo en una habitación con humo). También depende de los elementos que ya tengamos reciclados de otros inventos.

El láser

Probé con varios láseres, desde los baratos tipo puntero hasta uno “bueno” de 300 mW. Ojo con estos láseres que generalmente vienen de China. Venden diferentes modelos de diferentes potencias, pero luego descubres que te llega exactamente el mismo y que lo único es juegas con el potenciómetro. Así que en caso de utilizar estos láseres, es mejor comprar el de menor potencia y luego ajustar el potenciómetro. Yo alguna vez he jugado con este de 50 mW (11€), y este de 5 mW (5€), y me llegaron exactamente iguales.

El que finalmente utilicé fue este de 300 mW, por unos 80 €. Un láser bueno “de discoteca” puede costar varios cientos de euros o incluso miles. Lo importante es que sea TTL y que tenga cuanta más potencia os podáis permitir, pues entonces podrá verse el haz de láser mejor, o con mayor luz ambiente. Los más típicos (y baratos) son los láseres verdes de 532 nm de longitud de onda.

img_1736

No penséis en ningún momento que puede verse el haz del láser a plena luz del día o, o en una sala muy iluminada. Es necesario que esté en un entorno oscuro, y lo ideal es emplear humo para que se vea mejor…

cuation-laser

Advertencia. Jugar con láseres es muy peligroso, y no es una advertencia banal. En menos tiempo de lo que el ojo puede reaccionar un láser dirigido al ojo, o reflejado en una superficie brillante puede dañar permanentemente tu visión. Para toda la vida. Por ello, es necesario llevar siempre unas gafas protectoras adecuadas al láser específico que estemos manejando. En mi caso empleo láseres de 532 nm, pero ojo, algunos láseres chinos de mala calidad emiten a la vez a 1064 nm, por lo que opté por protegerme para ambas frecuencias y compré estas gafas por unos 35 €.

img_1737

Estas son las características que da el fabricante del láser:

  • Output Wavelength:532nm
  • Output Power:300mW with 5%
  • operating Voltage:DC12V
  • Lifepan:>5000 hours
  • Laser Shape: DOT
  • Focusable:Yes (By Tool)
  • Working Temperature:+10dgC-+40dgC
  • Working Temperature:+10dgC-+50dgC
  • Focus lens:Glass
  • Cooling mode:Heatsink and Fan
  • TTL signal:0~30K

El motor

Aquí está el quid de la cuestión. El láser es importante, sí, pero sólo depende de cuánto me quiera gastar en comprar un láser de mayor potencia, así que hay pocas incógnitas. En cambio con el motor es bastante más delicado. Debe ser muy rápido, y además permitir un control preciso del ángulo de giro para que se dé el efecto de persistencia de la visión y que al reflejar el láser de forma sincronizada con los giros sobre un espejo en el eje del motor dé la sensación de tener varios haces de luz.

Hice muchísimas pruebas con diversos motores y drivers (ver esta entrada). Lo primero, que se pregunta mucho en otras páginas, es dejar claro que el típico stepper de todos los kits de iniciación a la electrónica, el 28BYJ-48 no vale para un arpa láser, es muy lento. Hablo sobre este motor aquí.

En varias páginas se dice que con un motor sacado de una vieja impresora funciona. Yo probé con un MITSUMI M35SP-9, sacado de una vieja impresora Deskjet HP. Puede valer, aunque obtuve mejores resultados con otros motores.

Lo ideal sería emplear un galvanómetro (lo que se emplea en láseres de discoteca) que son capaces de girar a más de 20.000 revoluciones por minuto, pero son extremadamente caros, así que lo descarté desde el principio.

El motor que finalmente empleé fue este de Adafruit, aunque estuve a punto de utilizar uno que rescaté de una vieja impresora.

adafruit

También es muy importante qué driver (controlador) del motor empleamos. En mi caso empleé el A3967 EasyDriver. Aquí se explica de forma muy sencilla su manejo.

En esta entrada explico cómo hacer funcionar el motor con este driver.

MIDI

El protocolo MIDI es bastante sencillo. En esencia, Arduino no genera música, sino que envía comandos por este protocolo para que otra máquina genere la música con el instrumento que queramos. En mi caso, como ya tenía un teclado MIDI (Casio CT-655), solo he tenido que comprar el enchufe MIDI y un cable. También se puede hacer sin un teclado/sintetizador, conectando el cable MIDI al ordenador por un adaptador USB, y configurar el ordenador para que se encargue de generar el sonido que queramos (ver más abajo).

Lo primero es hacer una pequeña prueba para ver que hemos conectado bien todo y que nuestro teclado/sintetizador/ordenador es generar de interpretar lo que Arduino le manda por MIDI y produce sonidos. Podemos seguir el tutorial sencillo que viene en el SDK y la página web de Arduino.

midi_bb

 

En la siguiente página se explica en profundidad el protocolo MIDI y la estructura de comandos. Voy a conectar el arpa láser a un teclado CASIO CT-655, y me interesa, además de las notas en concreto, poder decirle al teclado que cambie a un instrumento determinado.

Por cierto, cada vez que actualicemos el código de Arduino y lo subamos a la placa, debemos desconectar el cable MIDI, pues si no el teclado puede recibir instrucciones erróneas y el resultado que obtendremos sonará muy raro…

 

Audio

Como es un poco trabajoso tener que conectar el arpa láser a un teclado MIDI o a un ordenador para producir algún sonido, he probado a que además de enviar el sonido por MIDI produzca sonido digital directamente, a través de un pequeño altavoz piezo, y un jack de 2.5mm al que se puede conectar unos auriculares.

[Explicar más]

Secuencia de audio al inicio

Se me ocurrió que podía añadir un sonido de encendido de espada láser de Star Wars, así que le añadí un módulo lector de tarjeta SD, busqué por internet y descargué un audio con el sonido de espada láser, lo convertí a wav con el Audacity y pasándolo a mono, 16.000 Hz, 32 bits y grabado como “Unsigned 8-bit PCM”. Aquí está el audio final:

 

Diagrama fritzing

Código

El código de Arduino empleado en este proyecto es el siguiente:

#include 	// Cargo la librería de motores a pasos
#include        // Cargo la librería SD, para reproducir audio al comienzo por altavoz
#define SDPin 10      // Conecto el CS al pin 10, para reproducir audio al comienzo por altavoz
#include    // Cargo la librería TMRpcm, para reproducir audio al comienzo por altavoz
#include       // Cargo la librería SPI, para reproducir audio al comienzo por altavoz

TMRpcm audio;   // Creo el objeto audio

int pinStep = 7;  	// Pin de Step del EasyDriver
int pinDirec = 8;	// Pin de Direction del EasyDriver
int micropausa = 600;	// microsegundos de pausa entre (micro)paso y (micro)paso (velocidad del motor)

int micropausaInicio = 15000;  //microsegundos de pausa entre (micro)paso y (micro)paso en la secuencia de inicio

int posVert = 465;  // Número de (micro)pasos que deja el espejo para que el láser esté en su sitio al comienzo

int sensor = 155;   // Umbral de sensibilidad del fotorresitor. Cuanto más bajo, más sensible a la luz. En cuarto oscuro funciona bien con 160

int micropausaLaser = 2000;   // Tiempo que se queda encendido el láser (microsengudos). En mi caso, va bien con 2000
int micropausaSensor = 2000; // Pausa tras apagar láser y antes de girar, para dar tiempo al sensor a reaccionar (microsengudos). En mi caso, va bien con 2000

int haces = 6;        // Número de notas / haces de láser
int pasosHaces = 12;  // Número de (micro)pasos entre haz y haz

int pinLaser = 4;   // Pin donde tengo conectado el láser
int pinLed = 6;     // Pin donde tengo conectado el LED de estado
int pinAudio = 9;   // Pin donde está conectado el altavoz piezo. Debe ser el Pin 9 en Arduino Uno y Nano, y 11 en el Mega
int pinBoton = 3;   // Pin donde está conectado el interruptor de fin de carrera del motor

int valBot = 0;   //Estado del botón del motor

int noteStatus[] = {0,0,0,0,0,0};	// Inicializo el estado de las notas (sonando/no sonando). Debe haber el mismo número que número de haces

int notasMIDI[] = {58,62,65,70,72,74};	// Nota asignada a cada haz. Debe haber el mismo número que número de haces



void setup() {

  pinMode(pinLaser, OUTPUT);        // Declaro el pin del laser
  digitalWrite(pinLaser, LOW);   // Apago el laser

  pinMode(pinLed, OUTPUT);  // Declaro el pin del Led de status
  digitalWrite(pinLed, LOW);  // Dejo el Led de estatus apagado

   // Para que suene el sable láser al arrancar
  audio.speakerPin = pinAudio; // Debe ser el Pin 9 en Arduino Uno y Nano, y 11 en el Mega
  Serial.begin(9600); // Para reproducir el audio al comienzo
  pinMode(SDPin, OUTPUT); 

  ajusteMotor();  // Llamo a la función ajusteMotor() para colocar el espejo en su sitio y arrancar la secuencia de incio

  //Arranco MIDI:
  Serial.begin(31250);	// Especifico el canal de comunicación para MIDI  
  Serial.write(192);	// Byte para cambiar de instrumento en canal 0
  Serial.write(15);	// Número de instrumento

  delay(100);

}

// Pongo el motor/espejo en su sitio al comienzo y secuencia de inicio:
void ajusteMotor()
{
int numpasosini;   //número de pasos en la secuencia de inicio (se calcula automáticamente)
int contini=0;  // contador secuencia de inicio (se calcula automáticamente)
  
  pinMode(pinBoton, INPUT); // Declaro el pin del boton como input
  pinMode(pinDirec, OUTPUT);
  pinMode(pinStep, OUTPUT);
  digitalWrite(pinDirec, LOW);
  digitalWrite(pinStep, LOW);

  for (int pos = 0; pos < 4000; pos++)
  {
   valBot = digitalRead(pinBoton);
   if (valBot == LOW)
   {         // si el botón está pulsado:
    //digitalWrite(pinLed, HIGH);   // Enciendo el led
    digitalWrite(pinDirec, HIGH);  // Cambio la dirección
    for (int pos2 = 0; pos2<posVert; pos2++) { digitalWrite(pinStep, LOW); digitalWrite(pinStep, HIGH); delayMicroseconds(micropausa); } digitalWrite(pinLaser, HIGH); // Enciendo el laser // Reproduzco el sonido de sable láser: if (SD.begin(SDPin)) { // Solo ejecuto si la tarjeta está accesible audio.volume(6); // Fijo el volumen (min=0, max=7) audio.play("laser.wav"); } // Secuencia abanico desplegado totalmente, acelerando linealmente: numpasosini=(haces-1)*pasosHaces*17/2; // Calculo el número de pasos en la secuencia de inicio // Compruebo la célcula fotoeléctrica, y mando arrancar la secuencia de inicio cuando se active: while(true) { if ( (analogRead(0) > sensor*2 ) )     // Si el sensor recibe señal
      {
        digitalWrite(pinLed, HIGH);   // Enciendo el led
        digitalWrite(pinDirec, LOW);  // Cambio la dirección
        for (int pos2 = 0; pos2<((haces-1)*pasosHaces/2); pos2++)
        {
           digitalWrite(pinStep, LOW);
           digitalWrite(pinStep, HIGH);
           digitalWrite(pinLaser, HIGH);   // Enciendo el laser
           delayMicroseconds(micropausaInicio-(micropausaInicio-micropausa)/numpasosini*contini++);
           digitalWrite(pinLaser, LOW);   // Apago el laser
        }
        for (int pos3 = 0; pos3<4; pos3++)
        {
          digitalWrite(pinDirec, HIGH);  // Cambio la dirección
          for (int pos2 = 0; pos2<((haces-1)*pasosHaces); pos2++)
          {
             digitalWrite(pinStep, LOW);
             digitalWrite(pinStep, HIGH);
             digitalWrite(pinLaser, HIGH);   // Enciendo el laser
             delayMicroseconds(micropausaInicio-(micropausaInicio-micropausa)/numpasosini*contini++);
             digitalWrite(pinLaser, LOW);   // Apago el laser
          }
          digitalWrite(pinDirec, LOW);  // Cambio la dirección
          for (int pos2 = 0; pos2<((haces-1)*pasosHaces); pos2++)
          {
             digitalWrite(pinStep, LOW);
             digitalWrite(pinStep, HIGH);
             digitalWrite(pinLaser, HIGH);   // Enciendo el laser
             delayMicroseconds(micropausaInicio-(micropausaInicio-micropausa)/numpasosini*contini++);
             digitalWrite(pinLaser, LOW);   // Apago el laser
          }
        }
        break;
      }
    }

   
//    // Si quiero ahorrarme la secuencia de inicio, habría que comentar la sección anterior.
//    // Dejo el espejo en la posición del primer haz:
//    digitalWrite(pinDirec, LOW);  // Cambio la dirección
//    for (int pos2 = 0; pos2<((haces-1)*pasosHaces/2); pos2++)
//    {
//       digitalWrite(pinStep, LOW);
//       digitalWrite(pinStep, HIGH);
//       delayMicroseconds(micropausa);
//    }     


 
    break;
   }
   else
   {        // el botón no está pulsado:
    digitalWrite(pinLed, LOW);  // Mantengo el led apagado

    digitalWrite(pinStep, LOW);
    digitalWrite(pinStep, HIGH);
    delayMicroseconds(micropausa);

   }
  }
}




void loop()
{
  for (int pos = 1; pos < haces; pos++) { // En una dirección digitalWrite(pinDirec, HIGH); // Establezco la dirección del motor digitalWrite(pinLaser, HIGH); // Enciendo el láser delayMicroseconds(micropausaLaser); // Dejo el láser encendido el tiempo micropausaLaser // Compruebo la célcula fotoeléctrica, y mando tocar/parar de tocar la nota correspondiente: if ( (analogRead(0) > sensor ) && ( noteStatus[pos] == 0 ))     // Si el sensor recibe señal, y la nota no está sonando
    {
      noteMIDI(0x90, notasMIDI[pos-1], 0x45); // Que se toque la nota por MIDI
      //tone(pinAudio,notas[pos-1]);  // Que se toque la nota por el piezo/auriculares
      digitalWrite(pinLed, HIGH); // Enciendo el Led de estado
      noteStatus[pos]++;  // Cambio el estado de esa nota a "sonando"
    }
    else if (analogRead(0) < sensor ) // Si el sensor no recibe señal { if (noteStatus[pos] >= 1) // Si hay una nota tocando (porque aún no la he apagado, aunque no haya señal)
      {
        //if (noteStatus[pos]++ == 2)   //Solo para de sonar si ya han pasado tres ciclos sin recibir señal...
        //{
          noteMIDI(0x90, notasMIDI[pos-1], 0x00);  // Parar de tocar la nota por MIDI
          //noTone(pinAudio);   // Parar de tocar la nota por el piezo/auriculares
          digitalWrite(pinLed, LOW);  // Apago el led de estado
          noteStatus[pos]=0;  // Cambio el estado de esa nota a "apagada"
        //}
      }
    }
    
    digitalWrite(pinLaser, LOW);      // Apago el láser   
    delayMicroseconds(micropausaSensor); // Antes de pasar al siguiente haz, pequeña pausa para reacción del sensor fotoeléctrico

    //Muevo el motor al siguiente haz:
    for (int pos2 = 0; pos2<pasosHaces; pos2++) // Avanzo un haz (el número de (micro)pasos definidos en la variable pasosHaces { digitalWrite(pinStep, LOW); digitalWrite(pinStep, HIGH); delayMicroseconds(micropausa); } } for (int pos = haces; pos > 1; pos--)
  { // En la otra dirección
    digitalWrite(pinDirec, LOW);	// Pongo el motor en el sentido contrario
    digitalWrite(pinLaser, HIGH);	// Enciendo el láser
    delayMicroseconds(micropausaLaser);	// Dejo el láser encendido el tiempo micropausaLaser
    
    // Compruebo la célcula fotoeléctrica, y mando tocar/parar de tocar la nota correspondiente:
    if ( (analogRead(0) > sensor ) && ( noteStatus[pos] == 0 ))     // Si el sensor recibe señal, y la nota no está sonando
    {
      noteMIDI(0x90, notasMIDI[pos-1], 0x45); // Que se toque la nota
      //tone(pinAudio,notas[pos-1]);  // Que se toque la nota por el piezo/auriculares
      digitalWrite(pinLed, HIGH); // Enciendo el Led de estado
      noteStatus[pos]++;  // Cambio el estado de esa nota a "sonando"
    }
    else if (analogRead(0) < sensor ) // Si el sensor no recibe señal { if (noteStatus[pos] >= 1) // Si hay una nota tocando (porque aún no la he apagado, aunque no haya señal)
      {
        //if (noteStatus[pos]++ == 2)   //Solo para de sonar si ya han pasado dos ciclos sin recibir señal...
        //{
          noteMIDI(0x90, notasMIDI[pos-1], 0x00);  // Parar de tocar la nota por MIDI
          //noTone(pinAudio);   // Parar de tocar la nota por el piezo/auriculares
          digitalWrite(pinLed, LOW);  // Apago el led de estado
          noteStatus[pos]=0;  // Cambio el estado de esa nota a "apagada"
        //}
      }
    }
    
    digitalWrite(pinLaser, LOW);      // Apago el láser   
    delayMicroseconds(micropausaSensor); // Antes de pasar al siguiente haz, pequeña pausa para reacción del sensor fotoeléctrico

    //Muevo el motor al siguiente haz:
    for (int pos2 = 0; pos2<pasosHaces; pos2++) // Avanzo un haz (el número de (micro)pasos definidos en la variable pasosHaces
    {
       digitalWrite(pinStep, LOW);
       digitalWrite(pinStep, HIGH);
       delayMicroseconds(micropausa);
    } 
  }
}



void noteMIDI(int cmd, int pitch, int velocity) {
  Serial.write(cmd);
  Serial.write(pitch);
  Serial.write(velocity);
}


Puede descargarse aquí.

 

Pruebas iniciales y montaje

img_1751

 

Detalles

img_2417

img_2418

img_2419

img_2420

img_2421img_2422

img_2423

img_2424

Referencias

http://www.instructables.com/id/Frameless-Laser-Harp/

http://www.instructables.com/id/Easy-and-cheap-Laser-Harp/

http://open-source-energy.org/?topic=1129.0

http://hacknmod.com/hack/create-techno-with-a-laser-harp/

https://gist.github.com/mlorenz92/9775363

http://thecreatorsproject.vice.com/blog/make-peaches-laser-harp-how-to

http://harplaser.blogspot.com.es/

http://laserharpseniorproject.blogspot.com.es/2015/05/tutorial-parts-and-setup.html