MICROCONTROLADORES

La internet Industrial

2015-05-16T09:02:00.003-07:00

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!.

Building a PRINTRBOT Simple Kit 1405 in a weekend

2014-11-27T14:12:00.002-08:00

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!

Knob Class for Processing 2.0

2012-03-28T17:00:00.001-07:00

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

VIDEO: Button Class for Processing helps Arduino's Interaction

2012-03-17T09:12:00.000-07:00

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

Simple Button Class for Processing

2012-03-16T15:46:00.002-07:00

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

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

2012-03-10T11:53:00.000-08:00

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!

Sending temperature data to pachube using pic based microcontroller

2012-02-27T09:50:00.001-08:00

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

Internet of Things: Using Komposer to visualize Pachube' s charts

2012-02-16T19:24:00.000-08:00

In my previous article I described the way to send data to pachube and showed a little example of how to show the charts alternatively.

The way Pachube shows charts can be modified to our requirements using Komposer. The video is self explanatory... take a look!

VIDEO: How to create a litlle Web Page to visualize Pachube's Charts

Internet of things: How to send data to Pachube

2012-02-05T14:56:00.000-08:00

Abstract

Last article was dedicated to describe Pachube, today I am going to show you how to send data from a PC to datastreams created on Pachube's Web Site. The information depicted here will give you a general idea of the procedures needed to send information to a datastream from a sensor inside a laptop (i.e. temperature sensor) , and in the next article we will use this background to obtain values from a temperature sensor attached to an arduino platform, to have a chart updated in real time at pachube.

This way we can have a database of any kind of values obtained from any source of data on the internet, totally free and 24 hours uptime.

VIDEO: How to send data to a feed on pachube

So, let get started.

How to send data to patchube

A feed is a database that we can create on www.pachube.com, after create an account. This service is free and can be used anywhere.

A quickstart of pachube can be accessed here, where there are instructions to automatically get statistical information of out twitter.. give it a try!

VIDEO: How to send data to a feed on pachube

Once we have created a feed, we are ready to send information to our database.

There are several ways to do it. I have chosen the python method due to it's versatility and because python is multi-platform.

For our experiment I have decided to read the temperature of my laptop based on Ubuntu. This can be accomplished using the sensors command. Using a simple filter we can isolate the temperature value from the output of sensors:

acpitz-virtual-0

Adapter: Virtual device
temp1: +54.0°C (crit = +100.0°C)
temp2: +54.0°C (crit = +100.0°C)

I have used the follwing command to isolate the temperature value of one of the cores of my laptop Dell.

sensors | grep temp1 | cut -d: -f2 | awk '{print $1}' | sed s/+//g | sed s/"°C"//g

... and the result after I execute the above command is:

54.0

Which is the temperature that I want to send and have a chart of it.

After we are confident that we can obtain a consistent value every time we ask for it, it is time to create the python script to get that value and send it to our database on pachube. We can send a value every 30 seconds or every minute, or using the interval that is suitable for our application. This interval is going to be programmed using the automated command execution facility on linux called cron.

The code is very simple and is written below:

1 #!/usr/bin/python

2 import subprocess

3 import eeml

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

5 pachubeKEY="bfr0eqPG26CdsRgwTOrgIPZV86DRGJr1q9Ept4ZjaJ8"

6 proceso = subprocess.Popen("/home/ydirgan/SCRIPTS/pachube/tempRead.ksh",stdout=subprocess.PIPE,stderr=subprocess.PIPE)

7 temperatura, errores = proceso.communicate()

8 pachube = eeml.Pachube(pachubeURL,pachubeKEY)

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

10 pachube.put()

Lines 4 and 5 defines the feed and our unique key needed to authenticate and access the web service.

In line 6 we execute tempRead.ksh that is a simple script thet execute the filter shown above.

#!/usr/bin/ksh

sensors | grep temp1 | cut -d: -f2 | awk '{print $1}' | sed s/+//g | sed s/"°C"//g

Line 7 reads the output of the script tempRead.ksh which is a value that will be packed in line 9 using eeml. In our case the UID of our feed is 0, the value is in temperatura variable and the units are in Celsius.

Finally we send the value using the put method in line 10.

This simple script can be manipulated and modified to send more than one value if we have more than one feed. Every feed is enumerated when we create it (see video). An example of this might be give the following line as parameter of the update() method:

[eeml.Data(0, temperatura, unit=eeml.Celsius()), eeml.Data(1, cpuUser, unit=eeml.none())]

Using this simple procedure we can update our feeds to have our sensors values up to date on the internet publicly or in a private fashion.

VIDEO: How to send data to a feed on pachube

In the next article I am going to show you how to get values from sensors attached to arduino and send them to our feeds.

Internet of things

2012-01-29T10:59:00.000-08:00

Abstract

In this chapter we will describe pachube. This is a web based tool for showing graphics about values red from devices connected to internet.

This is intended to be short and concise, which will allows to understand the next entry of this blog, when we connect our arduino to this tool for track a temperature sensor.

The information described here was extracted from their URL: www.pachube.com

What is Pachube anyway?

Pachube is a realtime data infrastructure platform for the Internet of Things , managing millions of datapoints per day from thousands of individuals, organisations & companies around the world. Pachube's powerful and scalable infrastructure enables you to build 'Internet of Things' products and services, and store, share & discover realtime sensor, energy and environment data from objects, devices & buildings around the world.

What allows Pachube?

Manage realtime sensor & environment data :
Pachube is a data brokerage platform for the internet of things , managing millions of datapoints per day from thousands of individuals, organisations & companies around the world. Convenient, secure & economical, Pachube stores, converts & serves data in multiple data formats , which makes it interoperable with both established web protocols & existing construction industry standards. All feeds include contextual metadata (timestamps, geolocation, units, tags) that actually make datastreams valuable.

Graph, monitor & control remote environments :
Embed realtime graphs & widgets in your own website. Analyse & process historical data pulled from any public Pachube feed. Send realtime alerts from any datastream to control your own scripts, devices & environments. Out-of-the-box configurable tools include a zoomable graph , a mapping/tracking widget , anaugmented reality viewer , SMS alerts & apps for various smartphones . As soon as something is plugged into Pachube, you're ready to monitor & control it.

Build mobile & web apps that create value :
With a rapid development cycle & dozens of code examples & libraries, Pachube's simple yet sophisticated'physical-to-virtual' API makes it quick & easy to build applications that add value to networked objects & environments. That's because real value-creation comes from the applications that are built on top of sensor systems. Pachube handles the scalability & high-availability required for complex data management, so that you are empowered to develop applications that make decision-making more sophisticated.

Share data & create communities :
Pachube is built to encourage open ecosystems. Connect electricity meters , weather stations , building management systems , air quality monitors , biosensors , geiger counters — build communities around devices & data collection. While privacy options will soon be available, Pachube's unique openness promotes growth: most hardware & software libraries & real world applications are being created by its community!

Pachube's website is a little like YouTube, except that, rather than sharing videos , it enables people to monitor and share real time environmental data from sensors that are connected to the internet. Pachube acts between environments, able both to capture input data (from remote sensors) and serve output data (to remote actuators). Connections can be made between any two environments, facilitating even spontaneous or previously unplanned connections. Apart from being used in physical environments, it also enables people to embed this data in web-pages, in effect to "blog" sensor data. Through the extensive use of metadata, Pachube adds value to physical interconnectivity: it's not just about datastreams, but about the environments that make up the datastreams.

Pachube makes it simple to build applications, products and services that bridge physical and virtual worlds. With a rapid development cycle (it can take just one line of code to start prototyping ), and a sophisticated development path (working with both web-protocols and data formats that are interoperable with construction industry formats) people have used Pachube to build sensor-logging systems, remote monitoring apps, integrate building management systems, develop geo-tracking systems, create mashups and networked objects and a whole host of other things. For more on what you might do see What can I use Pachube for? .

Apart from CSV and JSON , Pachube also makes use of Extended Environments Markup Language (EEML) , which extends the construction industry protocol IFC. An extensive RESTful API makes it possible to both serve and request data in all formats. Data can be pushed to Pachube using an HTTP PUT request (especially useful for those operating behind firewalls or with non-static URLs) or Pachube can pull data from devices that are able to serve.

There are extensive tutorials and software and hardware libraries and examples available for all sorts of platforms.

Relevant URLs:

- http://www.pachube.com/ (main website)
- http://www.economist.com/node/17388392 "The Economist: Special Report on Smart Systems - Augmented Business"
- http://www.ugotrade.com/2009/01/28/pachube-patching-the-planet-interview... (interview with Pachube's founder)
- http://eeml.org/ (Extended Environments Markup Language)
- http://api.pachube.com/ (technical documentation)

Email Communication with Arduino (English Version)

2012-01-29T10:34:00.000-08:00

Abstract

In the previous chapter we saw how to communicate with the micro using a chatting client. Very useful if you want to execute commands from a mobile client or from another PC, cities away.

In this chapter we will be exploring how to do it by e-mail, which allows both send and receive information from the micro using a very commonly mean used today.

Arduino code: led-1.pde
Download: SCRIPT
VIDEO: E-mail communication with Arduino

Communication with the Arduino using the e-mail

The really interesting part of the email is the ability to format the information we sent from the micro to the PC and then to the user. In this way we can create very good-looking reports to communicate the status of, for example, open status of doors of a house, commercial establishments, factories, offices, etc..

In my search for options that would enable this capability, in a simple way, I found a thunderbird add-on called Mailbox-Alert . This add-on installs very easily (see link) and can configure your thunderbird to identify incoming messages, and then run scripts created by us to perform different tasks.

The information contained in this article applies not only to communicate with a microcontroller, but may be used in different situations to automate tasks as required. For example, if we need to ask our server for some event or information about resource utilization.

Let's see how to configure our components to enable communication via email. Here are the steps to follow to implement this configuration:

Programmingthe microcontroller using the Arduino IDE
Create the script that will send commands through the serial port
Mail-Alert configuration to link a filter to the script indicated below

The flow chart shown indicates that an incoming message is filtered by thunderbird. In the event that the subject of the message do match the conditions specified in the filter, this will trigger a rule defined in the add-on Mail-Alert that will run the script which makes the interface to the serial port and to the arduino. This script is also capable of responding to the original email sender with the actions taken.

(1) Programming the arduino

Like the previous article we used a setting of 4 LEDs connected to the arduino. The firmware (software) that we use is the same as in the previous article which can be downloaded here .

(2) Python script to interact with Arduino

So far we have developed our scripts using ksh, which can run on any linux. To increase portability, in this example we have created a python script which is multiplatform.

This script takes as parameters the subject content of incoming mail, the sender of the email and the serial port with which it is interacting.

This script also interacts with a mail client installed on the PCs. In my case I use ssmtp for its simplicity and effectiveness. As I use Ubuntu as my operating system, ssmtp does the job very well and I point out a link where you can get information on how to install it.

Installing and using ssmtp in ubuntu

Our script uses ssmtp making a call to the operating system using the subprocess library, which allows a fork of an operating system to execute a command, and we can the parameters to that command. The following excerpt shows the routine to send the mail back to sender.

send_email def (message):

try:

ssmtp = subprocess.Popen (('/ usr / sbin / ssmtp', recipient), stdin = subprocess.PIPE)

except OSError:

print 'I can not begin ssmtp, sothe email was not sent'

# Pass the contents of the mail through stdin

ssmtp.communicate (body% (recipient, sender, message))

# Wait until sending mail

ssmtp.wait ()

Download: SCRIPT

(3) Mail-Alert Settings

This step is one that allows everything to work. When you get a thunderbird mail through their filters, it can redirect it to a rule defined for Mail-Alert, which will execute the script that interacts with the Arduino.

(3.1) Create a Mailbox rule-Alert

(3.2) Create a filter that redirects to the MailboxAlert rule

After setting all the parties involved in the process we can try sending an email to the following features yadirganbot@gmail.com.

The message must contain the instructions on the subject
The subject must begin with "@, ->" string (without quotes)
You can specify more than one command in the subject separated by spaces
The commands supported are:

ledon, ledoff (Turn on all LEDs)
ledNon, ledNoff: (1 <N <4) (Light a LED at a time)
titilar (Run all LEDs flashing)
secuencia1 (Run an LED chaser from left to right)
secuencia2 (Run an LED chaser from right to left)
pN, N> 0 integer or decimal (indicating a pause in milliseconds)
xN, N> = 1 (to repeat N times a command)

In this example we see how to send a sequence of commands to arduino to yadirganbot@gmail.com.

To: yadirganbot@gmail.com
Subject: @,-> x3 secuencia1 p.5 x3 secuencia2 p.5 titilar p.5 ledon p2 ledoff

Thunderbird, through a filter, detects that sequence @,-> is in the subject of the mail and sends it to the rule created in Mailbox-Alert. Mailbox Alert shows up a pop-up indicating the sender and the message and also run the following command:

/ home/ydirgan/SCRIPTS/mailboxAlert/led-1.py %subject %sender /dev/ttyACM0

in which we are passing as parameters the email subject, which contains the commands.The sender and finally the serial port where the arduino is connected to.

The script runs led-1.py sending serial commands, logging at led-1.log and sending back a message to the sender via ssmtp.

In the video you can see the life-cycle of communication with the arduino.

VIDEO: email communication with Arduino

Communication with Arduino using chat client (english version)

2012-01-29T08:45:00.000-08:00

Abstract

In the previous article we saw the basic theory of how to communicate with the microcontroller using the serial port of your PC.

In this article we look at the basics to make the micro responds to commands sent using an instant messaging client, email, or twitter Pachube.

Downloads: serialLed.pde , led1log.py , led-1.ksh , external
VIDEO: Step by Step

Communication with Arduino using chat client

We have seen how to send or receive information to and from the microcontroller using the serial port. The next step is to use the micro to react to commands sent using our PC or analyze and react to information received from the micro.

In a first study how to react to micro according to the orders that we can send to serial port we initially send orders directly through the port by using the direct method, but the idea is to use a interface.

We will be working with some type of communication interfacing such as a chat client, email, twitter or Pachube to name the four that we will explore in this and the next 3 entries.

Communication with micro via messenger

Looking extensively on the Web for free software to use as a chat client I finally found CenterIM . This application is a lightweight chat client, which can be configured with a variety of public accounts as a messenger, yahoo, etc..

REF1: CenterIM home
REF2: Installation CenterIM

In the previous references you can access the product home and a very good article on how to install it ubuntu.

The documentation found in reference 1 is very broad and can be used to initially configure the package. In my case I set it up with an account especially created for this experiment.

As a chat client, centerIM works like any other messaging client, but with additional features that fits well for our purpose. CenterIM allows us to program scripts to execute tasks according to the content of incoming messages.With this capability you can program different behaviors of how to send commands to the microcontroller via serial port. This allows us to communicate from the messenger to the home computer to perform some tasks such the activation of an alarm, turn on or off lights and appliances, and so on.

This configuration must be done using a script that should be copied at $HOME/.centerim and whose name must be external.

The format of the external script is very simple.

% Action Action to take according to the following conditions
msg event
# Reacts only to messages
proto msn
# Only for the protocol messenger
online status
# It only if the status of the account is online
stdin stdout options
# .. external commands (below) read from
# Stdin, stdout it's output is sent as a response
# To a remote user
% Exec
msg = `cat`
echo $(/ home/ydirgan/.centerim/commTest.ksh "$msg")

% Exec redirects the message to a simple script that just returns the message via the same mean.

# CommTest.ksh
#! /usr/ bin/ksh
msg = `echo $ 1 | tr az AZ`;
printf "arduino-1 command received: $msg";

Upon receiving the message, CenterIM script redirects the output to commTest.ksh, it receives the title of the email as a parameter which we convert to uppercase and return it to the stdout via CenterIM (email).

From this simple example we can model a small script to turn on/off 4 LEDs connected to the digital pins 0 .. 3 of our teensy (arduino compatible microctroller).

Here are the steps that we have to follow:

Creation of an arduino script that responds to commands recieved via serial (From the microcontroller)
Creation of a logging script to log serial port output (from the PC)
Creation of a script that is called from "external", which contains the execution logic
Creation of the script "external" to be used by CenterIM

(1) Script for the Microcontroller

The script responds to commands received by the teensy serial port (like the Arduino micro).

The script turns on or off a LED on pin n (1 <= n <= 4). It waits for a character that is available on the serial port.

serial input = 1:LED 1 will be turned on

serial input = 2:LED 1 will be turned off

serial input = 3: LED 2 will be turned on

serial input = 4: LED 2 will be turned off

serial input = 5: 3 LED will be turned on

serial input = 6: 3 LED will be turned off

serial input = 7: 4 LED will be turned on

serial input = 8: 4 LED will be turned off

Once you download the program it must be loaded it into the arduino. Once loaded you can test the behavior directly interacting with the serial port, as seen in the video at the end of the article.

Download: serialLed.pde

(2) logging script
This script is intended to run on background and the purpose of it is to copy each line of output of /dev/ttyACM0 to a file.

ydirgan@pragma-systems:~/scripts/$CenterIM led1log.py /dev/ttyACM0 &

Download: led1log.py

(3) Script with the execution logic

The third script allows you to execute sequences of commands that needs to be sent to the arduino. With the limited instructions that are defined on the micro script we can actually increase the funcionalities using this script.

In this program we can turn on or off individual LEDs, but also we can light them all, turn off them all, make a blink or running a sequence. All this using the primitives that we have programmed into the micro.

In addition to the instruction set defined, we have programmed an instruction to obtain information of using by typing HELP from the chat window, and the result becomes:

arduino-1: This is a finite state machine to interact with an Arduino microcontroller type. Its use is intended only as an example. The microcontroller re-weight when it recognizes the command to execute. They have 4 LEDs on and off each of them. The commands you can use are: ledNon, where n is the number of LEDs (1 <= N <= 4). ledNoff, where n is the number of LEDs (1 <= N <= 4). ledon, all LEDs will light. ledoff, all the LEDs go out. Tilite, all LED's will flash 20 times.stream1, all the LEDs light up in sequence (LED chaser) from left to right. stream2, all the LEDs light up in sequence (LED chaser) from right to left. help shows this help.

Download: led-1.ksh

(4) external script to CenterIM
Finally, the script that runs CenterIM when we send a message. This will trigger the execution of the script led-1.ksh that will be sending our commands to arduino using the serial port. The microcontroller will process it and respond according to the script.

Download: external

Finally run CenterIM from our terminal to activate the robot.

The video to show the sequence of steps is as follows:

VIDEO: Step by Step

Serial Communication with Arduino (English Version)

2012-01-29T08:07:00.000-08:00

Abstract

One of the main advantages of a micro is the chance we have of communicating with it via serial port.

In this article, and next we will have an idea of what we can do, and some of the tools I have found interesting to interact with a microcontrollers, involving internet ...

Unless a micro is programmed with a standalone implementation, ie, that its operation is limited to actions that do not depend on external interaction (beyond digital or analog inputs) is not necessary to implement the mechanisms that this article describes. It is true that many applications do not require microcontrollers to get outside the inner environment, but it is increasingly common to think of communication as a tool of interaction with applications designed for these environments. Consider the following example.

...

Arduino microcontroller communication type

If we have a house with panoramic windows (these that open by sliding horizontally), such that a person can enter smoothly through when opened, and we often like to go on vacation, we will have a security problem. The probability of breaking into our home at that time in the house alone is very high.

For someone who wants to design your security system, first of all probably think of placing motion sensors to trigger a very noisy alarm when an intrusion into the residence is detected.This may be a solution, but the alarm will alert only to the immediate surroundings of the house, and intruders.

But we can also think of a silent security system emiting an alarm message to the house's owner via the Internet, sending a text message alert to a receiving means, either email, client chat (IM) or twitter!.

Another example of remote communication is the possibility of creating a system that could controls lights or appliances in our home. These can be automated from the microcontroller defining scheduled events for turning on or off lights, moving a sun-oriented solar cell efficiently, to power a window for the entry of light according to ambient brightness or just turn on air conditioning in our room near the hour of our arrival.

With this last example, what if we come home early?. We could communicate with our microcontroller using the cellular using our messenger by sending a message like the following:

AC: turn on

In this way, and through the proper software, this message can be received and executed online.

To perform tasks like explained above, we must start from the simple to the complex. The first thing to know is that with microcontrollers like the Arduino, pinguino, teensy, etc.. we can communicate to a server via serial port .

With arduino or teensy serial communication is established via USB interface from which we have to connect the microcontroller to the computer. Once serial port is initialized from the microcontroller environments, linux / unix directory is mapped to / dev / ttyXXXn that will give us the opportunity to send or receive information.

The following code, using Arduino, defines the sequential output of a message to our computer's serial port.

int i = 0;

void setup ()

{

Serial.begin (9600);

}

void loop ()

{

Serial.print ("test message");

Serial.println (++ i);

delay (1000);

}

In block setup () we initialize the serial port to 9600 baud with Serial.begin (9600). In the block loop () we send the message via serial port followed by a number sequencially updated by ++ i.

From the computer we will see this output if we properly interrogate the port mapping in /dev/ttyACMn.Where n> = 0.

For this example the port was mapped to / dev/ttyACM0. In my case I use ubuntu, but for any Linux / MAC should be very similar.

When the microcontroller is plugged into any USB port on our computer it can be accessed via command line from a terminal or through a program made for this purpose. A third option is to create our own program of reading and / or writing to the serial port. This last option is appropriate if we want to interact withthe microcontroller to get information or instruct it to perform any action.

For our simple example, we can initially examine the serial port using the tool that comes with the Arduino IDE or through gtkterminal or minicom.

VIDEO: Serial Communication 1

From the microcontroller you can also read from the serial port so there is the posibility to make decisions and run actions according to the input.

The following program simply read the serial input and return the string obtained by detecting the end of line.

char character;

byte i = 0;

char string [100];

void setup ()

{

Serial.begin (9600);

}

void loop ()

{

if (Serial.available ())

{

caracter=Serial.read();

if (character == 10)

{

string [i ++]=' \ 0 ';

i = 0;

Serial.println (string);

}

else

string [i ++] = character;

}

In setup() block we initialize the port, then in the loop() block we check for the port buffer using Serial.available ().

If there are characters available Serial.read sequentially reads each one. If we detect the end of line caracter (10) we add it to the string and reset the counter, sending back the string to the port.

If the character received is not an end of line (10) then we attach it to the end of the string updating the counter.

VIDEO: Serial Communication 2

Now let's see how to use the latter program to bring to power on or off to the air conditioning in the second example shown in this article.

# Include string.h
# Define ON 1
# Define OFF 0
char caracter;
byte i = 0;
char string [100];
AC_Action void (int action)
{

if (action == ON)

{

Serial.println ("Turning AC ON ...");

/ / Action to light

/ / Wait for result

delay (500);

Serial.println ("Air conditioning was activated ... Status OK");

}

if (action == OFF)

{

Serial.println ("Turning OFF AC ...");

/ / Shutdown action

/ / Wait for result

delay (500);

Serial.println ("Air conditioning was deactivated ... Status OK");

}

}
void setup ()
{

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

if (Serial.available ())

{

caracter= Serial.read();

if (caracter == 10)

{

string [i ++]=' \ 0 ';

i = 0;

if (strcmp (string, "AC: On"))

AC_Action (ON);

if (strcmp (string, "AC: OFF"))

AC_Action (OFF);

}

else

string [i + +] = caracter;

}

}

We have created a procedure depending on the action parameter to turn on or off the air conditioning, assuming we have a device that controls the AC connected to the microcontroller. In our case the microcontroller, via serial port, return the message on and off accordingly.

The block loop () maintains the same pattern, except that when you match a specific string runs AC_Action function () passing the parameter set ON or OFF at the beginning of the program.

VIDEO: Serial Communication 3

The next step will be communicating ourselves from outside to PC using several means to interact with the microcontroller.

In future articles we will continue to explore possibilities for communication, interaction and execution.

Comunicación vía email con Arduino

2012-01-21T09:33:00.000-08:00

Abstract

(go to English Version)

En el capítulo anterior vimos como comunicarnos con el micro a través del chat de msn. Muy útil si queremos ejecutar órdenes desde un cliente móvil o desde otro PC a ciudades de distancia. ref: Comunicación con microControladores tipo Arduino. Enviando órdenes al micro a través del chat, email, pachube o twitter

En este capítulo exploraremos la forma de hacerlo por medio del correo electrónico, lo cual permite tanto enviar, como recibir información del micro por un medio utilizado muy comúnmente en la actualidad.

Código Arduino: led-1.pde
Download: SCRIPT
VIDEO: Comunicación por email con Arduino

Comunicación con el Arduino vía correo Electrónico

Lo realmente interesante del email es la capacidad de darle formato a la información que podemos enviar desde el micro al PC y luego al usuario. De esta forma podemos crear reportes de muy buen aspecto para informar del status de, por ejemplo, los puntos de seguridad de una casa particular, establecimiento comercial, fábrica, oficina, etc.

Dentro de mi búsqueda por opciones que permitiesen esta capacidad, de manera simple, encontré un add-on de thunderbird llamado Mailbox-Alert. Este add-on se instala de forma muy sencilla (ver enlace) y permite configurar nuestro thunderbird para identificar mensajes entrantes, para luego ejecutar scripts creados por nosotros para ejecutar diferentes tareas.

La información contenida en este artículo no solo aplica para la comunicación con un microcontrolador, sino que puede ser empleada en diversas situaciones para automatizar tareas que requiramos. Por ejemplo, si necesitamos interrogar nuestro servidor por algún evento, o información de utilización del mismo.

Por lo pronto veamos como configurar nuestros componentes para activar la comunicación vía email. A continuación los pasos a seguir para ejecutar esta configuración:

Programación del micro vía Arduino IDE
Creación del script que enviará los comandos a través del puerto serial
Configuración de Mail-Alert el cual enlaza una regla con el script que creamos ateriormente

El diagrama de flujo mostrado indica como un mensaje entrante es filtrado por thunderbird. En el caso que el subject del mensaje haga match con las condiciones indicadas en el filtro, este activará una regla definida en el add-on Mail-Alert la cual ejecutará el script que hace la interfaz con el puerto serial y hacia el micro. Este script también es capaz de responder al remitente del correo original con las acciones tomadas.

(1) Programación del micro

Al igual que el artículo anterior estaremos utilizando una configuración de 4 leds conectados al micro. El firmware (programa) que utilizaremos es el mismo que en el artículo anterior el cual puede ser bajado aquí.

(2) Script de interacción con Arduino en python

Hasta ahora hemos programados nuestros scripts con ksh, el cual puede ejecutarse desde cualquier linux. Para aumentar la portabilidad hemos creado para este ejemplo un script en python el cual es multiplataforma.

Este script recibe como parámetros el contenido del subject del correo entrante, el remitente de dicho correo y el puerto serial con el cual se estará interactuando.

Este script también tiene interacción con algún cliente de correo que tengan instalado en sus PCs. En mi caso utilizo ssmtp por su simplicidad y efectividad. Como yo utilizo Ubuntu como sistema operativo, ssmtp hace el trabajo muy bien y les indico un link en donde se puede obtener información de como instalarlo.

Instalación y uso de ssmtp en ubuntu

Nuestro script hace uso de ssmtp haciendo una llamada al sistema operativo utilizando la libreria subprocess, la cual permite hacer un fork de una llamada al sistema operativo para ejecutar un comando, y además podemos hacerle llegar los parámetros indicados. El siguiente extracto muestra la rutina para enviar el correo de vuelta al remitente.

def send_email(mensaje):

try:

ssmtp = subprocess.Popen(('/usr/sbin/ssmtp', destinatario), stdin=subprocess.PIPE)

except OSError:

print 'No se puedo iniciar sSMTP, por lo que el email no fue enviado'

#pasamos el contenido del mail a traves del stdin

ssmtp.communicate(cuerpo % (destinatario, remitente, mensaje))

# Esperamos a que termine de enviar el correo

ssmtp.wait()

Download: SCRIPT

(3) Configuración de Mail-Alert

Este paso es el que permite que todo funcione. Cuando llega un correo thunderbird a través de sus filtros permite redireccionar el mismo a una regla que definimos para Mail-Alert, el cual ejecutará el script que interactua con el Arduino.

(3.1) Creamos una regla en Mailbox-Alert

(3.2) Creamos un Filtro que direccione a la regla de Mailbox-Alert

Una vez configuradas todas las partes involucradas en el proceso podemos probar enviando un email a yadirganbot@gmail.com con las siguientes características.

El mensaje debe contener las instrucciones en el subject
El subject debe empezar con @;->
Se puede indicar más de un comando en el subject
Los comandos permitidos son:

ledon, ledoff (Enciende o apaga todos los leds)
ledNon, ledNoff: (1<N<4) (Enciende un led a la vez)
titilar (Ejecuta intermitencia de todos los leds)
secuencia1 (Ejecuta un led chaser de izquierda a derecha)
secuencia2 (Ejecuta un led chaser de derecha a izquierda)
pN, N>0 entero o decimal (indica una pausa en milisegundos)
xN, N>=1 (permite repetir un comando)

En este ejemplo vemos como enviamos una secuencia de comandos en el subject de un email cuyo destinatario es yadirganbot@gmail.com.

To: yadirganbot@gmail.com
Subject: @;-> x3 secuencia1 p.5 x3 secuencia2 p.5 titilar p.5 ledon p2 ledoff

Thunderbird a través del filtro creado detecta que la secuencia @;-> se encuentra en el subject del correo y lo envía a la regla creada en Mailbox-Alert. Por su parte Mailbox-Alert en su regla sabe que tiene que mostrar un pop-up indicando el remitente y el mensaje, además ejecutar el siguiente comando:

/home/ydirgan/SCRIPTS/mailboxAlert/led-1.py %subject %sender /dev/ttyACM0

en el cual se le pasan como parámetros (%subject) el título del correo, el cual contiene los comandos. El remitente (%sender), y finalmente el puerto serial por donde el micro está conectado al PC.

El script led-1.py se ejecuta enviándole los comandos vía serial al micro, dejando huella en led-1.log y devolviendo el correo vía ssmtp al remitente.

En el video que verán a continuación se puede observar el ciclo de comunicación con el micro.

VIDEO: Comunicación por email con Arduino

Comunicación con Arduino usando un cliente de mensajería

2012-01-15T17:54:00.000-08:00

Abstract

(go to English Version)

En el artículo anterior vimos la teoría básica de como comunicarnos con el microcontrolador a través del puerto serial de nuestro PC. ref: Comunicación con microcontroladores tipo Arduino

En este artículo veremos lo básico para hacer que el micro responda a órdenes enviadas a través de un cliente de mensajería, correo electrónico, pachube o twitter.

Downloads: serialLed.pde, led1log.py, led-1.ksh, external
VIDEO: Paso a Paso

Sesión Interactiva:
Agregar contacto vía messenger (msn) ydirganbot@hotmail.com y Verificar el broadcast del circuito montado para ver los leds AQUI.

Intrucción

Ya hemos visto como enviar o recibir información hacia y desde el micro utilizando el puerto serial. El paso a seguir es utilizar el micro para hacerlo reaccionar a órdenes enviadas a través de nuestro PC o analizar y reaccionar a información recibida del micro.

En una primera instancia estudiaremos la forma de hacer reaccionar al micro de acuerdo a las órdenes que le podamos enviar por el puerto serial. Inicialmente hicimos enviar directamente las órdenes a través del puerto utilizando la modalidad directa, pero la idea de fondo es poder utilizar alguna interfaz que nos haga el trabajo más sencillo.

Por ejemplo, trabajar con algún tipo de interfaz de comunicación, como un cliente de chat, correo electrónico, pachube o twitter, por nombrar los cuatro que vamos a explorar en este y los próximos 3 artículos.

Comunicación con el micro a través de messenger

Buscando extensamente en la Web por software gratuito para utilizar algún cliente de chat me encontré con centerIM. Esta aplicación es un cliente muy ligero de chat, el cual puede configurarse con una variedad de cuentas públicas como messenger, yahoo, etc.

REF1: CenterIM home
REF2: centerIM Installation

En la referencia anterior puede accederse la página del producto así como un muy buen artículo de como instalarlo en ubuntu.

La documentación que encuentran en la referencia 1 es muy amplia y con ella pueden configurar inicialmente el paquete. En mi caso yo lo configure con una cuenta que cree especialmente para este experimento.

Siendo un cliente de chat funciona como cualquier otro cliente de mensajería, pero con un adicional que encaja muy bien para nuestro objetivo. El centerIM permite programar scripts para ejecutar tareas de acuerdo al contenido de los mensajes entrantes. Con esta capacidad se pueden programar diferentes comportamientos de forma de enviar vía serial comandos al microcontrolador. Esto permite comunicarnos desde el messenger con el computador de la casa para por ejemplo ejecutar alguna tarea de activación de alarma, encender luces o apagarlas, etc.

Esta configuración se debe hacer a través de un script que debe copiarse en $HOME/.centerim y cuyo nombre debe ser external.

El formato del script external es muy simple.

%action Acción a tomar de acuerdo a las siguientes condiciones

event msg
# Reacciona solo a mensajes
proto msn
# Solamente para el protocolo messenger
status online
# responde solo si el status de la cuenta es online
options stdin stdout
# .. los comandos externos (abajo) leen de
# stdin, luego su salida stdout es enviada como una respuesta
# a un usuario remoto
%exec
msg=`cat`
echo $(/home/ydirgan/.centerim/commTest.ksh "$msg")

%exec redirecciona el mensaje a un simple script que solo devuelve el mensaje por la misma vía.

#commTest.ksh
#!/usr/bin/ksh
msg=`echo $1 | tr a-z A-Z`;
printf "arduino-1 orden rebibida: $msg";

Al momento de recibir el mensaje, centerIM redirecciona la salida al script commTest.ksh, este recibe el mismo como un parámetro el cual lo convertimos en mayúsculas y lo devolvemos a centerIM por el stdout.

A partir de este simple ejemplo podemos modelar un pequeño script para encender/apagar 4 leds conectados a los pines digitales 0..3 de nuestro teensy.

A continuación los pasos que deberemos seguir:

Crear un script ara el micro que responda a las órdenes enviadas vía serial
Crear un script de logging del puerto serial
Crear el script que es llamado desde "external", el cual contiene la lógica de ejecución
Crear el script "external" para centerIM

(1) Script para el Microcontrolador

Este script responde a los comandos recibidos por el puerto serial del teensy (micro como el arduino).

El script enciende o apaga un led en el pin n (1<=n<=4). Espera por un caracter que esté disponible en el puerto serial.

entrada serial = 1: enciende el led 1

entrada serial = 2: apaga el led 1

entrada serial = 3: enciende el led 2

entrada serial = 4: apaga el led 2

entrada serial = 5: enciende el led 3

entrada serial = 6: apaga el led 3

entrada serial = 7: enciende el led 4

entrada serial = 8: apaga el led 4

Una vez que descarguemos el programa debemos cargarlo en el micro. Una vez cargado podemos probar su comportamiento interactuando directamente conb el puerto, como se puede apreciar en el video al final del artículo.

Download: serialLed.pde
(2) Script de logging

Este script tiene como objetivo copiar cada línea de salida de /dev/ttyACM0 a un archivo.log y deberemos ejecutarlo en background para que se mantenga recopilando la salida del puerto.

ydirgan@pragma-systems:~/SCRIPTS/centerIM$ led1log.py /dev/ttyACM0 &
Download: led1log.py

(3) Script con la lógica de ejecución

El tercer script permite ejecutar las secuencias de los comandos que requerimos enviarle al micro. Con las reducidas instrucciones que definimos en el micro podemos desde este script aumentar las funcionalidades.

En este programa podemos encender o apagar leds individuales, pero también podemos encenderlos todos, apagarlos todos, hacer que titilen o que ejecuten una secuencia. Todo esto utilizando las primitivas que hemos programado en el micro.

Además de las instrucciones propias de ejecución, se ha programado una ayuda que puede obtenerse al tipear HELP desde la ventana de chat, y su resultado será:

arduino-1: este es una maquina de estado finita que permite interactuar con un microcontrolador tipo Arduino. Su uso esta destinado solo como ejemplo. El microcontrolador repondera cuando reconozca la orden a ejecutar. Se tienen 4 led, para encender y apagar cada uno de ellos. Los comandos que puedes utilizar son: ledNon, en donde n es el numero del led (1<=N<=4). ledNoff, en donde n es el numero del led (1<=N<=4). ledon, todos los leds se encenderan. ledoff, todos los led se apagaran. tilitar, todos los led titilaran 20 veces. secuencia1, todos los led encienden en secuencia (tipo led chaser) de izquierda a derecha. secuencia2, todos los led encienden en secuencia (tipo led chaser) de derecha a izquierda. help, muestra esta ayuda.

Download: led-1.ksh
(4) Script external para centerIM
Por último el script que ejecuta centerIM cuando le enviamos un mensaje. Este será el que dispare la ejecución del script led-1.ksh, que enviará nuestros comandos vía serial. El micro los procesará y responderá de acuerdo a la secuencia de comandos.

Download: external

Finalmente ejecutamos centerim desde nuestro terminal para activar el robot.

El video para mostrar la secuencia de pasos es el siguiente:

VIDEO: Paso a Paso

Para probarlo solo habría que agregar a ydirganbot@hotmail.com al messenger. Este responderá cuando esté online.

Comunicación Serial con Arduino

2012-01-11T07:53:00.000-08:00

Abstract

(go to English Version)

Una de las principales ventajas de un micro es la posibilidad que tenemos de comunicarnos con el mismo vía puerto serial.

En este artículo y próximos tendremos un acercamiento a lo que podemos hacer, y algunas de las herramientas que he encontrado interesantes para interactuar con un microcontrolador, involucrando internet...

A menos que un micro se programe con una implementación standalone, es decir, que se su funcionamiento se circunscriba a acciones que no dependan de la interacción externa (más allá de sus entradas digitales o analógicas), no será necesario ejecutar los mecanismos que en este artículo se describen. Es cierto que muchas de las aplicaciones de los microcontroladores no requieren asomarse a su entorno, pero cada vez es más común pensar en la comunicación como herramienta de interacción con las aplicaciones que diseñamos para estos ambientes. Para muestra, veamos el siguiente ejemplo.
...
Comunicación con microControladores tipo Arduino

Si poseemos una casa con ventanas panorámicas (de estas que se abren deslizándolas horizontalmente), tal que una persona puede entrar sin inconvenientes a través del espacio disponible una vez abiertas, y nos gusta salir a menudo de vacaciones, tendremos un problema de seguridad. La probabilidad que irrumpan en nuestro hogar en esos momentos en que la casa está sola será muy alta.

Para alguien que quiera diseñar su sistema de seguridad, en primera instancia seguramente pensará en colocar sensores de movimiento o apertura para activar una alarma muy ruidosa al momento que haya una intrusión en la residencia. Esto puede ser una solución, pero la alarma alertará solo al entorno inmediato a la casa, y a los intrusos.

Ahora bien, también podemos pensar en un sistema de seguridad silencioso al entorno inmediato a la residencia, pero que a través de un sistema de comunicación al exterior vía internet, envíe un mensaje de texto con la alerta a algún medio de recepción, sea email, chat client (messenger) o a twitter!.

Otro ejemplo de comunicación remota es, por ejemplo, la posibilidad de crear un sistema de control de luces y electrodomésticos en nuestro hogar. El mismo puede ser automatizado desde el micro definiendo un horario de ejecución de eventos para encender o apagar luces, mover una celda solar orientándola al sol de forma eficiente, motorizar una ventana para la entrada de luz de acuerdo a la luminosidad del entorno o simplemente encender el aire acondicionado de nuestra habitación cercano a la hora de nuestra llegada.

Con este último ejemplo, que tal si llegamos más temprano a casa?. Pudiéramos comunicarnos con nuestro micro utilizando nuestro celular inteligente a través de messenger enviando un mensaje como el siguiente:

AC: encender

De esta forma y a través del software adecuado, este mensaje puede ser recibido y ejecutado, en línea.

Como estos ejemplos, existen muchos más que solo la imaginación y la necesidad particular pueden producir.

Para realizar tareas como estas, debemos empezar de lo sencillo a lo complejo. Lo primero que debemos saber es que con los microcontroladores como el arduino, pinguino, teensy, etc. podemos comunicarnos a un servidor vía puerto serial.

Con arduino o teensy la comunicación serial se establece a través de la interfaz USB de la cual disponemos para conectar el micro al computador. Al inicializar el puerto serial desde el micro, en ambientes linux/unix se mapeará un directorio en /dev/ttyXXXn que permitirá enviar o recibir información.

El siguiente código define la salida secuencial de un mensaje al puerto serie de nuestro computador.

int i=0;
void setup()
{
  Serial.begin(9600);
}
void loop()
{
  Serial.print("mensaje de prueba: ");
  Serial.println(++i);
  delay(1000);
}

En el bloque setup() inicializamos el puerto serial a 9600 baudios con Serial.begin(9600). En el bloque loop() enviamos vía serial el mensaje seguido de un consecutivo el cual actualizamos secuencialmente con ++i.

Desde el computador podremos observar esta salida si interrogamos adecuadamente al puerto mapeado en /dev/ttyACMn. Donde n>=0.

Para este ejemplo el puerto fue mapeado contra /dev/ttyACM0. En mi caso utilizo ubuntu, pero para cualquier linux/MAC debe ser muy similar.

Cuando el micro es conectado a cualquier puerto USB de nuestro computador el mismo puede ser accedido vía línea de comando desde un terminal o a través de algún programa hecho para este fin. Una tercera opción es crear nuestro propio programa de lectura y/o escritura al puerto serial. Esta última opción es la adecuada si quisiéramos interactuar con el puerto para obtener información del puerto o instruir al micro a ejecutar alguna acción.

Para nuestro sencillo ejemplo podemos interrogar inicialmente al puerto utilizando el terminal serial que viene como herramienta del IDE de Arduino o a través de gtkterminal o minicom.

VIDEO: Comunicación Serial 1

Desde el micro podemos también leer desde el puerto serial y así poder tomar decisiones de que ejecutar de acuerdo a la entrada.

El siguiente programa permite simplemente leer la entrada serial y devolver la cadena de caracteres obtenida, detectando el fin de línea.

char caracter;
byte i=0;
char cadena[100];
void setup()
{
  Serial.begin(9600);
}
void loop()
{
  if (Serial.available())
  {
    caracter=Serial.read();
    if (caracter == 10)
    {
      cadena[i++]='\0';
      i=0;
      Serial.println(cadena);
    }
    else
      cadena[i++]=caracter;
  }
}

En el bloque setup() inicializamos el puerto, seguidamente en el bloque loop() chequeamos el buffer del puerto con Serial.available().

Si hay caracteres disponibles los leemos secuencialmente con Serial.read(). Si detectamos el fin de línea agregamos a la cadena de caracteres el caracter de fin de cadena y reseteamos el contador, enviando de vuelta la cadena de caracteres al puerto.

En caso que no sea un fin de linea (10) entonces vamos anexando a la cadena cada catacter recibido actualizando el indice i.

VIDEO: Comunicación Serial 2

Ahora veamos como utilizar este último programa para adecuarlo para accionar el encendido o el apagado el aire acondicionado del segundo ejemplo mostrado en este artículo.

#include string.h
#define ENCENDER 1
#define APAGAR 0
char caracter;
byte i=0;
char cadena[100];

void AC_Action(int accion)
{
    if (accion == ENCENDER)
    {
        Serial.println("Encendiendo el Aire Acondicionado Principal... ");
        //Accion de encender
        //esperar resultado
        delay(500);
        Serial.println("Aire Acondicionado Encendido... Status OK");
    }
    if (accion == APAGAR)
    {
        Serial.println("Apagando el Aire Acondicionado Principal... ");
        //Accion de apagado
        //esperar resultado
        delay(500);
        Serial.println("Aire Acondicionado Apagado... Status OK");
    }
}
void setup()
{
    Serial.begin(9600);
}
void loop()
{
    if (Serial.available())
    {
        caracter=Serial.read();
        if (caracter == 10)
        {
              cadena[i++]='\0';
              i=0;
              if (!strcmp(cadena,"AC: Encender"))
                AC_Action(ENCENDER);
              if (!strcmp(cadena,"AC: Apagar"))
                AC_Action(APAGAR);
        }
        else
          cadena[i++]=caracter;
      }
}

Hemos creado una procedimiento que dependiendo del parámetro acción encenderá o apagará el aire acondicionado, asumiendo que tenemos un dispositivo conectado al micro capaz de hacerlo. En nuestro caso el micro devolverá vía serial el mensaje de encendido y apagado correspondiente.

El bloque loop() mantiene el mismo esquema, solo que cuando se hace match con una cadena específica se ejecuta la función AC_Action() pasándole el parámetro ENCENDER o APAGAR definidos al principio del programa.

VIDEO: Comunicación Serial 3

El próximo paso va a ser comunicarnos desde el exterior del PC a través de diferentes medios para poder interactuar con el micro.

En próximos artículos seguiremos explorando posibilidades de comunicación, interacción y ejecución.

Entrada Analógica (Analog Input)

2011-06-19T07:22:00.001-07:00

Hoy nos dedicaremos a interactuar con una entrada analógica, la cual a diferencia de una entrada digital (entrega anterior) permite leer un rango de valores. Estos valores representan voltaje, pero dentro del microcontrolador pueden ser representados por un rango de valores enteros, los cuales pueden ir de 0 a 255 o de 0 a 1024, etc., esto depende del tipo de procesador que estemos utilizando... por eso es muy útil obtener las especificaciones del micro y las funciones asociadas (en el lenguaje que escogiéramos) a la lectura de un puerto analógico.

La idea de un puerto analógico es leer de un puerto diferentes valores, lo cual permite tomar decisiones más amplias o interactuar con rangos que permiten realizar tareas diferentes.

En lo personal, cuando pienso en una entrada digital pienso en un switch on/off, y cuando pienso en una entrada analógica pienso en un potenciómetro, o cualquier dispositivo cuya salida oscile entre 0V y 5V.

Estos dispositivos (ejemplo un lm35 - termómetro digital) alimentándolos con 5V, pueden entregar al puerto en donde se conecten un rango de valores de acuerdo a las características con las cuales el dispositivo está diseñado.

Por ejemplo, un potenciómetro permite entregar al micro un rango de voltaje que depende del voltaje con el cual esté alimentado. Un termómetro digital, entregará un voltaje de acuerdo a la alimentación del mismo y a las condiciones de temperatura a la cual esté expuesto. En cualquier caso, siempre se obtiene un voltaje asociado a la lectura del dispositivo, y a través de este voltaje podemos tomar decisiones y ejecutar tareas.

El siguiente circuito conecta 8 leds a la plataforma de prototipado pinguino en los pines 0-7, que son puertos digitales. Un potenciómetro es conectado a los puertos GND,VCC del micro y su salida la enviamos al puerto 13, el cual es analógico.

El código que utilizaremos permite utilizar los 8 leds como una barra de indicación. Cuando el potenciómetro está en el tope izquierdo, este entrega al puerto 13 cero voltios. Cuando el potenciómetro está en el tope derecho le entrega al puerto 5V.

El micro traduce este voltaje en un número entero que oscilará entre 0 y 1024, dependiendo del voltaje, el cual estará en un rango de oV a 5V.

Nuestra intención es que a medida que vamos rotando el potenciómetro a la derecha (0->5)V la barra de 8 leds debe ir iluminándose a la derecha hasta llegar a encender los 8 leds, justamente cuando el potenciómetro esté en el tope derecho. En la rotación contraria (5->0)V, los leds deben irse apagando uno a uno de derecha a izquierda hasta quedar todos apagados.

A continuación el codigo

// Ejemplo de utilización de lectura de potenciometro y encendido de leds

#include "ADlib/__map.c"

const int potPin=13;

void setup()

{

byte i;

for (i=0; i < 8; i++)

pinMode(i,OUTPUT);

pinMode(potPin,INPUT);

}

void apagarLeds()

{

byte i;

for (i=0; i<8; i++)

digitalWrite(i,LOW);

}

void encenderLeds(int count)

{

byte i;

for (i=0; i<count; i++)

digitalWrite(i,HIGH);

}

void loop()

{

apagarLeds();

encenderLeds(map(analogRead(potPin),0,1024,0,8));

delay(50);

}

Veamos como funciona esto. En primer lugar tenemos la declaración de una constante (potPin) que nos indica cual es el puerto que utilizaremos para leer el voltaje que nos entrega el potenciómetro.

Luego tenemos la función setup() para definir la modalidad de los puertos. Los puertos de entrada(0,7) los definimos como salidas en el ciclo for. Asimismo, el puerto 13 lo definimos como entrada con la función pinMode.

Hemos creado 2 funciones. apagarLeds() nos permite apagar todos los leds al tiempo utilizando un ciclo for con el siguiente rango (0<=i<8). Luego definimos una función que nos permite encender hasta el led definido por el parámetro count.

En el ciclo Loop(), vemos como apagamos los leds para luego encender hasta el led que nos devuelve la función map.

La función map es una función que nos permite convertir un rangoA en un rangoB. Esta función es estándar en arduino, pero no en pinguino, por lo que está programada y agregada al directorio de librerías de pinguino, y es por esta razón que la segunda línea existe.

#include "ADlib/__map.c"

En nuestro caso, la función mapea el rango (0,1024) al rango (0,8) utilizando como entrada lo que devuelve analogRead(potPin). Esta conversión es muy conveniente ya que directamente le pasamos un valor entre 0 y 8 a la función encenderLeds(). Este ciclo se repite infinitamente cada 50 milisegundos debido la función delay(50) que hemos colocado al final del loop.

// map function

// Alejandro-Dirgan 2011

#ifndef __MAP__

#define __MAP__

#define MAP 1

float map(int value, int fLow, int fHigh, int tLow, int tHigh)

{

return ((float )tHigh*(float )(value-fLow)+(float )tLow*(fHigh-value))/(float )(fHigh-fLow);

}

#endif

Veamos como funciona en la práctica.

link de Video

Con las entradas analógicas se pueden hacer infinidad de cosas, solo la imaginación y los requerimientos lo dirán.

En la próxima entrega veremos las salidas analógicas.

Entrada Digital (Digital Input)

2011-06-16T17:21:00.000-07:00

En el artículo anterior vimos como utilizar las salidas del microcontrolador para encender y apagar leds, utilizando valores lógicos altos y bajos (0,5V):(LOW;HIGH) con la función digitalWrite(). En este artículo utilizaremos los puertos para obtener información del entorno.

Generalmente cuando pensamos en una entrada digital, inmediatamente evocamos un switch ON/OFF. Cuando el swith está en off, no hay paso de energía y nuestro puerto, al cual está conectado el switch, se encontrará en un nivel bajo (LOW, 0v). Por el contrario, si el switch está en ON, el mismo permitirá el paso de energía y el puerto destino obtendrá un valor alto (HIGH, 5v). Esta lógica esta perfecta, pero veamos como podemos implementarla adecuadamente y veremos las variantes correspondientes.

Lo primero que debemos entender es como mantenemos un valor estable en un puerto de entrada. Como estamos hablando de una entrada digital, nuestra intención es determinar cuando la misma tiene un valor alto o bajo, y luego tomar una decisión al respecto, para por ejemplo encender un led, iniciar una secuencia de comandos, para activar un parámetro, etc.

En general, si no definimos una voltaje en una entrada digital esta podrá tener un valor flotante, lo cual debemos evitar. Requerimos tener un valor alto o un valor bajo, y esto se logra a través de las resistencias pull-up o pull-down.

En la figura de la derecha vemos como el terminal 1 del circuito lógico puede ser alimentado con un valor bajo (LOW, 0V) en el momento que el switch S1 es presionado.

Esto efectivamente sucede cuando el switch S1 se presiona, ya que hay un camino directo desde tierra a este terminal. Pero que pasa cuando S1 esta abierto?. El problema es que no podemos garantizar que valor lee el terminal 1 cuando esta condición prevalece.

En toda entrada lógica digital siempre debemos garantizar los dos valores a leer (alto y bajo), de forma que no haya ambigüedad.

Para ello existen dos modalidades, utilizando conceptos básicos de circuitos digitales: las resistencias pull-up y pull-down.

Veamos la siguiente figura:

En el circuito de la izquierda podemos observar que el terminal 1 esta conectado a través de una resistencia pull-up a Vcc (HIGH, 5V), cuando S1 está abierto. En este estado estamos garantizando un valor Alto cuando S1 no está presionado. Cuando S1 se presiona, el terminal 1 quedará conectado directamente a tierra, obteniendo un valor bajo (LOW, 0V). El valor de la resistencia puede conseguirse persiguiendo un valor bajo de corriente a circular entre VCC y Masa, utilizando V=I*R. La idea es dejar pasar menos de 1 mA para no dañar ni el circuito ni el cableado (en general el valor de esta resistencia está entre 10K y 47K).

En el circuito de la derecha estamos implementando una resistencia pull-Down a Tierra (LOW, 0V), garantizando 0V cuando S1 está abierto y 5V cuando S1 esta cerrado. De esta forma estamos garantizando en cualquier caso un valor predicho que podemos leer desde nuestro microcontrolador.

Como podemos observar, dependiendo que variante hayamos escogido, S1 puede representar un valor alto o bajo cuando está presionado, y viceversa. Depende de nuestra lógica y de como deseemos programar nuestro la escogencia de alguna de las modalidades descritas anteriormente.

OK. ya sabemos entonces como colocar un valor predecible en una entrada, ahora veamos como leerla y utilizarla para nuestros fines.

La figura muestra la conexión hecha para que el sketch que mostramos funcione adecuadamente.

El siguiente programa muestra

const int potPin=14, ledPin=12;

void setup()

{

pinMode(potPin,INPUT);

pinMode(ledPin,OUTPUT);

}

void loop()

{

if (analogRead(potPin))

digitalWrite(ledPin,LOW);

else

digitalWrite(ledPin,HIGH);

delay(50);

}

Objetivo:

Demostrar como leer una entrada digital y tomar una decisión de acuerdo a lo leído, para la ejecución de una acción.

Descripción:

(1) const int potPin=14, ledPin=12;

Definen constantes asociadas a el pin de entrada (14) y el pin de salida (12).

(2) Procedimiento setup()

{

pinMode(potPin,INPUT);

pinMode(ledPin,OUTPUT);

}

Definimos los pines como de entrada y salida en el procedimiento de setup.

(3) procedimiento loop()

{

if (analogRead(potPin))

digitalWrite(ledPin,LOW);

else

digitalWrite(ledPin,HIGH);

delay(50);

}

En el loop del programa, vemos una estructura de toma de decisiones.

if (analogRead(potPin))

analogRead es una función que permite obtener una lectura del pin potPin (14). En la estructura if lo único que requerimos es saber si esta lectura es mayor que cero (0), para apagar el led, o si la lectura es cero (0) (cuando se evalúa el else), para en encender el led.

Esta lógica aplica porque el circuito que montamos está basado en una resistencia pull-up.

Este ciclo se repite cada 50 milisegundos. Si el switch está abierto el if (analogRead(potPin)) nos retornará true, y apagaremos el led con digitalWrite(ledPin,LOW).

Por el contrario, si el switch está cerrado el potPin estará conectado directamente a tierra y se leerá un valor bajo (oV), lo que hace que en el ciclo del programa la instrucción asociada al else se ejecute: digitalWrite(ledPin,HIGH).

Es muy sencilla su programación. Luego compilamos el programa buscando que todo esté OK y reprogramamos el microcontrolador (en mi caso el pinguino) y dejamos que ejecute el programa.

En el video se puede observar que he agregado un display lcd 16x2 para mostrar si el valor de potPin es alto o bajo y para indicar que estamos ejecutando de acuerdo a estos valores.

Playing with LEDS

2011-06-06T10:32:00.000-07:00

En la entrega anterior vimos como utilizar las salidas digitales. En este artículo solo quiero mostrar que lo que se puede hacer con las salidas digitales es directamente proporcional a lo que podemos hacer programando.

La inteligencia de estos dispositivos electrónicos es solo cuestión de imaginación y capacidad de programación.

En esta entrega quiero mostrarles como hacer un divertimento de iluminación de leds.

EL ESQUEMA

7 LEDs conectados a las salidas 0-6 del pinguino 2550.

EL CODIGO

Un simple programa que permite iluminar 7 leds. El código está definido con 6 procedimientos:

- ledOff(): Pone las salidas 0-6 en LOW
- secuencia1(): hace una secuencia del pin 0 al 6 con 10 ms de retardo
- secuencia2(): hace una secuencia del pin 6 al 0 con 10 ms de retardo
- secuencia3(): enciende los leds impares y hace flash en los pares
- secuencia4(): enciende los leds pares y hace flash en los impares
- secuencia5(): hace flash alternativo entre los leds pares e impares

//Playing with leds
byte const pines[]={0,1,2,3,4,5,6};
byte pausa1, pausa2;

void ledOff()
{
byte i;
for (i=1;i<7;i++)
digitalWrite(pines[i-1],LOW);

}

void setup()
{
byte i;
for (i=0;i<7;i++)
pinMode(pines[i],OUTPUT);
pausa1=10;
pausa2=50;
ledOff();
}

void secuencia1()
{
byte i;
ledOff();
for (i=1;i<7;i++)
{
digitalWrite(pines[i-1],HIGH);
delay(pausa1);
digitalWrite(pines[i-1],LOW);
delay(pausa1);
}
}

void secuencia2()
{
byte i;
ledOff();
for (i=7;i>=1;i--)
{
digitalWrite(pines[i-1],HIGH);
delay(pausa1);
digitalWrite(pines[i-1],LOW);
delay(pausa1);
}
}

void secuencia5()
{
byte i;
ledOff();
for (i=0;i<7;i++)
{
digitalWrite(pines[0],HIGH);
digitalWrite(pines[2],HIGH);
digitalWrite(pines[4],HIGH);
digitalWrite(pines[6],HIGH);
delay(pausa2);
digitalWrite(pines[0],LOW);
digitalWrite(pines[2],LOW);
digitalWrite(pines[4],LOW);
digitalWrite(pines[6],LOW);
delay(pausa2);
digitalWrite(pines[1],HIGH);
digitalWrite(pines[3],HIGH);
digitalWrite(pines[5],HIGH);
delay(pausa2);
digitalWrite(pines[1],LOW);
digitalWrite(pines[3],LOW);
digitalWrite(pines[5],LOW);
delay(pausa2);
}
}

void secuencia3()
{
byte i;
ledOff();
digitalWrite(pines[0],HIGH);
digitalWrite(pines[2],HIGH);
digitalWrite(pines[4],HIGH);
digitalWrite(pines[6],HIGH);
for (i=0;i<7;i++)
{
digitalWrite(pines[1],HIGH);
digitalWrite(pines[3],HIGH);
digitalWrite(pines[5],HIGH);
delay(pausa2);
digitalWrite(pines[1],LOW);
digitalWrite(pines[3],LOW);
digitalWrite(pines[5],LOW);
delay(pausa2);
}
digitalWrite(pines[0],LOW);
digitalWrite(pines[2],LOW);
digitalWrite(pines[4],LOW);
digitalWrite(pines[6],LOW);
}

void secuencia4()
{
byte i;
ledOff();
digitalWrite(pines[1],HIGH);
digitalWrite(pines[3],HIGH);
digitalWrite(pines[5],HIGH);
for (i=0;i<7;i++)
{
digitalWrite(pines[0],HIGH);
digitalWrite(pines[2],HIGH);
digitalWrite(pines[4],HIGH);
digitalWrite(pines[6],HIGH);
delay(pausa2);
digitalWrite(pines[0],LOW);
digitalWrite(pines[2],LOW);
digitalWrite(pines[4],LOW);
digitalWrite(pines[6],LOW);
delay(pausa2);
}
digitalWrite(pines[1],LOW);
digitalWrite(pines[3],LOW);
digitalWrite(pines[5],LOW);
}

void loop()
{
byte j;
for (j=0;j<7;j++)
secuencia1();
for (j=0;j<7;j++)
secuencia2();
secuencia3();
secuencia4();
secuencia5();
}

EL RESULTADO

El siguiente video muestra el resultado de cargar este programa en el pinguino y ejecutarlo conectado al breadboard con los 7 leds.

Playing with leds

Salida Digital - Encender y apagar un led

2011-05-22T12:44:00.000-07:00

El Hola Mundo que les propongo es utilizar un puerto de salida digital para encender y apagar un led con una secuencia definida.

Empezaremos por alistarnos para ejecutar un demo de utilización de la salida digital de un microcontrolador. A continuación lo que requerimos para hacer nuestro hola mundo.

1) El ambiente de desarrollo instalado en nuestro computador del microcontrolador que hallamos escogido.

2) El microcontrolador que hallamos comprado o construido por nosotros mismo (DIY)

3) Un led de cualquier color

4) Un protoboard (opcional)

Utilizar una salida digital de nuestro micro requiere que sepamos cuales son puertos de e/s digitales y analógicos. Para ello lo primero que debemos hacer es obtener el mapa de entrada y salida de nuestro hardware. Este lo podemos obtener desde la páqina web del fabricante del mismo.

Para nuestro hola mundo he escogido utilizar una plataforma de prototipado rápido basado en el PIC18f2550 (pinguino). El mismo lo construí hace un tiempo y lo he utilizado por algunos meses con todo éxito.

El mapa de E/S de este microcontrolador lo podemos ver en la figura. Los puertos 0-10 son puertos que permiten tanto la entrada digital como la salida digital.

Los puertos 11-12 permiten entrada digital pero su salida es analógica. Los puertos 13-17 permiten entradas analógicas y salidas digitales.

asimismo vemos dos puertos que nos ofrecen tierra y VCC 5V, lo cuales podemos utilizar para darle energía a nuestro led.

Teniendo claro el mapa de puertos y que hace cada uno, es mas fácil ejecutar la siguiente tarea: Armar el circuito básico.

El protoboard es opcional ya que si ven el mapa, pudiéramos colocar el led directamente entre tierra (gnd) y el puerto 9. El puerto nueve permite salida digital (0-5V/0-1), por lo que si queremos encenderlo colocamos el puerto nueve en high (1 o 5V). Si queremos el led apagado colocamos el puerto 9 en low (0 o 0V).

El led debe soportar la corriente que el micro le estregará. Si no es el caso, habría que colocar un limitador de corriente, el cual sería una resistencia. Para este ejemplo no la requeriremos ya que el led que utilizamos puede manejar la corriente que el micro le entrega.

El diagrama muestra la conexión si utilizáramos un protoboard. En este caso el ánodo del led (el terminal posivo) lo conectamos al puerto 9 y el cátodo, o terminal negativo, lo conectamos a tierra (GND).

Una vez conectado estamos listos para programar al microcontrolador. Para hacer un programa que prenda y apague un led de forma periódica solo requiere de unas pocas líneas de programación, pero requerimos entender un poco la arquitectura de un programa en el lenguaje que usa Arduino y sus parientes.

Anatomía de un Sketch

Un programa o sketch de Arduino tiene tres partes fundamentales:

1) Sección de encabezados

Esta sección se utiliza para inicializar variables, definir constantes o invocar librerías.

2) Sección de Setup

Esta sección, la cual se ejecuta una sola vez, permite ejecutar aciones o asignarle valores a variables que se requieren para su utilización en la ejecución del programa.

3) Sección de Ejecución Continua

En esta sección, la cual se ejecuta continuamente, se colocan las líneas de programa que son requeridas para definir el comportamiento del proyecto.

Veamos como encender intermitentemente un led en un skecth de Arduino.

#define ledPort 9

void setup(void)

{

pinMode(ledPort,OUTPUT); // pin 9 como salida

}

void loop(void)

{

digitalWrite(ledPort,HIGH);

delay(500);

digitalWrite(ledPort,LOW);

delay(500);

}

El skecth que acabamos de listar muestra las tres partes fundamentales de cualquier sketch de arduino.

En el encabezado definimos una variable la cual indicará el puerto en donde conectaremos el ánodo del led. En nuestro caso ledPort mantendrá el valor 9, indicando el puerto número 9 el cual permite una salida digital.

En la sección Setup, la cual es una procedimiento llamado setup(), definimos la caraterística de nuestro puerto. Cada puerto debe definirse como una entrada o una salida.

Como nuestra intención es usar el puerto para encender o apagar un led, el puerto debe configurarse como una salida.

La instrucción pinMode(ledPort,OUTPUT) permite definir a través de una constante (OUTPUT) que el puerto 9 será utilizado como puerto de salida.

Finalmente definimos la sección loop, la cual es otro procedimiento, pero este se ejecuta continuamente (mientras el microprocesador esté energizado). En esta sección típicamente colocamos instrucciones que se ejecutarán de forma cíclica y que definirán el comportamiento.

En nuestro ejemplo, utilizamos el comando digitalWrite indicando en que puerto debemos escribir la constante HIGH. Esta constante escribe en el puerto un valor alto (1) para colocarlo en 5V, lo cual será la salida.

Luego utilizamos el comando delay(500), cuyo argumento indica los milisegundos que el programa o sketch suspende su ejecución, para luego reanudar con la ejecución del comando que apaga el led.

digitalWrite(ledPort, LOW) escribe en el puerto un valor bajo (0) para colocar el puerto en 0V, lo cual apagará el led. Luego de este comando se ejecuta de nuevo delay(500) para suspender la ejecución del sketch por 500ms.

Esto ejecutado continuamente tiene como efecto la intermitencia del led cada 500ms o medio segundo.

Una vez escrito el programa en el ambiente de desarrollo se debe compilar para convertir el programa de alto nivel en un formato que pueda exportarse al microcontrolador para su ejecución.

Lo primero que debemos hacer es presionar el botón circunscrito en el recuadro rojo. La compilación puede tener dos resultados.

Mostrar errores o mostrar el mensaje que vemos en la parte inferior del ambiente de desarrollo, el cual muestra los mensajes que el compilador emite.

En nuestro caso, el mensaje obtenido es:

Compilation Done...

y luego muestra la cantidad de bytes que el programa ocuparía en memoria y el total de la memoria (en bytes) que el procesador tiene disponible para sketchs.

Adicionalmente indica en porcentaje la memoria utilizada.

Una vez compilado el programa se encuentra listo para ser exportado al dispositivo.

Conectamos el dispositivo a través de su puerto USB a nuestro computador. El procedimiento estándar de grabar el sketch en el micro es presionando el botón de reset del micro y pulsar el botón de escribir (ver figura) un par de segundos luego de haber presionado el botón de reset.

Lo que sucede en este pequeño intervalo de tiempo, es que el micro se presenta a través del puerto USB y el ambiente de desarrollo puede contactar el dispositivo y pasarle el archivo .hex, gracias al bootloader que tiene implementado el microcontrolador.

Luego de pasar el programa al micro también veremos un mensaje en el área de mensajes del IDE. En nuestro ejemplo podemos ver:

Processing device 005
erasing section [2000, 7fff]
writing section [2000, 7fff]

Lo que indica que no hay errores, y que el dispositivo descubierto con identificación 05, se borró totalmente (en su área de de programa) y se re-escribió con el programa.

Pinguino tiene 2 leds on board. Un led está destinado a indicar que el micro está energizado, por lo que desde se conecta al computador este led enciende. El otro led es el testigo de ejecución de programa. Este solo enciende luego que el micro se conecta y pasan 5 segundos y se ejecuta el programa que tiene grabado.

Por tanto, luego de grabar el skecth, el micro tardará unos segundo antes de empezar a ejecutar automaticamente el mismo. Este comportamiento se repetirá cada vez que se encienda el dispositivo.

Para este ejemplo, y si todo está ok, el led conectado el pinguino empezará parpadear con medio segundo entre encendido y apagado.

Arduino and relatives - 101

2011-05-18T15:48:00.000-07:00

Los componentes básicos de una plataforma Arduino o relacionados son, en primer lugar el hardware con el cual vamos a interactuar.

En nuestro contexto, y basándonos en artículos anteriores, es el microcontrolador. Veamos algunos de ellos.. todos basados en su precursor y más evolucionado ancestro- Arduino.

La imagen muestra un Arduino UNO. Esta plataforma de desarrollo presenta un número considerable de puertos de entrada y de salida para interactuar con el micro y un puerto USB para contectarlo con nuestro ordenador y poder programarlo o comunicarnos con El vía protocolo serial sobre el USB.

Generalmente utilizamos la energía del puerto USB (+5V) para alimentar el hardware, es decir, conectándolo al ordenador lo energizamos para poder programar el dispositivo.

Algunos parientes de Arduino los podemos encontrar en la red. Por ejemplo el Teensy permite trabajar como lo haríamos con Arduino pero a menor costo.

Los componentes se mantienen muy similares. Un puerto USB que energiza el componente de hardware y permite comunicarnos con El, así como puertos de entrada y salida para ponerlo a hacer algo con el exterior.

Pinguino, como comentaba en un artículo anterior, es una plataforma muy parecida a las anteriores, con la diferencia fundamental de que está basado en un micro PIC. Es muy sencillo de ensamblar desde cero y es muy barato de implementar.

Adicionalmente a los puertos de entrada/salida y USB, podemos encontrar un botón que nos permite resetear el dispositivo. Resetear el mismo permite:

Llevar al dispositivo a un estado consistente de inicio.
Ejecutar desde cero el programa cargado en El.
Generalmente, existe un delta de tiempo antes de iniciar el programa cargado en un micro, que nos permite pasar del IDE el archivo .hex producto de la compilación del programa con el cual deseamos cargarlo. Por tanto, si queremos reprogramar el dispositivo utilizamos el botón de reset y el IDE.

Para más info de arduino pueden ir a esta introducción.

El segundo componente es el IDE, en el cual programamos, compilamos y cargamos nuestro programa en el dispositivo.

El IDE puede verse de la siguiente forma.

También llamado ambiente de desarrollo, el mismo consta de:

Editor de Texto, el cual nos permite escribir nuestro código.
Area de Mensajes, en donde recibimos los mensajes de compilación y en algunos casos las salidas de la comunicación del dispositivo vía serial.
Area de Botones, los cuales nos permiten compilar y cargar nuestro .hex en el dispositivo.
Menú, en donde conseguiremos las opciones que el IDE nos ofrece.

El código en arduino se denomina Sketch, lo cual es un nombre diferente a lo que nosotros estamos acostumbrados, pero básicamente es lo mismo que un programa.

Para mayor referencia del ambiente de desarrollo pueden entrar aqui (IDE).

Estos dos componentes básicos son indivisibles si queremos desarrollar, aunque si tenemos el dispositivo programado y en producción, el ambiente de desarrollo no es necesario... solo la energía para alimentar al dispositivo utilizado.

Para obtener el componente de hardware tenemos básicamente dos (2) opciones: lo compramos o lo fabricamos.

Arduino y sus parientes son plataformas de hardware abierto, lo que nos permite obtener los diseños en las páginas web de los fabricantes y fabricarlos nosotros mismos (DIY - Do It Yourself).

Existe toda una tendencia hoy para los que nos gusta tomar los planos o esquemáticos y ejecutar desde cero... los DIYers y los Tinkerers. Los primeros ya los intuimos, los segundos son personas que les gusta reparar y/o esperimentar con máquinas y sus partes.

Lo más sencillo sin duda alguna es buscar algún proveedor local y obtener inicialmente el más modesto de los dispositivos. También podemos fabricarlos, como lo he hecho yo con pinguino... pero esa es otra historia.

Otros componentes de hardware que debemos buscar con nuestro proveedor de electrónica son:

Lista Básica para iniciarnos con un Hello World y entreternernos con algunos ejemplos simples para poder aprender.

Protoboard
Algunos leds
Algunas resistencias de 470 Ohm
1 potenciometro de 10K Ohm
1 switch
1 pulsador
cables
y algunas herramientas básicas como una pinza y un cortafrio y un tester

Les aseguro que esta lista empezará a crecer muy rápido en lo que le tomen el gusto a esto.

El segundo componente lo obtenemos del fabricante directamente. En las páginas de Arduino, teensy y pinguino podrán conseguir los links desde donde bajarse la versión que más se ajuste al sistema operativo de su preferencia.

En mi caso trabajo con Linux, y aunque es un poco más elaborada la instalación en estos ambientes operativos, no es dificil realmente, aunque en Windows siempre es muy sencillo e intuitivo.

Como lectura complementaria les dejo:

The secret is to bang the rocks together

What you can do with Processing and Arduino

No pierdan de vista a Processing... lo estaremos usando para hacer cosas muy interesantes.

Arduino o No Arduino

2011-05-15T16:17:00.000-07:00

En artículos anteriores hemos avanzado en el tema teórico de los microcontroladores, lo cual es "Nice" cuando queremos introducirnos a un terreno donde nunca hemos estado. Habiéndolo recorrido con suficiente extensión desde una perspectiva de hobby, creo ya conveniente que vayamos directo a la experimentación.

Pero no iremos directamente a experimentar sin antes escoger que tecnología debemos usar para, desde mi punto de vista, cumplir con tres objetivos:

1) Ser sencillo

Esto es muy importante. Yo soy un fiel creyente que se pueden hacer cosas muy interesantes y útiles sin la necesidad de ser un ingeniero... solo hay que tener conocimientos básicos, ser ávido lector, y tener suficiente curiosidad como para escudriñar temas y llegar a su núcleo para entenderlos lo suficiente como para empezar a crear.

2) Ser Amplio

Tener capacidad de ser utilizado en múltiples aplicaciones.

3) Estar al Alcance

Ser una tecnología accesible a cualquier en muchas partes del mudo, y sobre todo en nuestros países latinoamericanos.

Cuando inicié a investigar acerca de los micros, lo primero que conseguí fue información del microcontrolador más popular de todos los tiempos... el PIC. De este se consiguen todos los modelos y tamaños (pines, memoria, etc), y aunque es relativamente sencillo aprender a programarlos, no cumple fielmente con mi primer objetivo... ser sencillo.

Recuerdo que después de algunas semanas leyendo acerca de ellos y trabajando en simuladores pensé... debe haber otras tecnologías que permitan hacer lo mismo de manera más rápida y sencilla. Con esta idea en mente empecé a buscar como hacer algo basado en PIC que me permitiera no tener que adquirir un programador especializado y además que fuese sencillo... y dando vueltas en la red conseguí a Arduino.

"Arduino is an open-source electronics prototyping platform based on flexible, easy-to-use hardware and software. It's intended for artists, designers, hobbyists, and anyone interested in creating interactive objects or environments."

Y en el pequeño concepto obtenido de su página web vemos algo clave: prototyping. Esta es una herramienta de prototipado rápido, lo que permite llevar un concepto de la idea a la práctica de forma muy rápida, además de ser sencillo y flexible, y es suficientemente multipropósito como para cubrir al menos los objetivos 1 y 2.

Inmediatamente después de conseguir a Arduino me dediqué a la tarea de averiguar si lo podía conseguir en algún lugar cercano a mi residencia, lo cual efectivamente conseguí, por lo que el tercer objetivo fue cumplido.

Ahora bien, luego de tener mi primer encuentro con Arduino decidí que este era el microcontrolador para mi, y empecé a estudiarlo y recorrer la red para ver que había. Es asombroso ver como una plataforma abierta puede ser tan masiva y tan apetecible por expertos y principiantes.

Siendo una plataforma abierta se presta para que mucha gente desarrolle y cree cosas nuevas, además de plataformas afines (no clones) que pueden ser alternativas válidas de desarrollo.

Lo interesante de arduino es que ha creado todo un ambiente de desarrollo basado en un lenguaje de programación muy intuitivo y una forma de interactuar con el dispositivo realmente sencillo, por lo que los desarrollos alternativos han buscado aprovechar este esquema y reproducirlo, lo cual permite que alguien que ha estudiado arduino pueda con muy poco esfuerzo intelectual hacer las mismas cosas que con arduino.

Navegando en la red me topé entonces con Teensy. Esta es una plataforma alternativa a arduino mucho más económica y con prestancias similares, a lo cual respondí comprando un Teensy 2.0+.

Luego, buscando cosas acerca de esta plataforma conseguí algo que me pareció más interesante aún... conseguí a Pinguino.

Esta plataforma es un clone de arduino pero basado en el microcontrolador PIC, además de ser muy simple de implementar desde el punto de vista de hardware. Cuando hablo de un clone es que el look-and-feel de su lenguaje de programación, así como la interacción con el micro es muy parecida (para no decir igual) a arduino, lo que permite tener una plataforma de prototipado rápido adicional, amén que es muy barato construir los dos modelos propuestos en hackinglabs.

Pero entonces cual escoger?. Arduino o No Arduino?... esa es la cuestión.

Como mi intención es aprender y escribir acerca de mis experiencias, y pensando en los primeros tres objetivos, creo que el tema no es escoger a arduino como plataforma sino como filosofía. Esto hace que uno pueda comprar un arduino original o adquirir o construir cualquiera de las plataformas alternativas que existen basados en la filosofía de arduino.

En el próximo artículo iniciaremos a arduino y su filosofía y empezaremos a experimentar.

Antes de finalizar quisiera mostrar algo de verdad interesante... es tan masivo el tema de Arduino que hace poco Google lanzó una plataforma de desarrollo para Android basado en arduino.

Detalles en Android Open Accessory Development Kit.

English Section

In previous articles we have advanced in the theoretical subject of the microcontrollers, which is " Nice" when we want to introduce ourselves to a land where we never have been. Having studied this subject with sufficient extension from a hobby perspective, I think it is the time to go directly to the experimentation arena.

But we can't go to experimentation if we haven't choose which technology is the ideal technology to work on. From my point of view we have to fulfill three objectives first:

1) Simple

This is very important. I am a believing faithful that we can make very useful and interesting things without a Master Degree… The only prerequisites needed is basic knowledge, to be an eager reader, and to have sufficient curiosity to dig in subjects and to arrive at his core to understand them.

2) Ample

Have the capacity to be used in multiple applications.

3) everybody's reachable

Need to be an accessible technology to everybody in many parts of the world, and mainly in our Latin American countries.

When I started to investigate about microcontrollers, the first micro that came up was the PIC micro. You can find PIC in all models and sizes (pins, memory, etc), and although this technology is relatively simple to learn and program, does not fulfill my immediate goal faithfully… to be simple.

I remember that after some weeks reading about them and working over simulators I thought… there must have other technologies that allow me to do the same, faster and simpler. With this idea in mind I began to look for something based on PIC that allowed me to program them without a specialized burner and in addition, it had to be simple… and digging out on internet I got Arduino..

"Arduino is an open-source electronics prototyping platform based on, easy-to-uses hardware and software. Its' for intended artists, designers, hobbyists, and anyone interested in creating interactivates objects or environments."

At the small reading above obtained from its Web page we can see something that for me is the key: prototyping. This is a prototyping tool, which allows us to convert a concept from an idea to a final result in a very fast way. Additionally it is simple, flexible, and it is multipurpose.

Immediately after knowing Arduino I dedicated myself to the task of finding out if it could be obtained anywhere near to my place, which indeed I found, reason why the third objective was fulfilled.

After to have my first encounter with Arduino I decided that this was the microcontroller for my projects, and began to study it and looked out on internet to see what is in there about this technology. It is amazing to see how an open platform can be so massive and so tempting for experts or beginners.

As an open platform, a lot of people are developing and creating new things, additionally to create compatible platforms that can be a valid alternative for development.

The most interesting thing of arduino is that the development environment is based on a very intuitive programming language and the way of interacting with the microcontroller is really simple, reason why alternative developments are adopting this technology more and more.

Navigating internet, few days after, I found Teensy. This is an alternative platform but far less expensive than arduino and with similar features, to which I responded buying a Teensy 2.0+.

Then, looking for things related to this platform I obtained something even more interesting to me… Pinguino. This platform is a clone of arduino but based on PIC microcontroller, and it is very simple to implement from the hardware stand point. Understanding by clone that the look-and-feel of its programming language is practically the same as arduino environmet, as well as the interaction with the microcontroller, which allows us to have a fast prototyping platform and it is cheaper than teensy.

But then what to choose?. Arduino or Not Arduino? … that is the question. As my intention is to learn and to write about my experiences, and thinking about the first three objectives, I believe that the goal is not to choose arduino as a platform, but a philosophy. This gives us the ability to have a wide number of platforms related to arduino, learning only one technology.

In the next blog we are going to start introducing arduino and make some hello world examples and experimentation.

... Arduino is so massive that Google launched a developing environment to Android based on Arduino... very nice.

Android Open Accessory Development Kit.

Microcontroladores - parte V - E/S

2011-04-01T12:36:00.001-07:00

En esta entrega estaremos ahondando un poco en los puertos de entrada y salida de los microcontroladores, con ejemplos básicos de como interactuar con ellos dependiendo de tu tipo, y por consiguiente de su utilidad.

Pero antes una nota especial a este artículo que conseguí en internet que habla de Limor Fried, una chica cuyo objetivo ha sido impulsar el hardware de electrónica de línea abierta. Muy interesante el artículo, pero aún más interesante es luego ver la página de la empresa para la cual trabaja!... vean los siguientes links.

ARTICULO

PUERTOS DE ENTRADA Y SALIDA

Los puertos de los microcontroladores son su sinapsis con el mundo exterior. Los mismos permiten llevar datos a los micros u obtener datos de ellos.

La final
idad de un microcontrolador al final es realizar tareas repetitivas (como cualquier computador) ejecutando programas y respondiendo a estímulos externos.

En un computador, un software de diseño gráfico permite crear imágenes a partir de múltiples fuentes:

1) Imágenes ya creadas por otros. En este caso la imagen es un archivo que se encuentra en un periférico llamado disco (almacenamiento) y el mismo está conectado al computador a través de un puerto (internos o externos).

2) Inspiración del ejecutante. A través del teclado y el mouse o cualquier otro dispositivo de adquisición de información, el programa de diseño responde al input de los mismos. El teclado está conectado a un puerto (interno o externo) y el mouse seguramente estará conectado a un puerto USB.

3) El usuario del programa de diseño obtiene feedback del mismo a través de la pantalla, la misma es un dispositivo de salida conectada a un puerto del computador.

4) El producto final de la ejecución del programa de diseño seguramente será un archivo que finalmente se guardará en un periférico de almacenamiento que está conectado a un puerto de E/S del computador.

Como podemos observar de los puntos anteriores, un micro no se aleja de un computador en mucho.

Los puertos de E/S de un micro son entradas digitales o analógicas que nos permiten hacer diferentes actividades:

1) Obtener datos de periféricos como switches, potenciómetros, celdas fotoeléctricas, sensores de temperatura, sensores de humedad, sensores de proximidad, Memorias EEPROM, dispositivos de conexión Wifi, dispositivos de conexión alámbrica a internet, tarjetas para lectura/escritura de memorias SD, Keypads, Lectores RFID, etc.

2) Sacar datos del micro hacia diferentes periféricos tales como: leds, reles, memorias EEPROM, displays LCD, altavoces, dispositivos con interfaces serial, USB, I2C, 1Wire, etc.

Los datos de entrada/salida pueden venir en formatos: digitales o analógicos.

Entradas Digitales

Un pin se define como entrada digital cuando este permite leer solo dos estados. Valor lógico LOW o (0) cuando el pin está conectado a tierra. Valor lógico HIGH o (1) cuando el pin está conectado a 5+ V.

Salidas Digitales

Un pin se define como salida digital cuando este permite sacar solo dos estados. Valor lógico LOW o (0) cuando el pin entrega 0V. Valor lógico HIGH o (1) cuando el pin entrega 5+ V.

Entradas Analógicas

Un pin se define como entrada análoga cuando este permite leer un rango de voltaje entre 0V y +5V. Estos valores son mapeados hacia el microcontrolador en un rango de valores numéricos entre 0 y 1023 o 0 y 255.

Para saber que voltaje se está leyendo en un pin analógico solo requerimos hacer una simple regla de 3. Por ejemplo:

0V equivale al valor 0 leído desde el micro
1V equivale al valor 204 leído desde el micro
2.5V equivale al valor 511 leído desde el micro
3.5V equivale al valor 716 leído desde el micro
5V equivale al valor 1023 leído desde el micro

Salidas Analógicas

Un pin se define como salida análoga cuando este permite variar el voltaje del pin en un rango de voltaje entre 0V y +5V. Estos valores son mapeados desde el microcontrolador en un rango de valores numéricos entre 0 y 1023 o 0 y 255.

De forma análoga a la entrada analógica, si queremos colocar un pin analógico en un voltaje de 3.5V, solo tenemos que hacer el cálculo correspondiente, que en nuestro ejemplo es el valor numérico 716 si utilizamos el rango (0,1023).

Las salidas analógicas se trabajan con una técnica llamada PWM o Pulse Width Modulation, el cual es una técnica para obtener valores análogos a través de medios digitales.

El control digital es utilizado para crear una onda cuadrada, la cual cambia periódicamente entre un estado ON y un estado OFF. Este patrón ON-OFF puede simular un voltaje entre 5V y 0V cambiando la porción del tiempo que la señal se mantiene en ON versus el tiempo que la misma se mantiene en OFF.

La duración que la señal esta ON se denomina ancho del pulso. Para obtener valores de voltaje diferentes hay que modular o cambiar el ancho del pulso (también llamado ciclo de trabajo). Si esta modulación se hace lo suficientemente rápido el efecto final es un voltaje que permite por ejemplo hacer que un LED ilumine con diferentes intensidades de luminiscencia, o controlar un motor de pulso o un servo.

La siguiente gráfica muestra algunos ejemplos de modulación del ancho de pulso con pic.

En general, los pines de los microcontroladores vienen con diferentes capacidades, en diferentes proporciones. No todos los pines son digitales o analógicos. Cada micro viene con la documentación para determinar que pines usar de acuerdo a las tareas a realizar.

Si requerimos encender o apagar un LED, hay que escoger un pin que sea digital, el cual solo permite aplicar dos estados (ON,OFF) o (HIGH, LOW).

Si requerimos controlar un servo debemos escoger un pin con salida analógica.

Si requerimos leer un sensor de temperatura que entrega un rango de voltaje entre 0V y 5V de acuerdo a la temperatura ambiente, debemos escoger como entrada un pin análogo.

Esto aplica para muchos micros del mercado, como por ejemplo PIC o AtMega, así como generaciones posteriores que utilizan estos micros para construir sobre ellos, microcontroladores ampliados que permiten hacer lo mismo que los anteriormente mencionados pero de forma más amigable y con lenguajes de alto nivel. Tal es el caso de Arduino el cual se basa en AtMega, o Pinguino cuya plataforma es PIC.

Como ejemplo podemos ver el siguiente código el cual enciende y apaga un LED cada 300 milisegundos. Este ejemplo solo permite mostrar como utilizar un pin como una salida. En próximas entregas estaremos empezando con el "Hola Mundo" con dos de mis favoritos... Arduino y Pinguino, y empezaremos formalmente a interactuar con ellos.

Código para Pinguino

LEDBlink.pde

void setup()

{
// Definimos el pin 0 como salida

pinMode(0,OUTPUT);

}

void loop()

{
//Colocamos el pin 0 en 5V (encendemos el LED)

digitalWrite(0,HIGH);
//Establecemos una pausa de 300ms

delay(300);

//Colocamos el pin 0 en 0V (apagamos el LED)

digitalWrite(0,LOW);

//Establecemos una pausa de 300ms

delay(300);

}

Links de interés:

Arduino

Pinguino

Algunos conceptos (Wikipedia y otros)

1) I²C es un bus de comunicaciones en serie. Su nombre viene de Inter-Integrated Circuit (Circuitos Inter-Integrados)

Fuente: Wikipedia

2) 1-Wire es un protocolo de comunicaciones en serie diseñado por Dallas Semiconductor. Está basado en un bus, un maestro y varios esclavos de una sola línea de datos en la que se alimentan. Por supuesto, necesita una referencia a tierra común a todos los dispositivos.

Fuente: Wikipedia

Microcontroladores - Parte IV

2011-03-31T10:19:00.001-07:00

Después de mucho tiempo vuelvo a escribir algo... honestamente el trabajo no me deja mucho tiempo con fuerzas para experimentar y escribir.

Hoy hablaremos de que debemos hacer para que los microcontroladres se comporten o ejecuten las actividades que uno requiere para cierta aplicación.

Pero antes... como es mi costumbre veamos algo interesante hecho con micros para entusiasmarnos con lo que se puede hacer.

Esta vez es interesante pero algo soso, aunque habrá gente que le parezca impresionante.

Icono Like it de Facebook

Pues esto es interesante solo como ilustración de lo que se puede hacer con un micro. En este caso es el icono de facebook que se pulsa cuando a alguien le gusta lo que uno cuelga en esta página. Lo interesante es que es como una lámpara hecha con legos, que se enciende cuando alguien presiona like it en algún post nuestro.

Veamos que hay detrás... Pues un arduino como microcontrolador para conectarse al computador y a través del API gráfico de Facebook y una librería diseñada para arduino, podemos hacer pooling de nuestros like it y encender la lámpara cuando esto sucede.

Algo que yo no sabía es que nosotros podemos diseñar nuestros legos y pedirlos a fábrica con un software que se baja de la página web de la LEGO. ESTO SI QUE ES INTERESANTE, sobre todo para robótica.

LEGO Design by ME

Bueno.. ahora a la materia.

Un microprocesador tiene la posibilidad de cambiar su comportamiento mediante la programación del mismo. En los viejos tiempos, el único lenguaje que se utilizaba para tal fin era el Assembler.

Este era el único lenguaje disponible por ese tiempo debido a la poca memoria con la que contaban los micros, por lo que el assembler era el lenguaje por excelencia, ya que el mismo no tiene los desperdicios que lenguajes de alto nivel introducen.

Lo que es cierto, es que esto ha evolucionado y ya los temas de memoria no son tan neurágilcos. Por un lado, porque la memoria ha bajado de precio en los últimos años. A su vez los micros han evolucionado en capacidades y memoria, por lo que los lenguajes de alto nivel se han metido en este terreno... y debo ser honesto, a Dios gracias.

Trabajar en lenguaje de alto nivel es realmente una bendición, ya que podemos con nuestros conocimientos de la universidad, hacer trabajar a estos controladores. Desde que los lenguajes de alto nivel aparecieron en este terreno, han proliferado desde pascal, pasando por C y hasta Basic.

En lo particular programo en C desde que tengo memoria y por tanto me ciento cómodo trabajando con el mismo. Pero entiendo que C no es del gusto popular, así que no problem, existen lenguajes como Pascal y Basic para los gustos restantes.

Algunos de los fabricantes con más éxito en este terreno se han especializado no solo en los compiladores sino en los ambientes de desarrollo. Tal es el caso de la gente de MikroElectronika.

Esta gente tiene muy buenos compiladores y además, desde mi perspectiva, presentan la curva de aprendizaje más sencilla, al ocultar muchas particularidades y configuraciones que deben hacerse de acuerdo al micro que utilicemos.

El compilador de estos lenguajes, toma nuestra fuente... este ejemplo enciende y apaga un led conectado al puerto RB0 en intervalos de 50 milisegundos:

...

#define led0 0b00000001

void main() {

TRISB=0; //puerto B Salida

PORTB = 0; //todas las salidas en 0 lógico

do {

PORTB = led0;

Delay_ms(50);

PORTB = led0;

Delay_ms(50);

} while(1);

}

No nos asustemos aún. En el próximo artículo explicaremos para que son los puertos y los tipos de puertos que hay, etc. Por lo pronto hagamos un acto de FE y entendamos que este programita de pocas líneas solo hace titilar un led en intervalos de 50 milisegundos.

Al ser compilado lo que obtendremos es un archivo de extensión .hex, con la siguiente información.

:0A00000005280000000000000028A1

:10000A00831686018312860101308600A330CC0054

:10001A005530CD00CD0B0F28CC0B0F2801308600B0

:10002A00A330CC005530CD00CD0B1928CC0B1928A4

:04003A0009281E284B

:02400E00FA3F77

:00000001FF

Finalmente este es el archivo que vamos utilizar para programar nuestro micro. Este archivo contiene registros en hexadecimal que traduce lo que programamos en el lenguaje que escogimos. Esto sucede para cualquier lenguaje, incluyendo al assembler.

Con que programamos el micro?... no con el código de alto nivel sino con el producto compilado el cual es este archivo .hex. Existen programas especializados, que utilizan nuestro código compilado y permiten programar el micro, pero esto es harina de otro costal... o material de otro artículo, el cual prometo será pronto.

De hecho, y es para otro artículo también, hay simuladores que permiten probar nuestro código compilado y verificar que el mismo se comporta adecuadamente. Puedo comentarles que uno de los mejores que he visto y en el cul me he divertido más es ISIS de Proteus.

En este simulador no solo puedes armar el circuito virtual, sino cargar en el microprocesador escogido el código compilado y ejecutarlo. El simulador es tan bueno que permite crear los circuitos con los componentes virtuales y estos interactúan como si fuesen reales (ejemplo, leds, reles, servos, etc.)

OK, pero no nos distraigamos del objetivo de este artículo, terminemos con este capítulo de lenguajes de programación para micros.

Lo que hemos visto hasta el momento refiere a los lenguajes que nos permiten programar a los microprocesadores PIC, pero hay otros en el mercado. No me voy a extender mucho porque hay tanto que no tiene sentido.

Mi interés principal está en entender la tecnología y por lo que he revisado, he escogido dos tipos: PIC y ARDUINO-Like.

Ya veremos en otros artículos de que se trata y explicaremos cada uno en específico, por lo pronto entendamos que de la gran cantidad de tecnologías existentes en el mercado, he escogido 2 para seguir este viaje.

Lo que si puedo decir en este punto es que Arduino o sus clones (y tendremos oportunidad de extendernos aquí) son mucho más amigables que los PIC, pero cada uno tiene sus encantos.

ARDUINO es más amigable, más sencillo y con las mismas prestancias que los PIC, pero los PIC están muy difundidos en el mercado desde hace años, por lo que se consiguen muchísimos desarrollos para estos, lo cual los hace atractivos.

Ya seguiremos con los micros y cada vez más cercanos a proyectos prácticos que nos permitan verle el queso a la tostada.

Cheers!

Algunos conceptos (Wikipedia y otros)

1) Assembler

El término ensamblador (del inglés assembler) se refiere a un tipo de programa informático que se encarga de traducir un fichero fuente escrito en un lenguaje ensamblador, a un fichero objeto que contiene código máquina, ejecutable directamente por la máquina para la que se ha generado. El propósito para el que se crearon este tipo de aplicaciones es la de facilitar la escritura de programas, ya que escribir directamente en código binario, que es el único código entendible por la computadora, es en la práctica imposible. La evolución de los lenguajes de programación a partir del lenguaje ensamblador originó también la evolución de este programa ensamblador hacia lo que se conoce como programa compilador.

Fuente: Wikipedia

2) Hex files

Intel HEX es un formato de archivo para la programación de microcontroladores, EPROMs y otros circuitos integrados. Datando de los años 70[cita requerida], está entre los formatos más viejos con esta finalidad.

Consiste en un archivo de texto cuyas líneas contienen valores hexadecimales que codifican los datos, y su offset o dirección de memoria.

fuente: Wikipedia

Microcontroladores - parte III

2011-01-23T16:21:00.000-08:00

Hoy seguiremos detallando los componentes de los microcontroladores, y el turno hoy es para la memoria y el subsistema de entrada/salida.

Pero antes, revisemos otro de los videos relacionados con el macro mundo de los micros.

NAO

Lo que podemos hacer con los micros es interminable... vean los features de comunicación que tiene este pequeño robot para interactuar con su entorno... Excelente.

Para llegar a hacer algo como NAO, no solo debemos conocer como diseñar aplicaciones para micros, sino como programarlos, como integrarlos la mundo real, como determinar su comportamiento, etcetera.

Debemos saber un poco de electrónica, de robótica, de mecánica, y mucha imaginación... y aunque este es un modelo comercial, la red está plagada de ejemplos de gente como nosotros que hace cosas interesantes, útiles e inútiles, que hacen de este mundo uno fascinante.

En el árticulo anterior hablamos de la CPU de los microcontroladores. Para que este pueda operar debe tener acceso a datos, los cuales son albergados en lo que se conoce como memoria.

MEMORIA

Existen 2 tipos básicos de memoria: Memoria de Programa y Memoria de Datos.

De Progama

En esta memoria se guardan las instrucciones de los programas que definen el comportamiento del micro. Esta puede ser de una sola escritura (ROM) o pueden ser volátiles, es decir, son reprogramables. Existen diferentes tipos de memoria volátil, las diferencias fundamentales están en los procedimientos de escritura y borrado de las mismas. Entre los tipos de memoria volátiles se encuentran la EPROM, EEPROM y la FLASH, esta última muy utilizada últimamente por sus prestancias, capacidad y confiabilidad, llegando a ofrecer hasta 1000 ciclos escritura-borrado.

De Datos

La memoria de datos permite mantener la información con la que los programas trabajan. Esta memoria puede ser volátil como la memoria RAM (SRAM). Este tiene el inconveniente que si existe una caída de voltage, los datos se perderán. Hay aplicaciones que permiten este tipo de comportamiento, pero en el caso de aplicaciones que no lo permitan por su criticidad existen memorias no volátiles, como EEPROM la cual la traen disponible muchos micros. Estas memorias mantienen sus datos inclusive sin alimentación eléctrica.

NOTA: La memoria tipo EEPROM y la tipo Flash pueden escribirse y borrarse eléctricamente, sin necesidad de sacar el circuito integrado del grabador.

ENTRADA y SALIDA

Un microcontrolador puede obtener input de su entorno, o sacar información al exterior a través de sus líneas de entrada y salida. Estas son las patas que se pueden ver en la siguiente imagen.

A excepción de dos patas destinadas a recibir la alimentación, otras dos para el cristal de cuarzo (no todos los modelos requieren cristales externos), que regula la frecuencia de trabajo, y una más para reiniciar el micro, las patas restantes sirven para la comunicación con los periféricos externos que pudiera controlar.

Las líneas de E/S que se adaptan con los periféricos manejan información en paralelo y se

agrupan en grupos de ocho, y reciben el nombre de Puertas (Gates). Hay modelos con líneas que soportan la comunicación en serie; otros disponen de conjuntos de líneas que implementan

puertas de comunicación para diversos protocolos, como el I2oC, el USB, etc.

Estas patas o pines pueden configurarse como líneas de entrada o líneas de salida, es decir, estas pueden ser adaptadas a las necesidades del proyecto.

E/S Analógicos y Digitales.

Existen diferentes tipos de puertos. Los que son analógicos pueden aceptar diferentes voltages (generalmente entre 0V y 5V) en escalas decimales. Desde adentro del micro estos valores de voltaje pueden ser leídos desde una pin de entrada como un valor numérico (i.e. 0-1023).

Por ejemplo, un sensor de temperatura genera, de acuerdo a la temperatura a la cual se somete (Ambiental), un voltaje que si está conectado a un pin análogo, este podrá leerse como un valor numérico. De acuerdo al fabricante este valor numérico se podrá convertir a grados celsius o farenheit, de acuerdo a la la escala que necesitemos.

Las líneas Digitales solo aceptan valores binarios. OV o cero lógico (FALSE) y 5V o 1 lógico (TRUE).

Ejemplo, una salida digital puede utilizarse para encender o apagar un led que esté conectado a un pin de salida digital.

Existe un tipo de salida especial llamado PWM (Pulse Width Modulation). Generalmente se usa para cambiar la resolución de la salida de un micro a valores más discretos en rangos grandes. Esto permite, por ejemplo, graduar la intensidad de un led como si usáramos un dimmer o para controlar un servo.

Otros RECURSOS

Existen otros recursos en los procesadores que pueden ser útiles para hacerlos comportarse de una u otra forma de forma más rápida. Estos recursos pueden ser:

a) Circuitos de reloj, encargados de generar los impulsos que sincronizan el funcionamiento de todo el sistema.

b) Temporizadores, orientados a controlar tiempos.

c) Perro Guardián («watchdog»), el cual permite generar una inicialización cuando el programa quede bloqueado eventualmente.

d) Conversores AD y DA, para poder recibir y enviar señales analógicas.

e) Comparadores analógicos, para verificar el valor de una señal analógica.

f) Sistemas de protección ante fallos de alimentación.

Entrar en estos conceptos puede ser interesante, pero lo haré de aquí en adelante cuando sea requerido implementarlo para algún ejemplo o proyecto.

Algunos conceptos (Wikipedia y otros)

1) PWM: La modulación por ancho de pulsos (también conocida como PWM, siglas en inglés de pulse-width modulation) de una señal o fuente de energía es una técnica en la que se modifica el ciclo de trabajo de una señal periódica (una senoidal o una cuadrada, por ejemplo), ya sea para transmitir información a través de un canal de comunicaciones o para controlar la cantidad de energía que se envía a una carga.