Felix Maocho

Para quien le interese lo que a nosotros nos interesa

1º Ejercicio de uso de pines de entrada analógica – Linterna multiuso con potenciómetro

Por Félix Maocho
27/4/2017

Conocimientos que se precisan

Para realizar este ejercicio tal como aquí se resuelve solo se necesitan los conocimientos que se han ido explicando hasta el capítulo dedicado al uso de entradas analógicas, que podemos resumir en los siguientes puntos:

Saber crear sketch o programa. Conocer las funciones “int”, “delay”, “pinMode” , “digitalWrite”, “analogicWrite, “analogicRead” , “if” y “millis”. Saber que es una función cómo se definen y la forma de llamarlas desde algún punto del sketch. Saber que se pueden declarar variables de diversos tipos y conocer los tipos “byte”,”int”, “long” y “unsigned long”

Enunciado del ejercicio

Modificamos un poco nuestro modelo de linterna multiuso varias veces puesta como ejemplo. En este caso, sustituimos el pulsador por un potenciómetro con deslizador, a medida que aumentamos el voltaje aumenta el brillo de las tres bombillas, hasta llegar a un as intensidad, para llegado un punto, en el que cesa la luz de las tres bombillas y se enciende una luz intermitente roja.

Queremos construir una linterna multiuso que funcione de la siguiente forma:

  • – La linterna contara con un potenciómetro
  • – Mientras el potenciómetro este en los 4/5 de su recorrido las tres leds blancos brillarán con intensidad proporcional al recorrido del potenciómetro.
  • – Superado este punto se apagan las luces blancas y se enciende un cuarto led rojo intermitente.
  • – Para apagar la linterna se retrocede el potenciómetro a voltajes próximos a 0 volts.

Material necesario

  • Tarjeta Arduino y cable de conexiones.
  • Tarjeta de prototipado o “protoboard”.
  • 12 Cables de conexiones macho/macho (preferiblemente 5 rojos , 6 azules 1 ).
  • 4 Resistencias de 220 Ω.
  • 4 Led ( preferiblemente 3 blancos y 1 rojo).
  • 1 potenciómetro preferiblemente del tipo dializador.

Objetivos

  • Ejercitarse en el uso de los pines de entrada analógica.
  • Practicar con pines de salida PWM.
  • Utilizar el mandato “millis” como forma sustituir el mandato “delay” en ocasiones que “paralizar” el sketch de lugar a problemas.
  • Explicar la forma de crear un sketch a partir del enunciado, hasta la programación, pasando por las fases de Análisis Funcional y Análisis Orgánico..

Especificaciones

La linterna tiene un potenciómetro que controla su funcionamiento, Mientras que el pin de entrada analógico mide valores, (“val”), por debajo 20, la linterna está apagada, por encima de 50 y debajo de 900, (aproximadamente los 9/10 de 1023), tres pines PWM permiten alimentan cada uno a un led con un brillo (“num”) proporcional a la lectura, (num = 880*val/255) Si a lectura excede a 900 se apagan las luces y enciende un intermitente rojo.

Hardware

Habrá por tanto que abrir un pin digital, (el 4), a OUPUT, para alimentar el intermitente rojo
y tres pines PWM ( los pines 5, 6 y 9 ) para controlar los leds blancos. Para leer el pulsador destinaremos el pin A0

En función de lo indicado el esquema será tal como se indica en esta imagen.

Linterna-multiuso

Todo lo que hacemos es conocido. 4 circuitos diferentes, alimentados por los pin 4, (led rojo) y 5. 6 y 9 (pines PWM que alimentan leds blancos), todos con sus correspondientes resistencias de 220 Ω y otro circuito que contiene el potenciómetro, en este caso del tipo botón, alimentado a partir de los pines V5 y GND y que da su lectura por el pin A0

Análisis Funcional

Nuevamente nos encontramos con un ejemplo con trampa. Aparentemente basta con leer A0 y hacer en cada momento lo que indique la lectura, apagar, encender las luces blancas, o hacer la intermitencia roja, pero nos vamos a encontrar con el problema ya conocido de la intermitencia y el botón.

Anteriormente para resolverla, utilizamos la técnica de simular un multiproceso, dedicando los “loop” partes a atender lo que pasa en el botón y los impares a cuidar de la intermitencia. Para ello precisamos que el los ”loop” se ejecute rápidamente, por este motivo dividíamos un solo “delay” largo , que nos “dormía” el “loop” en su ejecución, por lo que dividimos el “delay” en múltiples “delay” cortos, ejecutando cada uno en “loops” diferentes y llevando un control de cuantos habíamos ejecutado. (pueden ver como lo hicimos en ….

En este caso vamos a utilizar un sistema que permite el control de amibos procesos en un mismo “loop”. Para ello utilizaremos el mandato “millis” que aprendimos en el capítulo anterior “Conceptos previos a la resolución de la “Linterna con potenciómetro”

El mandato “millis” devuelve los milisegundos que han transcurrido desde el inicio del arranque del Sketch, Si leemos el tiempo en el instante de iniciar un semiperíodo de la intermitencia y lo volvemos a leer repetidas veces, bastara que la diferencia de tiempos sea superior al semiperíodo para saber que tenemos que cambiar el estado del led rojo.

La primera medida va a ser comparar la lectura del potenciómetro con la hecha en el loop anterior, pues si no ha variado, dejamos todo como está antes, y tan solo si es necesario atendemos al cambio de intermitencia, si hay que efectuar la intermitencia Si el potenciómetro ha variado, actuamos de acuerdo con lo que indique su valor actual y luego, si viene al caso. cuidamos la intermitencia.

Si el valor del potenciómetro está por debajo 20. apagamos las luces, Si esta entre 20 y 900 encendemos las luces rojas de forma proporcional, Si esta por encima de 900 iniciamos la intermitencia de luz roja, si no lo habíamos hecho antes.

Independientemente de ello cuando haya que hacer intermitencias, estudiaremos el tiempo transcurrido y superado el semiperíodo cambiaremos de encendido a apagado o viceversa. Para ello al iniciar la intermitencia leemos el tiempo con “miliss” y al entrar en esta parte lo volvemos a leer, si la diferencia no llega a un semiperíodo dejamos el led rojo como esté, si lo supera cambiamos el estado del led rojo, si esta apagado lo encendemos y si esta encendido lo apagamos.

Para evitar los “overgflow” si el tiempo medido por “millis” es inferior del tiempo actual, deducimos que hemos superado mayor tiempo posible de medir (4,294,967,295), en ese caso en vez de por diferencia sumaremos los milisegundos para llegar al límite y los transcurridos desde el inicio.

En función de este análisis diseñamos el funcionamiento del sketch, de forma que los “loops” se sucedan con frecuencia y podamos vigilar los posibles cambios del potenciómetro. El Análisis Funcional se centra en pensar en el QUE VA A HACER el programa y no tanto en el COMO LO VA A HACER, que es el objeto del Análisis Orgánico. Por tanto, de momento, no pretendemos averiguar COMO se van a hacer las cosas, sino que nos centramos en QUÉ se va a hacer.

El programa será pues en principio como sigue, aunque aun esta sujetos a cambios que surjan al profundizar mas en el avance del análisis :

/* Sketch E8.2 Linterna multiuso con potenciómetro */
// Área de declaración de variables y parámetros***********
byte pinblanco1 = 5 ; // pines del tipo PWM
byte pinblanco2 = 6 ;
byte pinblanco3 = 9 ;
byte pinrojo = 4 ; // pin digital mo PWM
byte pinanalog = 0 ; // pin analógico de entrada A0
int valoractual = 0 ; // valor de lectura analógica (de 0 a 1023)
int valoranterior = 0 ; // valor en el loop anterior
byte intermitencia = 0 ; // 0 no hay 1 hay intermitencuia
unsigned long tactual = 0 ; // tiempo leido por millis
unsigned long tanterior = 0 ; // tiempo de inicio del semiperiodo
unsigned long tpasado = 0 ; // tiempo pasado en el semiperiodo
unsigned long semiperiodo = 1000 ; // milisegundos de un semiperiodo
byte encendidorojo = 0 ; //0 apagado, 1 encendido
// Función setup ******************************************
void setup() { pinMode (pinrojo, OUTPUT); }
// Funcion loop *******************************************
void loop() {
// Control del potenciometro ******************************
// leer el pinanlogico de entrada (AO) y comparar con el anterior
valoractual = analogRead(pinanalog) ;
if (valoranterior != valoractual) { // cambio en potenciómetro
actuar(valoractual) ; // actuamos de acuerdo a valoracionactual
delay(1000); // ********** Linea provisional de control ****************************
valoranterior = valoractual ; // preparado para el siguiente loop
}
// Control de la intermitencia *****************************
if (1 == intermitencia) { // si ha que atander la intermitencia
tactual = millis() ; // tomamos el tiempo actual
if (tanterior<tactual) {
tpasado = tactual-tanterior;
}
else {
tpasado = ((4294967295 -tanterior) + tactual );
}
delay(1000); // ********** Linea provisional de control ****************************
tanterior = tactual ; // nuevo origen de semiperiodo
if (semiperiodo < tpasado) { cambiarintermitencia(encendidorojo);}
}
} // fin loop
// Área de definición de las Funciones **********************
void actuar(int val) { //***** actuar de acuerdo con val
}
void cambiarintermitencia(int enc) { // ***** encendido apaga, apagado enciende
}

El Análisis Funcional se ha acabado, aun no sabemos como haremos las cosas pero sabemos LO QUE TENEMOS QUE HACER, la estructura general que tendrá el programa y lo que tiene que hacer cada función. En principio, parece que las funciones no generen parámetros, solo la función “actuar” parece necesitar el valor leído en A0. Por otra parte la funcion “cambiarintermitencia” precisa para actuar, recibir por parámetro si el led rojo está encendido o apagado.t

Se han originado dos funciones una “actuar”, que se ejecutará con cada cambio del pulsador y otra  “cambiarintermitencia” que se ejecutará sólo, si estamos realizado intermitencias y hay que cambiar el estado del led rojo.

Hemos declarado una serie de parámetros y variables que utilizaremos en el programa con tipos de acuerdo con el uso que se las va a dar en es Sketch, los que nunca superaran el valor de 255 los declaramos de tipo “byte”, los que nunca llegaran a 30.000 de tipo “int”, y todos los relacionados con el tiempo los declaramos de tipo “unsigned long” posiblemente algunos como “semiperíodo” no fuera necesario pero ante la duda, los hacemos todos grandes,

Compilar y quitar el errores

Vamos a compilar y eliminar los errores preliminares antes de continuar. Aconsejo para ello utilizar el simulados UnoArduSim porque te marca donde ha encontrado el error y indica el valor de las variables en ese momento, lo que facilita bastante la comprobación.

Observarán que henos puesto dos lineas provisionales como estas

delay(1000); // ********** Linea progisional de control ****************************

Esto es un recurso muy habitual para hacer paradas en el programa que permitan copribar que el programa pasa por ese punto y que den tiempo a cerciorarse del valor de las variables, Normalmente finalizadas las pruebas estas lineas se eliminan o se dejan como comentarios para que no interfieran en el funcionamieento del programa cuando actua en real.

Lo habitual es que el sketch tenga la primera vez que le compilé muchos pequeños errores como dejar paréntesis abiertos, errores en los nombres de variables y funciones, faltas de “;” al final de las lineas y cosas por el estilo. El error que más me costó encontrar es que faltaba la línea final con el “}” de cierre de la función “loop” con lo que el compilador entendía que toda el área de definición de funciones pertenecía a la función loop y se armaba el taco y los mensajes de error que generaban, no hacían mas que aumentar el desconcierto.

Siempre cuando no veas claro, o no venga a cuento el mensaje de error que da el compilador, sospecha que el error viene de mas arriba de la linea donde ha parado.

En el momento que está el programa solo podemos comprobara en cuanto a sus funcionamientos las siguientes cosas:

  • Que si no se cambia el potenciómetro el programa no pasa por ninguno de las dos lineas de “delay” que hemos  puesto como control, pero que “valoranterior” vale lo mismo que “valoractual”
  • Que si se cambia el potenciómetro el programa  pasa por la primera de las dos lineas de “delay” de control, y que “valoranterior” vale diferente que “valoractual”
  • Que en ningún caso c entra en el segundo delay de control porque nunca “intermitencia” adquiere el valor “1”

Análisis Orgánico

En esta fase, se comienza a “traducir” las funciones descritas en mandatos del lenguaje, o sea CÓMO se hace lo pensado en el Análisis Funcional, es el trabajo de los programadorees. Es por tanto la fase donde definimos los mandatos  que van a hacer las cosas. Si alguna de las funciones aun presenta complejidad, las descomponemos a su vez en funciones más simples como en nuestro caso ocurre con la función “actuar”

Función actuar

Según el valor de “val”,  apagamos los led, (<20) encendemos los led blancos (entre 20 y 920), y pasado el 920 iniciamos la intermitencia roja

Con el fin de no apagar innecesariamente los led cundo esten encendidos lo marcaremos con una variable que adquiere el valor 1  y si están apagados le damos el valor 0, (esto se llama tecnicamente utilizar un “flag” o bandera). Para ello añadimos una nueva variable mas que nos faltaba “encendidoblanco” que será también de tipo “byte”.

La función será algo como;

void actuar(int val) { //***** actuar de acuerdo con val
if (20> val) {
// apagar todo ****
testigo =1 ; // ********** Linea provisional de control ************************
}
else {
if (920 > val) {
// encender blancas (val) *******
testigo =2 ; // ********** Linea provisional de control ************************

}
else {
// iniciar intermitencia *********
testigo =3 ; // ********** Linea provisional de control ************************
}

Observarán que para el control de la funcion hemos añadido en el área de deeclaración de variables la vartiable “testigo” que nos indicará por los valores que toma si la función actúa como se espera según los valores de “val” que demos con el potenciómetro. Algo que poderemos leer cuando se para en el delay que hemos puesto a la salidade la función.

La variable “testigo” la podíamos haber declarado comno local pero al desaparecer al salir de la función nos dejaria menos tiempo para ver su valor despues de variar el potenciómetro, pues mientras este no varíe el valor de “testigo” sera el del último sitio por donde pasó.

Esta función origina módulos de programa, el que apaga todo, el que enciende blancas y el que inicia las intermitencias rojas.

En este momento al compilar no podremos mas que quitar los errores de “ortografía” y ver si su funcionamiento es correcto según el valor de “vaL” pues aun no hace nada mas.

Módulo “apagar todo”

Para no hacer trabajar inútilmente a la tarjeta comprobamos previamente a apagar los led si están encendidos y ponemos los indicadores de led apagados y de no intermitencia. Ello nos obliga a usar otro “flag” mas “encendidoblanco” que nos dirá si hay que apagar los leds blancos. Lo declaramos en el Área de declaración de variables porqeu otras funciones tendran que encargarse de encederla

// apagar todo ****
testigo =1 ; // ********** Linea provisional de control ************************
if (intermitencia == 1) { // si se hacia la intermitencia se paraliza
intermitencia =0 ;
if (1== encendidorojo) {
digitalWrite(pinrojo,LOW) ;
encendidorojo = 0;
} // fin if (1== encendidorojo)
} // fin if (intermitencia == 1)
if (1 == encendidoblanco) {
analogWrite(pinblanco1, 0);
analogWrite(pinblanco2, 0);
analogWrite(pinblanco3, 0);
encendidoblanco = 0;
} // fin if (1== encendidoblanco)

Como siempre compilamos y quitamos errores, pero no podemos probar mas de lo probado proque nadie ha encendido las luces que este módulo apaga, eso lo dejaremos para más adelante.

Modulo “encender blancas”

Tomamos como parámetro de entrada el valor que generó la lectura del potenciómetro, y con el generamos “num” que será proporcional a “val”; hacemos una regla de tres  num = (val*^255)/(1023-20). Simplificando la formula queda num =val*255/1003   aproximadamente  num =val* (255/1000)= val* 0.255

Para eliminar problemas de oferflow vamos a definir como flotante  (float)  el resultado de la operación (val*0.255) (observen que en los sketch, los decimales se separan de los enteros con un punto (.) como hacen los americanos y no con una coma) Luego se lo vamos asignar a un valor int que llamaremos “brillo” que es lo que podemos llevar a analogWriten como para metro de intensidad de luz.  No obstante y pese a nuestro cuidado para evitar sorpresas vigilaremos este punto con mucho cuidado en las pruebas..

// encender blancas (val) *******
testigo =2 ; // ********** Linea provisional de control ************************
if (1 == intermitencia) { // Si se estaba haciendo la intermitencia
intermitencia = 0 ; // se paraliza la intermitencia
if (1== encendidorojo) {
digitalWrite(pinrojo,LOW) ;
encendidorojo = 0;
} // fin if (1== encendidorojo)
} // fin if (intermitencia == 1)
float num = 0 ; // definimos num como variable local flotante (comoa con 6 cifra significativas)
int brillo = 0 ; // vaiable cocal para guardar el birllo de los led
num = val*0.255 ; // ¡OJO! vigilar el valor de num y de brillo
brillo =num  ;// quitamos los decimales analogWrite(pinblanco1, brillo);
analogWrite(pinblanco2, brillo);
analogWrite(pinblanco3, brillo);
encendidoblanco = 1;
}

Observen que  hemos declarado dos nuevas variables que necesitamos para realizar los calculos “num” y “brillo” que se podian haber declarado dentro de la función “actuar”, es decir de forma que sólo tengan existencia cuando el sketch está dentro de la función, oues al salir desaparecen, algo que se puede observar  bien en el simulador vigilando las variables que aparecen en la esquina inferior izquierda. Esto es lo adecuado, ¿para que cargar al ordenado con el recuerdo de variables que solo va a utilizar aquí?. Sin embargo las hemos declarado como globales es decir en el Área de declaracion de variables, porque queriamos a observar sus valores con todo detalle y estando declaradas ahi no desapqarecen y se pueden analizar con detalle.

Ahora ya si podemos probar en parte el sketch:

Si movemos el patín del potenciómetro entre 0 volts y 2,5 volts deberemos ver que cuando está en cero se pagan las luces blancas y cundo esta aumentando cada vez lucen mas los leds, lo que notaremos sólo parcialmente, viendo como cada vez está parpadeando mas rato encendidos pues la variacion del brillo en esta simulación como explicamos en el capítulo anterior Conceptos previos a la resolución de la “Linterna con potenciómetro” es muy mala y sólo se observan intermitencias que duran mas tiempo encendidas a medida que aumenta el voltaje en el potenciómetro..

Módulo “inicia las intermitencias”

Solo lo hacemos si “intermitencia” es “0” pues si no ya lo hemos hecho otra vez

i// iniciar intermitencia *********
testigo =3 ; // ********** Linea provisional de control ************************
if (0 == intermitencia) { // si no se hacían intermitencias
if (1 == encendidoblanco) { // si encendidas luces blancas las apagamos
analogWrite(pinblanco1, 0);
analogWrite(pinblanco2, 0);
analogWrite(pinblanco3, 0);
encendidoblanco = 0;
} // fin if (1 == encendidoblanco)
digitalWrite(pinrojo,HIGH) ; // encendemos el led rojo
encendidorojo = 1;
valoranterior = millis() ; // inicio del semiperíodo
intermitencia =1 ; // cuidar intermitencia
} // fin if (0 == intermitencia)

Aun no podemos probar la intermitencia roja pero si podemos probar todo  lo que nos faltaba,

  • En el sector 1 apagar luces que esten encendidas sean balancas o rojas
  • En el sector 2 apagar las rojas y encender las luces con brillo variable
  • En el sector 3 apagar las luces blancas y encender el led rojo (que quedara encendido fijo hasta que lo apaguemos en otro sitio).

Función “cambiarintermitencia”

Sólo nos resta definir la segunda función del programa, en la que solo entraremos si se ha iniciado la intermitencia, osea cuando “intermitencia == 1”. Si el led rojo esta encendido lo apagamos y viceversa, la funcvion tiene como entrada el flag,(bandera) que indica si el pin rojo está encendido o apagado

void cambiarintermitencia(int enc) { // ***** encendido apaga, apagado enciende
if (0 == enc) { // apagado, se enciende
digitalWrite(pinrojo,HIGH) ;
encendidorojo = 1;
}
else { //apagar led rojo
digitalWrite(pinrojo,LOW) ;
encendidorojo = 0;
}
}

probamos el sketch completo y vamos haciendo diversas pruebas moviendo el potenciómetro y estudiando los valores que se producen hasta darlo por bueno.

Les paso el sketch completo tal como queda al final, Les dejo las lineas que he pued to de control para que puedan jugar con ellas, pero lo correcto seria una vez acabadas las pruebas retirarlas pues no hacen mas que entorpecer y retrasar el funcionamiento del sketch cuando este programa funcione en real.

/* Sketch E8.2 Linterna multiuso con potenciómetro */
// Área de declaración de variables y parámetros***********
byte pinblanco1 = 5 ; // pines del tipo PWM
byte pinblanco2 = 6 ;
byte pinblanco3 = 9 ;
byte pinrojo = 4 ; // pin digital mo PWM
byte pinanalog = 0 ; // pin analógico de entrada A0
int valoractual = 0 ; // valor de lectura analógica (de 0 a 1023)
int valoranterior = 0 ; // valor en el loop anterior
byte intermitencia = 0 ; // 0 no hay 1 hay intermitencuia
unsigned long tactual = 0 ; // tiempo leido por millis
unsigned long tanterior = 0 ; // tiempo de inicio del semiperiodo
unsigned long tpasado = 0 ; // tiempo pasado en el semiperiodo
unsigned long semiperiodo = 1000 ; // milisegundos de un semiperiodo
byte encendidorojo = 0 ; //0 apagado, 1 encendido
byte encendidoblanco = 0 ; //0 apagado, 1 encendido
float num = 0 ; // definimos num como variable local flotante (comoa con 6 cifra significativas)
int brillo = 0 ; // vaiable cocal para guardar el birllo de los led
int testigo = 0 ; // ********** Linea provisional de control ****************************
// Función setup ******************************************
void setup() { pinMode (pinrojo, OUTPUT); }
// Funcion loop *******************************************
void loop() {
// Control del potenciometro ******************************
// leer el pinanlogico de entrada (AO) y comparar con el anterior
valoractual = analogRead(pinanalog) ;
if (valoranterior != valoractual) { // cambio en potenciómetro
actuar(valoractual) ; // actuamos de acuerdo a valoracionactual
delay(1000); // ********** Linea provisional de control ****************************
valoranterior = valoractual ; // preparado para el siguiente loop
}
// Control de la intermitencia *****************************
if (1 == intermitencia) { // si ha que atander la intermitencia
tactual = millis() ; // tomamos el tiempo actual
if (tanterior<tactual) {
tpasado = tactual-tanterior;
}
else {
tpasado = ((4294967295 -tanterior) + tactual );
}
delay(1000); // ********** Linea provisional de control ****************************
tanterior = tactual ; // nuevo origen de semiperiodo
if (semiperiodo < tpasado) { cambiarintermitencia(encendidorojo);}
}
} // fin loop
// Área de definición de las Funciones **********************
void actuar(int val) { //***** actuar de acuerdo con val
if (20> val) {
// apagar todo ****
testigo =1 ; // ********** Linea provisional de control ************************
if (intermitencia == 1) { // si se hacia la intermitencia se paraliza
intermitencia =0 ;
if (1== encendidorojo) {
digitalWrite(pinrojo,LOW) ;
encendidorojo = 0;
} // fin if (1== encendidorojo)
} // fin if (intermitencia == 1)
if (1 == encendidoblanco) {
analogWrite(pinblanco1, 0);
analogWrite(pinblanco2, 0);
analogWrite(pinblanco3, 0);
encendidoblanco = 0;
} // fin if (1== encendidoblanco)
}
else {
if (920 > val) {
// encender blancas (val) *******
testigo =2 ; // ********** Linea provisional de control ************************
if (1 == intermitencia) { // Si se estaba haciendo la intermitencia
intermitencia = 0 ; // se paraliza la intermitencia
if (1== encendidorojo) {
digitalWrite(pinrojo,LOW) ;
encendidorojo = 0;
} // fin if (1== encendidorojo)
} // fin if (intermitencia == 1)
num = val*0.255 ; // ¡OJO! vigilar el valor de num y de brillo
brillo =num ;// quitaos los decimales y redondeamos a num
analogWrite(pinblanco1, brillo);
analogWrite(pinblanco2, brillo);
analogWrite(pinblanco3, brillo);
encendidoblanco = 1;
}
else {
// iniciar intermitencia *********
testigo =3 ; // ********** Linea provisional de control ************************
if (0 == intermitencia) { // si no se hacían intermitencias
if (1 == encendidoblanco) { // si encendidas luces blancas las apagamos
analogWrite(pinblanco1, 0);
analogWrite(pinblanco2, 0);
analogWrite(pinblanco3, 0);
encendidoblanco = 0;
} // fin if (1 == encendidoblanco)
digitalWrite(pinrojo,HIGH) ; // encendemos el led rojo
encendidorojo = 1;
valoranterior = millis() ; // inicio del semiperíodo
intermitencia =1 ; // cuidar intermitencia
} // fin if (0 == intermitencia)
}
}
}
void cambiarintermitencia(int enc) { // ***** encendido apaga, apagado enciende
if (0 == enc) { // apagado, se enciende
digitalWrite(pinrojo,HIGH) ;
encendidorojo = 1;
}
else { //apagar led rojo
digitalWrite(pinrojo,LOW) ;
encendidorojo = 0;
}
}

Es una pena que el editor de WordPress se como los espacios en blanco según ellos “innecesarios” porque desaparecen los indentados que indican lo que abarca cada par de corchetes “{…}” lo que facilita mucho la comprensión del programa. Les copio por ello un pantallazo de el aspecto del programa en UnoArduSim para que tengan al menos una idea de lo que yo realmente manejo.

 

La otra recomendación que les hago es que no pretendan poner a punto un programa de arriba abajo, hay que g hacerlo por fases como lo hemos hecho en este caso, porque asi los errores están, (sobre todo), en lo ultimo que hemos escrito con lo que resulta mucho mas fácil de controlar sus posibles fallos. Se que es pesado el sistema pero creanme y es experiencia de muchos años , pese a todo la forma más rápida de poner a punto un programa.

En este ejercico he planteado la forma de enferentarse a un problema, Cómo iniciar el Análisis Funcional, cómo realizar el Análisis Organico, y la forma de ir poniendo a punto los sketch asi como algunos “trucos” que ayudan a poner el sketch a punto. Todas estas técnicas son la forma de buscar la solucion digital a los problemas y se aplican tanto en grandes proyectos como en pequeños, pues siempre consisite de buscar la forma de dividir un problema en otros mas pequeños más fáciles de abordar y poner a punto, y tratar de dividir los problemas en partes que pueden probarse como si las otras ya las hubieramos desarrollado y fueran operativas.

Les dejo la prueba final, Cambiando el potenciómetro recorro las diferentes posibilidades que tiene la linterna tanto de encender las los leds balancos como el rojos intermitente.

Félix Maoch0.

 

Anuncios

27 abril 2017 - Posted by | Curso de Arduino, Robotica | , , , ,

Aún no hay comentarios.

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s

A %d blogueros les gusta esto: