Arduino básico: escribir y leer datos de la memoria EEPROM

Si bien el grueso de la memoria de un Arduino está representado por la memoria volátil, que se borra una vez se corta la alimentación o resetea, estas placas poseen también una memoria no volátil donde almacenar permanentemente una serie de datos: La memoria EEPROM (Electrically Erasable Programmable Read-Only Memory) . Según el modelo varía entre los 512 bytes y los 4KB.

Para trabajar con esta memoria necesitamos hacer uso de la librería EEPROM, que viene junto al IDE oficial de Arduino. Posee un método para escribir, write(), y otro para leer, read(). Tanto para leer como para escribir se trabaja por direcciones y byte a byte. Esto implica que enl modelo de 512 bytes tendías posiciones de 0 a 511 y en cada una de ellas podrías guardar un valor comprendido entre 0 y 255. El primer ejemplo que vamos a ver es muy simple: vamos a escribir el mismo valor en todas las posiciones de la memoria y luego a leerlo. Una chorrada, pero muy didáctico:

 

//Se incluye la librería EEPROM
#include <EEPROM.h>
//Creamos una variable para el valor de la posición de memoria
//en la que se va a almacenar el dato.
int Direccion = 0;

//Creamos una variable para leer los valores de la memoria EEPROM
byte valor;

void setup()
{
  Serial.begin(9600);
  // La "B" indica que pasamos los datos
  // en binario (en decimal sería un 18)
  byte Informacion = B10010;
  
  //para el ejemplo nos pateamos
  //512 bytes.
   for (int i = 0; i < 512; i++){
     EEPROM.write(i, i);
   }
}

void loop()
{
  while(Direccion < 512){
    valor = EEPROM.read(Direccion);  
    Serial.print("En la dirección ");
    Serial.print(Direccion);
    Serial.print(" almacenamos el valor: ");
    // DEC para mostrar el resultado en decimal
    Serial.print(valor, DEC);
    delay(100);
    Direccion++;
  }
}

Más adelante seguiremos viendo otros ejemplos de programación con el IDE de Arduino.

Aprender Git (y GitHub) en 15 minutos

Git es un sistema de control de versiones creado por Linus Torvalds en su día para facilitar el trabajo en el desarrollo del núcleo de Linux. Su buen funcionamiento, su flexibilidad y el ser software libre ha facilitado su popularización entre los programadores y su uso tanto en el ámbito académico como empresarial.

GitHub logo

Los principales comandos de Git serían los siguientes:

  •  git fetch: para descargar los cambios desde el repositorio
  • git merge: permite unir dos «ramas» de un proyecto
  • git pull: básicamente unificaría las acciones de fetch y merge en un solo comando
  • git commit -am: confirma los cambios realizados. Se puede añadir como parámetro una cadena de texto con un título descriptivo para que al consultar el log veamos qué hemos heco de forma más sencilla
  • git push origin: nos permite subir una «rama» al servidor
  • git status: nos muestra el estado de una rama y qué cambios hay sin confirmar
  • git add: añadimos un archivo
  • git checkout -b: crea una «rama» nueva a partir de donde estamos, con el nombre que le asignemos
  • git checkout -t: en este caso nos permite crear una «rama» local a partir de una «rama» remota especificada.
  • git branch: nos permite listar las ramas locales
  • git branch -a: con este parámetro además de las ramas locales muestra las remotas.
  • git branch -d: borra la rama que le especifiquemos como parámetro
  • git remote: muestra los repositorios remotos
  • git remote -v: muestra los repositorios remotos y la url asociada a ellos
  • git remote prune origin: permite actualizar tu repositorio remoto desde tu versión local en caso de que alguien haya borrado una rama remota.
  • git push origin: :Ojo a esta sintaxis, te mando a la documentación para que la ojees porque es puñetera. La cosa es que borre una «rama» remota y es similar a la orden para subirla, pero con la diferencia de que añade los dos puntos (sí, no me equivoqué y los puse duplicados). Mira el enlace para verlo bien.
  • git reset –hard HEAD: elimina los cambios que no hayan sido objeto de un commit todavía
  • git revert: en este caso le pasamos el id de un commit para deshacer los cambios que realizamos en él.

El tema de listar los comandos es útil, pero yo te prometía aprender a usar Git, y por extensión la popular plataforma web GitHub, en 15 minutos. Y por mucho que te leas un listado de comandos no vas a aprender por ósmosis… pero aquí viene el recurso que necesitas: un minicurso de uso de Git a través de la plataforma GitHub. Pégale un ojo y la cosa te quedará mucho más clara, que seguro que la lista de arriba te ha dejado dudas. A través de sencillos ejercicios el tutorial te mostrará el funcionamiento de la plataforma en poco más de un cuarto de hora. Aprovecha ya y añade Git a tu lista de conocimientos, pues es una utilidad valiosa.

Código PHP para comprobar si un servidor está funcionando o caído.

Estaba los día pasados liado con un desarrollo en PHP para uso interno en la oficina que requería que, en un punto dado, el código recogiera qué servidores de los clientes están activos y cuales no.

Tras sucesivas búsquedas y documentación llegué a dos soluciones. Esta primera lo que haría sería mostrarnos si en una máquina está funcionando el servidor web:

/*La función recibe la ip
o la url del servidor*/
function testServidorWeb($servidor) {
    $a = @get_headers($servidor);
    
    if (is_array($a)) {
        return true;
    } else {
        return false;
    }
}

En este primer ejemplo creamos una función que recibe o la ip externa o la url del servidor que queremos comprobar que tiene su servidor web funcional. Dicha función hará una petición HTTP al servidor y recogerá las cabeceras de la respuesta con get_headers. En caso de que haya recibido la respuesta la función devuelve true, y si no ha habido respuesta alguna entonces devuelve false.

En el segundo ejemplo tenemos una función que comprueba si se recibe respuesta desde un puerto concreto. Así podemos comprobar varios servicios como el servidor web, el servidor ftp, la conexión por telnet…

function checkPuerto($dominio,$puerto){
    $starttime = microtime(true);
    $file      = @fsockopen ($dominio, $puerto, $errno, $errstr, 10);
    $stoptime  = microtime(true);
    $status    = 0;
 
    if (!$file){    
        $status = -1;  // Sitio caído
    } else {
        fclose($file);
        $status = ($stoptime - $starttime) * 1000;
        $status = floor($status);
    }
    
    if ($status <> -1) {
        return true;
    } else {
        return false;
    }
    
}

En este caso le enviamos a la función el dominio del servidor a probar y el puerto que queremos chequear, sirviéndonos de la función fsockopen de PHP. Ojo si queréis comprobar los sockets UDP, que podéis recibir un falso positivo debido a que UDP es un protoclo «sin conexión» (en el enlace a fsockopen ya hay un aviso donde lo explican).

Clase para prevenir ataques XSS en Java

Buscando información para aumentar la seguridad de una aplicación web basada en Java me encontré con esta clase para filtrar los posibles ataques XSS en la web de un veterano ingeniero llamado Ricardo Zuasti.

Su solución propone dos clases. La primera, que copio de su entrada original a continuación, lo que hace es filtrar las peticiones HTTP para que sean filtradas por la clase especializada creada para eso:

public class XSSFilter implements Filter {
 
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }
 
    @Override
    public void destroy() {
    }
 
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
        throws IOException, ServletException {
        chain.doFilter(new XSSRequestWrapper((HttpServletRequest) request), response);
    }
 
}

Tras esto propone la siguiente clase para realizar el filtrado. Esta clase sobreescribe los métodos getParameterValues(), getParameter() y getHeader() y utiliza una serie de patrones para evitar la entrada de código malicioso en tu web. El método stripXSS() es el que realiza la labor de filtrado.

import java.util.regex.Pattern;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
 
public class XSSRequestWrapper extends HttpServletRequestWrapper {
 
    private static Pattern[] patterns = new Pattern[]{
        // Script fragments
        Pattern.compile("<script>(.*?)</script>", Pattern.CASE_INSENSITIVE),
        // src='...'
        Pattern.compile("src[\r\n]*=[\r\n]*\\\'(.*?)\\\'", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL),
        Pattern.compile("src[\r\n]*=[\r\n]*\\\"(.*?)\\\"", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL),
        // lonely script tags
        Pattern.compile("</script>", Pattern.CASE_INSENSITIVE),
        Pattern.compile("<script(.*?)>", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL),
        // eval(...)
        Pattern.compile("eval\\((.*?)\\)", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL),
        // expression(...)
        Pattern.compile("expression\\((.*?)\\)", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL),
        // javascript:...
        Pattern.compile("javascript:", Pattern.CASE_INSENSITIVE),
        // vbscript:...
        Pattern.compile("vbscript:", Pattern.CASE_INSENSITIVE),
        // onload(...)=...
        Pattern.compile("onload(.*?)=", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL)
    };
 
    public XSSRequestWrapper(HttpServletRequest servletRequest) {
        super(servletRequest);
    }
 
    @Override
    public String[] getParameterValues(String parameter) {
        String[] values = super.getParameterValues(parameter);
 
        if (values == null) {
            return null;
        }
 
        int count = values.length;
        String[] encodedValues = new String[count];
        for (int i = 0; i < count; i++) {
            encodedValues[i] = stripXSS(values[i]);
        }
 
        return encodedValues;
    }
 
    @Override
    public String getParameter(String parameter) {
        String value = super.getParameter(parameter);
 
        return stripXSS(value);
    }
 
    @Override
    public String getHeader(String name) {
        String value = super.getHeader(name);
        return stripXSS(value);
    }
 
    private String stripXSS(String value) {
        if (value != null) {
            // NOTE: It's highly recommended to use the ESAPI library and uncomment the following line to
            // avoid encoded attacks.
            // value = ESAPI.encoder().canonicalize(value);
 
            // Avoid null characters
            value = value.replaceAll("\0", "");
 
            // Remove all sections that match a pattern
            for (Pattern scriptPattern : patterns){
                value = scriptPattern.matcher(value).replaceAll("");
            }
        }
        return value;
    }
}

Entre las recomendaciones que da en el artículo original está la de configurar este filtro como el primero en tu web.xml y también, en referencia al código que aparece comentado en la segunda clase, echarle un ojo a la librería ESAPI, que nos proporciona diversas soluciones de seguridad.

Desde aquí sólo me queda enviarle mi agradecimiento por su trabajo al señor Zuasti y animarle a recuperar su blog, que tiene material interesante pero hace tiempo que no actualiza.

Dar formato a un float para mostrar sólo dos decimales en Python

A la hora de trabajar con números decimales en cualquier lenguaje nos topamos con la necesidad de darles un formato adecuado en muchas ocasiones (por ejemplo si trabajamos con valores monetarios, con estaturas, etc) para presentar un resultado en pantalla. El más habitual es recortar o redondear los decimales para mostrar sólo dos. ¿Cómo podemos hacer esto en Python? Con la función format() y los operadores de formateo de cadenas es muy simple:

#Formateamos 5.1234554321
print "{0:.2f}".format(5.1234554321)
#El resultado sería
>>5.12
#¿Y si queremos tres?
print "{0:.3f}".format(5.1234554321)
#El resultado sería
>>5.123

Javascript: Devolver 0 cuando parseInt() o parseFloat() reciban una cadena vacía

Tip rápido sobre Javascript: Imaginad que recogemos los datos de un formulario para que calcule en pantalla un sumatorio conforme el usuario los va introduciendo. Ahora imaginad que el usuario se deja un campo vacío. Cuando la función javascript se encuentre una cadena vacía, e intente convertirla a un número (con parseInt() o parseFloat() según lo que necesitemos) el resultado de la suma será NaN. ¿Cómo lo evitamos? Pues con un OR.

Si utilizamos el operador || seguido de un cero, tal como está en el ejemplo que verás a continuación, este evaluará de forma lógica la expresión, y en caso de que el primer término evaluado sea falso devolverá el segundo, un cero (el resultado NaN que devolverá la función que parse a número será evaluado como falso):

var s = '';
var total = 1;

//Si hago esto, el resultado es NaN
total = total + parseInt(s);

//Si hago esto, el resultado es 1
total = total + (parseInt(s) || 0;);

//con parseFloat funciona igual

Otra opción, utilizar el operador ternario ?:, como pusimos en otro ejemplo pasado.

El operador ternario ?: en Java

Seguramente hayas visto en algún ejemplo de código usar el símbolo de interrogación como un operador. Y te preguntarás ¿esto cómo va?. La idea es que más o menos funciona como un condicional if/else devolviendo un valor según una condición se cumpla o no. La sintaxis sería expresiónAEvaluar?valorADevolverSiCierto:valorADevolverSiFalso;

Y como ejemplo práctico, el siguiente código:

/*
Comprobamos si x es mayor que y. 
En caso afirmativo nuestra variable vale x,
y en caso negativo y.
*/
variable=(x>y)?x:y;
/*la alternativa al operador ternario, usando if/else sería*/
if(x>y){
  variable = x;
}else{
  variable = y;
}

Dicho operador existe, con algunas variantes en su sintaxis, también en PHP, C, C++, Python, Perl y aunque en VB.NET no existe sí disponéis de la función IIF cuyo funcionamiento es similar. Como puedes ver te permitirá ahorrar líneas de código y tener un código más elegante.

jqPlot: mostrar la leyenda en varias columnas

El otro día trabajaba con la librería jqPlot, una librería para crear gráficas por medio de javascript y jQuery, y me encontraba con que la leyenda de un gráfico de tarta que estaba haciendo se salía de su elemento contenedor, dado que tenía muchas líneas (en concreto, 58). Me pregunté ¿Cómo hago para que se muestre en dos columnas?. Pensé que era obvio que a alguien le habría pasado ants y encontré la solución en stack-overflow:

//La localización no es importante, sólo el 
//rendererOptions
legend: { 
  show: true, 
  location: 'ne',
  rendererOptions: {numberColumns: 2}
}

Luego decidí bucear un poco más en la documentación y me encontré con un plugin que nos dará mayor versatilidad para trabajar con la leyenda: jqplot.enhancedLegendRenderer.js

La cuestión es invocarlo dentro de la configuración de la leyenda y, además de permitirnos definir el número de filas y columnas (cosa que ya podemos hacer con el renderer normal, pero en este han pulido algunos bugs) también nos permite ocultar/mostrar una serie al pinchar en la leyenda. Se me ocurrió usarlo para mostrar los resultados debajo de la gráfica, en 6 columnas de 10 filas, para que quedara más bonito. Total, que la cosa fue así:

//La localización no es importante, sólo el 
//rendererOptions
legend: {
  renderer: $.jqplot.EnhancedLegendRenderer, 
  show: true, 
  location: 's',
  rendererOptions: {numberColumns: 10, numberRows: 6}
}

Creando un bot que hace FAV automáticamente en Twitter con un script de Python

Ayer aproveché el festivo para repasar un poco de scripting de Python (vicios que tiene uno), y me encontré este tutorial para crear un bot de Twitter, que he supuesto que podría interesarle a alguno de mis lectores por lo que vamos con una traducción no literal del mismo (como otras veces os cuento lo que pone pero no traduzco línea por línea).

El funcionamiento del bot/script es el siguiente: le das al bot una palabra clave, este la busca por Twitter y reparte FAV a diestro y siniestro.

El primer paso es descargar el módulo de herramientas de Twitter para Python (en el artículo original os dirige a la versión 1.10, pero es una entrada de 2013, ya van por la 1.17, yo os dejo apuntando al general para que seleccionéis la versión que os convenga). Luego tendréis que dar de alta el app en Twitter también. Al registrar el app Twitter os dará unas claves de autentificación, que se usarán para realizar la conexión tal que así:

from twitter import Twitter, OAuth, TwitterHTTPError

OAUTH_TOKEN = 'tu oauth token'
OAUTH_SECRET = 'tu oauth secret'
CONSUMER_KEY = 'tu consumer key'
CONSUMER_SECRET = 'tu consumer secret'

t = Twitter(auth=OAuth(OAUTH_TOKEN, OAUTH_SECRET,
            CONSUMER_KEY, CONSUMER_SECRET))

Lo siguiente es definir un método de búsqueda, que recoja los tweets:

def search_tweets(q, count=100):
    return t.search.tweets(q=q, result_type='recent', count=count)

Y definir el método que hará FAV al tweet:

def fav_tweet(tweet):
    try:
        result = t.favorites.create(_id=tweet['id'])
        print "Favorited: %s" % (result['text'])
        return result    
    # En caso de que ya esté marcado con FAV
    # devolverá un error.
    except TwitterHTTPError as e:
        print "Error: ", e
        return None

Y ahora ¿qué nos queda? Pues el código principal del script:

def auto_fav(q, count=100):
    result = search_tweets(q, count)
    a = result['statuses'][0]['user']['screen_name']
    print a
    success = 0
    for tweet in result['statuses']:
        if fav_tweet(tweet) is not None:
            success += 1
    print "Marcamos  %i tweets como favoritos de un total de %i tweets" % (success,
          len(result['statuses']))

Y listo, nuestro bot está preparado. Queda guardarlo en un archivo .py, como por ejemplo twitter_bot.py (respetamos el nombre del artículo original) y ya podemos ejecutarlo desde el terminal tal que así:

$ python

>>> import twitter_bot
>>> twitter_bot.auto_fav('#python','50')

El ejemplo buscará en los 50 últimos tweets el hashtag #python y marcará como favoritos los tweets que lo lleven. Ojo, porque abusar de este script podría llevar a que Twitter te aplique un baneo con todas las de la ley.

En fin, resumiendo aquí os dejo el script del artículo original (con los comentarios y el texto de salida en inglés) completo, por si queréis probar:

from twitter import Twitter, OAuth, TwitterHTTPError

OAUTH_TOKEN = 'your oauth token'
OAUTH_SECRET = 'your oauth secret'
CONSUMER_KEY = 'your consumer key'
CONSUMER_SECRET = 'your consumer secret'

t = Twitter(auth=OAuth(OAUTH_TOKEN, OAUTH_SECRET,
            CONSUMER_KEY, CONSUMER_SECRET))

def search_tweets(q, count=100):
    return t.search.tweets(q=q, result_type='recent', count=count)

def fav_tweet(tweet):
    try:
        result = t.favorites.create(_id=tweet['id'])
        print "Favorited: %s" % (result['text'])
        return result
    # when you have already favourited a tweet
    # this error is thrown
    except TwitterHTTPError as e:
        print "Error: ", e
        return None

def auto_fav(q, count=100):
    result = search_tweets(q, count)
    a = result['statuses'][0]['user']['screen_name']
    print a
    success = 0
    for tweet in result['statuses']:
        if fav_tweet(tweet) is not None:
            success += 1
    print "We Favorited a total of %i out of %i tweets" % (success,
          len(result['statuses']))

Calculando la distancia entre dos coordenadas en Java

Si no hace mucho os comenté por aquí cómo calcular la distancia entre dos puntos dadas sus coordenadas en MySQL (en ese artículo tenéis todo el tema del algoritmo para el cálculo más desarrollado, aquí vamos al grano), hoy vamos a ver cómo hacer una función que nos haga esta operación con Java.

La función recibe cuatro parámetros: las latitudes y longitudes de ambos puntos. Y devuelve un double con la distancia como resultado

public static double distanciaCoord(double lat1, double lng1, double lat2, double lng2) {  
        //double radioTierra = 3958.75;//en millas  
        double radioTierra = 6371;//en kilómetros  
        double dLat = Math.toRadians(lat2 - lat1);  
        double dLng = Math.toRadians(lng2 - lng1);  
        double sindLat = Math.sin(dLat / 2);  
        double sindLng = Math.sin(dLng / 2);  
        double va1 = Math.pow(sindLat, 2) + Math.pow(sindLng, 2)  
                * Math.cos(Math.toRadians(lat1)) * Math.cos(Math.toRadians(lat2));  
        double va2 = 2 * Math.atan2(Math.sqrt(va1), Math.sqrt(1 - va1));  
        double distancia = radioTierra * va2;  
  
        return distancia;  
    }