domingo, 30 de junio de 2013

Hydrogen Arduino WiFi Shield

El Hydrogen es una tarjeta del fabricante DIY Sandbox. Llamada también "Hydrogen Arduino WiFi Shield". Respecto al uso de esta tarjeta, no experimenté todas sus funcionalidades pero aquí ustedes tienen el link de su, digamos, DATASHEET hydrogen_quickstart_guide_rev03. Ese documento, indica paso a paso como instalar su librería y como usar la tarjeta.
El ejemplo que hice consisten en prender y apagar un led conectado en el pin 13 del Arduino desde una aplicación Web creada en el mismo código. 
Lo que hice fué agregarle unas lineas de código a un ejemplo dado por el propio fabricante (el ejemplo es cambiar el color del led de la tarjeta HYDROGEN desde la aplicación Web).

###########################################################################
CÓDIGO
###########################################################################
/*
LedDemoAp.pde - Hydrogen board LED demo sketch

Copyright (C) 2011 DIYSandbox LLC

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
*/

#include <Wirefree.h>
#include <WifiServer.h>

WIFI_PROFILE wireless_prof = {
                        /* SSID */ "diysandbox",
         /* WPA/WPA2 passphrase */ "12345678",
                  /* IP address */ "192.168.1.1",
                 /* subnet mask */ "255.255.255.0",
                  /* Gateway IP */ "192.168.1.1", };
                             
// port 80 is default for HTTP
WifiServer server(80, PROTO_TCP);
int led = 13;

void setup()
{
   pinMode(led, OUTPUT);
  // connect as AP & start server
  Wireless.begin(&wireless_prof, AP_MODE);
  server.begin();
 
  delay(1000);
}

void loop()
{
  // Listen for incoming clients
  WifiClient client = server.available();
  int count = 0;
 
  if (client) {
    // an HTTP request ends with a blank line
    boolean currentLineIsBlank = true;
    while (client.connected()) {
      if (client.available()) {
        char c;
        int  b;
       
        while((b = client.read()) == -1);
        c = b;
        // if you've gotten to the end of the line (received a newline
        // character) and the line is blank, the http request has ended,
        // so you can send a reply
        if (c == '\n' && currentLineIsBlank) {
          count = 0;
         
          // send a standard http response header
          client.println("HTTP/1.1 200 OK");
          client.println("Content-Type: text/html");    
          client.println("");    
          //client.println("");    
                    
          // Output HTML page
          client.println("<html><head><title>LED PIN</title></head><body>");
          client.println("<center><h1>DIY Sandbox LED Color Change Demo and LED PIN</h1>");

          client.println("<p><form method=\"get\" action=\"\"><select name=\"l\">");
          client.println("<option value=\"r\">Red</option>");
          client.println("<option value=\"g\">Green</option>");
          client.println("<option value=\"b\">Blue</option>");
          client.println("<option value=\"c\">Cyan</option>");
         
          client.println("<option value=\"m\">Magenta</option>");      
          client.println("<option value=\"y\">Yellow</option>");
          client.println("<option value=\"w\">White</option>");
          client.println("<option value=\"p\">pinON</option>");
          client.println("<option value=\"f\">pinOFF</option>");
          client.println("</select><input type=\"submit\" value=\"Change\" /></form></p>");

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

          client.flush();

          break;        
        }
        if (c == '\n') {
          // you're starting a new line
          currentLineIsBlank = true;
          count = 0;
        }
        else if (c != '\r'){
          // you've gotten a character on the current line
          currentLineIsBlank = false;
          count++;
          if ((c == '=') && (count == 8)){
             while((b = client.read()) == -1);
             c = b;
             if ( c == 'r')
             Wireless.setLED(LED_RED);
             else if ( c == 'g')
             Wireless.setLED(LED_GREEN);
             else if ( c == 'b')
             Wireless.setLED(LED_BLUE);
             else if ( c == 'c')
             Wireless.setLED(LED_CYAN);
             else if ( c == 'm')
             Wireless.setLED(LED_MAGENTA);
             else if ( c == 'y')
             Wireless.setLED(LED_YELLOW);
             else if ( c == 'w')
             Wireless.setLED(LED_WHITE);
             else if ( c == 'p'){
             digitalWrite(led, HIGH);
             }
              else if ( c == 'f'){
             digitalWrite(led, LOW);
             }
          }         
        }
      }
    }
    // give the web browser time to receive the data
    delay(1);
    // close the connection        
    client.stop();            
  }
}


Graba el programa de arriba y conéctate al WIFI de la tarjeta:

Despues de conectarte, digita en tu navegador:




La pagina web diseñada es:
Las dos ultimas opciones: pinON y pinOFF sirven para prender y apagar un led conectado al pin 13 del Arduino.

En la figura de abajo, el led de la derecha fue prendido con pinON:

En la siguiente figura el led fue apagado con el pinOFF:

La luz de la izquierda, es del led multicolor de la tarjeta. Cambia utilizando las opciones: RED, GREEN, BLUE, CYAN, MAGENTA, YELLOW, WHITE.





























































































































































































































































































martes, 29 de enero de 2013

Instalación del TinyOS 2.1.1 en Ubuntu 12.04



Holas,
Ahora estoy haciendo algo con wireless sensor network (WSN) específicamente los Mica2 y Micaz. Para trabajar con ellos tuve que instalar el TinyOS. Voy a colocar paso a paso la instalación :]

TinyOS es un sistema operativo proyectado para dispositivos inalambricos de bajo consumo de energia, como los usados ​​en redes de sensores, computacion ubicuas, redes de área pessoal, edifícios inteligentes y medidores inteligentes.


Paso 1: en Ubuntu
primero vamos a quitar algun repositorio antiguo y agregar los nuevos para esta version:


$ Sudo gedit / etc / apt / sources.list
se abre un archivo y alli copiamos lo siguiente:

deb http://tinyos.stanford.edu/tinyos/dists/ubuntu lucid main
deb http://tinyos.stanford.edu/tinyos/dists/ubuntu natty main
deb http://tinyos.stanford.edu/tinyos/dists/ubuntu maverick main

despues de copiar se debe ser ver una imagen asi: 
luego guarda los cambios.

Paso 2: actualizacion

Ahora vamos a actualizar las modificaciones hechar

$ Sudo apt-get update
Paso 3: instalando tinyOS

ahora si, vamos a instalar el TinyOS 2.1.1

$ Sudo apt-get install TinyOS-2.1.1

Paso 4: el tinyos.sh

vamos a colocar el CLASSPATH correcto dentro del archivo que se abre con el codigo:

sudo gedit / opt/tinyos-2.1.1/tinyos.sh
dentro, el texto debe estar igual a lo siguiente

#! /usr/bin/env bash
# Here we setup the environment
# variables needed by the tinyos
# make system

echo "Setting up for TinyOS 2.1.1 Repository Version"
export TOSROOT=
export TOSDIR=
export MAKERULES=

TOSROOT="/opt/tinyos-2.1.1"
TOSDIR="$TOSROOT/tos"
CLASSPATH=$CLASSPATH:$TOSROOT/support/sdk/java/tinyos.jar:.
MAKERULES="$TOSROOT/support/make/Makerules"

export TOSROOT
export TOSDIR
export CLASSPATH
export MAKERULES
como en la siguiente figura:
compara con tu archivo .sh e modifica, luego guarda y cierra la ventana de texto.
Paso 5: mas modificaciones
ejecuta el siguiente comando:
$ Gedit ~ /. Bashrc
dentro del archivo agrega lo siguiente:

#Sourcing the tinyos environment variable setup script
source /opt/tinyos-2.1.1/tinyos.sh
guarda el archivo.
Paso 6: verificamos instalacion
para ver que no hay error en nuestra instalación:

$ Tos-check-env
debe ver como la imagen:

Proximos post sera: primeros pasos con el mica2 :]

miércoles, 30 de mayo de 2012

SOLUCIÓN PASO A PASO: NO PUEDO SELECCIONAR EL "Serial Port" DEL ARDUINO


Hoy tuve problemas al conectar mi Arduino UNO a mi computador.
 No reconocía el puerto y tampoco aparecía opciones para escoger el puerto por mas que lo conecte en todas mis entradas USB siempre me salía error!! Pero finalmente conseguí arreglar ese problema:

El error al correr un programa era:



processing.app.SerialNotFoundException: Serial port 'COM3' not found.  Did you select the right one from the Tools > Serial Port menu?
                at processing.app.Serial.<init>(Serial.java:191)

                       ........


Pasos para arreglar ese problema:


1. conecta el arduino a tu computadora
2. selecciona tu arduino, en mi caso es el uno
3. Como no esta habilitado la opción Serial Port,  ve a:

   Panel de Control / Hardware e Sonido, ya dentro elige la opción Administrador de Dispositivos
4. Click a la derecha sobre el Dispositivo
    opción: Actualizar software de controlador
    luego la opción: Buscar controlador en el equipo
5. Finalmente coloca la ruta de la carpeta drivers ubicada dentro de la carpeta arduino-1.0.1
    asi:


                                   C:\............\arduino-1.0.1\drivers
Finalmente ya reconoce
y como muestra la figura ya se puede selecionar el puerto:



martes, 29 de noviembre de 2011

JAVA Y ARDUINO

PASO 1: Ejecuta el programa arduino.
Paso 2: ya con el arduino ejecutándose, ejecuta el programa Main.java
el resultado se imprime en la tela del programa java:



el Programa usado en arduino envia una frase y java lo lee y lo imprime.
java tambien le envia un caracter: 8, arduino lo recibe y se lo vuelve a enviar.
programa Arduino:
////////////////////////////////////////////////////////
///////////////////////////////////////////////////////


int incomingByte = 0;
void setup(){
  Serial.begin(9600);
}

void loop(){
  Serial.println("Is there anybody out there? \n");
  delay(1000);
  if (Serial.available() > 0)

   {
// read the incoming byte:
incomingByte = Serial.read();
     
// say what you got:
Serial.print("arduino recibe: ");
Serial.println(incomingByte, DEC);
}}


/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////

/*Programa en: */ JAVA usado para leer escribir en el arduino


package serialtalk;

import gnu.io.CommPortIdentifier;
import gnu.io.NoSuchPortException;
import gnu.io.SerialPort;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;




public class Main {
    static InputStream serialInt;
    static OutputStream serialOut;
 
 
 
    public static void main(String[] args) throws Exception{
     
 
    try {
CommPortIdentifier portId = null;
try {
portId = CommPortIdentifier.getPortIdentifier("COM3");
} catch (NoSuchPortException npe) {

}
SerialPort port = (SerialPort)portId.open("Título comunicação serial", 9600);
serialOut = port.getOutputStream();
serialInt = port.getInputStream();
port.setSerialPortParams(9600,
SerialPort.DATABITS_8,
SerialPort.STOPBITS_1,
SerialPort.PARITY_NONE);


/*  */

while(true){
   serialOut.write(8);
           while(serialInt.available()>0) {
               System.out.print((char)(serialInt.read()));
           }
       }

/**/
   

} catch (Exception e) {
e.printStackTrace();
}
}

public void close(){
try {
serialOut.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

public void enviaDados(char opcao){
try {
serialOut.write(opcao);
} catch (IOException e) {
e.printStackTrace();
}
}

   
     
    }


domingo, 27 de noviembre de 2011

Circuito Emisor/ Receptor Infrarrojo y Arduino

Aqui el circuito del transmisor receptor infrarrojo y la entrada al Arduino:
Para el proyecto use los sensores: 

Infrared Emitters and Detectors de sparkfun.

el que tiene un color rosado es el receptor:
El que es incoloro es el emisor:



// Pequeño programa para detectar si hay un obstáculo entre el transmisor y receptor infrarrojo.
// set pin numbers:
const int buttonPin = 12;     // Pin de entrada
const int ledPin =  13;      // the number of the LED pin

// variables will change:
int buttonState = 0;         // variable for reading the pushbutton status

void setup() {
  // initialize the LED pin as an output:
  pinMode(ledPin, OUTPUT);    
  // initialize the pushbutton pin as an input:
  pinMode(buttonPin, INPUT);  
}

void loop(){
  // read the state of the pushbutton value:
  buttonState = digitalRead(buttonPin);

  // check if the pushbutton is pressed.
  // if it is, the buttonState is HIGH:
  if (buttonState == HIGH) {  
    // led se prende cuando hay un obstaculo entre el transmisor   y receptor
    digitalWrite(ledPin, HIGH);
  }
  else {
    // led se apaga cuando no se obstruye el paso entre el transmisor y el receptor
    digitalWrite(ledPin, LOW);
  }
}

viernes, 23 de septiembre de 2011

Sensor de Temperatura y Humedad SHT15 usando Arduino


la conexión del sensor con el Arduino UNO:


Aquí el código fuente que me funciono en mi proyecto:


///////////////////////////////////////////////////////////////////////////////////////////
int gTempCmd  = 0b00000011;
int gHumidCmd = 0b00000101;

int shiftIn(int dataPin, int clockPin, int numBits)
{
   int ret = 0;
   int i;

   for (i=0; i<numBits; ++i)
   {
      digitalWrite(clockPin, HIGH);
      delay(10);  // I don't know why I need this, but without it I don't get my 8 lsb of temp
      ret = ret*2 + digitalRead(dataPin);
      digitalWrite(clockPin, LOW);
   }

   return(ret);
}

void sendCommandSHT(int command, int dataPin, int clockPin)
{
  int ack;


  pinMode(dataPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  digitalWrite(dataPin, HIGH);// protocolo para la transmision
  digitalWrite(clockPin, HIGH);
  digitalWrite(dataPin, LOW);
  digitalWrite(clockPin, LOW);
  digitalWrite(clockPin, HIGH);
  digitalWrite(dataPin, HIGH);
  digitalWrite(clockPin, LOW);
         
  // The command (3 msb are address and must be 000, and last 5 bits are command)
  shiftOut(dataPin, clockPin, MSBFIRST, command);

  // Verify we get the coorect ack
  digitalWrite(clockPin, HIGH);
  pinMode(dataPin, INPUT);
  ack = digitalRead(dataPin);
  if (ack != LOW)
    Serial.println("Ack Error 0");
  digitalWrite(clockPin, LOW);
  ack = digitalRead(dataPin);
  if (ack != HIGH)
     Serial.println("Ack Error 1");
}

void waitForResultSHT(int dataPin)
{
  int i;
  int ack;

  pinMode(dataPin, INPUT);

  for(i= 0; i < 100; ++i)
  {
    delay(10);
    ack = digitalRead(dataPin);

    if (ack == LOW)
      break;
  }

  if (ack == HIGH)
    Serial.println("Ack Error 2");
}

int getData16SHT(int dataPin, int clockPin)
{
  int val;

  // Get the most significant bits
  pinMode(dataPin, INPUT);
  pinMode(clockPin, OUTPUT);
  val = shiftIn(dataPin, clockPin, 8);
  val *= 256;

  // Send the required ack
  pinMode(dataPin, OUTPUT);
  digitalWrite(dataPin, HIGH);
  digitalWrite(dataPin, LOW);
  digitalWrite(clockPin, HIGH);
  digitalWrite(clockPin, LOW);
         
  // Get the lest significant bits
  pinMode(dataPin, INPUT);
  val |= shiftIn(dataPin, clockPin, 8);

  return val;
}

void skipCrcSHT(int dataPin, int clockPin)
{
  // Skip acknowledge to end trans (no CRC)
  pinMode(dataPin, OUTPUT);
  pinMode(clockPin, OUTPUT);

  digitalWrite(dataPin, HIGH);
  digitalWrite(clockPin, HIGH);
  digitalWrite(clockPin, LOW);
}

void setup()
{
   Serial.begin(9600); // open serial
}

void loop()
{
  int theDataPin  = 10;
  int theClockPin = 11;
  int ack;


           int val;
           int temperatura;
           int humedad;
         
           sendCommandSHT(gTempCmd, theDataPin, theClockPin);
           waitForResultSHT(theDataPin);
           val = getData16SHT(theDataPin, theClockPin);
           skipCrcSHT(theDataPin, theClockPin);
           Serial.print("Temperatura:");
           //Serial.print(val, HEX);
           temperatura = -40.1 + 0.01 * (float)val;
           Serial.print("  ");
           Serial.println(temperatura, DEC);      
       
     
           //lee el pin Data, con el comando de humedad y imprime el resultado
       
         
           sendCommandSHT(gHumidCmd, theDataPin, theClockPin);
           waitForResultSHT(theDataPin);
           val = getData16SHT(theDataPin, theClockPin);
           skipCrcSHT(theDataPin, theClockPin);
           Serial.print("umidade:");
           //Serial.print(val, HEX);
       
           humedad = -2.0468 + 0.0367 * val + -0.0000015955 * val * val;
           Serial.print("  ");
           Serial.println(humedad, DEC);
     
           delay(1000); //demora 1s antes de leer otra vez la temperatura y humedad
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

jueves, 14 de julio de 2011

Arduino y teclado 3x4

  Para este proyecto use el   teclado de sparkfun de 12 teclas (0-9, *, # ) este teclado tiene el siguiente diagrama:

como se ve en la figura, el teclado cuenta con 7 pines de control. por ejemplo cuando aprietas la tecla numero 1 se conectan los pines 2 y 3, para la tecla 5 se conectan los pines 7 y 1.

después de comprobar cuales son los pines correspondientes a las filas (2,7,6,4) y columnas (3,1,5) del teclado matricial, definimos a que entradas del arduino van a ir conectado. en nuestro caso los defino de la siguiente forma:

pin del tecla(1, 2, 3, 4, 5, 6, 7) CONECTADOS RESPECTIVAMENTE A
pin del arduino(7D, 5D, 8D, 2D, 6D, 3D, 4D).


A la vez se conectaran resistencias de un 10K ohm a los pines correspondientes a las filas del teclado y el otro extremo de las resistencias se conectaran a 5v como se ve en la figura:
Código
El programa consiste  en visualizar en el monitor serial del arduino, cada tecla presionada del teclado matricial.
Antes de ejecutar el programa, baja el keypad.zip , descomprime y coloca la carpeta en "hardware\libraries\".
Aquí el programa que use:



//////////////////////////////////////////////////////////////////
//©2011
//Released under the MIT License - Please reuse change and share
//Reads the keys pressed on a keypad
//Thanks to Alexander Brevig for his original keypad code.
/////////////////////////////////////////////////////////////////

#include <Keypad.h>  //needs to be in the library folder (Arduino/Libraries)

const byte ROWS = 4; //four rows
const byte COLS = 3; //three columns
char keys[ROWS][COLS] = {
  {'1','2','3'},
  {'4','5','6'},
  {'7','8','9'},
  {'*','0','#'}
};
byte rowPins[ROWS] = {5, 4, 3, 2}; //connect to the row pinouts of the keypad
byte colPins[COLS] = {8, 7, 6}; //connect to the column pinouts of the keypad

Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

void setup(){
  Serial.begin(9600); //initialise the serial port (9600 baud)
}
 
void loop(){
  char key = keypad.getKey();
 
  if (key != NO_KEY){
    Serial.println(key); //print to serial the key that has been pressed
  }
}