Librería simplex.h

[fmco]

Muchas veces queremos añadir algún elemento a nuestras maquetas con algún tipo de efecto o pequeña automatización y consultando con nuestros amigos como implementarlo siempre hay alguien que dice: “Eso con Arduino es más sencillo de hacer!”.

Puede ser más sencillo pero tiene el pequeño inconveniente que hay que aprender a programar en lenguaje Arduino para sacar provecho de todo su potencial.

Os presento simplex.h una librería para Arduino para realizar animaciones y algo más en nuestras maquetas con comandos simples y compatibles con la programación tradicional del lenguaje Arduino.

https://github.com/fmcopaco/simplex

[fmco]

1. Introducción a simplex.h

simplex.h es una librería para Arduino que aprovechando la potencia del preprocesador del lenguaje Arduino proporciona comandos simples para automatizar nuestras maquetas y es plenamente integrable con el lenguaje Arduino.

La librería permite dar un nombre (SET_NAME) y definir los pines de Arduino como salidas simples (PIN_OUT) por ejemplo para usar relés o LED que se pueden activar normalmente o de forma invertida, o que pueden parpadear. Para activarlos se usa SET y para desactivarlos RESET.

También se pueden definir como salidas para LED con efectos de iluminación (PIN_EFFECT) (encendido/apagado lento, soldadura, fluorescentes,…) o por impulsos (PIN_COIL) para activar las bobinas de los desvíos o para controlar servos (PIN_SERVO).

Los pines también se pueden definir como entradas (PIN_INPUT) para señales digitales o para botones (PIN_BUTTON) o sensores (PIN_SENSOR).
Podemos definir esperas (WAIT) y algunos temporizadores (SET_TIMER) así como repetir acciones (REPEAT) y llamar (CALL) a funciones (FUNCTION) que realizarán más acciones.

Se puede definir de forma simple un maquina de estados finitos (FSM_STATE) y cambiar entre estados (FSM_GO).

Añadiendo el hardware adecuado podemos realizar un decodificador de accesorios que realice acciones al cambiar un accesorio a verde (DCC_ACC_GREEN) o a rojo (DCC_ACC_RED).

Para usar la librería sólo hay que copiar los archivos simplex.h y simplex.cpp al directorio donde se encuentra vuestro sketch, incluir la librería y en el loop() poner RUN_SIMPLEX al inicio:



Otra opción es descargar esta librería como archivo .zip y añadirla en el Arduino IDE desde el menú Programa -> Incluir Librería -> Añadir biblioteca .ZIP ..., además también estarán disponibles los ejemplos en el menú Archivo y no necesitareis copiar los archivos simplex.h y simplex.cpp al directorio donde se encuentra vuestro sketch.

La librería la podéis descargar desde Github:
https://github.com/fmcopaco/simplex

[fmco]

2. El perrito

Alfred tiene en su módulo un perrito que al accionar el público un pulsador sale de su caseta y ladra. El perrito se mueve con la ayuda de un servo y el ladrido lo consigue con un módulo con el sonido pregrabado que se activa al dar un pulso en una entrada. En su día lo hizo usando mi decodificador KDaktion (https://usuaris.tinet.cat/fmco/dccacc_sp.html#kdaktion).

Aquí tenéis el hilo: https://www.ctms1.com/forum/viewtopic.php?t=4544



Con la librería simplex.h sería así:

Código: Seleccionar todo

#include "simplex.h"        // Librería de acciones simples de Paco Cañada 2025

                            // Define los nombres aquí
SET_NAME(PERRITO, 11)               // Nombre para el pin del servo
SET_NAME(PULSADOR, 10)              // Nombre para el pin del pulsador
SET_NAME(SONIDO, 9)                 // Nombre para el pin del módulo de sonido
SET_NAME(LED, 13)                   // Nombre para el pin del LED

void setup() {
                           // Define los pines aquí
  PIN_SERVO(PERRITO)                // servo que mueve el perrito
  PIN_TIME(PERRITO, 80)             // velocidad del servo
  PIN_BUTTON(PULSADOR)              // pulsador del publico
  PIN_COIL(SONIDO)                  // salida impulso para modulo sonido
  PIN_TIME(SONIDO, 500)             // tiempo del pulso para modulo de sonido
  PIN_OUT(LED)                      // LED para el publico
                           // Estado inicial
  RESET(SONIDO)                     // no activar sonido
  SET(LED)                          // enciende LED para indicar listo
  SERVO(PERRITO, 0)                 // mover el perrito a la caseta
}

void loop() {
  RUN_SIMPLEX                       // Run Simplex debe estar al principio

  PRESSED(PULSADOR) {               // Cuando se pulse el botón
    PIN_MODE(LED, FLASH)            // parpadeo del LED para indicar ocupado
    SERVO(PERRITO, 100)             // mover el perrito fuera de la caseta
    WAIT_SERVO(PERRITO)             // esperar a que llegue
    SET(SONIDO)                     // activar el ladrido
    WAIT(6000)                      // esperar 6 segundos
    SERVO(PERRITO, 0)               // mover el perrito a la caseta
    WAIT_SERVO(PERRITO)             // esperar a que llegue
    WAIT(10000)                     // esperar 10 segundos para otros espectadores
    PIN_MODE(LED, NORMAL)           // modo LED fijo
    SET(LED)                        // enciende LED para indicar listo
  }
}

[fmco]

3. El Almacén

En mi módulo del Almacén de la estación del Carrilet de Salou he colocado dentro una carretilla con un pequeño imán que se mueve mediante un mecanismo accionado por dos servos para obtener movimiento en el eje X y en el eje Y. Al pulsar el botón se enciende la luz del almacén y aparece la carretilla dese el fondo, luego se mueve la grúa del muelle de carga para mover una carga al vagón





Como en el ejemplo anterior aquí movemos los servos con SERVO y variamos su velocidad con PIN_TIME, si queremos movimientos rectos usamos WAIT_SERVO, sino serán movimientos en diagonal.

Código: Seleccionar todo

#include "simplex.h"           // Simple actions library. Paco Cañada 2025

                                    // Define los nombres aquí
SET_NAME(CARRETILLA_X, 5)
SET_NAME(CARRETILLA_Y, 6)
SET_NAME(GRUA,         9)
SET_NAME(PULSADOR,    A4)
SET_NAME(LUZ,         A5)
SET_NAME(LED,          2)

void setup() {
                                    // Define los pines aquí
  PIN_OUT(LUZ)        
  PIN_OUT(LED)
  PIN_BUTTON(PULSADOR)
  PIN_SERVO(CARRETILLA_X)
  PIN_SERVO(CARRETILLA_Y)
  PIN_SERVO(GRUA)
  PIN_TIME(CARRETILLA_Y, 60)
  PIN_TIME(GRUA, 80)
                                    // Estado inicial
  RESET(LUZ)
  SET(LED)
  SERVO(CARRETILLA_X, 90)
  SERVO(CARRETILLA_Y, 90)
  SERVO(GRUA, 135)
}

void loop() {
  RUN_SIMPLEX                       // Run Simplex debe estar al principio

  PRESSED(PULSADOR) {               // Cuando se pulse el botón
    PIN_MODE(LED, FLASH)            // parpadeo del LED para indicar ocupado
    SET(LUZ)                        // encender luz del almacén 
    WAIT(2000)
    SERVO(CARRETILLA_Y, 60)         // mover la carretilla
    WAIT_SERVO(CARRETILLA_Y)
    PIN_TIME(CARRETILLA_X, 60)
    SERVO(CARRETILLA_X, 10)
    WAIT_SERVO(CARRETILLA_X)
    WAIT(2000)                     
    SERVO(GRUA, 150)                // mover grúa a recoger carga
    WAIT_SERVO(GRUA)
    WAIT(1500)
    SERVO(GRUA, 35)                 // mover carga al vagón
    WAIT_SERVO(GRUA)
    WAIT(2500)
    SERVO(GRUA, 135)                // mover grúa a posición inicial
    WAIT_SERVO(GRUA)
    WAIT(3000)                     
    PIN_TIME(CARRETILLA_X, 30)      // mover carretilla a posición inicial
    SERVO(CARRETILLA_X, 90)
    SERVO(CARRETILLA_Y, 90)
    WAIT_SERVO(CARRETILLA_Y)
    RESET(LUZ)
    WAIT(5000)                      // esperar 5 segundos para espectadores
    PIN_MODE(LED, NORMAL)           // modo LED fijo
    SET(LED)                        // enciende LED para indicar listo
  }
}

[fmco]

4. Ermita

Otra animación que Alfred tiene en sus módulos es una ermita con una campana funcional que al pulsar el público un botón se enciende la luz de la ermita, la campana se mueve con un servo y suena gracias a un módulo de sonido, al acabar las campanadas se enciende una vela en la capilla y después de un tiempo se apagan todas las luces. Como principiante en programación en lenguaje Arduino fue una tarea ardua ya que no tenía a su disposición la librería simplex.h.

Aquí tenéis el hilo: https://www.ctms1.com/forum/viewtopic.php?t=4262



Esta animación igual que las anteriores espera a que se pulse el botón, hace parpadear el LED del público y enciende la luz de la ermita, espera un tiempo y activa el sonido de la campana y la mueve. En este caso para activar el sonido lo hace activando la entrada del módulo de sonido través de un opto conectado a una salida del Arduino.

Para mover la campana repite 6 veces el movimiento del servo de un extremo a otro de la campana. REPEAT repetirá las veces indicadas las acciones que hay entre las { } finalmente volvemos a dejar la campana colgando.

Luego enciende la vela, esta salida la hemos definido como PIN_EFFECT y le hemos asignado el efecto CANDLE con PIN_MODE con lo que la librería simplex.h hará el efecto de luz temblorosa como una vela en esta salida. Estos son los efectos que se pueden conseguir con simplex.h

Efecto	Descripción
DIMMER	Encendido / apagado lento
FLASH	Parpadeo con encendido/apagado lento
CANDLE	Vela
FIRE	Fuego
FLUORESCENT	Luz fluorescente
WELDING	Soldadura

Código: Seleccionar todo

#include "simplex.h"        // Librería de acciones simples de Paco Cañada 2025

                            // Define los nombres aquí
SET_NAME(CAMPANA, 6)                // Nombre para el pin del servo
SET_NAME(PULSADOR, 3)               // Nombre para el pin del pulsador
SET_NAME(VELA, 4)                   // Nombre para el pin del LED amarillo
SET_NAME(LUZ, 5)                    // Nombre para el pin del LED blanco
SET_NAME(SONIDO, 9)                 // Nombre para el pin del módulo de sonido
SET_NAME(LED, 8)                    // Nombre para el pin del LED verde público

void setup() {
                           // Define los pines aquí
  PIN_SERVO(CAMPANA)                // servo que mueve la campana
  PIN_TIME(CAMPANA, 20)             // velocidad del servo
  PIN_BUTTON(PULSADOR)              // pulsador del publico
  PIN_COIL(SONIDO)                  // salida impulso para modulo sonido
  PIN_TIME(SONIDO, 500)             // tiempo del pulso para modulo de sonido
  PIN_OUT(LED)                      // LED verde para el publico
  PIN_OUT(LUZ)                      // LED blanco luz ermita
  PIN_EFFECT(VELA)                  // LED amarillo vela
  PIN_MODE(VELA, CANDLE)            // Efecto de vela
                          // Define el estado inicial aquí
  RESET(SONIDO)                     // no activar sonido
  SET(LED)                          // enciende LED para indicar listo
  SERVO(CAMPANA, 80)                // campana colgando
}

void loop() {
  RUN_SIMPLEX                       // Run Simplex debe estar al principio

  PRESSED(PULSADOR) {               // Cuando se pulse el botón
    PIN_MODE(LED, FLASH)            // hacer parpadear el LED para indicar ocupado
    SET(LUZ)                        // enciende luz de la ermita
    WAIT(2000)                      // espera al capellan
    SET(SONIDO)                     // activar el sonido
    REPEAT(6) {                     // repetir 6 veces
      SERVO(CAMPANA, 140)           // mover campana a un extremo
      WAIT_SERVO(CAMPANA)           // esperar a que llegue
      SERVO(CAMPANA, 20)            // mover campana al otro extremo
      WAIT_SERVO(CAMPANA)           // esperar a que llegue
    }
    SERVO(CAMPANA, 80)              // campana colgando
    SET(VELA)                       // enciende vela
    WAIT(5000)                      // espera 5 segundos
    RESET(VELA)                     // apaga vela
    RESET(LUZ)                      // apaga luz
    PIN_MODE(LED, NORMAL)           // modo LED fijo
    SET(LED)                        // enciende LED para indicar listo
  }
}

[raulm]

Enhorabuena Paco, una librería muy útil que simplifica mucho las cosas para este tipo de acciones y animaciones en la maqueta.

Muchas gracias por tu aportación.

Saludos,
Raúl.

[gon]

Muchas gracias Paco.


Un saludo

[sls_h0e]

Hola

Como siempre, expectacular!!

Gracias por compartir Paco

Saludos

[fmco]

hola,

todavía estoy practicando con GitHub, tengo fallos de principiante como de tener varias versiones para ponerlo luego en el directorio compartido y luego encontrar errores de corta/pega pero ya le voy pillando el tranquillo.

Una idea inicial que tengo en una versión de test pero que aun no he añadido a la rama actual es el interface Xpressnet. En principio quería poner XNET_SET_RED(n) y XNET_SET_GREEN(n) para mover un accesorio pero con los RS tengo dudas por su complejidad de decodificar para el estilo de la librería y tampoco sé si seria útil el control de locomotora o ya seria complicar mucho la sencillez de la librería.

Para Loconet el problema es que usa el Timer1 e interfiere con los servos, además la decodificación ocupa mucho.

saludos,

Paco

[fmco]

hola,

he actualizado la librería con comandos Xpressnet y añadido el efecto PWM para controlar la intensidad de un LED o velocidad de un motor de contínua.


8. Pequeño TCO Xpressnet

Con la librería simplex.h es bastante fácil realizar un TCO (Tablero de Control Óptico) para el bus Xpressnet. Necesitaremos un circuito con el MAX485 como interface que se conecta a TX, RX y A3:


Nuestro TCO tendrá cuatro pulsadores para mover los desvíos 1 al 4 y LEDs de color rojo y verde para cada desvío para mostrar la posición. Cuando pulsemos un botón se enviará la orden por Xpressnet para cambiar la posición del desvío. Para usar el interface Xpressnet con simplex.h tenemos que añadir XNET_ADDR en el setup() con la dirección del bus de nuestro TCO entre 1 y 31 que no coincida con la de otro dispositivo conectado al bus.

Código: Seleccionar todo

#include "simplex.h"   // Librería de acciones simples de Paco Cañada 2025

                            // Define los nombres aquí
SET_NAME(PULSADOR1, 2)
SET_NAME(PULSADOR2, 3)
SET_NAME(PULSADOR3, 4)
SET_NAME(PULSADOR4, 5)

SET_NAME(ROJO1, 6)
SET_NAME(VERDE1, 7)
SET_NAME(ROJO2, 8)
SET_NAME(VERDE2, 9)
SET_NAME(ROJO3, 10)
SET_NAME(VERDE3, 11)
SET_NAME(ROJO4, 12)
SET_NAME(VERDE4, 13)

                            // Define los estados aquí

                            // Define las variables aquí

                            // Define funciones adicionales aquí

Código: Seleccionar todo

void setup() {
                            // Define los pines aquí
  PIN_OUT(ROJO1)
  PIN_OUT(VERDE1)
  PIN_OUT(ROJO2)
  PIN_OUT(VERDE3)
  PIN_OUT(ROJO3)
  PIN_OUT(VERDE3)
  PIN_OUT(ROJO4)
  PIN_OUT(VERDE4)
  PIN_BUTTON(PULSADOR1)
  PIN_BUTTON(PULSADOR2)
  PIN_BUTTON(PULSADOR3)
  PIN_BUTTON(PULSADOR4)

  XNET_ADDR(5)             // Dirección del dispositivo en el bus Xpressnet

                           // Define el estado inicial aquí
}

En el loop() cuando se pulse un botón con PRESSED mandamos la orden de cambiar la posición del desvío correspondiente con XNET_TOGGLE y esperamos a soltar el botón con WAIT_RELEASE para que no vaya cambiando la posición del desvío continuamente.
Con un solo botón no sabríamos a priori la posición en la que está para encender o apagar los LED correspondientes pero la central nos informará del cambio de posición del desvío tanto si lo movemos nosotros como si se mueve desde otro mando mediante la retro señalización por lo que consultamos la retro señalización RS correspondiente a cada desvío con XNET_ACTIVE para encender o apagar el LED de cada posición.

Código: Seleccionar todo

void loop() {
  RUN_SIMPLEX               // Run Simplex debe estar al principio

  PRESSED(PULSADOR1) {
    XNET_TOGGLE(1)          // Cambia desvío numero 1
    WAIT_RELEASE(PULSADOR1)
  }
  PRESSED(PULSADOR2) {
    XNET_TOGGLE(2)          // Cambia desvío numero 2
    WAIT_RELEASE(PULSADOR2)
  }
  PRESSED(PULSADOR3) {
    XNET_TOGGLE(3)          // Cambia desvío numero 3
    WAIT_RELEASE(PULSADOR3)
  }
  PRESSED(PULSADOR4) {
    XNET_TOGGLE(4)          // Cambia desvío numero 4
    WAIT_RELEASE(PULSADOR4)
  }

  XNET_ACTIVE(1, 1) {       // Modulo RS 1, entradas 1 y 2 corresponden al desvío numero 1
    SET(ROJO1)
    RESET(VERDE1)
  }
  XNET_ACTIVE(1, 2) {
    RESET(ROJO1)
    SET(VERDE1)
  }
  XNET_ACTIVE(1, 3) {       // Modulo RS 1, entradas 3 y 4 corresponden al desvío numero 2
    SET(ROJO2)
    RESET(VERDE2)
  }
  XNET_ACTIVE(1, 4) {
    RESET(ROJO2)
    SET(VERDE2)
  }
  XNET_ACTIVE(1, 5) {       // Modulo RS 1, entradas 5 y 6 corresponden al desvío numero 3
    SET(ROJO3)
    RESET(VERDE3)
  }
  XNET_ACTIVE(1, 6) {
    RESET(ROJO3)
    SET(VERDE3)
  }
  XNET_ACTIVE(1, 7) {       // Modulo RS 1, entradas 7 y 8 corresponden al desvío numero 4
    SET(ROJO4)
    RESET(VERDE4)
  }
  XNET_ACTIVE(1, 8) {
    RESET(ROJO4)
    SET(VERDE4)
  }
}

saludos,

Paco

[Alfred]

Estoy preparando nuevos módulos/espectaculo que me irá de perlas!!!!!

[fmco]

hola,

actualizada la librería para controlar motores paso a paso.

9. Motores paso a paso

Con la librería simplex.h también se pueden controlar motores paso a paso unipolares tipo 28BYJ-48 o bipolar tipo NEMA con el controlador adecuado.
Para usar los unipolares necesitamos 4 pines consecutivos para controlarlos y en PIN_STEPPER4 indicamos el primer pin, para los bipolares necesitamos 2 pines consecutivos para controlarlos y en PIN_STEPPER2 indicamos el primer pin que es la señal STEP, el siguiente pin corresponde a la señal DIR en caso de usar un driver A4988 o similar.

Para su control con STEPPER_SET indicamos el paso actual (posición), por defecto es el paso 0. Luego con STEPPER_GO podemos mover el motor al paso especificado (posición absoluta). Si lo que queremos es movernos desde el paso actual (posición relativa) usaremos STEPPER_CW para movernos la cantidad de pasos indicada en sentido horario y STEPPER_CCW para movernos en sentido anti horario.

Con WAIT_STEPPER podemos esperar a que el motor paso a paso llegue a la posición indicada, la velocidad se puede cambiar con PIN_TIME, cuanto más bajo más rápido se moverá.

Los populares 28BYJ-48 en montajes de Arduino usan un controlador simple con un ULN2003 y se controlan con 4 cables. Son de 32 pasos y una reducción de un factor de 64 lo que da un total de 2048 pasos por vuelta, se suelen encontrar para tensiones de 5V y de 12V.

Estos motores se pueden controlar en pasos completos o también con medios pasos con lo que tendremos 4096 pasos por vuelta a costa de perder algo de fuerza. Para usar un modo u otro usamos PIN_MODE con el valor FULL_STEP para pasos completos (por defecto) o HALF_STEP para medios pasos.

Código: Seleccionar todo

#include "simplex.h" // Librería de acciones simples de Paco Cañada 2025

SET_NAME(MOTOR, 9) // 4 pins: 9, 10, 11, 12

void setup() {
PIN_STEPPER4(MOTOR)
PIN_TIME(MOTOR, 5)
PIN_MODE(MOTOR, FULL_STEP)
STEPPER_CW(MOTOR, 2048) // una vuelta completa
WAIT_STEPPER(MOTOR)
WAIT(100)
STEPPER_CCW(MOTOR, 2048)
WAIT_STEPPER(MOTOR)
}

void loop() {
RUN_SIMPLEX
}

Los motores paso a paso bipolares tipo NEMA, normalmente utilizados en impresoras 3D, necesitan un driver para controlarlos, hay diferentes tipos A4988, DRV8825, etc. que permiten usarlos con solo dos pines, STEP para mover un paso y DIR para indicar el sentido de movimiento, según el cableado puede haber un pin ENABLE para activar o desactivar las bobinas del motor. También tienen unas entradas, normalmente conectadas a unos interruptores DIP, para seleccionar si se mueve a pasos completos, medios pasos y hasta dieciseisavos de paso. Tienen un potenciómetro para regular la corriente que les llega a las bobinas, si es demasiado baja perderá pasos y si es demasiado alta se calentará el motor. Por suerte existen diferentes placas donde pinchar estos controladores con todo lo necesario.

Con STEPPER2 podemos seleccionar, dos modos de funcionamiento en PIN_MODE, el modo DRIVER (por defecto) para los drivers tipo A4988, DRV8825, etc. y el modo FULL_STEP para otro tipo de control.

Código: Seleccionar todo

#include "simplex.h" // Librería de acciones simples de Paco Cañada 2025

SET_NAME(MOTOR, 2) // 2 pins, STEP: 2, DIR: 3
SET_NAME(ENABLE, 4) // opcional, según driver

void setup() {
PIN_OUT(ENABLE)
PIN_STEPPER2(MOTOR)
PIN_TIME(MOTOR, 5)
PIN_MODE(MOTOR, DRIVER)
RESET(ENABLE) // según driver, activar motor
STEPPER_CW(MOTOR, 200) // una vuelta completa
WAIT_STEPPER(MOTOR)
WAIT(100)
STEPPER_CCW(MOTOR, 200)
WAIT_STEPPER(MOTOR)
SET(ENABLE) // opcional, desactivar motor
}

void loop() {
RUN_SIMPLEX // Run Simplex debe estar al principio
}

saludos,

Paco