Felix Maocho

Para quien le interese lo que a nosotros nos interesa

Curso de Arduino – 2º Uso de entradas analógicas.

Por Félix Maocho
31/3/2017

.

Objetivo de este capítulo

  • Comprobar que en la tarjeta Arduino UNO, los pines analógicos de entrada A0…A5, son simultánemente pines digitales con los números 14 a 19.
  • Saber que es un potenciómetro, oreostato, o resistencia veriable. Tipos y modelos mas habituales y su forma de uso.
  • Aprender a manejar los pines de entrada analógicos.
  • Aprender a utilizar las entradas analógicas en el simulador UnoArduSim.

Material necesario

  • Tarjeta Arduino y cable de conexión al PC
  • Tarjeta de prototipado o “protoboard”
  • 6 Cables de conexiones, (Preferiblemente, no imprescindible, 2 rojos, 1 verde y 3 grises)
  • 2 Resistencia de 220 Ω
  • 1 led (es indiferente el color)
  • 1 pusador (pushbutton)
  • 1 potencionetro

Conocimientos previos necesarios

Saber que son los pines analogicos de entrada  y como funcionan, Saber que son los pimes PWM o pines “analogicos” de salida. Tener nocion de los que supone una saliada modulada.

Como se explicó en el capitulo anterior, “Entradas analógicas. 1º Las puertas de los sensores”, lo que miden los pines analógicos de entrada es el voltaje de un cable eléctrico que penetra en el pin, siempre que ese voltaje esté comprendido entre los 5 voltios y los cero voltios. Lo que tenemos pues en cada pin de entrada analógico es un voltímero que “traduce” el voltaje recibido en un número comprendido entre el 0 y 1023 según el voltaje que recibe, de modo que por cada 0,01 voltios de más, el numero aumenta aproximadamente 2 unidades. Como trabajan los diferentes sensores es generando un voltaje proporcional a la realidad física que miden. Si la medida que realizan es un dígito alto, mandaban un voltaje alto y si es bajo, un voltaje bajo y si es un valor situado entre los dos, envían un voltaje proporcional, entre el voltaje bajo y el alto, de modo que Arduino, pueda deducir la medida realizada y en función de ello, mandar las ordenes pertinentes a los actuadores.

Los pines de entrada analógica son además pines digtales

Deben de conocer, (y que no toda la gente lo sabe), es que los pines marcados en la Tarjeta Arduino, con las letra A0 a A5, son pines digitales como los que hemos estado utilizando hasta ahora, que como otros determinados pines que existen, tiene además una utilidad diferente, en este caso leer medidas analógicas, pero como de igual forma que los pines marcados con el símbolo ”~”, además de ser pines digitales, son capaces de emitir ondas moduladas o sea son pines PWM

Por ello, el primer montaje es para demostrar que los pines A0 … A5, son también los pines digitales 14 … 19 y que por lo tanto, en caso de necesidad podemos tener en Arduino hasta 20 pines digitales, del 0 al 19, lo que puede ser de mucha utilidad en algunos caso, por ejemplo si queremos iluminar de forma controlada el árbol de Navidad, junto con su estrella y los diferentes escenarios del Nacimiento.

Así que esta primera practica, no tiene que ver con las entradas analógicas, y que si te es suficiente con mi palabra, te la puedes saltar, porque no voy a enseñar en ella nada nuevo, salvo lo que he indicado que los pines A0,…, A5 son pines digitales de números 14 a 19.

= = = = = = = SALTAR SI SE QUIERE ESTA PARTE DEL CAPITULO  = = = = = = =  

Loa pines A0,…., A5 son a la vez los pines 14,…,19

Para esta prueba vamos a utilizar el viejo y acreditado programa Blink, o intermitente, que es el catón de la programación de Arduino pero dando salida a la energía por un pin oficialmente destinado a “entrada analógica” por ejemplo el pin 16 o lo que es lo mismo el A3. Observen el montaje he puesto por el A3 un led con su correspondiente resistencia de 220Ω. A continuación he instalado el típico pulsador en montaje PULL DOWN, por la entrada 19, o sea la A5 con la típica resistencia de 10 KΩ, y haremos el programa ya hecho de encender y pagar el led con lo que quedara probado que los pines de entrada analógica son también pines digitales corrientes y molientes.

Vemos el montaje y los programas

Hardware

Pines de entrada analógica utilizado como pines digitles de OUPUT

El Hardware es igual que el utilizado en programa que vimos para pardear un led. Explicado en uno de los primeros capítulos del curso, el llamado “Principales opciones del Menú de Inicio de Arduino”

El programa se llamaba “Sketch 1 – Intermitente” y que decía:

En él que solo hemos cambiado el pin 13, (el que tiene asociado un pequeño led), por el pin 16 o lo que es lo mimo por el A2

Monta el circuito compila y carga en la tarjeta Arduino este sketch y verás como parpadea el led.
Con ello probamos que el PIN A2, actuá como si fuera el digital pin 16 en OUPUT. De igual forma podríamos probar que así funciona el resto de los “pines de entrada analógicos”, o sea que los llamado pines analógicos de entrada, son también, pines digitales de salida o OUPUT.

Pines de entrada analógica utilizado como pines digitles de INPUT

Vamos a hora con la segunda prueba prueba de que también actúan como INPUT para ello hemos preparado un montaje muy sencillo de un pulsador en PULL DOWN, (tirar abajo. o derribar, quiere decir que el voltaje, está normalmente a 0 voltios). Para lo que el orden de los elementos que interviene en el circuito es el siguiente:

  • Fuente de corriente eléctrica a 5V
  • Pulsador
  • Segmento de cable que acaba en el Pin que hará la lectura del voltaje
  • Resistencia del circuito
  • Tierra

El pulsador nos vale como señal para encender un led. Para el software utilizaremos el del sketch 3 que enseñamos en el capítulo “Uso de los pines digitales como entrada (INPUT)” , sólo que cambiando como en el caso anterior los pines digitales utilizado entonces por dos pines de “entrada analógica”. Un este caso como ya habíamos aprendido a parmetrizar los programas, es particularmente sencillo modificar el programa, pues basta cambiar los valores de “pinout” de “3” a “19” y de “pininp” de “4” a “17”, con lo que se demuestra una vez mas la ventaja de hacer las cosas bien, aunque en un primer momento nos parezca una tontería.

/* Sketch 3 Detectar cuando oprimen en pulsador
* Montaje Pull Down
* 1º Leer el pin 3
* 2º Si la lectura es “1” encender el led que sale del pin 4
* 3º Si la lecturas es “0” apagar el led que sale del pin 4
* Repetir el ciclo*/

// Área de definición de variables y parámetros
int pinout = 17;
int pininp = 19;
int valor = 0; // variable para guardar el valor de la lectura 0 = LOW 1 = HIGH

// Función setup

void setup() {
pinMode(pinout, OUTPUT); // Pin abierto como OUTPUT enciende led
pinMode(pininp, INPUT); // Pin abierto como INPUT, lee pulsador
}

// Función loop
void loop() {
// 1º Leer el pin4 y deposita el resultado en “valor”
delay (100) ; // para evitar los rebotes del pulsador
valor = digitalRead(pininp);
// 2º Si la lectura es “1” encender el led que sale del pin 4
if (valor == 1) {
digitalWrite(pinout, HIGH); // enciende el led
}
// 3º Si la lectura es “0” apaga el led que sale del pin 4
if (valor == 0) {
digitalWrite(pinout, LOW); // apaga el led
}
// Repetir el ciclo
}

Compile y pruebe este programa y vera como el pin 19 o lo que es lo mismo A5 funciona como un pin digital de INPUT.

Probado lo que pretendíamos nos introducimos plenamente en lo que realmente supone el manejo de pines analógicos de entrada.

= = = = = = = FINAL  DE LA PRUEBA DE PINES ANALÓGICA COMO DIGITALES  = = = = = = =  

Probado lo que pretendíamos nos introducimos plenamente en lo que realmente supone el manejo de pines analógicos de entrada.

Como se dijo, lo que tenemos pues en cada pin de entrada analógico es un voltímero que “traduce” el voltaje recibido en un número comprendido entre el 0 y 1023,  (en el Arduino UNO), según el voltaje que recibe, de modo que por cada 0,01 voltios de más, el numero aumenta aproximadamente 2 unidades para comprobarlo y ver como se utiliza vamos a hacer el siguiente montaje. Para poder hacer practicas con estos pines tenemos que poder crear voltajes diferentes a los 5 voltios habituales, Cualquier resistendcia reduce el voltaje de acuerdo con la ley básica en electricidad y electrónica, la Ley de Ohm que relaciona la intensidad el voltaje y la resistencia

I=VxR

Lo que indica que para una intensidad fija, (la que por ejemplo produce el pin 5V de la tarjeta), a mayor resistencia tiene que corresponder menos voltaje, de modo que el producto sea constante. Por tanto, si conseguimos modificar la resistencia, modificamos en sentido contrario el voltaje, a mas resistencia menos voltaje y viceversa. Esto es exactamente lo que hacen los llamados potenciómetros, reostatos , o resistencias variables, que de las tres formas se les llama

Potenciómetros

El potenciómetro, es un sencillo aparato que permite modificar mediante un mando, el valor de una resistencia por lo que conectado a un circuito,  nos va a ser muy útil para realizar el estudio de los pines analógicos de entrada.
Hay diferentes tipos de potenciómetros pero el funcionamiento de la inmensa mayoría se pueden concentrar en dos familias, los potenciómetros de Variación lineal, en donde la resistencia es directamente proporcional al giro o desplazamiento de su elemento de control y los de Variación logarítmica, en los que la resistencia inicialmente crece muy despacio para pasar a otra zona donde el crecimiento es muy rápido.

En el crecimiento lineal a iguales incrementos del control correponden iguales invrementos de la resitencia y por tanto la curva que representa el crecimiento es una recta de pendiente fija. En el crecimiento logaritmico al doble de incremento del contol corresponde  un crecimieto exponencial. Como consecuencia la curb¡va comienza creciendo muy lentamente op para aumentar con fuerza al poco tiempo.

Nosotros habitualmente utilizaremos potenciometros lineales pues facilitan mucho el control del crecimiento, si deseo el doble de resistencia que la que tengo simplemente duplico el movimiento del mando, Sin embargo hay fenómenos fñísiscos que son exponenciales como el sonido, la agudeza del sonido no es lineal sino exponencial, para estos casos la regulacion se simplifica si poseemos potenciómetros exponenciales

A su vez y sea cual sea su forma de funcionar, el mando con el que cambiamos la resistencia suele tener dos aspectos, o es un deslizador lineal, es un mando rotatorio, como muestran las imágenes.

Debe quedar claro, que el modo de control esta en relación con la usabilidad del aparato y no en relacion con que su funcionamiento es lineal o logarítmico. Por ejemplo en las mesas de sonido, lo habitual es que los potenciómetros que regulan el sonido sean patines deslizantes lineales, pese a que los potenciómetros serán mayoritariamente logarítmicos, mientras que en las guitarras eléctricas, habitualmente los mandos son rotatorios.

Como se ve en la imagen los potenciómetros tienen habitualmente 3 patillas, una se conecta a la fuente de alimentación, En Arduino UNO el pin V5  a 5Voltios, otra al pin tierra o GND y por último la tercera patilla será la salida del potenciómetro que alimentara la linea con tensión voltaje variable.

Nuestra primera practica sera identificar cada una de estas patillas en nuestro potenciómetro, algo que no siempre es obvio pues con frecuencia no estan marcadas las patillas y hay que deducirlo por lógica. Por ejemplo en el potenciometro que les muestro aparentemente no hay mas marka c visible que su maxima resistencia 10 K o 10.000Ω curiosamente y sorprendentemente, al fotografiarlo para ponerlo aquí, he descubierto que esta hecho en España, y digo sorprendentemente porque que yo recuerde llegó en mi primer kit de Arduino que compre v en un proveedor chino, Es posible que los proveedores armen los kit al menos con piezas que compran aquí para eliminar costes y transportes, pero el caso es que pone ACP SPIN,  aunque eso si cuesta distinguirlo. Para que se hagan una idea este potenciómetro tiene el mismo tamaño que los pulsadores o sea 6mm, que hemos venido utilizando y para manejarlo se precisa un destornillador muy fino, como el que utilizan los relojeros,

Pero ninguna marca sobre qué debe recibir cada patilla, tan solo en un costado el valor màximo de la resistencia

Hay que deducir cual es el cometido de cada pata, Yo deduje que como las resistencias, a diferencia de otros componentes electrónicos como los diodos o los led son indiferentes a la polaridad, también los potenciómetros lo serian y que por lo tanto las patas que se conectam a 5V y oV son intercambiables. En ese caso las patas iguales que hay por un lado tiene esa misión y que la pata solitaria que hay en el lado opuesto es la que da salida a un voltaje variable. Por supuesto la ranura superior en la que se mete la punta de un  destornillador de relojero y tiene cierta forma de punta de flecha marca los grados de giro que se ha dado al potenciómetro. Al lado izquierdo aproximadamente a las posición de las 7, estará el mínimo de resistencia  y en la posición de las 4 estará el máximo, ¿O será al revés porque marca no marca resistencia sino voltajes de salida?, Habrá que probarlo.

La parte buena de estos componentes es que son muy baratos, segun información que he leido en la hoja del fabricante, la cantidad menor que él vende

Manejo del potenciómetro

Como ocurre con los interruptores, que directamente se pueden utilizar para encender y apagar un led , pero habitualmente se utilizan indirectamente en montajes PULL DOWN,o PULL UP, se puede directamente poner el potenciómetro en serie con el led y modificar la intensidad de la luz, sin necesidad de utilizar la Placa Arduino, pero para tomar acciones mucho mas complejas y variadas que la simple variación del brillo de un led conviene que arduino se “entere” del cambio . Como en el caso anterior, podemos utilizar la información en el interior de la Tarjeta Arduino y procesarla de modo que nos permite una variedad de respuestas mucho mas amplia.

Por ejemplo, si asociamos este potenciómetro al movimiento de giro de una bisagra, habremos transformado el potenciómetro en un sensor de apertura de una puerta. Mediante la Tarjeta Arduino, al percibir la apertura de la puerta, podemos decidir poner en marcha diferentes dispositivos de seguridad, como pueden ser, encender la luz, mandar mensajes SMS, hacer sonar un timbre o poner en marcha una cámara de video. Todas esas acciones son fáciles de tomar con la ayuda de una Tarjeta Arduino como consecuencia de la lectura analógica, pero seria difícil de realizar con la sola variación de un potenciómetro en un montaje digital que no fuera percibido por una tarjeta controladora.

Como vimos en el programa anterior, hay en Arduino UNO los pines de entrada analógicos, de A0 a A5 específicamente diseñados para actuar como voltímetros de sensores y otros dispositivos con salida analógicos, como es el potenciómetro. En Arduino UNO estos pines tienen una respuesta de 10 bits o lo que es lo mismo una respuesta de 0 a 1023 niveles diferentes, es decir, que por cada 0.004V (5/1024) incrementamos la repuesta, que irán desde 0 hasta 1023, en una unidad a diferencia de las salidas PWM que son de solo 8 bites es decir que solo van de 0 a 255. Es decir que tenemos exactamente cuatro veces mas de precisión a la hora de leer que a la hora de escribir.

Y como la mejor manera de entender algo son los ejemplos, empezamos con uno muy sencillo. Mediante el brillo de un led podremos ir viendo variar los valores que vamos obteniendo en un pin analógico según vayamos modificando la posición del potenciómetro.

Hardware

En el siguiente esquema te muestro el conexionado.

Desde el pin 9, que es del tipo PWM, alimentamos un led y su la resistencia de protección de 220Ω, con una intensidad de corriente proporcional a la lectura que obtengamos en el pin de entrada analógica 0 o sea la marcada como A0 que recibe la señal procedente de un potenciómetro que se alimenta del pin V5 (5 voltios ) y acaba en tierra (pin GND)

Software

El programa hará lo siguiente:

  • Leer el valor del pin analógico 0 (A0) y depositar la lectura en “val”.
  • Con ese valor dar una salida proporcional del pin PWM 10,
  • Esperar un poquito
  • Repetir la lectura.

Nosotros mientras tanto podemos libremente podremos mover el potenciómetro de derecha a izquierda, variando así la intensidad de la luz del led.
Primer paso. Analizar el sketch

En primer lugar la función “leerpinanalogico” lee el pin AO, y deposita la lectura en “val”. Luego deducinos  el valor de “num” en la función “valorproporcional“, a partir de “val”  y por último, con la función “encenderPWM” mandamos encender el led “pinanalog” con esa intensidad “num” y pasado un “tiempo” repetimos el proceso.

El software a definir será algo parecido a esto:

/* Sketch 8.1 Variar el brillo de un led mediante un potenciómetro
* Leer la entrada analógica (0) y dejar en el valor en “val”
* Calcular el valor “num” en proporción al valor de “val”
* Abrir el pin PWM 10 de acuerdo con “num”
* Al cabo de un tiempo repetir el proceso
*/
// Área de definición de variables y parámetros *******************
int pinanalog =0; // pin analógico de entrada (A0)
int pinpwm =9; // pin PWM (9)
int val =0; // recoge el valor de la lectura
int num =0; // escribe pin PWM
int tiempo = 200; // tiempo para poder hacer la lectura
// Función setup *******************************************
void setup() { }
// Función loop ********************************************
void loop() {
val = leerpinanalogico(pinanalog);
num = valorproporcional (val);
encenderPWM(pinpwm, num);
delay (tiempo);
} //fin loop ***********************************************
// Área de definición de funciones **************************
int leerpinanalogico (int numpin){
int valor;
return (valor); }
int valorproporcional (int valor){
int numero;
return (numero); }
void encenderPWM (int pinPWN, int numpin){ }

Hemos hecho con esto una especie de boceto del programa. Observarán que la función “setup” no tiene nada porque los pines analógicos no precisan ningún tipo de inicialización sean de escritura o de lectura, siendo diferentes, pues son pines, que de forma analógica, sólo pueden hacer una cosa y esta viene definida de fábrica. A nosotros nos queda la precaución de asegurarnos que los pines que hemos seleccionado. lo que mandamos hacer, lo pueden hacer.

Como ven, tenemos sólo abocetado como va a ser el sketch, aunque aun no hemos desarrollado con detalle lo que hacen cada una de estas funciones, pero empezamos a tener una visión global de como va a funcionar el sketch. Por otra parte hemos definido una serie de cosas que necesitaremos, como parámetros y variables globales, la función “setup” y el esqueleto de “loop”. También observarán que no hemos escrito nada sobre lo que aun no conocemos, como por ejemplo cómo leer una entrada analógica.

Sin embargo, pese a que el sketch no hace de momento absolutamente nada y aun no sabemos e como lo va a hacer, una primera compilación nos permite quitar los primeros errores inevitables, como olvidos de “;” cerrar paréntesis y corchetes, alguna falta al escribir el nombre de los mandatos y variables, funciones que hemos escrito mal, uso de mayúsculas cuando debían ser minúsculas o viceversa.

Es normal en esta primera compilación que se encuentren montones de errores inadvertidos. La compilación permite depurar esos errores con cierta facilidad, estando así seguros que los errores que cometamos más adelante, están precisamente en lo que hemos escrito nuevo y no en lo anterior.

Yo para compilar este tipo de pruebas utilizo el compilador del simulado UnoArduSim, porque la barra azul indica muy claramente donde encuentra el primer error aparece un mensaje mas o menos orientativo, (atención no tomar los mensajes como si fueran la Biblia, muchas veces se detecta el error en una linea, pero el error se ha cometido varias lineas antes, por ejemplo hemos olvidado el ”;” y para el programa todo lo que hay a continuacion sigue siendo la misma linea). continua).

Para hacer esta depuración, igualmente se puede utilizar el compilador IDE de Arduino, pero ahí no tendrás la información del valor de parámetros y variables en el momento del error, aparte que los errores se pueden confuir con los errores que hayamos producido en el montaje. por lo que es preferible hacerlo en el simulador.

Como ven la última linea, blanco sobre negro, dice, COMPILED (Parsed) SUCCESSFULLY, o lo que es lo mismo, COMPILADO (analizado) CON ÉXITO, o sea que no ha detectado errores, pero sin embargo, tampoco ha detectado que aun no hace absolutamente nada. lo que parece mas obvio. No te fies de que una cosa porque compile esté perfecta.

Forma de efectuar los análisis de los problemas.

Esta es la forma de atacar los problemas en informática, ir en etapas sucesivas, desde lo general al detalle y dividir los problemas complejos, en varios problemas mas sencillos. Esto se llama técnicamente, “Seccionar el análisis en fases e interfases”, que consiste en dividir todo el problema en trozos, (fases), donde se realiza un cálculo determinado, (en nuestro caso, las “funciones”), que se conectan, con valores que navegan de un trozo a los siguientes, (interfases), (en nuestro caso los parámetros de entrada y salida que ven enhebrado las funciones).

En asuntos mas complejos, las fases serán largos programas de una aplicación y las interfases ficheros de datos o Bases de Datos, que no son mas que receptáculos donde se conservan los datos entrada y salida que se usan en los programas, pero en cualquier caso, son almacenamientos temporales que permiten trasladar los datos calculados desde una parte del programa a las siguientes.

O sea que, analizar en informática es ver la forma de dividir un gran problema, en muchos pequeños problemas que se pueden resolver mas fácilmente, uno tras otro y estudiar la forma de ir pasando los resultados obtenidos de una parte a otra parte.

La ventaja de esta forma de trabajar, es que se puede ir creando y poniendo a punto cada parte, independientemente de los demás y actuando en cada caso, como si lo demás lo tuviéramos ya resuelto, algo muy interesante cuando  se trabaja en equipo, porque se puede atacar en tantos puntos el programa como programadores tengamos, con la seguridad de que si el análisis está bien hecho, si nuestra parte funciona bien, no habrá que modificarla cuando se arme todo el programa. Y además  debidamente parametrizadas, podemos hacer funciones que se utilicen un muchos sitios diferentes.

Aunque no lo crean, esta es la forma de atacar los problemas en informática, independientemente de la complejidad que tengan el asunto que tenemos entre manos, sea el envío de un cohete a la luna, o de como variar la luminosidad de un led.

Segundo paso, programar por separado cada una de las funciones

Pasada la primera fase comenzamos a atacar cada una de las funciones, posiblemente tengamos que retocar algo mas a lo hecho, pues de momento solo tenemos un boceto de lo que será el programa, El que haya compilado con éxito no quiere decir que no cambiemos algo cuando nos parezca oportuno. Podemos resolver las funciones en el orden que prefiramos pero siempre es mas lógico hacerlo en el orden del programa y si no hay alguna razón para hacerlo de otro modo lo haremos así.

Puesta a punto de “leerpinanalogico”

Aun no sabemos leer un pin analógico de entrada, pero como existe un mandato que escribe un pin analógico de salida llama “analogWrite”, es fácil deducir que existe un mandato de lectura que por analogía se llamará “analogRead” y en efecto así es. Su sintaxis es la siguiente:

val = analogRead(analogPin)

Donde

  • “val” es el resultado calculado por el mandato, un número entero comprendido entre 0 y 1023 y que es proporcional al voltaje medido por el pin analógico que en Arduino UNO se moverá entre 0 y 5 voltios.
  • “analogRead”, que podríamos traducir como (analogicoLeer), es el nombre del mandato.
  • “analogPin” es el parámetro de entrada, que o bien es directamente el número del pin analógico de entrada. (en Arduino UNO, un valor comprendido entre 0 y 5) o bien una variable numérica que tenga asignado uno de estos valores.

Como ocurre con el mandato “analogWrite”, no hay nada que declarar en la función “setup”, pero nosotros nos tendremos que ocupar de elegir los pines adecuados a lo que queramos hacer.

Sabiendo esto ya es muy sencillo escribir nuestra función

int leerpinanalogico(int numpin){
int valor =o;
valor = analogRead(numpin) ;
return (valor); }

Llegado a este punto conviene utilizar un poco el sentido común. Las funciones se utilizan para simplificar el entendimiento y resolución del programa y su puesta a punto. No lo facilitan los casos en que es tan sencillo lo que vamos a hacer, que queda extremadamente claro puesto directamente en el cuerpo del programa.

Mi regla, (que como todas las reglas está llena de excepciones), es, no utilizar funciones que tengan menos de siete lineas, lo que excluido el encabezamiento y la linea de return supone que los cálculos a realizar ocupa al menos 4 líneas. Consecuentemente pongo directamente lineas de programación directamente en el cuerpo del programa y elimino esta función.

El programa quedara por tanto así

/* Sketch 8.1 Variar el brillo de un led mediante un potenciómetro
* Leer la entrada analógica (0) y dejar en el valor en “val”
* Calcular el valor “num” en proporción a el valor de “val”
* Abrir el pin PWM 10 de acuerdo con “num”
* Al cabo de un tiempo repetir el proceso
*/
// Área de definición de variables y parámetros *******************
int pinanalog =0; // pin analógico (A0)
int pinpwm =9; // pin PWM (9)
int val =0; // recoge el valor de la lectura
int num =0; // escribe pin PWM
int tiempo = 200; // tiempo para poder hacer la lectura
// Función setup *******************************************
void setup() { }
// Función loop ********************************************
void loop() {
val = analogRead(pinanalog) ;
num = valorproporcional (val);
encenderPWM(pinpwm, num);
delay (tiempo);
} //fin loop ***********************************************
// Área de definición de funciones *****************************
int valorproporcional (int valor){
int numero;
return (numero); }
void encenderPWM (int pinPWN, int numpin){ }

Como siempre que damos un paso, compilamos y probamos. Eso si necesito saber que ha leído el pin, lo cual es sencillo en el simulador, estudiando los diferentes valores que toma “val” y como existe un delay, hay “tiempo” para verlo tranquilamente. Ahora bien, nos falta saber como se pone una resistencia variable en el simulador UnoArduSim cosa que paso a contar ahora mismo

Utilizar resistencias en UnoArduSim

Para hacer pruebas con pines de lectura digital necesitamos simular en las entradas de esos pines voltajes equivalentes a los que van a tener en la realidad. Para ello el simulador tiene unos “potenciómetros simulados” con un cursor de tipo lineal, que según se posicione simula una entrada con un voltaje que puede fluctuar entre los 0 y los 5 voltios. Este cursor se puede mover cuando el programa está en marcha simulando que modificamos el potenciómetro y con ello la respuesta de la lectura del pin analógico de entrada que tenemos asociado al potenciómetro.

UnoArduSim esta provisto de unos elementos que se llaman “Analog Slider Pairs” (Pares Deslizadores Analógicos), que son un par de regletas, (o sea dos componentes independientes exactamente iguales). Con esos deslizaderos podremos simular de forma aproximada el voltaje que vamos a producir en cada una de las entradas analógicas. En este caso, aunque solicitemos dos. que es lo menos que se permite, solo vamos a utilizar uno.

La forma de hacerlo es muy sencilla se accede a la configuración de los componentes por la forma habitual. Menú “Configure”, (Configuración), I/O Devices (Dispositivos de INPUT/OUPUT) y llegamos a esta pequeña pantalla a la que añadimos 1 Analog Slider Pairs (Pares Deslizantes Analógicos), observarán que aunque pidan un solo par, el contador de dispositivos solicitados marca el doble, cuando se diga OK aparecerá el par de barras deslizadoras donde podemos mover el cursor de arriba a abajo simulando con ello el voltaje que que recibirá la entrada analógica escrita como A0 … A5, tal como se ve en estas dos pantallas.

Observan en el rincón superior izquierda el led rojo (R) asociado a la salida numero 9 y en el rincón inferior opuesto, dos deslizadores, uno asociado a la salida A0 y otro no asociado, El simulador obliga a sacar los potenciómetros por pares, pero permite dejarlos sin adjudicar a nadie. Observen igualmente que el pin A0 está en color azul muestra una “I” de INPUT y un “0” porque el voltaje lo tenemos ahora como “0” a medida que lo elevemos pasara al valor “?” que indica que no sabe que valor dar en caso de se utilizado como digital y llegara a “1” cundo el deslizador se aproxime a los 5v.

Pruebas de la función “leerpinanalogico”
Aprendido a poner los potenciómetros podemos pasar a hacer las pruebas

Observa en el vídeo que a medida que modifico el voltaje en el deslizador, el importe de “val” cambia, siendo inicialmente el valor de entrad próximo a 5Voltios, “val” se aproxima a 1023 y a medida que bajamos el deslizador, baja también el valor de “val”

También observaran que la simulación de las salidas PWM es bastante deficiente, en vez de brillar con más o menos intensidad que es como se ve en la realidad lo que hace es parpadear de forma mas o menos rápida pero de forma perceptible. Esto es lo má que hace este simulador pero es suficiente al menos para probar el programa.

Puesta a punto de “valorproporcional”

Hemos visto que de entrada los valores varían entre 0 y 1023 mientras que de salida solo pueden variar entre 0 y 255, o sea que exactamente por cada cuatro unidades leídas en la entrad analógica podemos aumentar una única unidad en la salida PWM.

Por tanto “num” es igual a “val “ dividido entre cuatro, pero como hemos definido valores del tipo “int” o lo que es lo mismo “integer”, (“entero”), no se pueden aceptar números decimales. Es decir, la división finaliza cuando se terminan de calcular los números enteros. Por tanto, igual da si por ejemplo, dividimos entre 4, 204. 205, 206, ó 207 el resultado será 51. Podemos conseguir al menos que el redondeo no sea siempre por defecto sumando 2 unidades a “num”.

En el caso anterior las cantidades a dividir serian entonces 206, 207, 208 y 209 que al dividir por cuatro y despreciar los decimales, daría 51 en los dos primeros casos y 52 en los dos últimos, lo cual es un poco mas preciso, aunque en nuestro ejemplo, tanto nos va a dar porque no vamos a ser capaces de apreciar la diferencia de brillo entre 51 y 52, pero en principio lo bien hecho, bien hecho esta.

Así pues los cálculos de esta función quedan como:

num = (val +2)/4

y como solo ocupa una linea, tampoco la vamos a utilizar como función y la ponemos directamente en el programa, que quedará:

/* Sketch 8.1 Variar el brillo de un led mediante un potenciómetro
* Leer la entrada analógica (0) y dejar en el valor en “val”
* Calcular el valor “num” en proporción a el valor de “val”
* Abrir el pin PWM 10 de acuerdo con “num”
* Al cabo de un tiempo repetir el proceso
*/
// Área de definición de variables y parámetros *******************
int pinanalog =0; // pin analógico (A0)
int pinpwm =9; // pin PWM (9)
int val =0; // recoge el valor de la lectura
int num =0; // escribe pin PWM
int tiempo = 200; // tiempo para poder hacer la lectura
// Función setup *******************************************
void setup() { }
// Función loop ********************************************
void loop() {
val = analogRead(pinanalog) ;
num = (val +2) / 4;
encenderPWM(pinpwm, num);
delay (tiempo);
} //fin loop ***********************************************
// Área de definición de funciones *****************************
void encenderPWM (int pinPWN, int numpin){ }

Puesta a punto de “encenderPWM”

Es algo que ya sabemos hacer de lecciones anteriores y tampoco tiene mas misterio, también lo resolvemos en una linea que diga

analogWrite(pinpwm, num)

con lo que el programa finalmente quedara su in ninguna de las funciones, algo que será muy poco probable que ocurra normalmente

/* Sketch 8.1 Variar el brillo de un led mediante un potenciómetro
* Leer la entrada analógica (0) y dejar en el valor en “val”
* Calcular el valor “num” en proporción a el valor de “val”
* Abrir el pin PWM 10 de acuerdo con “num”
* Al cabo de un tiempo repetir el proceso
*/
// Área de definición de variables y parámetros *******************
int pinanalog =0; // pin analógico (A0)
int pinpwm =9; // pin PWM (9)
int val =0; // recoge el valor de la lectura
int num =0; // escribe pin PWM
int tiempo = 200; // tiempo para poder hacer la lectura
// Función setup *******************************************
void setup() { }
// Función loop ********************************************
void loop() {
val = analogRead(pinanalog) ;
num = (val + 2) / 4;
analogWrite ( pinpwm, num) ;
delay (tiempo);
} //fin loop ***********************************************

Probamos finalmente todo el programa y …. nos sale el siguiente error;

ERROR DE EJECUCION DEL PROGRAMA DE USUARIO
El ciclo de trabajo debe estar entre 0,0 y 1,0 (valor pasado 0 a 255)
Valor = 256

Parecía que todo estaba bien y pero hay un pequeño problema, nos hemos pasado de listos

Si val =0 aplicando la fórmula num = 2/4 = 0, lo cual es correcto, pero si val=1023 (el máximo valor que puede registrar), aplicando la fórmula sale num = 1025/4 = 256 y el valor máximo que permite las Salidas PWM son 255.

Así que para evitar esto vanos a eliminar el 2 que sumábamos para redondear y que redondee siempre a la baja, De esta forma si val es 0, 1 2 o 3, la salida es siempre 0, pero si val es 1020, 1021, 1022, 1023, el valor es 255, que es el máximo posible con cualquiera de los valores.

Arreglamos el programa, probamos y definitivamente el sketch queda como:

/* Sketch 8.1 Variar el brillo de un led mediante un potenciómetro
* Leer la entrada analógica (0) y dejar en el valor en “val”
* Calcular el valor “num” en proporción a el valor de “val”
* Abrir el pin PWM 10 de acuerdo con “num”
* Al cabo de un tiempo repetir el proceso
*/
// Área de definición de variables y parámetros *******************
int pinanalog =0; // pin analógico (A0)
int pinpwm =9; // pin PWM (9)
int val =0; // recoge el valor de la lectura
int num =0; // escribe pin PWM
int tiempo = 200; // tiempo para poder hacer la lectura
// Función setup *******************************************
void setup() { }
// Función loop ********************************************
void loop() {
val = analogRead(pinanalog) ;
num = val / 4;
analogWrite ( pinpwm, num) ;
delay (tiempo);
} //fin loop ***********************************************

Probar, probar, probar,…

Con todo esto se demuestras dos cosas, que cuanto mas se prueben y sobre todo cuento mas se prueben los casos extremos, más probable es que el sketch no contenga errores, pero que nunca es posible decir que un programa carece de errores, sino sólo que en nuestras pruebas el sketch se comporta correctamente. Como nunca podemos probar todas las circunstancias posibles nunca tendremos la certeza de haber hecho un sketch perfecto.

Consideración sobre los errores informáticos

Por poner un caso real, con mucho, la informática mejor y más profundamente probada son los programas que se aplican en vuelos espaciales, pues ahí un error es irreparable, (y carísimo), si falla cualquier cosa, una vez lanzado el cohete.

Pues bien, recuerdan que cuando se mando el observatorio astronómico Hubble, allá por el año 1990, se descubrió el peor error que puede tener un telescopio, que era miope debido a un fallo en el programa de pulido del espejo primario del telescopio, pues en uno de los múltiples programas informáticos que utilizaba la pulidora, se había colado inadvertidamente un “+” cuando debía haber un “-”
.
Indudablemente se hicieron miles de pruebas, tanto del programa como de la lente, pero por lo que fuera el error paso inadvertido, probablemente por la absurda confianza que nos produce que algo lo ejecute una máquina numérica y no algo artesanal. Este error se descubrió ya cuando era tarde y el telescopio estaba en órbita, Hubo que mandar unos astronautas para que en el espacio pusieran “gafas correctoras”, Comprenderán que si cosas así pasan en la NASA, qué no pasará en otros lugares mas descuidados, entre otras cosas porque no hay tanto dinero en juego y porque la corrección de errores a posteriori, no supone problemas graves.

Deben saber que la prueba exhaustiva de un programa supone mucho mas horas hombre que el diseño del programa por lo que en casi todos los proyectos las pruebas es algo que se realiza bastante por encima, y que liego posteriormente se corrigen errores estando ya el objeto en funcionamiento real. Por ello no deben extrañarse cuando acuden a cualquier sitio y les dicen que “se les ha caído el sistema”, estas cosas pasan y si imposible asecurar un funcionamiento en el 100%, de los casos, pero se podría evitar en muchos de ellos, si se invirtiera mas en la puesta a puntos de programas, pero como digo eso es muy caro pasado un cierto punto razonable de seguridad.

Prueba en real

Ahora es el momento de montar el circuito de acuerdo con el esquema y cargar y compilar el programa y hacer la prueba final en real, Lo mñás probable esque los posibles errores de que podamos detectar sean debido a errores en el montaje de los componentes.

Repaso

Como repaso final te diré lo que has aprendido hoy

  • Aprender que los pines de entrada analógica son además pines digitales.
  • Que son los potenciómetros, que tipos hay y como se utilizando.
  • Identificar como se conectan las patas de un potenciómetro.
  • Aprender a analizar cualquier Sketch.
  • Utilidad de la compilación del boceto del Sketch.
  • Aprender a utilizar funciones y la ventaja de su uso.
  • Cómo decidir si utilizar funciones o no utilizarlas.
  • Sintaxis y manejo del mandato “analogRead”.
  • Utilizar potenciómetros en UnoArduSim.
  • Importancia de probar y problemas de la fiabilidad de los Sketch.
  • Finalizar haciendo las pruebas en realidad.

Ejercicios para resolver

1– Linterna multiuso con potenciómetro

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.

Próximamente presentare una solución a estos problemas.

Félix Maocho

indice

.

Anuncios

31 marzo 2017 - Posted by | Curso de Arduino, Robotica | , , , , ,

1 comentario »

  1. Reblogueó esto en tomtom_max.

    Comentario por tomtom_max | 4 abril 2017 | Responder


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: