Bootstrap Framework 3.3.6

Hola a todos, he visto que siempre es útil un circuito que encienda las luces, o lo que nos apetezca, como si fuese un interruptor electrónico pero decidiendo nosotros el punto exacto de conmutación, también pongo este post porque la electrónica que he comprado de alarma de perdida de señal no me gusta como reacciona, con este no hay qu esperar un minuto y medio o estar todo el rato tocando el joystick porque pita sin sentido cada dos por tres.
He usado un Arduino mini, por razones de peso y de espacio, y le he programado, a partir de un canal de la emisora, varias funciones, que no es necesario usar a la vez, aunque puede hacerse sin problema, estas son las siguientes:
Salida regulada de 0 a 100% en PWM, para controlar la luminosidad de una luz, la velocidad de un motor o lo que se os ocurra.
Salida nº 1, salida on/off pensada para encender las luces de posición, pensada originalmente para un barco, pero que se puede usar para otro tipo de aparato, su función original es simple, se enciende a partir de un punto desde un potenciómetro de la emisora, ojo, también se enciende si hay alarma de pérdida de señal.
Salida nº 2, salida on/off pensada para encender luces interiores del barco, tras haber encendido las luces de posición, se enciende en una posición mas avanzada del mismo potenciómetro, se apaga girando en sentido contrario, es simple
Salida de alarma, esta se conecta a los led rojos de alarma del barco, los enciende de manera intermitente cada vez que se queda sin señal de la emisora, al tirmpo que conecta de forma fija la salida nº1 o luces de posición y hace sonar un beeper, (salida nº , para poder buscar el modelo siguiendo el sonido.
No está acabado, de momento me cuesta mucho ponerme con ello, cuando esté bien de la vista intentare acabarlo, si alguien tiene ideas o sugerencias serán bien recibidas.

Este es el código a programar en el Arduino Mini:

/*Lee entrada desde un receptor de RC y regula la luz de un led, la velocidad de un motor o lo que se conecte a esta salida en función de la señal de uno de los potenciometros de la emisora, el potenciometro tambien puede ser uno de los joystick,
si se usa en un canal del receptor controlada por un interruptor de la emisora, obviamente no hay regulación, sino salidas todo o nada, tanto la que está regulada como las que conmutan on/off.
La luz nº 1, es decir, la salida 12 está pensada como luces de posición, si salta la alarma se encienden fijas tambien.
Es independiente de si el canal del receptor está conectado a un potenciometro o a un interruptor para dar la señal de perdida del modelo o de emisora apagada.
si la emisora está apagada o si el modelo está fuera del alcance de la radio, empieza a emitir una señal sonora por el altavoz, en forma de pitidos intermitentes y tambien pone intermitentes las luces conectadas a la salida nº 11.
todo esto con un solo canal, para mas canales es sencillo replicar el mismo programa.

Este codigo puede ser usado o modificado libremente

Jose Mª Escrich
*/


int rcPinA = 5; //Entrada desde el receptor TDP
int Speaker = 8; //Altavoz para señalizar modelo perdido en pin 8
int ledPin = 10; //Salida regulada
int errorled = 11; //Led de perdida de señal
int ledPin12 = 12; //Señal que se conmuta ON u OFF (1), usada como luces de posición
int ledPin13 = 13; //Señal que se conmuta ON u OFF (2), usada como luz interior
int servolimitLow = 1100; //Limite inferior para entrada desde receptor
int servolimitHigh = 1900; //Limite superior para entrada desde receptor
int CorteInterruptor1 = 1400; //Posición a partir de la que encendemos la luz fija 1
int CorteInterruptor2 = 1700; //Posición a partir de la que encendemos la luz fija 2
bool ErrorSignal = HIGH; //Señal de perdida del modelo
bool errorledout = LOW; //Variable para el led intermitente

// Variables usadas para generar intermitencia
int intermitencia = LOW; // señal que cambia de estado para usar como intermitente
unsigned long anteriorMillis = 0; // guarda el valor del tiempo del ultimo cambio
const long intervalo = 500; // intervalo para intermitencia en milisegundos

void setup()
{
pinMode(rcPinA, INPUT); //Entrada desde el receptor TDP
pinMode(ledPin, OUTPUT); //Salida regulada
pinMode(errorled, OUTPUT); //Led de perdida de señal
pinMode(ledPin12, OUTPUT); //Señal que se conmuta ON u OFF (1)
pinMode(ledPin13, OUTPUT); //Señal que se conmuta ON u OFF (2)
Serial.begin(9600);
}

void loop()
{

Intermitencias();//Llamada a la rutina que genera la señal intermitente

//int inputState = pulseIn(rcPinA, HIGH, 25000); //Lectura del pulso de entrada con timeout
int inputState = pulseIn(rcPinA, HIGH); //Lectura del pulso de entrada sin timeout

Serial.println(inputState);

//error aqui
if (inputState == 0)ErrorSignal = HIGH; //Si la señal es cero, hemos perdido la cobertura o la emisora está apagada
else
{
ErrorSignal = LOW;
}
if (ErrorSignal == HIGH)EmisoraApagada(); //Si no tenemos señal de emisora vamos a la rutina de Emisora Apagada

//****************************************************************************************************************************
//Encendido del led de error //Si no tenemos señal de emisora encendemos intermitentes las señales luminosas de perdida
if (ErrorSignal == HIGH && intermitencia == HIGH){
errorledout = HIGH;
tone(Speaker, 2400, 150);//Señal de alarma
}
else
errorledout = LOW;
digitalWrite (errorled, errorledout); //Activación de la salida de perdida de señal de emisora

//****************************************************************************************************************************
if (inputState < servolimitLow)inputState = servolimitLow; //Vigilamos los limites de la señal de entrada y los ajustamos si están fuera de rango
if (inputState > servolimitHigh)inputState = servolimitHigh;

//****************************************************************************************************************************
//Encendemos progresivamente las luces conectadas a esta entrada en función de la posicion del Joystick o potenciometro de la emisora
int ledBright = map(inputState, servolimitLow, servolimitHigh, 0, 255);
analogWrite(ledPin, ledBright);

//****************************************************************************************************************************
//Encendemos las luces conectadas a esta entrada si la posicion del Joystick o potenciometro de la emisora son mayores del valor establecido por nosotros para encender

if (inputState > CorteInterruptor1 || ErrorSignal) { //Luces de posición, si se enciende el led de error tambien se encienden las luces de posición
digitalWrite(ledPin12, HIGH);
Serial.println("Led uno encendido");
}
else
{
digitalWrite(ledPin12, LOW);
}

if (inputState > CorteInterruptor2) {
digitalWrite(ledPin13, HIGH);
Serial.println("Led dos encendido");
}
else
{
digitalWrite(ledPin13, LOW);
}

//****************************************************************************************************************************
delay (100); //Retardo para evitar parpadeos en las salidas

}

//#####################################################################################################
//*****************************************************************************************************
void EmisoraApagada() // Estado de alarma si se apaga la emisora o estamos fuera del radio de acción
{
Serial.println("Emergencia activada");
/*

//Generación señal Morse con SOS, a rehacer para que los retardos no influyan en la luz intermitente
int espacio = 400;
int tono = 2400;
int punto = 80;
int raya = 250;

tone(Speaker, tono, punto); //punto
delay (espacio);
tone(Speaker, tono, punto); //punto
delay (espacio);
tone(Speaker, tono, punto); //punto
delay (espacio);
tone(Speaker, tono, raya); //raya
delay (espacio);
tone(Speaker, tono, raya); //raya
delay (espacio);
tone(Speaker, tono, raya); //raya
delay (espacio);
tone(Speaker, tono, punto); //punto
delay (espacio);
tone(Speaker, tono, punto); //punto
delay (espacio);
tone(Speaker, tono, punto); //punto
delay (espacio);

*/
}
//#####################################################################################################
//*****************************************************************************************************
//Rutina que genera la señal intermitente para ser usada donde haga falta
void Intermitencias()
{
// Generación de señal intermitente

unsigned long actualMillis = millis();

if (actualMillis - anteriorMillis >= intervalo) {
// guarda el momento en que se produjo el ultimo cambio
anteriorMillis = actualMillis;
// Si la señal está a uno la pone a cero, si está a cero la pone a uno
if (intermitencia == LOW)
intermitencia = HIGH;
else
intermitencia = LOW;
}
}

Esta muy bien, yo acabo de afinar el programa de luces de un avión, beacon, strobes , navegación, rodadura etc. basándome por supuesto en un hilo de rcgroups y te diré lo que he encontrado durante la puesta a punto.

Los valores del pulso el arduino los calcula a su modo, a mi me da valores entre 1300 y 2400 con un comprobador de servos o con una emisora Futaba, tengo que probar con una Taranis que informa del valor del puso de cada canal para comparar con las lecturas del arduino.
Es práctico incorporar una rutina de debug, que saque todos los valores de las variables significativas al terminal.
Luego anivel de hard no tengo claro como resolver mejor la etapa de potencia, yo he colocado de momento un integrado de 7 darlintongs, que tu conoceras mejor que yo, para poder encender leds de al menos 1W, si no me soporta la carga colocare esos reguladores que aconsejaste en un hilo anterior, al menos para alguna de las salidas, de momento tengo siete luces diferentes.

Hola Juan, estoy bastante de acuerdo en lo que dices, por eso todos los valores van en variables, para poderlos adaptar a los valores que tengas en tu receptor, los valores que yo estuve viendo, además de leer lo que te da el Arduino, los estuve comprobando con un osciloscopio, debo tener todos apuntados por ahí, lo que leia en cada canal, rango de cada uno, etc, tambien vi en su dia el ruido que generaba la conmutacion del motor y aproveché para poner un "enchufable" de condensadores en paralelo con la alimentación en el mismo receptor, parece que los picos bajan bastante.

La rutina de debug está, lo que pasa es que una vez que lo pongo operativo voy quitando las ordenes de imprimir en pantalla, porque lo unico que hacen es consumir tiempo de ciclo, verás que hay alguna de esas instrucciones entre el programa, pero en la versión mas moderna, que la he encontrado hoy, y que ya tiene el Morse reparado, están todas como comentarios, para que no se compilen.

Una cosa que estuve pensando es poner sensores de temperatura, etc., y mandar esa información por Bluetooth, además de toda la información de debug, de esa manera estando cerca del cacharro puedes ver en el movil que es lo que pasa dentro, ya que verías todas las variables que quieras en la pantalla del movil, eso estoy tentado en hacerklo en un futuro proximo, pero mas por cacharrear que por necesidad.

Si los darlington que has usado son del tipo ULN2008 o ULN2809, o alguno de esa familia, eso es lo mejor que han inventado, aguantan lo que les eches, los he usado para diferentes cosas durante años y son super fiables, no creo que te den guerra.

La mayor ventaja que tiene este montaje, al tener un Arduino, aunque sea este tan enano, es que puedes hacer mezclas tomando señales externas y sobre todo, para mi gusto, el manejo de la perdida de señal de la emisora, que los chismes que venden por ahi no me acaban de convencer.

Muchisimas gracias Juan por tus acertados comentarios, si te puedo ayudar en algo especifico no dudes en preguntarme, seguro que se menos que tu, pero hay veces que suena la flauta y va y funciona.

Saludos:

JME

Estoy usando el ULM 2003.
Te envio el programita , la forma en que simula la luz giratoria es curiosa y muy aprovechable, otra picardia que utiliza el autor es desfasar las luces estroboscópicas para conseguir un efecto muy real.
En cuanto a la rutina de debug, si la condicionas ocupa memoria, que está prácticamente vacía, pero no procesador y es más cómoda de manejar.
Se puede probar solo conectando el arduino ya que el terminal te da el estado de las luces en cada momento.

Hola Juan, el array que usas es correcto, no debe darte guerra.
En cuanto al programa, es la leche, está super currado, super trabajado, hay montones de horas preparandolo para que además de funcionar quede bonito, es un buen trabajo, lo de poner la parte de debug en otro lado y ejecutarla en funcion de tus preferencias, me ha gustado, me lo apunto.
Los efectos luminosos, cuando pueda me gustaría verlos funcionar, ya te digo que a estos valores han llegado despues de muchas horas de trabajo, de pruebas, etc., y no merece la pena desaprovecharlos.

Gracias por tu información.

Saludos:
JME

https://youtu.be/UCRc78UIGgM
[youtube]https://youtu.be/UCRc78UIGgM[/youtube]

Muy chulo el efecto, tenías razón.

Muy logrado el efecto

Hola buenas.

Me alegra ver que poco a poco se va introduciendo la "auto-electrónica" en especial basada en Arduino a los modelos. No todo es comprarlo y ponerlo, sino auto-construirlo, que da mas orgullo sobre el propio modelo.

Quería comentar a lo que dice Juan con respecto a los valores del servo, a mí, con un nano y emisora FF9 convertida a 2,4 con FrSky tengo unos valores de 1108 a 1936 dejando las curvas de la emisora al 100% en ambos lados.

También comentar que existen unos transistores MosFET que dan una gran capacidad de carga, con una resistencia interna muy baja y su tamaño puede ser mínimo (algunos casos SMD).

Saludos y buena práctica.

Hola Órbita, yo tengo la costumbre de hacerme toda la electrónica que uso, aunque últimamente los precios me hacen comprar cosas en lugar de construirlas, si te puedo ayudar dímelo, si no se contestarte, seguro que acabamos encontrando respuestas, si necesitas los valores que da mi emisora en las salidas de servo te los puedo dar, aunque al final, si uso algún controlador de Atmel uso el comando Constrain para asignar el máximo y el mínimo y evitar errores y me va bien, en interruptores controlados por la emisora y cosas así, a veces con un Potenciometro y estas configuraciones , lo uso como un interruptor rotativo, con, por ejemplo, seis posiciones y dispositivos similares, además de dar la alarma de pérdida de emisora en cuanto la lectura del comando Pulsein es igual a cero, he enredado bastante con los servos, la emisora y los controladores de Atmel

Gracias Escrich.

De momento estoy con dos asuntos y uno lo tengo casi a punto. Me encontré un mini helicóptero coaxial encima de un contenedor y tenia el receptor roto. Como no estaba la emisora y era de 27MHz, le he quitado la electrónica y le he hecho la mía con un receptor de 2,4. De momento responde bien encima de la cama , a ver si lo saco a un sitio tranquilo y lo pruebo.

El otro proyecto es usar la telemetria para recibir datos del modelo a la emisora. Como ya recibe los datos de la tensión que tiene el propio receptor (gracias a los donantes de software ) ahora toca enviar los comandos serie para poder recibir lo que quiera en la emisora.

Te tomo la palabra y si necesito algo te lo digo.

P.D.: Por cierto, trabajo en Arganda

Saludos.

Qué pequeño es el mundo