La internet Industrial

El futuro ya está sucediendo en estos momentos! En los últimos dos siglos han ocurrido dos grandes revoluciones; la revolución industrial, en la cual nos acostumbramos a industrias mecanizadas, trenes eléctricos y viajes aéreos, lo cual cambió radicalmente nuestras vidas. Luego de esto empezó a gestarse la revolución de Internet, la cual nos dio poder de cómputo, redes de datos y acceso sin precedentes a la información y a las comunicaciones, y de nuevo esto cambió absolutamente nuestra forma de vida. Ahora estamos experimentando otro cambio radical… uno denominado la Internet Industrial, la cual amalgama dispositivos inteligentes, analítica avanzada y la creatividad de la gente que trabaja.
La tecnología está transformando el sector industrial y esto juega un papel preponderante en la economía y en nuestra vidas: energía, transporte, salud, seguridad… para la economía esto es muy inusual, pero sin duda es muy excitante porque esto es una revolución tan poderosa como en otrora lo fuera su homologa industrial. Muchas máquinas actualmente están siendo equipadas con un número cada vez mayor de sensores electrónicos que les permiten ver, escuchar y sentir mucho más que en el pasado, generando indiscutiblemente una enorme cantidad de información y datos. Adicionalmente han surgido una nueva casta de aplicaciones emergentes (Big Data) basadas en software de análisis de datos, que reciben y procesan esta información produciendo material digerible y pre-analizado que nos habilita ahora a operar estas máquinas de manera totalmente diferente, y de hecho, con mucha más eficiencia.

Estamos entrando en la era de los grandes volúmenes de información generados por maquinaria, aparatos domésticos, vehículos y sensores conectados en la red. Claro está, que los sensores de los cuales hablamos existen desde hace mucho tiempo… pero algo ha cambiado radicalmente. El costo de los sensores ha bajado drásticamente, han habido avances significativos en la arena del la computación en nube y además se está experimentando un descenso abrupto en  los costos del almacenamiento y del cómputo, con la integración brutal de cores y memoria en espacios cada vez más diminutos.

Estamos sin duda moviéndonos hacia un mundo de máquinas que no solo son rápidas, sino inteligentes y conscientes de su entorno, además de predictivas, reactivas y sociales!… son sistemas de navegación, turbinas eólicas o dispositivos médicos comunicándose entre sí y con nosotros. Es un mundo donde la información, por si misma, es inteligente y viene a nosotros cuando y donde la necesitamos sin necesidad de buscarla.

Estamos empezando a implementar en todo el sistema industrial sistemas virtualizados basados en tecnologías multi-core de procesamiento y comunicación avanzada en modalidad nube, además de software especializado que permite desacoplar funcionalidades del lado aplicativo y funcionalidades del lado del hardware, ayudándonos a monitorear y gestionar de forma automática y remota muchos activos industriales. Todo esto está habilitando una nueva era preventiva y proactiva que habilita la posibilidad de tomar acciones correctivas antes que hayan fallas, sin la necesidad de perder valioso tiempo dándole servicio en un esquema rígido de mantenimiento, lo cual nos empuja a una realidad potencial de cero disrupciones de servicio, es decir, cada vez será menos frecuente experimentar apagones, atrasos o re-planificación de vuelos o eventos que nos inhabiliten a continuar nuestras vidas cotidianas.

Por ejemplo, hoy día muchos de los retrasos y cancelaciones en vuelos a nivel mundial son debido a eventos de  mantenimiento no planificados, lo cual representa billones de dolares en costos adicionales para las aerolíneas cada año!, amen del impacto en nosotros como usuarios del servicio al experimentar estrés, incomodidad, reuniones de trabajo incumplidas mientras pasamos horas interminables en un aeropuerto. Como esta revolución puede ayudarnos en este caso?. En la actualidad hay desarrollos de sistemas de mantenimiento preventivo que se se instalan en la aviación comercial y que a través de sistemas expertos son capaces de detectar problemas que un operador humano puede no detectar. El avión en pleno vuelo puede comunicarse con personal en tierra de forma que cuando haya aterrizado, los ingenieros y personal de mantenimiento sepan si hay algo a lo cual se le debe dar servicio. Sistemas como estos pueden prevenir miles de retrasos o cancelaciones cada año, ayudando a millones de pasajeros a llegar a sus destinos.

En el área de la salud, una enfermera puede perder hasta 20 minutos de un turno completo ubicando material y equipamiento médico, lo cual puede parecer insignificante, pero es menos tiempo destinado a la atención de un paciente. Ya hay hospitales en el mundo que implementan tecnologías que permiten conectar pacientes, doctores y equipamiento para optimizar la utilización del tiempo lo que permite atender más pacientes por unidad de tiempo, todo interconectado haciendo uso de la internet industrial. En otras instancias se están implementando esquemas de nube para almacenar información de imágenes de CT y MRIs, desarrollando mejores técnicas de análisis mientras se bajan los costos. Imaginen a un paciente que ha experimentado un gran trauma y que esté siendo atendido por diferentes especialistas, y todos ellos sean capaces de acceder de forma simultánea las imágenes escaneadas en los diferentes dispositivos.Esto repercute positivamente en un mejor diagnóstico y en un mejor tiempo de ejecución de procedimientos que permitan salvarle la vida a este paciente. Todo esto puede traducirse en mejores resultados médicos mientras se logran substanciales beneficios económicos, ya que la optimización en estas ineficiencias puede repercutir en ahorros substanciales en la industria de la salud, y esto solo es un ejemplo de como se puede intervenir un modelo tradicional para hacerlo más accesible de manera sostenida en el tiempo.

Avances similares están siendo experimentados en el sector de la energía, incluyendo el sector de las energías renovables. Por ejemplo, ya existen granjas eólicas equipadas con dispositivos de monitoreo interconectados entre sí, generando data muy útil para el ajuste automático de la inclinación de las palas de las hélices de las turbinas, que de manera coordinada y actuando dependiendo de las condiciones climáticas y del viento, permiten generar energía eléctrica por debajo de 5 centavos de dolar por KW/h, cuando hace 10 años costaba al menos 6 veces más. Así como estos ejemplos, existen muchos otros y la lista sigue creciendo de forma acelerada, ya que la data industrial ahora crece de forma exponencial y se estima que para el 2020 esta será al menos la mitad de toda la data digital almacenada.

Como vemos, todo depende directa o indirectamente del almacenamiento digital, ya que la información debe mantenerse en algún lugar que debe tener algunas características fundamentales en principio: debe ser de bajo coste, debe ser seguro, debe ser rápido y debe poder accederse desde cualquier lugar. En los últimos años todas estas características han estado siendo cumplidas y el proceso de evolución es creciente por el esfuerzo de muchas compañías que se dedican a la investigación y producción de dispositivos de almacenamiento que permiten almacenar información producida por esta nueva revolución.

Viremos el rumbo y cambiemos un poco la perspectiva… veamos ahora como todo esto impacta nuestros trabajos cotidianos, ya que toda esta revolución nos está brindando nuevas herramientas y aplicaciones que nos permiten colaborar entre nosotros de forma más rápida e interesante, no solo permitiendo hacer nuestro trabajo de forma más eficiente sino más reconfortante. Imaginen por un momento a un ingeniero de la granja eólica con una tablet en sus manos informándole que una turbina requiere mantenimiento, contando con el stock de repuestos en sitio,  ya que este mantenimiento fue planificado con un diagnosticado temprano. Adicionalmente este mismo dispositivo permite al ingeniero comunicarse con sistemas remotos, para enviar información de diagnóstico que luego se traducirá en instrucciones detalladas de procedimientos complejos para llevar el equipamiento a su estado óptimo de nuevo, además del hecho que los procedimientos aplicados en sitio serán documentados y guardados en bases de datos que podrán ser consultadas en el futuro.

Pensemos por un momento en esto, ya que estamos tocando un punto muy importante y que muchos temen. Esta revolución está cambiando la forma en que trabajamos y muchos empiezan a preocuparse de como esto puede impactar los empleos a nivel mundial. Pero la realidad es que en esta generación ya desde niños somos capaces de manejar una tablet o un computador, además de que más y más aplicaciones intuitivas e inteligentes están siendo diseñadas para hacer la vida en el trabajo más sencilla para todos los niveles de especialización, llevando al trabajador del futuro  a ser más como un Iron Man que el Charly Chaplin de tiempos modernos!. Muchos más empleos especializados serán creados en donde ingenieros electrónico-mecánicos entenderán tanto a las máquinas como a sus datos. Los gerentes deberán entender el negocio y analizar la data del mercado para así poder eventualmente reorganizar el negocio para tomar ventajas de la tecnología.

Sin embargo retrocedamos un segundo y veamos esto en perspectiva. Hay gente hoy que argumenta que la innovación está en los juegos y aplicaciones sociales, menospreciando la innovación que supone la industrialización de la internet y sus datos, de hecho indicando que las mejores innovaciones son del pasado. Pero no nos equivoquemos, estamos viviendo el inicio de una nueva revolución, una nueva ola tecnológica, que tendrá barreras y obstáculos que tendremos que vencer, pero que como en otras épocas cambiaron nuestras vidas por completo. No va a ser fácil, pero de seguro valdrá la pena… al ver cada vez de forma más común la interacción entre hombres y máquinas inteligentes, y la forma en que esto impacta y cambia de manera positiva el mundo, nos hacen pensar que el futuro está cerca y quizás logremos verlo en todo su esplendor!.

Read More......

Building a PRINTRBOT Simple Kit 1405 in a weekend

The past weekend was a very challenging one. I received my PRINTRBOT Simple kit 1405.

The following pictures depicts a excerpt of the building process that took over 12 hours of work, and at the end of this entry you will find a video of the complete time lapsed process, including some testing printings.

 

 

 

 

 

Here is the video... enjoy!

Read More......

Knob Class for Processing 2.0

I just finished a knob class (library) for processing. The idea is simple... The need of using a knob on my sketches using a simple class and interact with my microcontrollers. The goal is to have a class that can be used in a very simple way.

The video shows how to use a knob class and a designer tool for getting the final geometry of a knob.

The knob class is useful to create sophisticated GUIs using Processing, a graphical java based programming environment.



Using in conjunction with the button class (previous article) we can create GUIs to interact with, showing values from variables, that we can read from microcontrollers like arduino. We'll show in the next article how to do it.

Also we can use a knob for change values to modify other widgets or for dim a led or change the brightness of a LCD connected to a arduino... uses are circumscribed to the imagination and needs.

Meanwhile, it is worth to understand the basics of the library (class).

The following example uses the knob class to change the background color of the window created in processing, using 3 knobs each one handling a component of a RGB tuple.


(1) ADknob rcolor, gcolor, bcolor;
int r,g,b;
(2) void activateMouseWheel()
{
 addMouseWheelListener(new java.awt.event.MouseWheelListener() 
 { 
   public void mouseWheelMoved(java.awt.event.MouseWheelEvent evt) 
   { 
     mouseWheel(evt.getWheelRotation());
   }
 });
}
(3) void setup()
{
   size(500,200);
   smooth();
   rcolor = new ADknob("R",100,100,45,255,0.0,1.0,4.0,20.0,34.0,19.0,34.0,15,7,53.0,20,19,10,-6,14,5,9,14,7,23,false,11,0);
   rcolor.setKnobPosition(234);
   rcolor.setColors(#D30606,0,-1,0,0,0,0,-11574371,-327681);
   gcolor = new ADknob("G",250,100,45,255,0.0,1.0,4.0,20.0,34.0,19.0,34.0,15,7,53.0,20,19,10,-6,14,5,9,14,7,23,false,11,0);
   gcolor.setKnobPosition(202);
   gcolor.setColors(#0FA705,0,-1,0,0,0,0,-11574371,-327681);
   bcolor = new ADknob("B",400,100,45,255,0.0,1.0,4.0,20.0,34.0,19.0,34.0,15,7,53.0,20,19,10,-6,14,5,9,14,7,23,false,11,0);
   bcolor.setKnobPosition(111);
   bcolor.setColors(#050EA7,0,-1,0,0,0,0,-11574371,-327681);
   activateMouseWheel();
}
(4) void draw()
{
  background(color(r,g,b));
  r=(int )rcolor.update();
  g=(int )gcolor.update();
  b=(int )bcolor.update();
}
(5) void mouseDragged()
{
  rcolor.change();
  gcolor.change();
  bcolor.change();
}
(6) void mouseWheel(int delta)
{  
  rcolor.changeKnobPositionWithWheel(delta);
  gcolor.changeKnobPositionWithWheel(delta);
  bcolor.changeKnobPositionWithWheel(delta);
}

(1) Object Creation
  1.1 We start creating one object for red, green and blue component of the RGB tuple
  1.2 And three integer variables for storing the knob values.

(2) The function activateMouseWheel
  2.1 Enable us to activate a listener for the mouse's wheel.

(3) Inside the setup function
  3.1 We define the windows with size() function
  3.2 We instantiate each knob with the parameters obtained from the knob tool
  3.3 We also set the value of the knob. This is necessary for setting an initial (r,g,b) background
  3.4 Finally we call for the activation of the mouse wheel

(4) Inside the draw() function
  4.1 We change the background using the variables r,g,b
  4.2 These values are obtained from the knob.update() function, which is in charge of return
        the value and draw the knob itself

(5) The mouseDragged() function
  5.1 Enable us to call the change() method of each knob while the mouse is dragged over the knob
  5.2 This function is also responsible of redrawing the knob on the screen

(6) the function mouseWheel()
  6.1 It is called by the listener of the mouse using the increment or decrement of the wheel mouse
  6.2 Inside we call the changeKnobPositionWithWheel() method for updating the knob

The structure of the code is very simple as I will describe next:

(1) Create the knob Object
(2) Instantiate the knob with the parameters obtained from the tool inside the setup() function
(3) Get the knob value and use it inside draw() function
(4) Create a mouseDragged() function to call the change of the knob if we drag the mouse over
(5) Create a mouseWheel() function to call changeKnobPositionWithWheel() when we use the wheel

Interaction:

The knob can be used dragging the mouse over it or using the mouse wheel or the keyboard.

(1) Mouse Wheel
  1.1 The wheel is used to increment or decrement in one step at a time
  1.2 Shift+wheel increments or decrements the knob at totalSteps/10 ratio
  1.3 Ctrl+wheel increments or decrements the knob at totalSteps/4 ratio

(2) Keyboard

  2.1 LEFT || DOWN decrements the knob at totalSteps/10 ratio

  2.2 RIGHT || UP increments  the knob at totalSteps/10 ratio

Look at the video to see more details about the class and the tool and download the source to essays different examples.

Download: knob class
Download: button class
Download: color example
Download: Designer tool


Read More......

VIDEO: Button Class for Processing helps Arduino's Interaction

This is a very short video which demonstrates how the button class helps to interact with a microcontroller like teensy (arduino clone).





DISCLAIMER **
THIS SOFTWARE IS PROVIDED TO YOU "AS IS," AND WE MAKE NO EXPRESS OR IMPLIED WARRANTIES WHATSOEVER WITH RESPECT TO ITS FUNCTIONALITY, OPERABILITY, OR USE, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR INFRINGEMENT. WE EXPRESSLY DISCLAIM ANY LIABILITY WHATSOEVER FOR ANY DIRECT, INDIRECT, CONSEQUENTIAL, INCIDENTAL OR SPECIAL DAMAGES, INCLUDING, WITHOUT LIMITATION, LOST REVENUES, LOST PROFITS, LOSSES RESULTING FROM BUSINESS INTERRUPTION OR LOSS OF DATA, REGARDLESS OF THE FORM OF ACTION OR LEGAL THEORY UNDER WHICH THE LIABILITY MAY BE ASSERTED, EVEN IF ADVISED OF THE POSSIBILITY OR LIKELIHOOD OF SUCH DAMAGES.


Download source: ledSwicthesWithButtons.pde
Download source: buttonClass.pde

Read More......

Simple Button Class for Processing

Abstract

Continuing with our goal of communicating with arduino like micros, this time I brought you with a simple button class to use with processing. I've made a simple example of how to use it and also I have created a more elaborated example, using the buttons to turn on/off leds of my teensy.

Simple Button Class for Processing

The idea is to use it, as is, with no knowlegde about how to code a button... that' s why this class is like a library.

DISCLAIMER **
THIS SOFTWARE IS PROVIDED TO YOU "AS IS," AND WE MAKE NO EXPRESS OR IMPLIED WARRANTIES WHATSOEVER WITH RESPECT TO ITS FUNCTIONALITY, OPERABILITY, OR USE, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR INFRINGEMENT. WE EXPRESSLY DISCLAIM ANY LIABILITY WHATSOEVER FOR ANY DIRECT, INDIRECT, CONSEQUENTIAL, INCIDENTAL OR SPECIAL DAMAGES, INCLUDING, WITHOUT LIMITATION, LOST REVENUES, LOST PROFITS, LOSSES RESULTING FROM BUSINESS INTERRUPTION OR LOSS OF DATA, REGARDLESS OF THE FORM OF ACTION OR LEGAL THEORY UNDER WHICH THE LIABILITY MAY BE ASSERTED, EVEN IF ADVISED OF THE POSSIBILITY OR LIKELIHOOD OF SUCH DAMAGES.

A simple example in the following lines:


ADbutton button1;

 boolean pressed=false;

 void setup()

 {

     size(290,120);

     smooth();

     button1 = new ADbutton(80, 40, 150, 30, 7, "Press Me");

 }

 void buttonRun()

 {

     if (pressed)

       button1.label("Press Me");

     else

       button1.label("unPress Me");  

     pressed=!pressed; 

 }

 void draw()

 {

     background(#04583F);

     if (button1.update())

        buttonRun();

 }

A very simple approach to use button to run functions each time a button is pressed. This example instantiate button1,inside setup(), based on ADbutton class indicating (x,y) position on the screen, (width,height) of the button, radius of the rounded corners of the button and the label.

Then, on function draw() we run button1.update() that has to goals: the first one is to draw the button itself and the second one is to return a boolean indicating if the button was pressed.

If the button was pressed is evaluated at the if statement. If the returned value is true it runs buttonRun() function.

In the buttonRun() function we evaluate the boolean pressed variable to change the label of the button, so it behaves like a push button.

The better way I found to use the class is to create a tab on processing, copy and paste the code and then create your program in the main tab using the class.

The video shows the quick deploy of the class...



Download: buttonClass.pde
Download: arrayOfButtons.pde

Read More......

Internet of things: Sending data to Twitter using Python - part I

Abstract

Continuing with the goal of sending data using different means to connect a microcontroller to the outside world, this time we are going to describe how to interact with twitter as a way to show messages triggered by conditions defined and showing values of any kind of sources.

This article is divided in 2 parts. The first one is intended to show you how to send data from our computer to twitter. The second one is going to be dedicated to explains the procedure that have to be followed to send data produced by different sources to Twitter.

See the video:

Sending data to Twitter - part I

What we want to do is obtain data from a source (i.e. a sensor), then analyze it to trigger messages depending on specific conditions. With this goal in mind the first step is to know how the messaging system of twitter actually works.

In order to send messages  to twitter from command line it is not enough to use curl or whatever command line tool to send messages over internet. Instead, Twitter clients will need to use more secure authentication based on OAuth. OAuth is an authentication protocol that allows users to approve application to act on their behalf without sharing their password.

So this first part is going to help people to know what is the lifecycle to get ready for sending messages.

(1) Download Tweepy

To interact easily with Twitter from Python, is imperative to get in hand an API that can be used to get an abstraction, this way is easier to program what we need. It is worth to say that Tweepy is a very well documented Twitter library for Python. This is the python API that we will use to authenticate against twitter and send messages.

(2) Create the application on  https://dev.twitter.com/apps

Here you can create as much as applications as you need. This step will provide you with two authentication pieces required for the next step.


CONSUMER_KEY
CONSUMER_SECRET

It is important to remember to configure the application to Read, Write and Access direct messages located on settings tab.


(3) Authenticate against the application created in the above step.

This step engage with the authentication procedure of twitter and will provide you with another two pieces required to send the messages.


ACCESS_KEY
ACCESS_SECRET

The following script do this engage, just replace key and secret.


#!/usr/bin/python


import tweepy
CONSUMER_KEY = 'put here the consumer key'
CONSUMER_SECRET = 'put here de consumer secret'
auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
auth_url = auth.get_authorization_url()
print 'Use this URL to get the PIN: ' + auth_url
PIN = raw_input('PIN?: ').strip()
auth.get_access_token(PIN)
print "ACCESS_KEY = '%s'" % auth.access_token.key
print "ACCESS_SECRET = '%s'" % auth.access_token.secret

Execute the script, copy and paste the url on your favorite browser and get the PIN. Introduce this PIN number and the script will print the access_key and access_secret required for the next step.

(4) Sending messages to Twitter

With the information gathered before and a script created using the Tweepy API it is very easy to send messages. The following code is depict the simple procedure of getting the message using a command line parameter and then send the message to twitter.


#!/usr/bin/python
#sendMessage2Twitter.py
import sys
import tweepy
CONSUMER_KEY = 'put here the consumer key'
CONSUMER_SECRET = 'put here the consumer secret'
ACCESS_KEY = 'put here the access key'
ACCESS_SECRET = 'put here the access secret'
auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
auth.set_access_token(ACCESS_KEY, ACCESS_SECRET)
api = tweepy.API(auth)
api.update_status(sys.argv[1])

So, the last line get its argument from command line and update the status of our twitter, just by doing this.

./sendMessage2Twitter.py "This is a test of sending messages to twitter from command line using #teewpy and #python"

You can extend the script to gather any kind of information and send it to twitter. The next article will be dealing with getting info from a microcontroller and send it to twitter using this procedure.

VIDEO





Enjoy!

Read More......

Sending temperature data to pachube using pic based microcontroller

Abstract

In my previous article I described a way to send data to a feed created on pachube to store data that came from a temperature sensor of my laptop. The article was intended to show the procedure that has to be followed to send data to pachube's feed.

In this article I am going to show you how to obtain data from a lm35 (temperature) sensor attached to a arduino like board (pinguino), send them to pachube's feed and then visualize the data using Komposer.

Sending temperature data to pachube using pic based microcontroller

The first thing that we have to understand is the whole picture. The following image shows you how is  the relationship among the different components.

The components required are:

1x LM35 Precision Centigrade Temperature Sensor
1x Pic 2550 based Pinguino (arduino like board) or arduino board(1)
1x PC using linux (I use Ubuntu 11.10) with python installed

The above image shows the LM35 sensor attached to the microcontroller which is responsible for reading the analog pin where the sensor is attached, calculates an average of the values red and converts them to centigrades, then send this value through the serial port to the PC.

The PC will receive the values through the serial port where a python script is in charge for reading each value of temperature and send it to pachube's feed (previously created on pachube's web site).

A third component is related to the way we can access the data in a form of a charts such that we can easily see temperatures trends over an hour, a day or a week. This component is a simple static web page created with komposer.

Firt things first

The first thing we have to solve is reading the sensor from the microcontroller. To do this we have to have the components and attach them using a protoboard.

I have used fritzing to do this model where you can see the lm35 attached to the pin13 of our pinguino. The pin 13 is analog so it is suitable to read different voltages (0-5V). The LM35 is very simple to connect and read. It has only 3 pins (VCC, VOUT, GND). This link has a very good tutorial of how to read and convert the Vout value so the reading sent to the serial port is easily read in its final scale.

For this schematic we have used a pull-up 10K resistor due to the fact that pinguino 2550 lacks of these internally. VCC and GND comes directly from the pinguino VCC and GND.

With this all set on our protoboard it is time to load the code on the micro using the 32 bit Pinguino's IDE.


byte pinTemp=14;


void setup()
{
   pinMode(pinTemp,INPUT);
}


float temp(byte pin, int n, int milis)
{
  int i=0;
  int valorPin=0;
  //read cycle defined by n iterations waiting (millis) milliseconds
  for (i=0; i<n; i++)
  {
    valorPin= valorPin + analogRead(pin);
    delay(milis);
  }
  //return the average value coverted to celcius
  return (5.0 * (valorPin/n) * 100.0)/1024.0;  
}


void loop()
{
   CDC.printf("%d\n", (int)temp(pinTemp,100,600));
}

A little explanation of the code:

1) On the setup() block we initialize the pin as an analog input.

2) On the loop() block we print the result to the serial port using CDC and the custom temp() function.

3) On the temp() function we calculate the average of 100 values red with analogRead(), each one executed every 600 milliseconds, then return the value converted to centigrades.

With 100 reads each one executed every 600 millis we will obtain a temperature value every minute or so. This value is sent to the serial port (/dev/ttyACM0) and can be red with the following script using python.

#!/usr/bin/python

"""

tempLM35.py

"""

import os.path

from datetime import datetime

import serial

import signal

import sys

import subprocess

import eeml

pachubeURL="/v2/feeds/47024.xml"

pachubeKEY="bfr0eqPG26CdsRgwTOrgIPZV86DRGJr1q9Ept4ZjaJ8"

#Verificacion del parametro indicando el puerto serial /dev/ttyXXX

if len(sys.argv) > 1:

   if os.path.exists(sys.argv[1]):

      puerto = sys.argv[1]

   else:

      print "El puerto especificado %s no existe!" % (sys.argv[1])

      sys.exit(1)

else:

   print "uso: showSerial.py /dev/ttyXXXX"

   sys.exit()

#Apertura puerto serial

try:

   ser = serial.Serial(puerto, 9600)

except (serial.ValueError, serial.SerialException):

   print "\n::Error::\n Puerto=%s" % (puerto)

   sys.exit(2)

#Funcion para el catch del ^C

def signal_handler(signal, frame):

   print ' Saliendo...'

   ser.close()

   sys.exit(0)

signal.signal(signal.SIGINT, signal_handler)

pachube = eeml.Pachube(pachubeURL,pachubeKEY)

#while 1:

try:

   result=ser.readline()

except serial.SerialException:

   print "\n::Error::\n Puerto=%s" % (puerto)

   sys.exit(2)

result=result.replace("\n","")

pachube.update([eeml.Data(0, result, unit=eeml.Celsius())])

pachube.put()

print "("+str(datetime.now())+") --> "+result+" Celsius"

At the end of this code we use the eeml library to update and send one value to the feed 47024 referred with pachubeURL variable using our unique key for authentication (pachubeKEY).

This script have to be executed each time we decide to obtain a value from the serial port and send it to pachube's feed. Linux give us a tool called cron. Updating the crontab to execute the script every minute allows us to send the data at the same rate of the microcontroller.

* * * * * /home/ydirgan/SCRIPTS/pachube/tempLM35.py /dev/ttyACM0 >>/home/ydirgan/SCRIPTS/pachube/tempLM35.out 2>&1

The last line of the python script prints out the following formatted line (ie):

(2012-02-27 12:18:19.740213) --> 28 Celsius

(2012-02-27 12:19:10.317034) --> 29 Celsius

(2012-02-27 12:20:51.447645) --> 28 Celsius

(2012-02-27 12:21:41.929904) --> 28 Celsius

As you can notice on the cron entry above, the script is executed redirecting the referred output to tempLM35.out which will contain the historical values red from the sensor. This file can be used to create a chart on (i.e.) a libreoffice spreadsheet utility. Instead, we use pachube to store that data and let it to create the charts.

Finally using the same technique from our last article (using komposer) we can show the charts in one page and using labels to identify the charts and to make easier the interpretation.

Using an auto-load plugin on the browser you can keep up to date this page to see what is going on with the temperature of the room.

follow us on twitter, G+ or Facebook

Read More......