SETA43

lunes, 10 de diciembre de 2012

Arduino-red-webserver 6 entradas analógicas y 7 entradas digitales. Medidor de temperatura a través de la red.

Arduino-red-webserver
6 entradas analógicas y 7 entradas digitales.
Medidor de temperatura a través de la red.
xsetaseta@gmail.com

Este es mi primer contacto con la placa de red y lector de SD para arduino.
La tarjeta Arduino Ethernet Shield se puede encontrar en el mercado entre 9€ y 25€ depende del suministrador.
Para mas detalles visitar la página oficial http://www.arduino.cc/en/Main/ArduinoEthernetShield.

La comunicación con el chip W5100 y con la tarjeta SD se hace a través del bus SPI.
La activación del chip de red se efectúa con el pin 10 del arduino, y la activación tarjeta SD se realiza con el pin 4.
El primer montaje es una ampliación del programa que viene de ejemplo en el arduino, WebServer.
He añadido las 7 entradas digitales, además de poner color a las fuentes.

Imagen del valor de las entradas en un navegador.

// SETA43
// Modificacion 9-12-2012
/*
  Web Server
 
 A simple web server that shows the value of the analog input pins.
 using an Arduino Wiznet Ethernet shield. 
 
 created 18 Dec 2009
 by David A. Mellis
 modified 9 Apr 2012
 by Tom Igoe
 
 */

#include <SPI.h>
#include <Ethernet.h>

//numero de MAC
//numero de ip, depende de tu red

byte mac[] = { 
  0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192,168,2, 177);

// Initialize the Ethernet server library
// with the IP address and port you want to use 
// (port 80 is default for HTTP):
EthernetServer server(80);

void setup() {
 // Open serial communications and wait for port to open:
  Serial.begin(9600);
   while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  }

  Ethernet.begin(mac, ip);
  server.begin();
  Serial.print("server is at ");
  Serial.println(Ethernet.localIP());
}


void loop() {
  // listen for incoming clients
  EthernetClient client = server.available();
  if (client) {
    Serial.println("new client");

    boolean currentLineIsBlank = true;
    while (client.connected()) {
      if (client.available()) {
        char c = client.read();
        Serial.write(c);
        
        if (c == '\n' && currentLineIsBlank) {
          // Manda la cabecera del http
          client.println("HTTP/1.1 200 OK");
          client.println("Content-Type: text/html");
          client.println("Connnection: close");
          client.println();
          client.println("<!DOCTYPE HTML>");
          client.println("<html>");
          // Refresca cada 5 segundos
          client.println("<meta http-equiv=\"refresh\" content=\"5\">");
          client.println("<big><b>Seta43_Arduino</b></big><br>");
           client.print("xsetaseta@gmail.com ");
          client.println("<hr>");

          for (int analogChannel = 0; analogChannel < 6; analogChannel++) {
            int sensorReading = analogRead(analogChannel);                      
            client.print("Analog input ");            
            client.print("<font color=red>"); 
            client.print(analogChannel);
            client.print("</font>");            
            client.print(" is ");            
            client.print("<font color=blue>");   
            client.print(sensorReading);
            client.print("</font>");            
            client.println("<br />");       
          }
          
           client.println("<hr>");
          
          for (int digitalChannel = 2; digitalChannel < 10; digitalChannel++) {
            if(digitalChannel!=4)
            {
            int sensorReading = digitalRead(digitalChannel);                       
            client.print("Digital input ");           
            client.print("<font color=red>"); 
            client.print(digitalChannel);
            client.print("</font>");            
            client.print(" is ");           
            client.print("<font color=blue>");   
            client.print(sensorReading);
            client.print("</font>");            
            client.println("<br />");
            }
          }
          
           client.println("<hr>");
           client.print("Ping 11,12,13 para la comunicaci&oacute;n"); 
           client.println("<br />");
           client.print("Ping 10 selecciona Red W5100");
           client.println("<br />");
           client.print("Ping 4 selecciona SD");

           
          client.println("</html>");
          break;
        }
        if (c == '\n') {
          // you're starting a new line
          currentLineIsBlank = true;
        } 
        else if (c != '\r') {
          // you've gotten a character on the current line
          currentLineIsBlank = false;
        }
      }
    }
    // give the web browser time to receive the data
    delay(1);
    // close the connection:
    client.stop();
    Serial.println("client disonnected");
  }
}

Programa del arduino. WebServer con 6 entradas analógicas y 7 entradas digitales.

La primera aplicación que me vino a la mente que no fuera complicada, fue un medidor de temperatura mediante el LM35.
El integrado de 3 patillas LM35 es un detector de temperatura que varia 10mV cada ºC y su rango de medidas va de -55ºC a +150ºC.
El programa realizado lee el voltaje de salida del LM35 en la patilla A0 del arduino para luego transformarlo en grados centígrados.
No he querido complicar el montaje para medir grados negativos, el que quiera medir grados negativos le recomiendo ver un antiguo montaje ter876.htm donde se explica como hacerlo, es muy fácil.
Recordar que la alimentación del arduino puede ser del USB o del alimentador, y puede variar entre 5V y 5.6V, lo que hace variar la referencia del convertidor A/D , del mismo modo la medida de la temperatura. Esta variación la calculo en 1ºC arriba o abajo.

Montaje del circuito medidor de temperatura.

// SETA43
// Modificacion 9-12-2012
//Medidor de temperatura

/*
  Web Server
 created 18 Dec 2009
 by David A. Mellis
 modified 9 Apr 2012
 by Tom Igoe
 */

#include <SPI.h>
#include <Ethernet.h>

//numero de MAC
//numero de ip, depende de tu red

byte mac[] = { 
  0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192,168,2, 177);

float temperatura;

// Inicializa la libreria  Ethernet 
// Selecciona el puerto 80, por defecto HTTP):
EthernetServer server(80);

void setup() {
 // Open serial communications and wait for port to open:
  Serial.begin(9600);
   while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  }

  Ethernet.begin(mac, ip);
  server.begin();
  Serial.print("server is at ");
  Serial.println(Ethernet.localIP());
}


void loop() {
  // listen for incoming clients
  EthernetClient client = server.available();
  if (client) {
    Serial.println("new client");

    boolean currentLineIsBlank = true;
    while (client.connected()) {
      if (client.available()) {
        char c = client.read();
        Serial.write(c);
        
        if (c == '\n' && currentLineIsBlank) {
          // Manda la cabecera del http
          client.println("HTTP/1.1 200 OK");
          client.println("Content-Type: text/html");
          client.println("Connnection: close");
          client.println();
          client.println("<!DOCTYPE HTML>");
          client.println("<html>");
          // Refresca cada 5 segundos
          client.println("<meta http-equiv=\"refresh\" content=\"5\">");
          client.println("<big><b>Seta43_Arduino</b></big><br>");
           client.print("xsetaseta@gmail.com ");
          client.println("<hr>");

            temperatura = analogRead(0);  
            temperatura=(500*temperatura)/1024;           
            client.print("Temperatura "); 
             client.println("<h1><font color=red>");           
            client.print(temperatura);
            client.println("&ordm;C</font></h1>");
           
           client.println("<hr>");              
          client.println("</html>");
          break;
        }
        if (c == '\n') {
          // you're starting a new line
          currentLineIsBlank = true;
        } 
        else if (c != '\r') {
          // you've gotten a character on the current line
          currentLineIsBlank = false;
        }
      }
    }
    // give the web browser time to receive the data
    delay(1);
    // close the connection:
    client.stop();
    Serial.println("client disonnected");
  }
}

Programa del arduino. WebServer medidor de temperatura.

Bibliografía:
http://www.arduino.cc/en/Main/ArduinoEthernetShield
http://dam.mellis.org/

Saludos.
JUAN GALAZ

viernes, 30 de noviembre de 2012

Detector de obstáculos mediante arduino y el hc-sr04

xsetaseta@gmail.com

Ayer me llegó un hc-sr04, detector de obstáculos mediante ultrasonidos. Se puede encontrar por un precio entre 2€ y 6€.
En este montaje pretendo realizar un detector de obstáculos que produzca un sonido dependiendo la distancia.
El montaje se realiza mediante el buen arduino y el detector hc-sr04, ademas de un altavoz piezoelectrico.
Su utilización práctica puede ser extensa, pero la primera que me viene a la mente es de ayuda para aparcar un coche.

hc-sr04

Voltaje: 5VDC

Corriente en reposo: < 2 mA
Salida: High 5V/Low 0V
Angulo: < 15º
Distancia: 2 a 450 cm
Resolución: 0,3 cm

Pins de conexión:

VCC
Trig (Disparo del ultrasonido)
Echo (Recepción del ultrasonido)
GND

La formula para calcular la distancia es:
Distancia = {(Tiempo entre Trig y el Echo) * (V.Sonido 340 m/s)}/2
El montaje es el siguiente:

La asignación de los pin de arduino que se conectan al hc-sr04 se pueden cambiar a gusto de cada uno.
En mi montaje la conexión es la siguiente:

ARDUINO Digital	HC-SR04
GND	GND
5V	Vcc
9	Trig
8	Echo

En este primer montaje solo realizamos el detector que manda la distancia hasta el obstaculo al ordenador mediante la conexion usb.

// Ultrasonic - Library for HR-SC04 Ultrasonic Ranging Module.
// SETA43
// xsetaseta@gmail.com

#include <Ultrasonic.h>

Ultrasonic ultrasonic(9,8); // (Trig PIN,Echo PIN)

int sonar;                  //Declaramos la variable sonar

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

void loop()
{
 
  sonar = ultrasonic.Ranging(CM); //Leemos la distancia del sonar 
  
  Serial.print(sonar); // CM or INC
  Serial.println(" cm" );
  delay(100);  
}

Programa que utiliza la librería Ultrasonic.
En la versión de esta librería que he utilizado, está colocada para que solo mida hasta 50cm.
Para medir hasta 5m debes modificar el archivo de la librería Ultrasonic.ccp.
Cambiar:
Time_out=3000; // 30ms 5 metros // 3ms 50cm

// SETA43
// xsetaseta@gmail.com
//29-11-2012


#define ECHOPIN 8       // Pin to receive echo pulse  (Echo PIN)
#define TRIGPIN 9        // Pin to send trigger pulse (Trig PIN)


unsigned int tiempo,distancia;                  


void setup() {
  Serial.begin(9600); 
  pinMode(ECHOPIN, INPUT);
  pinMode(TRIGPIN, OUTPUT);
}
  
void loop()
{
 
  digitalWrite(TRIGPIN, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIGPIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIGPIN, LOW);
  // Calcula la distancia midiendo el tiemp que est el pin ECHOPIN en alto.
  tiempo = pulseIn(ECHOPIN, HIGH);
  // La velocidad del sonido es 340 m/s o 29 microsegundos por centimetro.
  distancia= tiempo/58;
  //manda la distancia al puerto serie.  
  Serial.print(distancia);
  Serial.println(" cm");
  delay(200);
  
}

En este caso no utiliza ninguna librería, emplea el comando pulseIn.

Consola del arduino recibiendo datos de distancia.
En el caso que vemos en la consola, hemos utilizado float para ver decimales en los centímetros.

Una vez probado el funcionamiento del circuito, nos disponemos a poner el altavoz piezoelectrico.
Al utilizar un altavoz piezoelectrico no hace falta colocar resistencia debido a su alta impedancia.
Si se utiliza un altavoz de 8 ohmios se debería utilizar una resistencia en serie de 330 ohmios.

La conexión del altavoz se realiza al pin Digital 7, y a la masa GND.
También se puede variar el pin de conexión en el programa.

// SETA43
// xsetaseta@gmail.com
//29-11-2012


#define ECHOPIN 8       // Pin to receive echo pulse  (Echo PIN)
#define TRIGPIN 9        // Pin to send trigger pulse (Trig PIN)

#define PINTONO 7


unsigned int tiempo,distancia;                  


void setup() {
  Serial.begin(9600); 
  pinMode(ECHOPIN, INPUT);
  pinMode(TRIGPIN, OUTPUT);
  pinMode(PINTONO, OUTPUT);
}
  
void loop()
{
 
  digitalWrite(TRIGPIN, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIGPIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIGPIN, LOW);
  // Calcula la distancia midiendo el tiemp que est el pin ECHOPIN en alto.
  tiempo = pulseIn(ECHOPIN, HIGH);
  // La velocidad del sonido es 340 m/s o 29 microsegundos por centimetro.
  distancia= tiempo/58;
  //manda la distancia al puerto serie.  
  Serial.print(distancia);
  Serial.println(" cm");
  tone(PINTONO,2000);
  delay(200);
  //Si la distancia es menor que 10cm, produce un tono continuo
  if (distancia>10)noTone(PINTONO);
  delay(distancia*3);
  
}

Vídeo del montaje funcionando: http://youtu.be/Efmkj8W7ai

Bibliografía:

http://electronicavm.wordpress.com/2011/07/07/sensor-de-aparcamiento-con-arduino/
http://www.ardublog.com/library-for-arduino-ultrasonic-ranging-hc-sr04/

Un saludo.
JUAN GALAZ

lunes, 26 de noviembre de 2012

Viejos montajes - Spectrum 16 entradas/salidas

Página principal

Viejos montajes - Spectrum 16 entradas/salidas

Abriendo mis cajones he encontrado un viejo montaje realizado para el Spectrum.
Eran los años 80, el Spectrum era el ordenador mas vendió en España, simple y barato, basado en el procesador Z80.
El Z80 era un procesador de 8 bit, que estaba montado en muchos de los ordenadores de aquella época, Spectum, Amstrad, MSX, etc..
Por aquella época empece hacer mis pinitos en ordenadores, programación en Basic, y algún montaje que otro.
Investigando para poder controlar aparatos mediante el ordenador, decidí comprar un Z80-PIO.
El Z80-PIO era un integrado de 16 entrada/salidas y circuitos de control. Podían programarse las 16 E/S a gusto del programador.
La programación del Z80-PIO se realizaba mediante el Basic de Spectrum.
Me puse manos a la obra y realice el montaje que a continuación muestro.

Un saludo.
Juan Galaz

martes, 2 de octubre de 2012

GPS - Monitor de señal. Arduino

GPS - Monitor de señal.
Arduino
xsetaseta@gmail.com

Después de realizar un monitor de GPS con un PC, me dispongo a realizar un monitor con un arduino.
Teniendo toda la información de mi anterior programa http://seta43.duckdns.org/gps.html la realización en el arduino me a resultado muy fácil.
Además de procesar los datos del GPS los manda por la línea serie al ordenador a 38400bps.
Se conecta un LCD al arduino y se utiliza la librería LiquidCrystal.h .He utilizado la conexión estándar de 4bits según viene en la librería.
The circuit:
* LCD RS pin to digital pin 12
* LCD Enable pin to digital pin 11
* LCD D4 pin to digital pin 5
* LCD D5 pin to digital pin 4
* LCD D6 pin to digital pin 3
* LCD D7 pin to digital pin 2
* LCD R/W pin to ground
* 10K resistor:
* ends to +5V and ground
* wiper to LCD VO pin (pin 3)

Esquema con el programa fritzing.

Montaje realizado y funcionando.
Video funcionando http://www.youtube.com/watch?v=uIa1Pc7ilTw&feature=plcp

Salida de gps con señales TTL.

Programa para el arduino.

/*
xsetaseta@gmail.com
 seta comunicaciones
 
 */

// include the library code:
#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

char VARI[100];
int contador;
boolean stringComplete = false; 
//char hora[10];
byte pantalla;

struct DATOSGPS{
 char cadena[16];
};
struct DATOSGPS datosgps[22];

void split (char separador)
{
 int x,xx,y,z;
 z=sizeof(VARI);
 y=0; 
 xx=0;
 for(x=0;x<z;x++)
  {
  datosgps[y].cadena[xx]=VARI[x];
  if(VARI[x]==0) break;
  if( separador==VARI[x]) 
   {
    datosgps[y].cadena[xx]=0;
    xx=0;
    y++;
   }
   else
   {
    xx++;
   }
  }
}


void insert(int n,char caracter)
{
 int x;
 x=sizeof(VARI);
 for(;x>n;x--)
 {
  VARI[x]=VARI[x-1];
 }
 VARI[x]=caracter;
}

void setup() {
  // initialize both serial ports:
  lcd.begin(16, 2);
  Serial.begin(38400);
}


void serialEvent()
{
  while (Serial.available())
  {
    char inChar = (char)Serial.read(); 
    VARI[contador]=inChar;  
    if (inChar == '\n')
        {
          stringComplete = true;
          VARI[contador]=0;
        } 
    contador++;   
  }
}

void loop() {
 if (stringComplete) 
    {
      WriteComand();
    }
}

void WriteComand()
{
  if(!strncmp(VARI,"$GPGGA",6))
      {
        Serial.print("OK->");    
        Serial.println(VARI);

      split(',');
    if(pantalla==0)
     {
       pantalla=1;
       lcd.clear();
//Hora      
       strcpy(VARI,datosgps[1].cadena);
       insert(2,':');
       insert(5,':');
       VARI[8]=0;
       Serial.println(VARI);
       lcd.setCursor(0, 0);
       lcd.print(VARI);
       
         
      if(datosgps[6].cadena[0]!='0')
   {
            lcd.setCursor(0, 1);
       lcd.print("");
   }
 else
   {
     lcd.setCursor(0, 1);
       lcd.print(" ");
   }    

     }
     else
     {      
      pantalla=0; 
      lcd.clear();
      strcpy(VARI,datosgps[2].cadena);
      insert(2,' ');
      Serial.print(VARI);
      lcd.setCursor(0, 0);
      lcd.print(VARI);
      
      strcpy(VARI,datosgps[3].cadena);
      Serial.println(VARI);
      lcd.setCursor(10, 0);
      lcd.print(VARI);
      
      strcpy(VARI,datosgps[4].cadena);
      insert(3,' ');
      Serial.print(VARI);      
      lcd.setCursor(0, 1);
      lcd.print(VARI);
      
      strcpy(VARI,datosgps[5].cadena);
      Serial.println(VARI);
      lcd.setCursor(11, 1);
      lcd.print(VARI);
      }
     }
  contador=0;
  stringComplete = false;
      
}

Un saludo.
Juan Galaz

jueves, 13 de septiembre de 2012

GPS - Monitor de señal. SDL y Gambas

GPS - Monitor de señal.
SDL y Gambas

Siempre he querido hacer algún montaje con gps, y ahora en este articulo me pongo manos a la obra.
Dispongo de un modulo gps modelo HOLUX M-1200, que se enlaza al móvil mediante Bluetooth, funcionando a las mil maravillas.
El Holux dispone de otro tipo de comunicaciones, modo serie, utiliza los cables del usb (D- y D+) como señales serie funcionando a: Baud rate : 38400 bps Data bit : 8 Parity : N Stop bit : 1.
Las señales funciona en niveles de CMOS Level, por lo cual podemos utilizar multitud de montajes o aparatos que trabajan con esas señales.
Puedes comprar por internet cables adaptadores (GR230-A2)- (GR230-A1).
También puedes utilizar adaptadores de mis anteriores circuitos. terser.html
En mi caso voy a utilizar un antiguo cable de un teléfono móvil que adapta USB-SerieTTL.

USB-SerieTTL

Usando un adaptador Bluetooth

Los programas realizados leen los datos transmitidos por el gps. Cuando encuentra la línea que empieza por $GPGGA la captura y trata los datos segun la norma NMEA.

GGA —Global Positioning System Fixed Data

El primer programa realizado está hecho en Gambas una especie de Visual Basic para Linux, es fácil de hacerlo debido a su IDE y su apariencia es limpia.

Programa en Gambas
En el programa se selecciona el tipo de conexión ya sea mediante usb o serie, y con solo dar al botón start empieza a recibir datos del gps. En este programa no tiene registro de datos, es solo visualización.

El segundo programa está realizado mediante la librería SDL, es una librería para realizar juegos pero se puede utilizar para distintos propósitos.


Funcionamiento en Linux Programa Linux	Funcionamiento en Windows Programa Windows

En este programa realizado mediante la librería SDL el interfaz serie hay que ponerlo como argumento del programa. Si no ponemos argumento, el valor por defecto del interfaz de comunicaciones es /dev/ttyUSB0 para Linux y COM4 para Windows.
He incorporado un registro de datos que se almacenan en el fichero gpsreg.txt donde se almacena las coordenada y la fecha.

Lo que me satisface más, es el poder compilar para las dos plataformas, Linux o Windows, con solo cambiar la directiva YesWindows 0 por #define YesWindows 1 .
Como he dicho en el anterior trabajo, la programación se ha realizado en Linux con el IDE Anjuta, y en Dev-C++ bajo Windows.

Un saludo.
Juan Galaz

Bibliografía:

http://www.muchotrasto.com/gps.php

NMEAReferenceManual.pdf

lunes, 25 de junio de 2012

Arduino Control de 12 salidas y 6 entradas analógicas

Página principal

Arduino
Control de 12 salidas y 6 entradas analógicas
mediante rs232
Librería SDL

xsetaseta@gmail.com

Esta es la continuación de mi anterior trabajo Arduino ,Control de salidas mediante rs232 .
En el PC se ha realizado un programa mediante la librería SDL donde se muestra el estado de 6 entradas analógicas con un piloto verde y el valor en voltios, y 12 salidas digitales.
Como lenguaje he utilizado el C, hubiese sido mas fácil hacerlo en Visual Basic en Windows y en Gambas bajo Linux, pero mi meta era hacerlo multiplataforma y utilizar el mismo código para ambas plataformas.
Para mandar las ordenes al arduino se puede utilizar la consola del programador de arduino o cualquier otro programa de comunicaciones como por ejemplo CuteCom o minicom en Linux.
Para pedir el valor del pin analógico 0 se realiza mediante la orden IANA0, y la placa arduino devuelve ANA0=valor, siendo un valor entre 0 y 1023. El valor 1023 corresponde a el valor de Vcc, alrededor de 5V. El programa en el PC lo transforma a voltios reales medidos. Existe variación en el valor de Vcc dependiendo si se alimenta a través del USB o a través de un alimentación externa. Esta diferencia origina una diferencia en el valor medido. Para solucionar este problema he puesto la posibilidad de seleccionar el tipo de alimentación.
Para activar el pin Digital13 se manda al arduino la orden 1Dig13, entonces el arduino pone el pin Digital13 a 5V. Si recibe la orden 0Dig13 el arduino pone la salida Digital13 a 0V.

Programa en el PC funcionando.

PROGRAMA , fuentes y programas compilados para Windows y Linux.

Lo que me satisface más, es el poder compilar para las dos plataformas, Linux o Windows, con solo cambiar la directiva YesWindows 0 por #define YesWindows 1 .
Como he dicho en el anterior trabajo, la programación se ha realizado en Linux con el IDE Anjuta, y en Dev-C++ bajo Windows.

Un saludo.
Juan Galaz

lunes, 18 de junio de 2012

Página principal

Arduino
Control de entradas mediante rs232
Librería SDL

xsetaseta@gmail.com

Esta es la continuación de mi anterior trabajo Arduino ,Control de salidas mediante rs232 .
Ahora mi pretensión es hacer un monitor de las 18 entradas del arduino, mandado la información mediante conexión serie rs232 al PC. En el PC se ha realizado un programa mediante la librería SDL donde se muestra el estado de cada entrada con un piloto verde.
Como lenguaje he utilizado el C, hubiese sido mas fácil hacerlo en Visual Basic en Windows y en Gambas bajo Linux, pero mi meta era hacerlo multiplataforma y utilizar el mismo código para ambas plataformas.

El funcionamiento del programa en la parte de arduino es la siguiente:
Cuando se quiere leer el puerto PORTB del micro, se manda una orden desde el PC "IPORTB" al arduino mediante la conexión rs232. En el arduino se procesa esta orden devolviendo el valor del puerto como "PORTB=valor" donde valor es el número leído en el PORTB. Funciona como un cliente-servidor, uno pide y el otro contesta. Existe otro modo llamado "AUTO" que transmite los valores de los tres puerto cada segundo. Este modo se activa o desactiva mediante la orden AUTO y NOAUTO.
Para mandar las ordenes al arduino se puede utilizar la consola del programador de arduino o cualquier otro programa de comunicaciones como por ejemplo CuteCom o minicom en Linux.

if(!strcmp(entrada,"IPORTB"))
      {
       Serial.print("PORTB=");
       Serial.println(PINB);
       goto salir1;
      }

    if(!strcmp(entrada,"IPORTC"))
      {
       Serial.print("PORTC=");
       Serial.println(PINC);
       goto salir1;
      }
    if(!strcmp(entrada,"IPORTD"))
      {
        Serial.print("PORTD=");
        Serial.println(PIND);
       goto salir1;
      }

Ejemplo de una parte del programa del arduino.

En la parte del PC como se ha dicho antes se realizó el programa mediante la librería multiplataforma SDL. La monitorización de las entradas se realizan mediante luces verdes en forma de led que se encienden o se apagan dependiendo del estado de las 18 entradas de el arduino. También he querido añadir un pequeño sonido cuando se detecta un cambio en cualquiera de las entradas.
He añadido 3 velocidades de lectura de los puertos 1 Segundo, 0,5 Segundos y 0,3 Segundos. Este es el retardo máximo entre el cambio de estado de una entrada y su representación en la pantalla del PC.
El programa admite el argumento del puerto de comunicaciones. En caso de no poner ningún argumento, asume en Linux "/dev/ttyUSB0" y en Windows "COM3" .
Para manejar el puerto bajo Windows he visitado www.mcbtec.com donde existe un buen tutorial.

El programa funcionando.

Programa

Lo que me satisface más, es el poder compilar para las dos plataformas, Linux o Windows, con solo cambiar la directiva YesWindows 0 por #define YesWindows 1 .
Como he dicho en el anterior trabajo, la programación se ha realizado en Linux con el IDE Anjuta, y en Dev-C++ bajo Windows.

Antes de nada he de pedir perdón por la forma de programar que tengo, un poco desordenada y poco optimizada en algunos casos. También he probado formatear el código fuente mediante programas al efecto, pero el resultado no me satisfacía demasiado.

Un saludo.
Juan Galaz