Archivo de la categoría: Programación

Entendiendo ASCII en el desarrollo de lenguaje de máquina integrado

Este artículo, que sirve como preparación para una discusión de cadenas (strings) en lenguaje C, presenta el concepto de caracteres ASCII y explica dos beneficios de las técnicas de codificación basadas en ASCII.

Un microprocesador o microcontrolador es una colección compleja de circuitos que manipulan voltajes lógicos altos y voltajes lógicos bajos. Para mayor comodidad, nos referimos a estos voltajes como unos y ceros, y diseñamos los procesadores de manera que estos unos y ceros puedan manipularse en conjunto y tratarse como números binarios.

La mayoría de la gente se volvería loca o se quedaría dormida si se vieran obligados a observar el flujo interminable de números binarios dentro y fuera de un microprocesador. La tecnología computacional ha transformado la existencia humana porque estos números binarios se pueden usar para representar cosas que a las personas realmente les importan: música, fotografías o, en el caso del ASCII, letras y dígitos.

Entendiendo el ASCII

ASCII significa Código Estándar Americano para el Intercambio de Información (American Standard Code for Information Interchange = ASCII). En este código, un número binario significa exactamente un caracter, donde «caracter» se refiere a una letra mayúscula, una letra minúscula, un dígito, un signo de puntuación, o varias otras cosas que se pueden encontrar en un teclado. La siguiente tabla le brinda la «traducción» entre los números (aquí, escrita en notación decimal en lugar de binaria) y los caracteres ASCII correspondientes al alfabeto en mayúsculas y minúsculas.

(Nota: Quede claro que cuando en EEUU dicen “americano” se refieren a algo que se aplica solamente a ellos, no a toda América. Quedaba afuera, en principio, toda letra que no se usa en el inglés actual, letras con acentos, diéresis, circunflejo, tildes, y otras diferenciaciones fonéticas en otros idiomas, y por eso se creó la tabla de ASCII extendido, que está incluida más abajo).

Es esencial comprender que su microcontrolador no sabe nada acerca de las letras del inglés u otra lengua (y menos aún de los caracteres acentuados de diferentes maneras o especiales en cada idioma), los signos de puntuación o los dígitos. Su microcontrolador es una máquina muy pequeña, diseñada para procesar números binarios, y cualquier carácter que esté presente en su lenguaje de máquina (firmware) es simplemente su interpretación de los números binarios.

Se puede producir una seria confusión debido a la impresión errónea de que sus variables, o elementos de matriz, contienen realmente caracteres ASCII de una forma u otra. El desarrollo de firmware se vuelve más claro, más ágil y más flexible cuando uno se da cuenta de que los caracteres en realidad son números binarios, y se pueden almacenar, transferir y manipular como números binarios; no se convierten en caracteres ASCII hasta que esté todo listo para interpretarlos como caracteres ASCII.

ASCII Extendido

Beneficios y contras del ASCII

El ASCII es necesario para la programación humana. Hay muchas aplicaciones integradas que pueden beneficiarse del uso de caracteres ASCII, y creo que es una buena idea adquirir el hábito de reconocer situaciones en las que se puede incorporar caracteres ASCII en su código.

Un estándar ampliamente utilizado

Un beneficio innegable de ASCII es la estandarización. Los entornos de desarrollo integrado, los programas de terminal y los paquetes de software computacional comprenden el ASCII y, por lo tanto, los caracteres ASCII son una forma conveniente y efectiva de transferir y mostrar información.

En este ejemplo, una aplicación muestra una representación binaria basada en datos de un sensor:

Transferencia de datos confiable

Un beneficio más sutil, pero quizás igual de importante, es el hecho de que el ASCII proporciona un medio para representar información utilizando un conjunto restringido de números binarios. Cualquier valor numérico puede representarse mediante una secuencia de los dígitos ASCII del 0 al 9 (junto con el punto decimal ASCII si es necesario). Estos caracteres ASCII corresponden a un subconjunto muy pequeño de los 256 valores ofrecidos por un número binario de 8 bits. Pero ¿por qué esto importa?

Imagine que tiene una aplicación en la que un microcontrolador debe transferir mediciones impredecibles y altamente variables de sensores de 8 bits a una PC. Si se transfieren los datos como números binarios ordinarios, un byte individual puede contener un número cualquiera del 0 al 255. Esto nos deja sin una forma conveniente y sencilla de organizar datos o incorporar comandos en el flujo de datos, porque para transferir las mediciones en bruto solo son necesarios todos los números binarios posibles. El PC (y menos nosotros) no puede distinguir entre los datos de medición numéricos y otros tipos de información.

Si se transfieren los datos de medición utilizando caracteres ASCII en lugar de números binarios ordinarios, entran en juego los beneficios de un conjunto restringido. Solo se necesitan diez valores binarios (correspondientes a los dígitos ASCII del 0 al 9) para representar los datos numéricos, y varios otros valores binarios pueden reservarse para una funcionalidad especial, porque nunca aparecerán en los datos de medición.

Aquí, los dígitos ASCII se utilizan para transferir una lectura de temperatura. El final de cada lectura se identifica con un retorno de carro (abreviado CR = Carrier Return); el valor binario correspondiente a CR nunca aparecerá en los datos de medición.

Reducción de la eficiencia

El precio que se paga por esta estandarización y transferencia de datos mejorada es que se usa con menos eficiencia la memoria, el ancho de banda del procesador y el ancho de banda de la comunicación.

El ASCII es un sistema basado en bytes. Cada carácter requiere ocho bits, incluyendo, por ejemplo, el dígito «1», que en circunstancias binarias normales puede representarse mediante un número de 1 bit en lugar de un número de 8 bits.

En la experiencia de un programador actual, esto rara vez es un problema serio; los microcontroladores modernos tienen recursos de procesamiento y memoria que exceden con creces los requisitos de muchas aplicaciones. Sin embargo, si realmente se necesita maximizar el rendimiento o minimizar el uso de la memoria, es posible que debamos renunciar a la conveniencia de usar ASCII.

De ASCII a cadenas de caracteres

Este artículo no es solo una descripción general de ASCII sino también una introducción a la forma en que se maneja una representación basada en caracteres en el lenguaje de programación C. Nos referimos a este tipo de representación como una cadena (string), que es una secuencia o «encadenamienro» de caracteres ASCII.

Veremos más en detalle las cadenas en un próximo artículo.

Servidor web básico NodeMCU con IDE de Arduino

Deja un comentario

Diseñamos aquí un servidor HTTP básico con una placa NodeMCU con ESP8266 y el IDE de Arduino

Para más referencia de cómo agregar la familia de plaquetas y las bibliotecas necesarias para la familia ESP, les ofrezco leer el reciente artículo ESP8266 (WiFi): Hacer que parpadee un LED desde el IDE de Arduino (más básico que este) donde se desarrollada con mucho detalle tanto que es un ESP8266 como esta instalación.

Es posible que la comunidad ESP no tenga mucho entusiasmo en programar con Arduino, y sí hacerlo con las herramientas propias de la línea del ESP8266. Y es totalmente lógico y razonable. Pero a veces es un alivio disponer de la facilidad del uso del IDE de Arduino y su lenguaje simplificado, más cuando uno está acostumbrado a estas herramientas.

Por eso se ha escrito una biblioteca (o librería) y definición de placas, para programar esta versátil y potente línea con el IDE de Arduino.

Usaremos una placa NodeMCU, que contiene un módulo ESP12E, versión 1.0, un cable USB adecuado para esta placa y una computadora conectada a Internet. El ESP8266, el chip básico del sistema, requiere una red WiFi, así que suponemos que ese tipo de conexión estará disponible.

Definición de dispositivos y librería

Necesitamos disponer del IDE de Arduino, una versión actualizada. La última que ofrece oficialmente http://arduino.cc es la 1.8.8. Si usted está trabajando con una de versión anterior a 1.8.x le recomiendo actualizar.

Copio aquí la explicación del artículo anterior. Si ya instaló en esa ocasión, no tiene que hacer todo esto y puede saltar a la sección Diseño del servido http básico, más abajo.

El ESP8266 se puede programar desde el IDE de Arduino. Para eso hay que instalar lo que se llama un plugin, en el que está incluido todo lo necesario para compilar y subir programas que fueron escritos tal como si fuesen .INO de Arduino.

Debemos incorporar librerías y los programas de manejo de las placas con el chip ESP8266 a nuestro IDE. Para hacerlo, debemos indicarle la URL desde donde se obtienen.

Para hacerlo, debemos abrir el menú Archivo, y luego Preferencias.

Veremos este panel, en la parte inferior el recuadro de texto rotulado Gestor de URLs Adicionales de Tarjetas. Dentro de él, usando copiar y pegar, se debe introducir el texto indicado aquí:

http://arduino.esp8266.com/stable/package_esp8266com_index.json

(copie y pegue en el recuadro):

Luego pulse en el botón Ok.

Ahora debemos ir al menú Herramientas, luego Placa.

Y finalmente Gestor de Tarjetas, se abrirá una ventana como la que sigue, en la cual escribimos, en el recuadro superior de filtro/busqueda, “ESP8266” (antes de terminar de escribir ya aparecerá el Gestor de Tarjetas que buscamos, que indica que fue creado por “ESP8266 Community”. Allí pulsamos sobre Instalar:

Al abrir nuevamente Herramientas, y luego Placa, deslizamos la lista para ver lo que aparece al final de ella (abajo), y vemos que ya existen las opciones referidas a los ESP8266:

Así queda todo preparado para programar NodeMCU ESP12E desde el IDE Arduino.

Servidor HTTP básico

Este pequeño servidor que proponemos muestra el título que elijamos en nuestro navegador. Hemos elegido escribir «Saludos de Robots Argentina», pero el texto es a elección del programador.

Declaramos la librería ESP8266WiFi.h al inicio, definimos el nombre y el password de la red (la de su proveedor y la de su conexión; y un puerto.

#include <ESP8266WiFi.h>

//Nombre de red
const char* nombre = "el_nombre_que_le_asigno_el_proveedor";

//Password
const char* password = "su_clave_para_conectarse";

// Puerto (se suele usar 80 por defecto, pero en algunos casos hay que
// consultar al proveedor de internet de cual dispone en su conexion)
WiFiServer server(80);

#include <ESP8266WiFi.h>

//Nombre de red

const char* nombre = "el_nombre_que_le_asigno_el_proveedor";

//Password

const char* password = "su_clave_para_conectarse";

// Puerto (se suele usar 80 por defecto, pero en algunos casos hay que

// consultar al proveedor de internet de cual dispone en su conexion)

WiFiServer server(80);

En la función setup() inicializamos el puerto Serial. A través de él podremos monitorear desde la PC para saber a qué IP se ha conectado la placa.

void setup() {
  Serial.begin(115200);
  delay(50); // breve espera para que se concrete la conexion

void setup() {

Serial.begin(115200);

delay(50); // breve espera para que se concrete la conexion

Ahora se realiza la conexión a la red WiFi. Si se logra, lo indica por serie y lo veremos en el Monitor Serie del IDE.

// Conexion al WiFi 
  WiFi.begin(nombre, password);
  while (WiFi.status() != WL_CONNECTED)
    delay(100); //aqui debemos esperar unos instantes
  Serial.println("Conexión exitosa a WiFi");

// Conexion al WiFi

WiFi.begin(nombre, password);

while (WiFi.status() != WL_CONNECTED)

delay(100); //aqui debemos esperar unos instantes

Serial.println("Conexión exitosa a WiFi");

Puesta en operación del servidor.

// Iniciar el servidor
  server.begin();
  Serial.println("Iniciado el servidor");

// Iniciar el servidor

server.begin();

Serial.println("Iniciado el servidor");

Mostrar por Monitor Serie la dirección IP que le ha otorgado a la placa el router de la red.

// Escribir la direccion IP
  Serial.print("el IP es: ");
  Serial.print(WiFi.localIP());
  Serial.println("");
}

// Escribir la direccion IP

Serial.print("el IP es: ");

Serial.print(WiFi.localIP());

Serial.println("");

}

En la función loop() se comprueba si está establecida la nueva conexión. Si así es, se envía el contenido de la página web, que consta de cabeceras HTML y el contenido que deseamos para la página.

void loop() {
  // Comprobar si se ha conectado algun cliente
  WiFiClient client = server.available();
  
  if (client) {
    Serial.println("Nueva conexion");
   
    // Escribir las cabeceras HTML
    client.println("HTTP/1.1 200 OK");
    client.println("Content-Type: text/html");
    client.println("");
    client.println("<!DOCTYPE HTML>");
  
    //Escribir el contenido que vamos a visualizar
    client.println("<html>");
    client.println("<body>");
    client.print("Saludos de Robots Argentina");
    client.println("</body>");
    client.println("</html>");
  }
  delay(1000); // reescribe cada 1 segundo
}

void loop() {

// Comprobar si se ha conectado algun cliente

WiFiClient client = server.available();

if (client) {

Serial.println("Nueva conexion");

// Escribir las cabeceras HTML

client.println("HTTP/1.1 200 OK");

client.println("Content-Type: text/html");

client.println("");

client.println("<!DOCTYPE HTML>");

//Escribir el contenido que vamos a visualizar

client.println("<html>");

client.println("<body>");

client.print("Saludos de Robots Argentina");

client.println("</body>");

client.println("</html>");

}

delay(1000); // reescribe cada 1 segundo

}

Programa completo:

#include <ESP8266WiFi.h>
 
//Nombre de red
const char* nombre = "el_nombre_que_le_asigno_el_proveedor";
 
//Password
const char* password = "su_clave_para_conectarse";
 
// Puerto (se suele usar 80 por defecto, pero en algunos casos hay que
// consultar al proveedor de internet de cual dispone en su conexion)
WiFiServer server(80);

void setup() {
  Serial.begin(115200);
  delay(50); // breve espera para que se concrete la conexion

  // Conexion al WiFi 
  WiFi.begin(nombre, password);
  while (WiFi.status() != WL_CONNECTED)
    delay(100); //aqui debemos esperar unos instantes
  Serial.println("Conexión exitosa a WiFi");

// Iniciar el servidor
  server.begin();
  Serial.println("Iniciado el servidor");

  // Escribir la direccion IP
  Serial.print("el IP es: ");
  Serial.print(WiFi.localIP());
  Serial.println("");
}

void loop() {
  // Comprobar si se ha conectado algun cliente
  WiFiClient client = server.available();
  
  if (client) {
    Serial.println("Nueva conexion");
   
    // Escribir las cabeceras HTML
    client.println("HTTP/1.1 200 OK");
    client.println("Content-Type: text/html");
    client.println("");
    client.println("<!DOCTYPE HTML>");
  
    //Escribir el contenido que vamos a visualizar
    client.println("<html>");
    client.println("<body>");
    client.print("Saludos de Robots Argentina");
    client.println("</body>");
    client.println("</html>");
  }
  delay(1000); // reescribe cada 1 segundo
}

#include <ESP8266WiFi.h>

//Nombre de red

const char* nombre = "el_nombre_que_le_asigno_el_proveedor";

//Password

const char* password = "su_clave_para_conectarse";

// Puerto (se suele usar 80 por defecto, pero en algunos casos hay que

// consultar al proveedor de internet de cual dispone en su conexion)

WiFiServer server(80);

void setup() {

Serial.begin(115200);

delay(50); // breve espera para que se concrete la conexion

// Conexion al WiFi

WiFi.begin(nombre, password);

while (WiFi.status() != WL_CONNECTED)

delay(100); //aqui debemos esperar unos instantes

Serial.println("Conexión exitosa a WiFi");

// Iniciar el servidor

server.begin();

Serial.println("Iniciado el servidor");

// Escribir la direccion IP

Serial.print("el IP es: ");

Serial.print(WiFi.localIP());

Serial.println("");

}

void loop() {

// Comprobar si se ha conectado algun cliente

WiFiClient client = server.available();

if (client) {

Serial.println("Nueva conexion");

// Escribir las cabeceras HTML

client.println("HTTP/1.1 200 OK");

client.println("Content-Type: text/html");

client.println("");

client.println("<!DOCTYPE HTML>");

//Escribir el contenido que vamos a visualizar

client.println("<html>");

client.println("<body>");

client.print("Saludos de Robots Argentina");

client.println("</body>");

client.println("</html>");

}

delay(1000); // reescribe cada 1 segundo

}

Copiamos el programa en el IDE del Arduino, y ahora, antes de probar si se compila correctamente, debemos conectar la placa NodeMCU a USB y decirle al IDE de Arduino qué tipo de placa vamos a programar. Debemos elegir en Herramientas el «NodeMCU 1.0 (ESP-12E Module)». Si usted tiene otro tipo de placa con ESP8266 y sabe cómo conectarla a USB, elija en la lista su módulo correcto y todo funcionará del mismo modo. Espere a que el IDE detecte la placa y defina en que número de COM serie está.

Cargar el programa

Dentro del menú «Herramientas» cambiamos el tipo de placa por una NodeMCU 1.0 (ESP-12E Module), o el modelo que tengamos.

Al elegir y si se conecta bien indicará estos valores: frecuencia de la CPU: 80 MHz, tamaño de flash: 4M (1M SPIFFS), velocidad de carga: 115200. El puerto dependerá de la máquina (en Linux puede ser /dev/ttyUSB0 o /dev/ttyUSB1).

Determinada esta elección dispositivo y conexión COM, ya se puede cargar el programa de la manera habitual.

Al correr el programa nos indicará en qué dirección IP encontramos la página web que hemos creado en la placa. Introduciéndola en la barra de dirección del navegador, podremos verla con el mensaje que hemos elegido. Si este mensaje tuviese una parte variable, por ejemplo algún valor que varía, como el registro de un sensor de temperatura u otro indicador, y/o la hora/minuto/segundo.

Artículos relacionados: ESP8266 (WiFi): Hacer que parpadee un LED desde el IDE de Arduino

Comprendiendo Variables al programar en C

Deja un comentario

Este es un análisis de la naturaleza y el uso de las variables en lenguaje C en el contexto de las aplicaciones para microcontroladores

Muchos de nosotros escuchamos la palabra «variable» en las clases de matemáticas mucho antes de saber mucho, si es que sabemos algo, acerca de la programación de computadoras. Una variable matemática es una cantidad cuyo valor no se conoce o no se limita a un número. Este uso es similar, aunque no idéntico, al concepto de una variable C.

Dos diferencias importantes: primero, en matemáticas, usualmente usamos una letra como x o y para representar una variable, mientras que en C usamos frecuentemente una palabra o frase descriptiva como contadorPulsos, velocidadMedia o cantidadVueltas. En segundo lugar, hay situaciones en las que usamos una variable de C para identificar una cantidad conocida y que no se pretende que cambie del valor original.

Variables en hardware

Las variables son convenientes e intuitivas para los programadores. Para el hardware computacional, por otro lado, no tienen un significado real. Los microprocesadores almacenan datos en registros y ubicaciones de memoria. Esta diferencia fundamental entre las personas que escriben el idioma de máquina y las máquinas que ejecutan este programa se supera mediante lenguajes de alto nivel como C, que maneja varios detalles asociados con la traducción entre variables basadas en texto y la realidad física de un procesador.

Los diseñadores de sistemas integrados trabajan a menudo con procesadores de 8 bits. En estos dispositivos, por lo general, el tamaño fundamental de los datos es un byte. La memoria se organiza de acuerdo con los bytes, el tamaño de los registros es de un byte y la CPU está diseñada para procesar datos de 8 bits. Esta es una limitación bastante incómoda porque hay muchas situaciones en las que el valor de una variable excederá el valor máximo de un número de 8 bits.

Finalmente, todas las variables C cuidadosamente definidas y con un nombre ilustrativo terminan como bits en la memoria (o registros)

El lenguaje C no limita el tamaño de una variable a 8 bits, incluso cuando está trabajando con un procesador de 8 bits. Esto significa que una variable en el programa en lenguaje de máquina que ejecuta el microprocesador puede corresponder a múltiples registros o ubicaciones de memoria en el hardware. «Manualmente» administrar variables de múltiples bytes (es decir, a través del lenguaje ensamblador) no parece muy deseable, pero a los compiladores no les importa en absoluto, y hacen el trabajo muy bien.

Definiendo variables

El primer paso para usar una variable es definir esa variable. Los componentes esenciales de una definición de variable son el tipo y el nombre.

Hay muchos tipos de variables; La lista completa, así como los detalles de la implementación del hardware, variarán según el compilador que esté utilizando. Aquí hay unos ejemplos:

■ char : un valor con signo de un byte
■ int : un valor con signo de dos o cuatro bytes
■ long : un valor con signo de cuatro bytes
■ float : un valor de cuatro bytes que puede tener números después del punto decimal; en otras palabras, no está limitado a enteros
■ bit : el valor de la variable puede ser cero o uno

Esta es una representación visual de cómo una serie de bits se interpreta de manera diferente en función de si una variable se considera con signo (utilizando la notación de complemento a dos) o sin signo:

El siguiente código muestra definiciones de variables que consisten solo en un tipo básico y un nombre (la forma más técnica de referirse al nombre es «identificador»):

int ADC_result;
char ReceivedByte;
float Reference_Voltage;

int ADC_result;

char ReceivedByte;

float Reference_Voltage;

Inicializando variables

En muchos casos, es una buena idea darle un valor inicial a una variable. Esto facilita la depuración y es esencial si la variable se utilizará antes de que le fije un valor conocido. Puede inicializar una variable en la definición, o en otra parte de su código, pero incluir el valor inicial en la definición es una buena manera de mantener el código organizado y desarrollar el hábito de inicializar siempre que sea necesario.

Aquí hay ejemplos de definiciones de variables que incluyen una inicialización:

int ADC_resultado = 0;
char ReceivedByte = 0x00;
float Referencia_Voltaje = 3.25;

int ADC_resultado = 0;

char ReceivedByte = 0x00;

float Referencia_Voltaje = 3.25;

Definiciones de variables delicadas

Hay varias otras palabras que se pueden incluir en una definición de variable. Estos se utilizan para especificar con mayor precisión la naturaleza de la variable o para dar instrucciones al compilador sobre cómo implementar la variable en el hardware.

Las siguientes palabras clave podrían ser útiles en sus proyectos de programa para microcontroladores:

■ unsigned : como habrá adivinado, esto le dice al compilador que interprete la variable como un valor sin signo en lugar de un valor con signo. Uno defino le mayoría de sus variables como sin signo, porque rara vez se necesitan números negativos.

■ const : el calificador de tipo const indica al compilador que el valor de una variable no debe cambiar. Como dice al principio del artículo, a veces el valor de una «variable» C no es variable. Si usted comete un error en su código e intenta modificar el valor de una variable const, el compilador generará un error.

■ volatile : los compiladores sofisticados no solo toman su código original y lo traducen directamente al lenguaje de máquina. También intentan hacer que el código funcione de manera más eficiente, y este proceso se conoce como «optimización». En general, la optimización es algo bueno. Sin embargo, de vez en cuando, puede arruinar el día, porque el compilador se optimiza solo en función del código y no puede tener en cuenta los eventos de hardware que interactúan con el código. Cuando una variable tiene el calificador de tipo volátil, el compilador sabe que debe tener cuidado con las optimizaciones relacionadas con esa variable.

Una interrupción puede hacer que el valor de una variable se modifique de una manera que el compilador no espera, y esto puede llevar a una optimización problemática

■ tipos de memoria, como xdata , idata y code : estas palabras obligan al compilador a ubicar una variable en una parte específica de la memoria del microprocesador. El tipo que aloja en la memoria de programa es particularmente útil: los recursos de RAM en un microcontrolador a menudo son mucho más limitados que la memoria de programa no volátil, y el tipo de memoria de código le permite utilizar memoria de programa adicional para almacenar datos que se usan en su programa pero nunca se modifican.

Aquí hay unos ejemplos:

unsigned char UART_byte; // The variable's range of acceptable values is 0 to 255. 
const float PI = 3.14159; 
volatile unsigned char ADC_Register /* The register can be modified by hardware, so we use the volatile qualifier to avoid optimizations that would cause the program to ignore hardware-generated events. */
unsigned char code CalibrationValue = 78;

unsigned char UART_byte; // The variable's range of acceptable values is 0 to 255.

const float PI = 3.14159;

volatile unsigned char ADC_Register /* The register can be modified by hardware, so we use the volatile qualifier to avoid optimizations that would cause the program to ignore hardware-generated events. */

unsigned char code CalibrationValue = 78;

Uso de las variables

No hay mucho que decir acerca de cómo usar sus variables después de que se hayan definido. En realidad, con respecto a la variable en sí, la definición es la mayor parte del trabajo. Después de eso, usted simplemente incorpora el identificador de la variable en operaciones matemáticas, bucles, llamadas a funciones, etc. Un buen compilador no solo manejará los detalles de la implementación del hardware, sino que también buscará formas de optimizar el código con respecto a la velocidad de ejecución o el tamaño del programa.

Quizás el error más común relacionado con el uso variable es un desbordamiento. Esto se refiere a una situación en la que el valor asignado a una variable está fuera del rango numérico asociado con el tipo de datos de la variable.

Se debe pensar en todos los escenarios posibles relacionados con una variable determinada y luego elegir el tipo de datos en consecuencia.

Resumen

La funcionalidad de la variable básica proporcionada por el lenguaje C es intuitiva y directa, pero hay algunos detalles que pueden ayudarlo a hacer que una aplicación integrada sea más confiable y eficiente. Si tiene alguna duda relacionada con las variables de C, no dude en preguntar en nuestro grupo en Facebook Robots Didácticos.

Ampliar la cantidad de entradas de Arduino

Deja un comentario

Para expandir la capacidad de entradas digitales se utilizan registros de desplazamiento (Shift Register en inglés) con entradas en paralelo y salida serie.

Para este ejemplo, utilizamos tres pines digitales de la placa Arduino en conjunto con el circuito integrado 74HC165 (puede ser, también, 74LS165), que nos aportará 8 entradas.

Diagrama de pines:

Se pueden conectar varios de estos chips en cadena, lo que le nos aporta 16, 24, 32 o más entradas, sin usar ningún pin digital adicional de Arduino, simplemente conectando la salida QH de un registro a la entrada de datos serie SER del otro.

En el diagrama que sigue se ve cómo es la conexión completa de dos 74HC165. Los conjuntos de llaves de corredera, llamados DIP Switch en inglés, representan a las diversas entradas que se podrían ingresar. Si son llaves que se cierran (pulsadores, microswitches, relés, salidas de colector abierto), corresponde el circuito tal como se lo ve, con un resistor de polarización (pull-up) conectado a +5V. Si se trata de salidas digitales de otros chips y placas con salidas compatible con lógica TTL, no es necesario colocar el resistor.

Con línea de puntos se indica la conexión para continuar la cadena indefinidamente. La señal CLK (pata 2) va unida entre chips, e igual la señal SH/LD (pata 1), con la única salvedad de que hay que leer la hoja de datos del microcontrolador (según cuál sea) para saber cuántas entradas de este tipo de chip TTL HC se le pueden conectar a una salida digital de Arduino.

La tabla que sigue, y el diagrama interno del chip, los agrego para ofrecer más información y mejor comprensión del funcionamiento. Se pueden encontrar más detalles en su hoja de datos.

Diagrama de tiempo

La señal SH/LD se mantiene en ALTO durante las operaciones de desplazamiento. Un pulso a BAJO en este pin ingresa nuevos datos desde las entradas al registro de desplazamiento. Cuando el pulso vuelve a ALTO, queda todo dispuesto para aplicar pulsos de CLK y desplazar uno a uno los bits del registro hacia la salida serie QH. Si hemos usado un solo chip 74HC165, con 8 pulsos se habrán leído todas las entradas a través de QH (luego de haberlo conectado a una entrada digital del Arduino). Cada chip adicional requiere 8 pulsos más. En los programas se puede entender claramente cómo se ingresan los datos a variables dentro de nuestro microcontrolador.

Leer una de las entradas del 74HC165 – Diseño del programa:

■ Se aplica un pulso de alto a bajo y luego de regreso a alto en SH/LD, y así las entradas ingresan al registro de desplazamiento (condición “LOAD”, o de carga).

■ Aplicar a la salida CLK la cantidad de pulsos necesarios, desplazando los datos, para que el bit que deseamos leer quede ubicado en la línea de salida QH.

■ Leer el valor del pin digital de entrada del Arduino.

Primer programa de prueba

Este programa lee de a un pin e indica su estado en el LED incluido en el Arduino UNO, pin 13 = LED_BUILTIN. Para determinar qué entrada queremos leer para conocer su estado, se lo indicamos tipeando los números 1 a 8 desde el teclado de la computadora a la que esté conectado el Arduino por USB.

Incluso, usando comparaciones con IF se podría elegir como comando cualquier caracter. Puede ser “a”, “b”, “c”, o “A”, “B”, “C”, o lo que usted elija. Si la entrada proviene de sensores de puertas o ventanas abiertas, o de luces encendidas, se puede usar, por ejemplo, “C” para cocina, “B” para baño, “P” para pasillo, “p” para patio, “E” para entrada, “H” para una habitación y “h” para otra habitación. Y así. Además, estas letras de comando se pueden enviar a través de un módulo Bluetooth HC-06 o HC-05 y controlar desde el teléfono celular, recibiendo la respuesta por el mismo medio.

En este programa —para simplificar— se eligió tipear un número desde el teclado para leer cada entrada. Lo más interesante es la función que lee las entradas y las desplaza hacia la salida. Se le envía como parámetro un valor numérico y entero de 1 a 8, y devuelve un 1 o un 0 según el estado de la entrada. No es difícil ampliar el código hasta la cantidad de entradas que desee.

Agregando esta función a su programa, puede usarla del modo que usted quiera.

Utilizamos este circuito, que es el mismo que servirá para todos los programas excepto el de manejo por SPI, que requiere conectar dos señales del circuito a las entradas MOSI y SCLK de esta interfaz, como luego veremos.

Disculpen si tiene un aspecto un poco antiestético, pero ocurre que es difícil cablear un conjunto de llavecitas DIP al chip 74HC165 con el programa de dibujo sin hacer cruces de cables, y que sea todo visible. Ya verán en la foto que el circuito real, en la protoboard, quedó más prolijo.

Programa para leer de a una entrada

/* Este programa no requiere el uso de bibliotecas */

int pinCargarDatos  = 8;  // Pin SH/LD: desplazar-cargar en paralelo del 165
int pinDato         = 11;  // Pin QH: salida serie del 165
int pinClock        = 12;  // Pin CLK: clock del 165

// esta funcion devuelve 1 o 0 segun el estado del pin
int leeBit(int pinLeer){
    int valorBit;
    // Pulso de carga paralela, guarda estado de las entradas
    digitalWrite(pinCargarDatos, LOW);
    digitalWrite(pinCargarDatos, HIGH);  // pulso carga datos

    // Lee el valor de bits de la salida QH del 74HC165
     for(int i = 0; i < pinLeer; i++) 
     {
        valorBit = digitalRead(pinDato); // leer el pin deseado
        digitalWrite(pinClock, HIGH);
        digitalWrite(pinClock, LOW); // pulso desplaza datos
     }
    return(valorBit);
}

void setup()
{
   Serial.begin(9600);

    // Inicializar los pines digitales
    pinMode(LED_BUILTIN, OUTPUT);
    pinMode(pinCargarDatos, OUTPUT);
    pinMode(pinClock, OUTPUT);
    pinMode(pinDato, INPUT);
    digitalWrite(pinClock, LOW);
    digitalWrite(LED_BUILTIN, LOW);
}

void loop()
{
  int numeroPin;
  char datoSerie;
  if (Serial.available() > 0) // espero el caracter tipeado
  {
    datoSerie = Serial.read();  // lo leo
    numeroPin = 8-(datoSerie-48)+1; // char ASCII en numero
    if (leeBit(numeroPin) == 1) { digitalWrite(LED_BUILTIN,HIGH); } 
      else { digitalWrite(LED_BUILTIN,LOW); }
  }
}

/* Este programa no requiere el uso de bibliotecas */

int pinCargarDatos = 8; // Pin SH/LD: desplazar-cargar en paralelo del 165

int pinDato = 11; // Pin QH: salida serie del 165

int pinClock = 12; // Pin CLK: clock del 165

// esta funcion devuelve 1 o 0 segun el estado del pin

int leeBit(int pinLeer){

int valorBit;

// Pulso de carga paralela, guarda estado de las entradas

digitalWrite(pinCargarDatos, LOW);

digitalWrite(pinCargarDatos, HIGH); // pulso carga datos

// Lee el valor de bits de la salida QH del 74HC165

for(int i = 0; i < pinLeer; i++)

{

valorBit = digitalRead(pinDato); // leer el pin deseado

digitalWrite(pinClock, HIGH);

digitalWrite(pinClock, LOW); // pulso desplaza datos

}

return(valorBit);

}

void setup()

{

Serial.begin(9600);

// Inicializar los pines digitales

pinMode(LED_BUILTIN, OUTPUT);

pinMode(pinCargarDatos, OUTPUT);

pinMode(pinClock, OUTPUT);

pinMode(pinDato, INPUT);

digitalWrite(pinClock, LOW);

digitalWrite(LED_BUILTIN, LOW);

}

void loop()

{

int numeroPin;

char datoSerie;

if (Serial.available() > 0) // espero el caracter tipeado

{

datoSerie = Serial.read(); // lo leo

numeroPin = 8-(datoSerie-48)+1; // char ASCII en numero

if (leeBit(numeroPin) == 1) { digitalWrite(LED_BUILTIN,HIGH); }

else { digitalWrite(LED_BUILTIN,LOW); }

}

Segundo ejemplo: ingresar todas las entradas a variables

El siguiente programa permite listar en el Monitor Serie el estado de los pines de entrada del circuito del ejemplo, o de una cadena de chips para ampliar 16, 24, 32 o más entradas. Tampoco necesita biblioteca. El listado se actualiza cada vez que cambia una entrada. Los comentarios explican en detalle su funcionamiento.

/* SN74HC165N_shift_reg
 * Traducido y modificado de https://playground.arduino.cc/
 * Programa para ingresar valores de 8 bits desde un 74HC165
 * (registro de desplazamiento entrada paralela/salida serie.
 * Este programa demuestra la lectura de 8 estados digitales
 * de un registro de desplazamiento 74HC165 usando solamente
 * 3 pines digitales del Arduino.
 * Se pueden conectar en cadena mas chips uniendo la salida serie
 * (pin QH) de un registro de desplazamiento a la entrada serie
 * (pin SER) del siguiente.
 * Por supuesto usted puede conectar en cadena tantos chips como
 * quiera y seguir usando solo 3 pines de Arduino (aunque hay que
 * ingresarlos en diferente variables unsigned long).
*/

// Definir la cantidad de chips que estan conectados en cadena.
#define CANTIDAD_CHIP   1

// Ancho de los datos (cuantas lineas de entrada).
#define ANCHO_DATOS  CANTIDAD_CHIP * 8

// Ancho del pulso para cargar el registro de desplazamiento
#define ANCHO_PULSO  5

// Espera opcional entre lecturas del registro de desplazamiento
#define ESPERA_DEL_CICLO 1

// Debera cambiar "int" a "long" si la cantidad
// CANTIDAD_CHIP es mayor que 2
#define TIPO_VAL_BYTES unsigned int

int pinCargarDatos  = 8;  // Pin SH/LD: desplazar-cargar en paralelo del 165
int pinDato         = 11; // Pin QH: salida serie del 165
int pinClock        = 12; // Pin CLK: clock del 165

TIPO_VAL_BYTES valoresPin;
TIPO_VAL_BYTES viejosValoresPin;

// Esta funcion es una rutina de "desplazamiento hacia adentro" que
// lee datos en serie desde el registro de desplazamiento de los chips
// y arma el estado de los pines en un unsigned integer (o long integer)
TIPO_VAL_BYTES lee_registros_desplaz()
{
    long valorBit;
    TIPO_VAL_BYTES valorBytes = 0;

    // Pulso de carga paralela para guardar el estado de las entradas
    digitalWrite(pinCargarDatos, LOW);  // pulso carga datos a BAJO
    delayMicroseconds(ANCHO_PULSO);     // duracion pulso
    digitalWrite(pinCargarDatos, HIGH); // pulso carga datos a ALTO

    // Lazo que lee el valor de cada bit de la salida serie del 74HC165
     for(int i = 0; i < ANCHO_DATOS; i++)
    {
        valorBit = digitalRead(pinDato);

        // poner el bit correspondiente en valorBytes
        valorBytes |= (valorBit << ((ANCHO_DATOS-1) - i));

        // Pulso de Clock (el flanco de subida desplaza el siguiente bit).
        digitalWrite(pinClock, HIGH);
        delayMicroseconds(ANCHO_PULSO);
        digitalWrite(pinClock, LOW);
    }
    return(valorBytes);
}

// Mostrar la lista de datos con su estado
void mostrar_valores_pines()
{
    Serial.print("Estado pines:\r\n");

    for(int i = 0; i < ANCHO_DATOS; i++)
    {
        Serial.print("  Pin-");
        Serial.print(i);
        Serial.print(": ");

        if((valoresPin >> i) & 1)
            Serial.print("ALTO");
        else
            Serial.print("BAJO");

        Serial.print("\r\n");
    }
    Serial.print("\r\n");
}

void setup()
{
    Serial.begin(9600);

    // Inicializar los pines digitales
    pinMode(pinCargarDatos, OUTPUT);
    pinMode(pinClock, OUTPUT);
    pinMode(pinDato, INPUT);

    digitalWrite(pinClock, LOW); // inicializa CLK en BAJO
    digitalWrite(pinCargarDatos, LOW); // inicializa carga datos a BAJO

    // Leer y mostrar los estados de los pines la 1ra vez
    valoresPin = lee_registros_desplaz();
    mostrar_valores_pines();
    viejosValoresPin = valoresPin;
}

void loop()
{
    // Lee el estado de todos los bytes
    valoresPin = lee_registros_desplaz();

    // Si hay un cambio de estado, muestra los que cambiaron
    if(valoresPin != viejosValoresPin)
    {
        Serial.print("*Detectado cambio de valor de Pin*\r\n");
        mostrar_valores_pines();
        viejosValoresPin = valoresPin;
    }

    delay(ESPERA_DEL_CICLO);
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

/* SN74HC165N_shift_reg

* Traducido y modificado de https://playground.arduino.cc/

* Programa para ingresar valores de 8 bits desde un 74HC165

* (registro de desplazamiento entrada paralela/salida serie.

* Este programa demuestra la lectura de 8 estados digitales

* de un registro de desplazamiento 74HC165 usando solamente

* 3 pines digitales del Arduino.

* Se pueden conectar en cadena mas chips uniendo la salida serie

* (pin QH) de un registro de desplazamiento a la entrada serie

* (pin SER) del siguiente.

* Por supuesto usted puede conectar en cadena tantos chips como

* quiera y seguir usando solo 3 pines de Arduino (aunque hay que

* ingresarlos en diferente variables unsigned long).

// Definir la cantidad de chips que estan conectados en cadena.

#define CANTIDAD_CHIP 1

// Ancho de los datos (cuantas lineas de entrada).

#define ANCHO_DATOS CANTIDAD_CHIP * 8

// Ancho del pulso para cargar el registro de desplazamiento

#define ANCHO_PULSO 5

// Espera opcional entre lecturas del registro de desplazamiento

#define ESPERA_DEL_CICLO 1

// Debera cambiar "int" a "long" si la cantidad

// CANTIDAD_CHIP es mayor que 2

#define TIPO_VAL_BYTES unsigned int

int pinCargarDatos = 8; // Pin SH/LD: desplazar-cargar en paralelo del 165

int pinDato = 11; // Pin QH: salida serie del 165

int pinClock = 12; // Pin CLK: clock del 165

TIPO_VAL_BYTES valoresPin;

TIPO_VAL_BYTES viejosValoresPin;

// Esta funcion es una rutina de "desplazamiento hacia adentro" que

// lee datos en serie desde el registro de desplazamiento de los chips

// y arma el estado de los pines en un unsigned integer (o long integer)

TIPO_VAL_BYTES lee_registros_desplaz()

{

long valorBit;

TIPO_VAL_BYTES valorBytes = 0;

// Pulso de carga paralela para guardar el estado de las entradas

digitalWrite(pinCargarDatos, LOW); // pulso carga datos a BAJO

delayMicroseconds(ANCHO_PULSO); // duracion pulso

digitalWrite(pinCargarDatos, HIGH); // pulso carga datos a ALTO

// Lazo que lee el valor de cada bit de la salida serie del 74HC165

for(int i = 0; i < ANCHO_DATOS; i++)

{

valorBit = digitalRead(pinDato);

// poner el bit correspondiente en valorBytes

valorBytes |= (valorBit << ((ANCHO_DATOS-1) - i));

// Pulso de Clock (el flanco de subida desplaza el siguiente bit).

digitalWrite(pinClock, HIGH);

delayMicroseconds(ANCHO_PULSO);

digitalWrite(pinClock, LOW);

}

return(valorBytes);

}

// Mostrar la lista de datos con su estado

void mostrar_valores_pines()

{

Serial.print("Estado pines:\r\n");

for(int i = 0; i < ANCHO_DATOS; i++)

{

Serial.print(" Pin-");

Serial.print(i);

Serial.print(": ");

if((valoresPin >> i) & 1)

Serial.print("ALTO");

else

Serial.print("BAJO");

Serial.print("\r\n");

}

Serial.print("\r\n");

}

void setup()

{

Serial.begin(9600);

// Inicializar los pines digitales

pinMode(pinCargarDatos, OUTPUT);

pinMode(pinClock, OUTPUT);

pinMode(pinDato, INPUT);

digitalWrite(pinClock, LOW); // inicializa CLK en BAJO

digitalWrite(pinCargarDatos, LOW); // inicializa carga datos a BAJO

// Leer y mostrar los estados de los pines la 1ra vez

valoresPin = lee_registros_desplaz();

mostrar_valores_pines();

viejosValoresPin = valoresPin;

}

void loop()

{

// Lee el estado de todos los bytes

valoresPin = lee_registros_desplaz();

// Si hay un cambio de estado, muestra los que cambiaron

if(valoresPin != viejosValoresPin)

{

Serial.print("*Detectado cambio de valor de Pin*\r\n");

mostrar_valores_pines();

viejosValoresPin = valoresPin;

}

delay(ESPERA_DEL_CICLO);

}

El Monitor Serie mostrará este mensaje, y se renovará cada vez que se cambie el valor de una entrada.

Biblioteca ShiftIn

Esta es una biblioteca que permite leer 8 o más entradas. Y también, si bien la biblioteca tiene una función que define 4 pines, se pueden usar sólo 3 pines al Arduino. Además, se puede conectar en cadena varios registros de desplazamiento utilizando la misma cantidad de pines digitales, o sea 3. El cableado es con la misma configuración que en el diagrama de protoboard mostrado arriba.

Instalación fácil (importar zip)

La forma más fácil de instalar esta biblioteca es descargar la última versión y luego importarla. No tiene que descomprimirlo. Simplemente abra su IDE de Arduino y navegue a Programa > Incluir Librería > Añadir Biblioteca .ZIP… y luego seleccione el archivo zip, que puede bajar desde aquí.

Instalación manual

Por supuesto también se puede instalar esta biblioteca manualmente. Para hacerlo, descargue la versión más reciente y descomprímala. Luego tiene que copiar la carpeta ShiftIn (NO la carpeta ShiftIn-x.y.z) y colocarla en la carpeta de la biblioteca Arduino:

Windows: Documentos\Arduino\libraries\
Mac and Linux: Documents/Arduino/libraries/

Después de esto solo hay que reiniciar el IDE de Arduino.

Uso de ShiftIn

Si ha instalado esta biblioteca, puede incluirla navegando a Programa > Incluir Librería > ShiftIn. Esto agregará la línea #include <ShiftIn.h> a su programa (por supuesto, también puede escribir esta línea manualmente).

Ahora se puede usar esta biblioteca:

/*
  Este programa es ejemplo de la libreria ShiftIn.h
  que se encuentra aqui https://github.com/InfectedBytes/ArduinoShiftIn
*/
#include <ShiftIn.h>
// Inicia una instancia de ShiftIn un 1 chip.
// El numero define la cantidad de chips 74HC165 conectados en serie
// Si usted arma un circuit con 2 chips debe escribir: ShiftIn<2> shift;

ShiftIn<1> shift;

void setup() {
// iniciar serie. El programa muestra en Monitor Serie
  Serial.begin(9600);
  
// declar pines: 
// pLoadPin (SH/LD = 8), clockEnablePin (CLK INB = 9), 
// dataPin (SER = 11), clockPin (CLK = 12)
// si bien la librería usa 4 pines solo usamos 3
// no hace falta usar CLK INB en el circuito, va a GND
  shift.begin(8, 9, 11, 12);
}

void displayValues() {
  for(int i = 0; i < shift.getDataWidth(); i++)
    Serial.print( shift.state(i) ); // obtiene el estado de la entrada i
  Serial.println();
}

void loop() {
// lee los valores. Retorna VERDADERO
// si alguna entrada ha cambiado y
// muestra los valores en Monitor Serie
  if(shift.update()) 
    displayValues();
  delay(1);
}

Este programa es ejemplo de la libreria ShiftIn.h

que se encuentra aqui https://github.com/InfectedBytes/ArduinoShiftIn

#include <ShiftIn.h>

// Inicia una instancia de ShiftIn un 1 chip.

// El numero define la cantidad de chips 74HC165 conectados en serie

// Si usted arma un circuit con 2 chips debe escribir: ShiftIn<2> shift;

ShiftIn<1> shift;

void setup() {

// iniciar serie. El programa muestra en Monitor Serie

Serial.begin(9600);

// declar pines:

// pLoadPin (SH/LD = 8), clockEnablePin (CLK INB = 9),

// dataPin (SER = 11), clockPin (CLK = 12)

// si bien la librería usa 4 pines solo usamos 3

// no hace falta usar CLK INB en el circuito, va a GND

shift.begin(8, 9, 11, 12);

}

void displayValues() {

for(int i = 0; i < shift.getDataWidth(); i++)

Serial.print( shift.state(i) ); // obtiene el estado de la entrada i

Serial.println();

}

void loop() {

// lee los valores. Retorna VERDADERO

// si alguna entrada ha cambiado y

// muestra los valores en Monitor Serie

if(shift.update())

displayValues();

delay(1);

}

Los datos en el Monitor Serie se verán así:

Si usted necesita usar dos shift registers, sólo tiene que cambiar la declaración de ShiftIn<1> shift; a ShiftIn<2> shift;, y así sucesivamente.

El diagrama para 2 chips – 16 entradas es este:

Detalle de las funciones de la biblioteca ShiftIn

Dependiendo de la cantidad de chips, esta biblioteca utilizará diferentes tipos de datos. Si solo está utilizando un chip, el tipo ShiftType será un unsigned byte (uint8_t). Para dos chips será un unsigned int (uint16_t). Para tres o cuatro chips será un unsigned long (uint32_t) y para 5 a 8 chips será un unsigned long long (uint64_t). La biblioteca todavía no maneja más de ocho chips.

Esta función debe ser llamada en la función de configuración. Se utiliza para indicar a la biblioteca los pines que debe usar.

void begin(int ploadPin, int clockEnablePin, int dataPin, int clockPin)

GetPulseWidth() define el retardo para el pin de clock en microsegundos. Este valor está fijado en 5 us y en general no habrá necesidad de cambiarlo, aunque teniendo en cuenta el tiempo de programa transcurrido entre la ejecución de el inicio del pulso y de su final, puede ser tan pequeño como 1 us, incluso 0.

uint8_t getPulseWidth()
void setPulseWidth(uint8_t value)

Retorna la cantidad de entradas (bits en el estado)
uint16_t getDataWidth()

Retornan VERDADERO si ha cambiado alguna entrada durante la última lectura.
boolean hasChanged()
boolean hasChanged(int i) // lo mismo de arriba, pero solo para la entrada i

Retornan el estado completo del actual y el último grupo de bits
ShiftType getCurrent()
ShiftType getLast()

Retornan el estado de una sola entrada en el grupo actual de bits y el último grupo de bits
boolean state(int i)
boolean last(int i)

Indica cuando una entrada ha cambiado. En el ejemplo de los esquemas, se ha presionado o se ha soltado un pulsador
boolean pressed(int id) // no estaba presionado en la última lectura, pero ahora sí
boolean released(int id) // estaba presionado en la última lectura, pero ahora fue liberado

Esta función (la función para actualizar) debe ser llamada una vez por cada grupo de bits. Leerá todos los valores de los shift registers y retornará el nuevo estado.
ShiftType read()

Esta función es básicamente la misma que la función read, pero retorna VERDADERO si ha cambiado de estado alguna entrada, y FALSO en el caso contrario
boolean update()

Ingresando datos por SPI

Conectando el 74HC165 a la interfaz SPI se puede leer rápidamente 8 entradas digitales, ingresando los 8 bits en una sola instrucción de SPI. Se los puede encadenar para leer 16, 24, 32 o más entradas a la vez.

Podría usarse, por ejemplo, para examinar la configuración de un interruptor DIP de 8 interruptores (donde se fijaría la configuración del dispositivo).

En el 74HC165 se tiene que pulsar el pin de «cargar» (pin 1 del chip) para que el registro ingrese las entradas externas en sus registros internos.

La habilitación del chip, en esta prueba, es fija. El pin de activación de chip (/CLK INH) está a tierra, ya que el chip también puede funcionar estando siempre habilitado. Tenga en cuenta que la línea MISO siempre está activa, por lo que no es posible compartir este chip con otros dispositivos SPI utilizando el hardware SPI. Se puede solucionar agregando un circuito selector, pero no lo describiré en este artículo ya que si necesita usar otro dispositivo SPI, puede utilizar los otros ejemplos de programa, sin necesidad de SPI.

Código de programa

Es fácil de leer desde el registro. La biblioteca SPI se ocupará de todo.

Los pasos importantes son (dentro de la función de bucle):

1. Aplique un pulse al pin de carga paralela para cargar el registro desde las entradas.
2. Haga una transferencia SPI para leer el registro del chip.

Si desea leer más de 8 interruptores, simplemente use más registros, conecte en paralelo los pines 1, 2 y 15 de los chips, y la salida de cada chip «anterior» en la secuencia (QH) a la entrada del siguiente (SER).

Para leer cuatro bancos de interruptores, se cambia la sección de lectura del programa:

digitalWrite(LATCH, LOW);
digitalWrite(LATCH, HIGH);
bancoEntradas1 = SPI.transfer(0);
bancoEntradas2 = SPI.transfer(0);
bancoEntradas3 = SPI.transfer(0);
bancoEntradas4 = SPI.transfer(0);

NOTA: OBSERVE QUE HAY QUE CAMBIAR, EN EL DIAGRAMA DEL PROTOBOARD DE ARRIBA, LOS PINES QUE IBAN A SALIDA DIGITAL 11 Y SALIDA DIGITAL 12 DEL ARDUINO. LA CONEXIÓN QUE ESTABA EN 12 SE DEBE PASAR A 13, Y LA QUE ESTABA EN 11 SE DEBE PASAR A 12.

/* Programa Demo para leer desde 74HC165
   Autor: Nick Gammon
   Fecha: 23 Marzo 2013

   Conexiones para Uno y similares:
   Chip pin 1 (SH/LD)  conectado a LATCH (8) queda igual
   Chip pin 2 (CLK)   conectado a SCK (13) antes en 12
   Chip pin 9 (QH)   conectado a MISO (12) antes en 11

   Conexiones para Mega2560:
   Chip pin 1 (SH/LD)  conectado a LATCH (8)
   Chip pin 2 (CLK)   conectado a (52)
   Chip pin 9 (QH)   conectado a (50)
*/

#include <SPI.h>

const byte LATCH = 8;

void setup()
{
  SPI.begin();
  Serial.begin(9600);
  Serial.println ("Comienza la prueba de entradas");
  pinMode(LATCH, OUTPUT);
  digitalWrite(LATCH, HIGH);
}

byte bancoEntradas1;
// agregar declaracion: byte bancoEntradas2;
// agregar declaracion: byte bancoEntradas3;
// agregar declaracion: byte bancoEntradas4;
byte bancoEntradas1Viejo; // estado previo

void loop()
{
  digitalWrite (LATCH, LOW);
  digitalWrite (LATCH, HIGH); // pulso en carga paralela
  bancoEntradas1 = SPI.transfer(0);
  //  donde se debe agregar: bancoEntradas2 = SPI.transfer(0);
  //  donde se debe agregar: bancoEntradas3 = SPI.transfer(0);
  //  donde se debe agregar: bancoEntradas4 = SPI.transfer(0);
  
  byte mascara = 1;
  for (int i = 1; i <= 8; i++) {
    if ((bancoEntradas1 & mascara) != (bancoEntradas1Viejo & mascara))
      {
      Serial.print ("Llave ");
      Serial.print (i);
      Serial.print (" ahora ");
      Serial.println ((bancoEntradas1 & mascara) ? "cerrada" : "abierta");
      }  // fin de "el bit ha cambiado"
    mascara <<= 1;  
    }  // final para cada bit
  
  bancoEntradas1Viejo = bancoEntradas1;
  delay (10);
}

/* Programa Demo para leer desde 74HC165

Autor: Nick Gammon

Fecha: 23 Marzo 2013

Conexiones para Uno y similares:

Chip pin 1 (SH/LD) conectado a LATCH (8) queda igual

Chip pin 2 (CLK) conectado a SCK (13) antes en 12

Chip pin 9 (QH) conectado a MISO (12) antes en 11

Conexiones para Mega2560:

Chip pin 1 (SH/LD) conectado a LATCH (8)

Chip pin 2 (CLK) conectado a (52)

Chip pin 9 (QH) conectado a (50)

#include <SPI.h>

const byte LATCH = 8;

void setup()

{

SPI.begin();

Serial.begin(9600);

Serial.println ("Comienza la prueba de entradas");

pinMode(LATCH, OUTPUT);

digitalWrite(LATCH, HIGH);

}

byte bancoEntradas1;

// agregar declaracion: byte bancoEntradas2;

// agregar declaracion: byte bancoEntradas3;

// agregar declaracion: byte bancoEntradas4;

byte bancoEntradas1Viejo; // estado previo

void loop()

{

digitalWrite (LATCH, LOW);

digitalWrite (LATCH, HIGH); // pulso en carga paralela

bancoEntradas1 = SPI.transfer(0);

// donde se debe agregar: bancoEntradas2 = SPI.transfer(0);

// donde se debe agregar: bancoEntradas3 = SPI.transfer(0);

// donde se debe agregar: bancoEntradas4 = SPI.transfer(0);

byte mascara = 1;

for (int i = 1; i <= 8; i++) {

if ((bancoEntradas1 & mascara) != (bancoEntradas1Viejo & mascara))

{

Serial.print ("Llave ");

Serial.print (i);

Serial.print (" ahora ");

Serial.println ((bancoEntradas1 & mascara) ? "cerrada" : "abierta");

} // fin de "el bit ha cambiado"

mascara <<= 1;

} // final para cada bit

bancoEntradas1Viejo = bancoEntradas1;

delay (10);

}

Resultados en Monitor Serie. Muestra una indicación del estado al inicio, y luego lista cada cambio que se produce en las entradas:

Otras opciones

Por último, existen dos librerías relacionadas, llamadas bitBangedSPI y bitBangedSPIfast, que permiten operar las múltiples entradas desde 74HC165 con un SPI implementado por software, y dejar libre el módulo SPI de hardware para otros dispositivos. Entiendo que es lo que hicimos con los programas de ejemplo anteriores, pero les dejo la inquietud de investigarlos y probarlos.

Arduino: alojar datos en la memoria de programa con PROGMEM

Deja un comentario

Almacene los datos en la memoria FLASH (memoria de programa) en lugar de RAM (a veces nombrada como SRAM, del inglés STATIC RAM = RAM estática).

Los distintos tipos de memoria disponibles en una placa Arduino son:

■ FLASH: Esta memoria almacena el código del programa.

■ RAM: Esta memoria almacena los datos del programa y es volátil. Cuando se apaga Arduino se pierden los datos.

■ EEPROM: Esta memoria almacena datos que son persistentes. Esta memoria puede ser utilizada para guardar configuración o cualquier otro dato que podamos utilizar si se apaga y enciende Arduino.

La palabra clave PROGMEM es un modificador de variable. Se debe usar solo con los tipos de datos definidos en la biblioteca pgmspace.h.

PROGMEM le dice al compilador «ponga esta información en la memoria flash», en lugar de en la RAM, donde iría normalmente.

PROGMEM es parte de la biblioteca pgmspace.h. Ésta se incluye automáticamente en las versiones modernas del IDE. Sin embargo, si estuviese utilizando una versión IDE por debajo de 1.0 (2011), primero deberá incluir la biblioteca en la parte superior de su programa, con esta declaración:

#include <avr/pgmspace.h>

1	#include <avr/pgmspace.h>

Sintaxis

const tipoDato nombreVariable[] PROGMEM = {dato0, dato1, dato2…};

1	const tipoDato nombreVariable[] PROGMEM = {dato0, dato1, dato2…};

tipoDato – algún tipo de variable
nombreVariable – el nombre de su matriz de datos

Tenga en cuenta que debido a que la indicación PROGMEM es un modificador de variable, no existe una regla estricta sobre dónde debe ir, por lo que el compilador acepta diversas posiciones, que también pueden ser sinónimos. Sin embargo, las pruebas han indicado que, en varias versiones de Arduino, PROGMEM puede funcionar en una ubicación y no en otra.

Los siguientes ejemplos se han probado y funcionan con los IDE actuales. Las versiones anteriores del IDE pueden funcionar mejor si la palabra PROGMEM se incluye después del nombre de la variable.

const dataType variableName[] PROGMEM = {}; // use esta sintaxis
const PROGMEM dataType variableName[] = {}; // no esta
const dataType PROGMEM variableName[] = {}; // ni esta

const dataType variableName[] PROGMEM = {}; // use esta sintaxis

const PROGMEM dataType variableName[] = {}; // no esta

const dataType PROGMEM variableName[] = {}; // ni esta

Tenga en cuenta que dado que PROGMEM se podría usar con una sola variable, pero en realidad solo vale la pena si tiene un bloque de datos más grande para almacenar, que por lo general es más fácil de poner en una matriz (o en otra estructura de datos C++, algo que queda más allá de la presente discusión).

Usar PROGMEM es un procedimiento de dos pasos. Después de tener los datos que están en la memoria Flash, se requieren métodos especiales (funciones), también definidos en la biblioteca pgmspace.h, para volcar los datos de la memoria de programa a la RAM, de modo de que podamos trabajar con ellos.

Código de ejemplo

Las siguientes secciones de código ilustran cómo leer y escribir unsigned char (bytes) e int (2 bytes) en PROGMEM.

// guardar algunos enteros sin signo (unsigned int)
#include <avr/pgmspace.h>

const uint16_t grupoNumeros[] PROGMEM = { 65000, 32796, 16843, 10, 11234};

// guardar algunos caracteres (char)
const char Mensaje[] PROGMEM  = {"ESTOS CARACTERES SE UTILIZARÁN, MÁS ADELANTE, EN ALGUN LUGAR"};

unsigned int intParaMostrar;
int k; // variable para contar
char miCaracter;

void setup() {
  Serial.begin(9600);
  while (!Serial);  // esperar que el puerto serie se conecte

  // Su código va aquí, en inicialización, para que corra una sola vez
  // Lee enteros de 2 bytes y los muestra
  for (k = 0; k < 5; k++)
  {
    intParaMostrar = pgm_read_word_near(grupoNumeros + k);
    Serial.println(intParaMostrar);
  }
  Serial.println();

  // Leer caracteres y mostrarlos
  for (k = 0; k < strlen_P(Mensaje); k++)
  {
    miCaracter =  pgm_read_byte_near(Mensaje + k);
    Serial.print(miCaracter);
  }
  Serial.println();
}

void loop() {
  // ponga aquí su código, donde correrá continuamente
}

// guardar algunos enteros sin signo (unsigned int)

#include <avr/pgmspace.h>

const uint16_t grupoNumeros[] PROGMEM = { 65000, 32796, 16843, 10, 11234};

// guardar algunos caracteres (char)

const char Mensaje[] PROGMEM = {"ESTOS CARACTERES SE UTILIZARÁN, MÁS ADELANTE, EN ALGUN LUGAR"};

unsigned int intParaMostrar;

int k; // variable para contar

char miCaracter;

void setup() {

Serial.begin(9600);

while (!Serial); // esperar que el puerto serie se conecte

// Su código va aquí, en inicialización, para que corra una sola vez

// Lee enteros de 2 bytes y los muestra

for (k = 0; k < 5; k++)

{

intParaMostrar = pgm_read_word_near(grupoNumeros + k);

Serial.println(intParaMostrar);

}

Serial.println();

// Leer caracteres y mostrarlos

for (k = 0; k < strlen_P(Mensaje); k++)

{

miCaracter = pgm_read_byte_near(Mensaje + k);

Serial.print(miCaracter);

}

Serial.println();

}

void loop() {

// ponga aquí su código, donde correrá continuamente

}

Matrices de cadenas de caracteres

A menudo es conveniente configurar una serie de cadenas de caracteres cuando se trabaja con grandes cantidades de texto, como por ejemplo en un proyecto con una pantalla LCD.

Debido a que las cadenas en sí son matrices, en realidad este es un ejemplo de una matriz bidimensional.

Estas tienden a ser grandes estructuras, por lo que por lo general es deseable colocarlas en la memoria del programa.

El siguiente código ilustra la idea.

/*
 PROGMEM - demostración con cadenas de caracteres
 Cómo guardar una tabla de cadenas en memoria de programa (flash),
 y recuperarlas para su uso.

 Información resumida de:
 http://www.nongnu.org/avr-libc/user-manual/pgmspace.html
 
 Configurar una tabla (matriz) de cadenas en la memoria 
 del programa es un poco complicado, pero aquí hay 
 un buen ejemplo para tomar como base.

 Configurar las cadenas es un proceso de dos pasos. 
 Primero se definen las cadenas de caracteres.
*/

#include <avr/pgmspace.h>
// cadenas a guardar – coloque los textos que necesite
const char texto_0[] PROGMEM = "La vaca es un animal";
const char texto_1[] PROGMEM = "todo forrado de cuero,";
const char texto_2[] PROGMEM = "tiene las patas tan largas";
const char texto_3[] PROGMEM = "que le llegan hasta el suelo";
const char texto_4[] PROGMEM = "Cancionero";
const char texto_5[] PROGMEM = "popular.";

// A continuación, configure una tabla para referirse a sus cadenas.

const char* const tabla_textos[] PROGMEM = {texto_0, texto_1, texto_2, texto_3, texto_4, texto_5};

char buffer[30];  // que sea suficiente para la mayor cadena que debe contener

void setup()
{
  Serial.begin(9600);
  while(!Serial); // espere a que el puerto serie se conecte
}

void loop()
{

/* El uso de una tabla de cadenas en la memoria de programa requiere el uso 
de funciones especiales para recuperar los datos. La función strcpy_P copia
una cadena del espacio de programa a una cadena en la RAM ("buffer").
Asegúrese de que su cadena de recepción en la RAM sea lo suficientemente
grande como para contener lo que sea que está trayendo del espacio de
programa. */

  for (int i = 0; i < 6; i++)
  {
    strcpy_P(buffer, (char*)pgm_read_word(&(tabla_textos[i])));
    // si este código de arriba le resulta complejo, simplemente copie
    Serial.println(buffer);
    delay( 500 );
  }
}

PROGMEM - demostración con cadenas de caracteres

Cómo guardar una tabla de cadenas en memoria de programa (flash),

y recuperarlas para su uso.

Información resumida de:

http://www.nongnu.org/avr-libc/user-manual/pgmspace.html

Configurar una tabla (matriz) de cadenas en la memoria

del programa es un poco complicado, pero aquí hay

un buen ejemplo para tomar como base.

Configurar las cadenas es un proceso de dos pasos.

Primero se definen las cadenas de caracteres.

#include <avr/pgmspace.h>

// cadenas a guardar – coloque los textos que necesite

const char texto_0[] PROGMEM = "La vaca es un animal";

const char texto_1[] PROGMEM = "todo forrado de cuero,";

const char texto_2[] PROGMEM = "tiene las patas tan largas";

const char texto_3[] PROGMEM = "que le llegan hasta el suelo";

const char texto_4[] PROGMEM = "Cancionero";

const char texto_5[] PROGMEM = "popular.";

// A continuación, configure una tabla para referirse a sus cadenas.

const char* const tabla_textos[] PROGMEM = {texto_0, texto_1, texto_2, texto_3, texto_4, texto_5};

char buffer[30]; // que sea suficiente para la mayor cadena que debe contener

void setup()

{

Serial.begin(9600);

while(!Serial); // espere a que el puerto serie se conecte

}

void loop()

{

/* El uso de una tabla de cadenas en la memoria de programa requiere el uso

de funciones especiales para recuperar los datos. La función strcpy_P copia

una cadena del espacio de programa a una cadena en la RAM ("buffer").

Asegúrese de que su cadena de recepción en la RAM sea lo suficientemente

grande como para contener lo que sea que está trayendo del espacio de

programa. */

for (int i = 0; i < 6; i++)

{

strcpy_P(buffer, (char*)pgm_read_word(&(tabla_textos[i])));

// si este código de arriba le resulta complejo, simplemente copie

Serial.println(buffer);

delay( 500 );

}

Notas y advertencias

Tenga en cuenta que las variables deben estar definidas globalmente, o definidas con la palabra clave static, para poder trabajar con PROGMEM.

El siguiente código NO funcionará cuando esté dentro de una función:

const char long_str[] PROGMEM = "Hola, me gustaría contarles un poco sobre mí.\n";

1	const char long_str[] PROGMEM = "Hola, me gustaría contarles un poco sobre mí.\n";

El siguiente código funcionará, incluso si está definido localmente dentro de una función:

const static char long_str[] PROGMEM = "Hola, me gustaría contarles un poco sobre mí.\n"

1	const static char long_str[] PROGMEM = "Hola, me gustaría contarles un poco sobre mí.\n"

La macro F()

Cuando se utiliza una instrucción como:

Serial.print("Escribir algo en el Monitor Serie");

1	Serial.print("Escribir algo en el Monitor Serie");

La cadena a imprimir normalmente se guarda en la memoria RAM. Si su programa imprime muchas cosas en el Monitor Serie, puede acabar llenando la RAM. Si tiene espacio libre en la memoria FLASH, puede indicar fácilmente que la cadena debe guardarse en FLASH, usando la sintaxis:

Serial.print(F("Escribir algo en el Monitor Serie"));

1	Serial.print(F("Escribir algo en el Monitor Serie"));