jueves, 6 de septiembre de 2012

Manejo de la micro SD del Shield Ethernet

Manejo de la micro SD del Shield Ethernet.

Categoría: 1. Programación y electrónica.

Se desarrolló un programa (C/C++) para tener juntas algunas instrucciones útiles en el manejo de los archivos contenidos en la tarjeta micro SD del Shield Ethernet de Arduino. Con base en algunos programas de ejemplo como dumpFile, cardInfo y readWrite se desarrolló un menú y las acciones leerArchivo, leerMicroSD y borrarArchivo se programaron como funciones. El monitor serial despliega el menú de opciones y el usuario introduce a través del mismo monitor serial la opción que desea que el programa ejecute. Se verificó cada una de las tres opciones del menú por separado, una vez que crrieron correctamente al cargarlas en la tarjeta Arduino se procedió a colocarlas en un programa único una a una, y teniendo cuidado de no sobrepasar el límite de almacenamiento de la tarjeta (32256 bytes). Para terminar, se verificó el programa completo (16598 bytes) y se cargó en la tarjeta electrónica.

El código es el siguiente:

#include <SD.h>
Sd2Card card;
SdVolume volume;
SdFile root;
const int chipSelect = 4;
void setup ()  {
  Serial.begin(9600);
  pinMode(10, OUTPUT);
  Serial.println("enter:\n 1. cardInfo\n 2. leerArchivo\n 3. borrarArchivo\n 0. Salir ");  }
 
void loop()  {
  if (Serial.available() > 0)  {
    char ch = Serial.read();
    if (ch == '1')  {
       cardInfo(); }
    else if (ch == '2')  {
       leerArchivo(); }
    else if (ch == '3')  {
       borrarArchivo();  }
    else if (ch == '4')  {  }
    else if (ch == '0')  {  }  }  }

void cardInfo ()  {
  Serial.print("\ninitializing SD card... ");
  if (!card.init(SPI_HALF_SPEED, chipSelect)) {
    Serial.println("initialization failed. Things to check:");
    Serial.println("* is a card is inserted?");
    Serial.println("* Is your wiring correct?");
    Serial.println("* did you change the chipSelect pin to match your shield or module?");
    return;  }
    else {
   Serial.println("Wiring is correct and a card is present.");  }
  Serial.print("\nCard type: ");
  switch(card.type()) {
    case SD_CARD_TYPE_SD1:
      Serial.println("SD1");
      break;
    case SD_CARD_TYPE_SD2:
      Serial.println("SD2");
      break;
    case SD_CARD_TYPE_SDHC:
      Serial.println("SDHC");
      break;
    default:
      Serial.println("Unknown");  }
  if (!volume.init(card)) {
    Serial.println("Could not find FAT16/FAT32 partition.\nMake sure you've formatted the card");
    return;  }
  uint32_t volumesize;
  Serial.print("\nVolume type is FAT");
  Serial.println(volume.fatType(), DEC);
  Serial.println();
 
  volumesize = volume.blocksPerCluster();   
  volumesize *= volume.clusterCount();      
  volumesize *= 512;                        
  Serial.print("Volume size (bytes): ");
  Serial.println(volumesize);
  Serial.print("Volume size (Kbytes): ");
  volumesize /= 1024;
  Serial.println(volumesize);
  Serial.print("Volume size (Mbytes): ");
  volumesize /= 1024;
  Serial.println(volumesize);
 
  Serial.println("\nFiles found on the card (name, date and size in bytes): ");
  root.openRoot(volume);
 
  root.ls(LS_R | LS_DATE | LS_SIZE);  }


void borrarArchivo ()  {
  Serial.print("Initializing SD card...");
  if (!SD.begin(chipSelect))  {
    Serial.println("initialization failed!...");
    return;  }
  Serial.println("initialization done!...");
 
  if (SD.exists("pulsedat.txt"))  {
    Serial.println("pulsedat.txt exists...");  }
  else  {
    Serial.println("pulsedat.txt doesn't exist...");  }
  Serial.println("removing pulsedat.txt...");
  SD.remove("pulsedat.txt");
 
  if (SD.exists("pulsedat.txt"))  {
    Serial.println("pulsedat.txt exists...");  }
  else  {
    Serial.println("pulsedat.txt doesn't exist..");  }  }


void leerArchivo ()  {
  Serial.print("Initializing SD card...");
    if (!SD.begin(chipSelect))  {
      Serial.println("initialization failed!...");
      return;  }
  Serial.println("initialization done!...");
 
  File dataFile = SD.open("pulsedat.txt", FILE_READ);
  if (dataFile)  {
    Serial.println("pulsedat.txt exists...");
    while (dataFile.available())  {
      Serial.write(dataFile.read());  }
      dataFile.close();  }
  else  {
    Serial.println("error opening pulsedat.txt...");  }  }
     
De esta manera, se puede trabajar de manera más amigable con el programa presentado anteriormente como EjercicioPulseDat04 para el registro de pulsaciones generadas por un multivibrador astable construido con un circuito integrado NE555 (o NE556).

Es todo por ahora. Saludos.

La bibliografía contenida en la entrada 'registro de datos a una micro SD' también aplica para esta entrada, y es la siguiente:
Bibliografía.

Stengel, Lester. 2006. El ABC de la electrónica. Steren Electrónica SA de CV. México.
Arduino. Sitio web: http://www.arduino.cc/. Consulta el 31 de julio de 2012.







sábado, 1 de septiembre de 2012

Registro de datos a una micro SD

Registro de un generador de pulsos a un archivo de texto (pulsedat.txt).

Categoría: 1. Programación y electrónica.

El programa generador de pulsos funciona registrando los momentos en que un generador de pulsos, un botón pulsador conectado a una resistencia de 10K o, como en este ejercicio, un circuito electrónico generador de pulsos. Este circuito está basado en un circuito integrado NE555 o NE556.

El circuito astable es como sigue:



El programa EjercicioPulseDat04 lee la salida digital del vibrador astable (pin 3 en el NE555 o pines 5 o 9 del NE556), registra en el monitor serial los tiempos de encendido (HIGH) y de apagado (LOW) utilizando la instrucción millis(); y también registra el número de pulsos acumulado. De esta manera es posible medir el tiempo de duración en HIGH y el tiempo de duración en LOW.
Estos mismos datos se registran en un archivo llamado pulsedat.txt, almacenado en la tarjeta de datos micro SD contenida en el Shield Ethernet de Arduino. Como se sabe, esta tarjeta va acoplada con la tarjeta electrónica Arduino UNO.

Las siguientes imágenes muestran la salida en el monitor serial y la ventana del ambiente Arduino con parte del programa a la vista.





El programa se desarrolló tomando como base el ejemplo 'state change detection' (edge detection) que proorciona el ambiente Arduino para la tarjeta electrónica Arduino UNO. También se utilizó parte del código del ejemplo 'datalogger' para la tarjeta Ethernet Shield.

/*
EjercicioPulseDat04
*/
/*
  State change detection (edge detection)

 Often, you don't need to know the state of a digital input all the time,
 but you just need to know when the input changes from one state to another.
 For example, you want to know when a button goes from OFF to ON.  This is called
 state change detection, or edge detection.

 This example shows how to detect when a button or button changes from off to on
 and on to off.

 The circuit:
 * pushbutton attached to pin 2 from +5V
 * 10K resistor attached to pin 2 from ground
 * LED attached from pin 13 to ground (or use the built-in LED on
   most Arduino boards)

 created  27 Sep 2005
 modified 30 Aug 2011
 by Tom Igoe
This example code is in the public domain.

 http://arduino.cc/en/Tutorial/ButtonStateChange

 */
#include <SD.h>
const int  buttonPin = 2;   
const int ledPin = 13;      
int buttonPushCounter = 0; 
int buttonState = 0;       
int lastButtonState = 0; 
File dataFile;
void setup() {
  pinMode(buttonPin, INPUT);
  pinMode(ledPin, OUTPUT);
  Serial.begin(9600);
  pinMode(10, OUTPUT);
 
    if (!SD.begin(4))  {
    Serial.println("card failed, or not present...");
    return;  }
  Serial.println("card initialized...");
 
  Serial.println("removing pulsedat.txt...");
  SD.remove("pulsedat.txt");
  if (SD.exists("pulsedat.txt"))  {
    Serial.println("pulsedat.txt exists...");  }
  else  {
    Serial.println("pulsedat.txt doesn't exist...");  }  }

void loop()
{
  buttonState = digitalRead(buttonPin);
  if (buttonState != lastButtonState)
  {
    if (buttonState == HIGH)
    {
      buttonPushCounter++;
      Serial.print("number of button pushes:  ");
      Serial.println(buttonPushCounter);
      Serial.print("time on= ");
      Serial.println(millis());
 
  dataFile = SD.open("pulsedat.txt", FILE_WRITE);
  if (dataFile) 
      {
    Serial.println("writing to pulsedat.txt...");
    dataFile.print("number of button pushes:  ");
    dataFile.println(buttonPushCounter);
    dataFile.print("time on= ");
    dataFile.println(millis());   
    dataFile.close();
    Serial.println("action done..."); 
      }
  else 
      {
    Serial.println("error opening pulsedat.txt"); 
      }   
    }
 
   
    else
      {
      Serial.print("time off= ");
      Serial.println(millis());
     
  dataFile = SD.open("pulsedat.txt", FILE_WRITE);
  if (dataFile) 
        {
    Serial.println("writing to pulsedat.txt...");
    dataFile.print("time off= ");
    dataFile.println(millis());
   
    dataFile.close();
    Serial.println("action done..."); 
        }
  else 
        {
    Serial.println("error opening pulsedat.txt"); 
        }
      }
 
  lastButtonState = buttonState;
  if (buttonPushCounter % 4 == 0)
      {
    digitalWrite(ledPin, HIGH);
      }
  else
      {
   digitalWrite(ledPin, LOW);
      }
  }
}
Este programa con algunas modificaciones puede adaptarse para medir variables de uno o más sensores (temperatura, humedad, presión atmosférica, intensidad lumínica, voltaje, etc) conectados a las entradas analógicas de la tarjeta electrónica.

Por lo pronto es todo. Saludos.

Bibliografía.

Stengel, Lester. 2006. El ABC de la electrónica. Steren Electrónica SA de CV. México.
Arduino. Sitio web: http://www.arduino.cc/. Consulta el 31 de julio de 2012.







domingo, 26 de agosto de 2012

Proyectos de electrónica con Arduino

Programas con Arduino UNO y Ethernet Shield.

Categoría: 1. Programación y electrónica.

En esta entrada se colocaron tres versiones de un ejercicio que emplea tres LEDs enviándoles pulsos de duración pre-establecida. El código del cuarto programa muestra la lectura de un archivo contenido en la tarjeta micro SD de la Ethernet Shield. Por último, el programa cinco borra el archivo contenido en la tarjeta micro SD de la Ethernet Shield.

Los primeros tres programas hacen parpadear tres LEDs colocados en una placa de prototipos (protoboard) con una resistencia de 470 Ohms en el polo positivo del LED conectadas a las salidas digitales 2, 3 y 4 de la Arduino UNO / Ethernet Shield. El polo negativo va conectado a tierra. En el tercer programa se muestra el empleo de una función con atributos para ahorrar en el tamaño del código (C/C++).
Los códigos de los primeros tres programas (con LEDs) son como sigue:

/*
Programa3leds03
Se utiliza la instrucción #define en la declaración de la salida
digital (asignación) en lugar de utilizar int ledPin=13;,
con lo que se ahorra en espacio de memoria
El programa hace parpadear tres LED sucesivamente
con pulsos de 250 milisegundos (con delay de 250 milisegundos)
Tamaño del sketch=1308 bytes de 32256 bytes disponibles
El formato de estos problemas tiene la ventaja de que la
inicializacion de las variables esta definida claramente y no se
modifica, por eso se facilita cambiar el pin que se utiliza
como salida y el cambio del tiempo de duracion del pulso
y la pausa
En este programa se utilizó una funcion para abreviar el codigo
dentro del void loop ()
 */

# define ledPin1 2
# define ledPin2 3
# define ledPin3 4
int delayPeriod = 250;

void setup ()  {
  pinMode(ledPin1, OUTPUT);
  pinMode(ledPin2, OUTPUT);
  pinMode(ledPin3, OUTPUT);  }

void loop ()  {
  digitalWrite(ledPin1, HIGH);
  delay(delayPeriod);
  digitalWrite(ledPin1, LOW);
  digitalWrite(ledPin2, HIGH);
  delay(delayPeriod);
  digitalWrite(ledPin2, LOW);
  digitalWrite(ledPin3, HIGH);
  delay(delayPeriod);
  digitalWrite(ledPin3, LOW);  }

El código para el segundo programa es como sigue: 

  # define ledPin1 2
  # define ledPin2 3
  # define ledPin3 4
  int delayPeriod = 250;

  void setup ()  {
    pinMode(ledPin1, OUTPUT);
    pinMode(ledPin2, OUTPUT);
    pinMode(ledPin3, OUTPUT);  }

  void loop ()  {
    digitalWrite(ledPin1, HIGH);
    digitalWrite(ledPin2, HIGH);
    digitalWrite(ledPin3, HIGH);
    delay(delayPeriod);
    digitalWrite(ledPin1, LOW);
    digitalWrite(ledPin2, LOW);
    digitalWrite(ledPin3, LOW);
    delay(delayPeriod);
    digitalWrite(ledPin1, HIGH);
    digitalWrite(ledPin2, LOW);
    digitalWrite(ledPin3, LOW);
    delay(delayPeriod);
    digitalWrite(ledPin1, LOW);
    digitalWrite(ledPin2, HIGH);
    digitalWrite(ledPin3, LOW);
    delay(delayPeriod);
    digitalWrite(ledPin1, LOW);
    digitalWrite(ledPin2, LOW);
    digitalWrite(ledPin3, HIGH);
    delay(delayPeriod);   
    digitalWrite(ledPin1, LOW);
    digitalWrite(ledPin2, LOW);
    digitalWrite(ledPin3, LOW);
    delay(delayPeriod);  }

A continuación, el código para el tercer programa:

# define ledPin1 2
# define ledPin2 3
# define ledPin3 4

void setup ()  {
  pinMode(ledPin1, OUTPUT);
  pinMode(ledPin2, OUTPUT);
  pinMode(ledPin3, OUTPUT);  }

void loop ()  {
  flash3Led(250, 300);
  flash3Led(100, 300);
  flash3Led(50, 300);
  flash3Led(25, 300);
  flash3Led(15, 300);
  flash3Led(10, 300);
  flash3Led(5, 300);
  digitalWrite(ledPin1, LOW);
  digitalWrite(ledPin2, LOW);
  digitalWrite(ledPin3, LOW);
  delay(2000);  } 

void flash3Led (int delayPeriod, int delayFinal)  {
    digitalWrite(ledPin1, HIGH);
    delay(delayPeriod);
    digitalWrite(ledPin2, HIGH);
    delay(delayPeriod);
    digitalWrite(ledPin3, HIGH);
    delay(delayPeriod);
    digitalWrite(ledPin1, LOW);
    delay(delayPeriod);
    digitalWrite(ledPin2, LOW);
    delay(delayPeriod);
    digitalWrite(ledPin3, LOW);
    delay(delayPeriod);
    delay(3000);  }

El cuarto programa despliega el contenido del archivo pulsedat.txt en el monitor serial. El archivo pulsedat.txt se genera con el programa ‘generador de pulsos’, que les compartiré más adelante.
El código es el siguiente:

/*
LeerArchivo01
El programa lee un archivo de texto de la SD card y lo
despliega en el monitor serial
*/

#include <SD.h>
const int chipSelect = 4;
void setup()  {
  Serial.begin(9600);
  Serial.print("Initializing SD card...");
  if (!SD.begin(chipSelect))  {
    Serial.println("initialization failed!...");
    return;  }
  Serial.println("initialization done!...");
   File dataFile = SD.open("pulsedat.txt", FILE_READ);
  if (dataFile)  {
    Serial.println("pulsedat.txt");
    while (dataFile.available())  {
      Serial.write(dataFile.read());  }
    dataFile.close();  }
  else  {
    Serial.println("error opening pulsedat.txt...");  }  }

void loop ()  {  }

Por último, el programa cinco de esta entrada borra el archivo pulsedat.txt, contenido en la tarjeta micro SD del Ethernet Shield. Si deseas conservar los datos, debes copiar el archivo a otra ubicación antes de borrarlo.
El código es el siguiente:

/*
BorrarArchivo01
El programa lee un archivo de texto de la SD card y lo
despliega en el monitor serial
*/

#include <SD.h>
const int chipSelect = 4;

void setup()  {
  Serial.begin(9600);
  Serial.print("Initializing SD card...");
  if (!SD.begin(chipSelect))  {
    Serial.println("initialization failed!...");
    return;  }
  Serial.println("initialization done!...");
   if (SD.exists("pulsedat.txt"))  {
    Serial.println("pulsedat.txt exists...");  }
  else  {
    Serial.println("pulsedat.txt doesn't exist...");  }
     Serial.println("removing pulsedat.txt...");
     SD.remove("pulsedat.txt");
   if (SD.exists("pulsedat.txt"))  {
    Serial.println("pulsedat.txt exists...");  }
  else  {
    Serial.println("pulsedat.txt doesn't exist..");  }  }

void loop ()  {  }

Los últimos dos ejercicios no requieren de hardware adicional a las tarjetas electrónicas Arduino. Por el momento es todo. Saludos.

Bibliografía.
Arduino. Sitio web: http://www.arduino.cc/. Consulta el 31 de julio de 2012.







sábado, 25 de agosto de 2012

Clichés, Estereotipos

Clichés, estereotipos.

Categoría: 3. Humanidades y comportamiento humano.

Los clichés son acciones, frases, comentarios, lugares, construcciones, bienes, alimentos y todo tipo de cosas que nos fuerzan a confrontar nuestras ideas con la realidad. Estas ideas pueden pertenecer al presente, al pasado o al futuro.


Si soy un individuo que decide hacer ejercicio los fines de semana para mantener una condición física mínima aceptable, es posible, además de lógico, que me encuentre en la pista de carreras junto con corredores experimentados, frente a los cuales me puedo sentir apabullado, sentirme como una caricatura respecto a la capacidad física de estos poderosos deportistas. Esto me puede llevar a replantearme la idea de hacer el ejercicio que estoy proponiéndome, es decir, a que confronte mi idea de hacer ejercicio para mantener la forma física y la salud. Este es un ejemplo de cliché sobre una acción presente.


Cuando decido comprar un automóvil para ir al trabajo y para utilizarlo como medio de transporte durante mis vacaciones, es posible escuchar comentarios de mis amigos y compañeros de trabajo respecto a los altos costos de mantenimiento y del combustible que consume un automóvil. Esto me puede llevar a cuestionarme sobre la conveniencia de tal adquisición, tomando en cuenta mi poder adquisitivo. Este es un ejemplo de un cliché sobre una acción futura.


Si hice un viaje en avión, es posible que a mi regreso, o un tiempo después me vea contando la historia de mi viaje y mientras tanto uno de mis interlocutores me platica que un amigo cercano o un familiar querido hizo un viaje en avión que tuvo un accidente en el que todos sus ocupantes murieron. Esto me puede llevar a pensar en la pena de quienes perdieron a un amigo o familiar en un accidente aéreo, mientras que yo pude vivir para contarlo. Desde luego, viajar en avión no es una actividad de alto riesgo, de manera que ¿Por qué debería sentir pena por haber viajado en avión? Este es un ejemplo de cliché sobre una acción pasada.


Los clichés son más o menos intensos según la sensibilidad de la persona y según la magnitud de la idea por confrontar. En algunas culturas o grupos sociales existen ejercicios que ayudan a sus integrantes a confrontar ideas de magnitud creciente, con la finalidad de fortalecer la sensibilidad de sus integrantes. Reunirse en torno a un sobreviviente de un accidente aéreo o a un sobreviviente de una guerra y escuchar sus experiencias durante estos acontecimientos ayuda a que se fortalezca el espíritu.


El texto de Óscar Domínguez Núñez y Elena María Barcellós Morante (http://civele.org/biblioteca/index.php?option=com_content&view=article&id=28:dominguez-o---la-cronica-periodistica-en-el-aula-de-ele-&catid=18:06aula&directory=2) menciona lo siguiente respecto a clichés y estereotipos:


“Los medios de comunicación y el estereotipo mantienen una estrecha relación desde su desarrollo en el siglo XIX. En esa época se fraguan los conceptos de “cliché” y de “estereotipo”, procedentes, respectivamente, del mundo de la fotografía y de la impresión industrializada. Ambas nociones comparten la función de proporcionar un molde fijo para reproducir una imagen o una página cuantas veces sea necesario.”


“El concepto de estereotipo se aplica a esquemas de pensamiento arraigados y preformalizados que son compartidos por miembros de una misma comunidad social. Entre las funciones que cumplen los estereotipos se destaca el papel que juega como fórmula extraordinariamente efectiva –y también afectiva- de reconocimiento y familiaridad sociocultural. En efecto, los estereotipos proporcionan un marco de seguridad ontológica para los miembros de la comunidad, reforzando la idiosincrasia particular de su identidad al tiempo que resaltan los rasgos de su singularidad entre el magmático flujo informativo de imágenes e informaciones a los que constantemente se hallan expuestos.”
De esta manera, los clichés son herramientas de una sociedad para reproducir su identidad en las generaciones de jóvenes.


Un concepto relacionado es la intelectualización. En Wikipedia se define de la siguiente manera:


“La intelectualización es un mecanismo de defensa, donde el razonamiento se utiliza para bloquear la confrontación con un conflicto inconsciente y su estrés emocional asociado, mediante el «uso excesivo de ideación abstracta para eludir sentimientos difíciles». Implica apartarse a uno mismo, emocionalmente, de un suceso estresante. La intelectualización puede estar acompañada, pero difiere de la racionalización, que es la justificación de la conducta irracional a través de clichés, historias y explicaciones oportunas. En lugar de confrontar los acontecimientos dolorosos, la intelectualización pretende analizarlos de forma indiferente y distante.”


“La intelectualización es uno de los mecanismos de defensa originales de Freud. Él creía que los recuerdos tienen aspectos tanto conscientes como inconscientes, y que la intelectualización permite el análisis consciente de un evento de una manera que no provoque ansiedad.”


“Anna Freud dedicó un capítulo de su libro El Yo y los Mecanismos de Defensa (1937) a la «Intelectualización en la Pubertad», al ver la forma como el «aumento intelectual, científico, y los intereses filosóficos de la época representan los intentos de dominar los impulsos y las emociones implicadas» como algo relativamente normal. A su juicio, sólo «si el proceso de intelectualización sobrepasa todo el campo de la vida mental» podría ser «entonces patológico».”


“Vaillant dividó los mecanismos de defensa en una jerarquía de «defensas inmaduras, defensas neuróticas y defensas maduras... siendo las inmaduras menos saludables que las neuróticas». Él coloca el proceso de intelectualización «que podríamos imaginar como un acto violento, sin los sentimientos violentos que normalmente le acompañan» entre las defensas "neuróticas" «...que suelen ser utilizados por personas de gama media».”


‘Los amigos del cine’ en su Blog (http://losamigosdelcine.blogspot.mx/ 2010/10/de-cliches-y-lugares-comunes-esta-lleno.html) hablan de los clichés como soluciones basadas en algo así como recetas de cocina, de las que no se apartan los directores que tratan el mismo género fílmico. En este Blog se habla de clichés como lugares comunes.


Erich Fromm en ‘El arte de amar’, también menciona que el lenguaje basado en clichés puede llegar a ser molesto y hasta hostil. Esto en referencia al concepto planteado inicialmente, en el que se considera que un cliché es una situación que confronta nuestra forma de pensar o de actuar.
En la realización de este ejercicio comencé por plantearme el concepto de cliché. Al ahondar en su significado llegué a un sinónimo que es el estereotipo. Sin embargo, el ejercicio alcanzó una meta más avanzada que lo planteado inicialmente al llegar al concepto de intelectualización, como un mecanismo de la mente que para eludir la confrontación de las ideas, planeada por los clichés, recurre al análisis de los acontecimientos dolorosos de forma indiferente y distante.

Por ahora es todo. Saludos.




Dado Electrónico

Dado electrónico con Arduino UNO.

Categoría: 1. Programación y electrónica.

En este ejercicio se construye un circuito electrónico con un display de siete segmentos con ánodo común. Las terminales (a, b, c, d, e, f y g) se conectaron a las I/O (2, 3, 4, 5, 6, 7 y 8) respectivamente. En la I/O número 9 se conectó un botón pulsador conectando un extremo al polo positivo (+5V), el otro extremo a una resistencia de 10K conectada a la terminal GND (tierra) de la tarjeta Arduino UNO. Los valores del uno al seis se despliegan simultáneamente en el display LED y en el monitor serial del ambiente Arduino. El monitor serial muestra además el estado de la entrada digital, el botón pulsador. Los números del uno al seis se despliegan 50 veces rápidamente (50 ms HIGH y 15 ms LOW). Durante esta etapa se aprieta el botón pulsador y el número seleccionado queda guardado en la variable optn. Al terminar el despliegue de la serie de números, el display LED muestra el número seleccionado (destellando 15 veces, 250 ms HIGH y 15 ms LOW) cuando se apretó el botón pulsador.

 
Figura 1. Display de LED, botón pulsador y placa Arduino UNO.

En el desarrollo del proyecto se comenzó con una primera versión del programa completo, aunque este no funcionaba correctamente pero sí era compilado. Después se construyó el circuito electrónico y se reinició la escritura del código. Primero haciendo encender y apagar cada uno de los segmentos del display y corrigiendo cualquier error en el hardware. Una vez que el hardware funcionó, se codificaron las funciones para generar los números (uno al seis). A continuación se estableció la comunicación con el monitor serial y la entrada digital a través del botón pulsador. Por último se desarrollaron dos fracciones de código, uno con la instrucción for, para seleccionar el valor a través del botón pulsador asociado a la asignación del valor para la variable optn y otra con la instrucción switch/case, para desplegar el valor seleccionado por la pulsación del botón.
Aunque el código que se presenta adelante es bastante extenso, es posible quitar partes que no intervienen directamente con el funcionamiento del dado. Las funciones para desplegar los números se repiten, cambiando únicamente los valores de la instrucción delay();. Como ejercicio, se puede quitar un juego de estos números colocando como argumentos de las funciones, las duraciones para la instrucción mencionada.

El código desarrollado para el proyecto es el siguiente:

/*
Un display LED de 7 segmentos despliega rápidamente números
del uno al seis. Se detiene cuando se presiona un botón
pulsador, mostrando el valor en forma estática.
Al pulsar nuevamente el botón pulsador vuelve a comenzar el
despliegue de números del uno al seis
Se utiliza la instrucción switch / case
*/

int a=2;
int b=3;
int c=4;
int d=5;
int e=6;
int f=7;
int g=8;
int pulsador=9;

void setup ()  {
  Serial.begin(9600);
  pinMode(a, OUTPUT);
  pinMode(b, OUTPUT);
  pinMode(c, OUTPUT);
  pinMode(d, OUTPUT);
  pinMode(e, OUTPUT);
  pinMode(f, OUTPUT);
  pinMode(g, OUTPUT);
  pinMode(pulsador, INPUT);  }


void loop ()  {
  digitalWrite(a, HIGH);
  delay(250);
  digitalWrite(a, LOW);
  delay(75);

  digitalWrite(b, HIGH);
  delay(250);
  digitalWrite(b, LOW);
  delay(75);

  digitalWrite(c, HIGH);
  delay(250);
  digitalWrite(c, LOW);
  delay(75);

  digitalWrite(d, HIGH);
  delay(250);
  digitalWrite(d, LOW);
  delay(75);

  digitalWrite(e, HIGH);
  delay(250);
  digitalWrite(e, LOW);
  delay(75);

  digitalWrite(f, HIGH);
  delay(250);
  digitalWrite(f, LOW);
  delay(75);

  digitalWrite(g, HIGH);
  delay(250);
  digitalWrite(g, LOW);
  delay(75);

  digitalWrite(a, HIGH);
  delay(200);
  digitalWrite(b, HIGH);
  delay(200);
  digitalWrite(c, HIGH);
  delay(200);
  digitalWrite(d, HIGH);
  delay(200);
  digitalWrite(e, HIGH);
  delay(200);
  digitalWrite(f, HIGH);
  delay(200);
  digitalWrite(g, HIGH);
  delay(200);

  digitalWrite(a, LOW);
  digitalWrite(b, LOW);
  digitalWrite(c, LOW);
  digitalWrite(d, LOW);
  digitalWrite(e, LOW);
  digitalWrite(f, LOW);
  digitalWrite(g, LOW);

  int optn =0;

for (int i=0; i<50; i++)  {
  Uno();
  int valUno= digitalRead(pulsador);
  Serial.print(" 1 ");
  Serial.println(valUno);
  if (valUno == 1)  {
    optn =1;  }

  Dos();
  int valDos= digitalRead(pulsador);
  Serial.print(" 2 ");
  Serial.println(valDos);
  if (valDos == 1)  {
    optn =2;  }

  Tres();
  int valTres= digitalRead(pulsador);
  Serial.print(" 3 ");
  Serial.println(valTres);
  if (valTres == 1)  {
    optn =3;  }

  Cuatro();
  int valCuatro= digitalRead(pulsador);
  Serial.print(" 4 ");
  Serial.println(valCuatro);
  if (valCuatro == 1)  {
    optn =4;  }

  Cinco();
  int valCinco= digitalRead(pulsador);
  Serial.print(" 5 ");
  Serial.println(valCinco);
  if (valCinco == 1)  {
    optn =5;  }

  Seis();
  int valSeis= digitalRead(pulsador);
  Serial.print(" 6 ");
  Serial.println(valSeis);
  if (valSeis == 1)  {
    optn =6;  }  }

Serial.print("el valor de optn es: ");
Serial.println(optn);

switch (optn)  {
  case 1:  {
    UnoDisplay();
    break;  }
  case 2:  {
    DosDisplay();
    break;  }
  case 3:  {
    TresDisplay();
    break;  }
  case 4:  {
    CuatroDisplay();
    break;  }
  case 5:  {
    CincoDisplay();
    break;  }
  case 6:  {
    SeisDisplay();
    break;  }
  default:
    break;  }  }

void Uno ()  {
  digitalWrite(f, HIGH);
  digitalWrite(e, HIGH);
  delay(50);
  digitalWrite(f, LOW);
  digitalWrite(e, LOW);
  delay(15);  }

void Dos ()  {
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(g, HIGH);
  digitalWrite(e, HIGH);
  digitalWrite(d, HIGH);
  delay(50);
  digitalWrite(a, LOW);
  digitalWrite(b, LOW);
  digitalWrite(g, LOW);
  digitalWrite(e, LOW);
  digitalWrite(d, LOW);
  delay(15);  }

void Tres ()  {
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(g, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  delay(50);
  digitalWrite(a, LOW);
  digitalWrite(b, LOW);
  digitalWrite(g, LOW);
  digitalWrite(c, LOW);
  digitalWrite(d, LOW);
  delay(15);  }

void Cuatro ()  {
  digitalWrite(f, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(g, HIGH);
  digitalWrite(c, HIGH);
  delay(50);
  digitalWrite(f, LOW);
  digitalWrite(b, LOW);
  digitalWrite(g, LOW);
  digitalWrite(c, LOW);
  delay(15);  }

void Cinco ()  {
  digitalWrite(a, HIGH);
  digitalWrite(f, HIGH);
  digitalWrite(g, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  delay(50);
  digitalWrite(a, LOW);
  digitalWrite(f, LOW);
  digitalWrite(g, LOW);
  digitalWrite(c, LOW);
  digitalWrite(d, LOW);
  delay(15);  }

void Seis ()  {
  digitalWrite(a, HIGH);
  digitalWrite(f, HIGH);
  digitalWrite(g, HIGH);
  digitalWrite(e, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(c, HIGH);
  delay(50);
  digitalWrite(a, LOW);
  digitalWrite(f, LOW);
  digitalWrite(g, LOW);
  digitalWrite(e, LOW);
  digitalWrite(d, LOW);
  digitalWrite(c, LOW);
  delay(15);  }

void UnoDisplay ()  {
  for (int i=0; i<15; i++)  {
  digitalWrite(f, HIGH);
  digitalWrite(e, HIGH);
  delay(250);
  digitalWrite(f, LOW);
  digitalWrite(e, LOW);
  delay(15);  }  }

void DosDisplay ()  {
  for (int i=0; i<15; i++)  {
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(g, HIGH);
  digitalWrite(e, HIGH);
  digitalWrite(d, HIGH);
  delay(250);
  digitalWrite(a, LOW);
  digitalWrite(b, LOW);
  digitalWrite(g, LOW);
  digitalWrite(e, LOW);
  digitalWrite(d, LOW);
  delay(15);  }  }

void TresDisplay ()  {
  for (int i=0; i<15; i++)  {
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(g, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  delay(250);
  digitalWrite(a, LOW);
  digitalWrite(b, LOW);
  digitalWrite(g, LOW);
  digitalWrite(c, LOW);
  digitalWrite(d, LOW);
  delay(15);  }  }

void CuatroDisplay ()  {
  for (int i=0; i<15; i++)  {
  digitalWrite(f, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(g, HIGH);
  digitalWrite(c, HIGH);
  delay(250);
  digitalWrite(f, LOW);
  digitalWrite(b, LOW);
  digitalWrite(g, LOW);
  digitalWrite(c, LOW);
  delay(15);  }  }

void CincoDisplay ()  {
  for (int i=0; i<15; i++)  {
  digitalWrite(a, HIGH);
  digitalWrite(f, HIGH);
  digitalWrite(g, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  delay(250);
  digitalWrite(a, LOW);
  digitalWrite(f, LOW);
  digitalWrite(g, LOW);
  digitalWrite(c, LOW);
  digitalWrite(d, LOW);
  delay(15);  }  }

void SeisDisplay ()  {
  for (int i=0; i<15; i++)  {
  digitalWrite(a, HIGH);
  digitalWrite(f, HIGH);
  digitalWrite(g, HIGH);
  digitalWrite(e, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(c, HIGH);
  delay(250);
  digitalWrite(a, LOW);
  digitalWrite(f, LOW);
  digitalWrite(g, LOW);
  digitalWrite(e, LOW);
  digitalWrite(d, LOW);
  digitalWrite(c, LOW);
  delay(15);  }  }


Como se comentó al inicio, el desarrollo del proyecto se hizo mediante avances parciales hasta completar las funciones que se habían contemplado en el programa inicial. Con la diferencia de que el formato final funcionó correctamente.
El proyecto y el código correspondiente fueron desarrollados por Miguel Angel Orduña Bustamante en el año 2012. Saludos.