Una buena forma de aprender a programar es realizar ejercicios prácticos, si existen errores en el proceso el solucionarlos por nuestra propia cuenta nos permite comprender de mejor manera, en esta ocasión veremos como aprender a utilizar los periféricos de entradas y salidas en Arduino, primeramente debemos saber que algunos pines pueden llegar a tener más de 2 funciones distintas es decir el pin puede ser utilizado como una entrada o salida como también puede ser utilizado para una salida para PWM dependiendo del pin utilizado, como vemos debemos tener el esquema de la placa Arduino para utilizar los periféricos que necesitamos.

Utilizar pines como salida

Como vimos en el artículo anterior la estructura necesaria para iniciar un programa es fácil de utilizar simplemente es necesario incluir la función setup() que sirve para agregar parámetros de iniciación y la función loop() conocido como el bucle principal que es donde nuestro programa se ejecutará todo el tiempo, pero también existen funciones propias del hardware de las cuales utilizaremos la función pinMode() y digitalWrite(). El programa que haremos consiste en hacer parpadear un led durante con una frecuencia de 1 segundo entre apagado y encendido, en electrónica es conocido como modo astable y es muy común utilizar el integrado 555 para estas funciones, pero en esta ocasión utilizaremos Arduino.

Primero mostraré el código completo y luego explicaré para qué sirve cada función para así tener una visión completa del código, el programa quedaría escrito de la siguiente manera:

/*
 *	Programa para hacer parpadear un led en arduino
 */
//variables globales
int led = A0; //utilizó un pin con función análoga en arduino atmega
setup(){
	pinMode(led,OUTPUT);  configurar el pin led como salida digital
}
loop(){ //bucle infinito
	digitalWrite(led,HIGH); //envio un 1 al pin el cual enciende el led
	delay(1000); //retardo de 1 segundo
	digitalWrite(led,LOW); //envio un 0 al pin el cual apaga el led 
	delay(1000);
}

Siempre es buena practica comentar el código y con la práctica logras ver que es de mucha ayuda ya que inclusive no necesitas documentar tu código si tus comentarios son bien explícitos, dividamos el código en secciones para entrar en detalle de que cada función, la primera parte sería de inicialización:

int led = A0; //utilizó un pin con función análoga en arduino atmega
setup(){
	pinMode(led,OUTPUT);  /configurar el pin led como salida digital
}

Cualquier placa de Arduino tiene un valor único para cada pin así de esta manera es identificado cada uno en específico, estos valores los puedes ver a la par de cada conector en la placa y se encuentran escritos en color blanco pueden ser letras y números o solo números, este valor es un entero entonces lo que hacemos con la línea int led = A0 es guardar el número de pin en una variable, como puedes notar el valor que ingrese es A0 y es porque estoy utilizando una placa Arduino Mega2560 para este ejemplo y no parece ser un entero pero el compilador sabe que valor le corresponde y lo convierte así no debes preocuparte por el valor exacto porque sabe que pin estás utilizando, regresando a lo anterior, lo que hacemos es guardar el valor del pin en una variable para que podamos configurar ese pin como salida.

Dentro de la función setup() nos encontramos como la función pinMode(led,OUTPUT), lo que hace esta función es configurar el pin que deseas utilizar ya sea como salida con la constante OUTPUT o como entrada cambiando OUTPUT por INPUT en nuestro caso lo utilizamos como salida, el siguiente bloque es la función loop:

loop(){ //bucle infinito
	digitalWrite(led,HIGH); //envio un 1 al pin el cual enciende el led
	delay(1000); //retardo de 1 segundo
	digitalWrite(led,LOW); //envio un 0 al pin el cual apaga el led 
	delay(1000);
}

A la función loop la llamaré bucle principal para referirme a ella ya que en realidad lo que hace es repetir cada línea de manera infinita y de manera secuencial, con la función digitalWrite(led,LOW) lo que hacemos es enviar o escribir un valor de salida al pin como podrás notar necesitamos el valor de identificación del pin el cual lo declaramos en una variable al principio del código es por esta razón que es que es buena práctica utilizar constantes para referirnos a valores repetitivos, la función digitalWrite() necesita el valor del pin que en este caso es la variable led y un parámetro de salida ya sea 1 ó 0, el compilador de Arduino posee valores constantes que podemos utilizar para hacer más entendible nuestro código en este caso la constante HIGH es igual a 1 y LOW es igual a 0 entonces primero encendemos el led con valor 1 luego esperamos un segundo con la función delay(1000), esta función es para realizar pausas de un milisegundo, 1000 milisegundos son igual a 1 segundo que es el valor que ingresamos, luego queremos apagar el led con valor 0 y esperar otro segundo, y esto se repetirá una y otra vez.

Para cargar el software a nuestro Arduino debemos dar click en el icono de cargar en la parte superior del IDE y si no cometimos ningún error y el software se encuentra configurado con la placa correcta, nos mostrará un mensaje de carga exitosa, luego debemos probar si nuestro programa funciona bien en la placa Arduino y para eso necesitamos realizar un circuito con protoboard, en el que tomaremos los voltajes de la placa Arduino y colocaremos el led con su resistencia para no quemar lo que irá conectado al pin A0 y el circuito quedaría de la siguiente manera:

Utilizar pines como entradas

Si no cometimos ningún error, deberíamos ver el led parpadear, de la misma forma se puede configurar cualquier pin como salida y no solo puede ser utilizado para encender un led sino que en aplicaciones reales puedes conectar cualquier componente que necesites,pero¿qué pasa si quieres leer el valor de un pin que puede ser un botón o switch por ejemplo? en este caso el pin debe ser configurado como entrada, y para poder mostrar como hacerlo realizaremos un cambio al código anterior agregando un switch para controlar la acción de parpadear, si el switch es igual a 1 entonces la acción se realizará pero si es igual a 0 no se ejecutará nada, el código quedara de la siguiente manera:

/*
 *	Programa para hacer parpadear un led en arduino
 */
//variables globales
int led = A0; //utilizó un pin con función análoga en arduino atmega
int switch = A1; //utilizo el pin como entrada para detectar el pulso del boton
int estado = LOW;
setup(){
	pinMode(led,OUTPUT);  //configurar el pin led como salida digital
	pinMode(button,INPUT); //configuro el pin como como entrada digital
}
loop(){ //bucle infinito
	estado = digitalRead(switch);
	if(estado == LOW){ //si el switch s
		digitalWrite(led,HIGH); //envio un 1 al pin el cual enciende el led
	delay(1000); //retardo de 1 segundo
	digitalWrite(led,LOW); //envio un 0 al pin el cual apaga el led 
	delay(1000);
}
}

En este ejemplo agregamos una resistencia en pull-up la cual nos sirve controlar el estado lógico de la entrada y para que el switch se pueda conectar en este caso a negativo, es una técnica muy utilizada en electrónica, siempre puedes consultar en google sobre pull-up y pull-down si así lo deseas, cabe mencionar que Arduino posee resistencia en pull-up internas pero esta vez no las utilizaremos ya que lo veremos mas adelante.

En el circuito solo debemos incluir un switch con una conexión a una resistencia en pull up que se coloca como se ve en la imagen anterior y el otro pin a tierra, la entrada se encontrara en alto con una baja tensión la cual al ser presionado el switch cederá el paso a tierra que sera reconocido como un 0, de nuevo debemos cargar el software a Arduino y veremos el circuito funcionar, el circuito quedaría de la siguiente manera:

De esta manera logramos configurar los pines de Arduino como entradas y salidas en este caso fue para controlar un led con un switch simple pero en el mundo real pueden tener varias aplicaciones según lo necesites, en el siguiente articulo veremos mas en detalle los periféricos especiales que poseen algunos pines y como siempre tratare de incluir ejemplos prácticos ya que es la mejor forma de aprender.

La entrada Tutorial arduino – Entradas y salidas aparece primero en Cronicas de un geek.

En el artículo anterior vimos como preparar nuestra placa arduino para realizar la programación y de esta manera comenzar a desarrollar nuestros proyectos, en el artículo de introducción mencione que es necesario comprender los conceptos básicos de programación de preferencia en lenguaje C y conocer sobre electrónica digital, en este artículo veremos una referencia de las funciones más utilizadas en el lenguaje de programación en arduino, toda esta información la puedes encontrar en la página oficial de arduino.

Estructura de un programa

Es común que antes de ejecutar un programa se deba respetar su estructura para que este compile correctamente, en el caso de programar para arduino se debe agregar la siguiente estructura:

#include<lib.h> // librerias necesarias, opcional
setup(){
	//configuraciones iniciales, obligatorio
}
loop{
	//bucle de ejecución del programa, obligatorio
}

En el código anterior vemos que hay 3 líneas de código #include, setup(), loop(), #include se utiliza en el caso de que necesitemos utilizar una librería adicional, el IDE de arduino permite importar librerías según las necesitemos, en el caso de setup() y loop() son funciones obligatorias.

Setup(): Esta función se utiliza para inicializar parámetros y funciones, se ejecuta una única vez al encender o reiniciar la placa, en esta función podemos configurar los pines según necesitemos, configurar parámetros de comunicación, establecer variables con valores iniciales etc.

Loop(): Esta es la función donde se ejecuta el programa, esta se repite de manera continua osea que entra en un bucle infinito lo que sería igual a un while(true) en lenguaje C, aquí debemos realizar el programa que necesitamos ejecutar.

Un ejemplo practico seria hacer parpadear un led cada segundo de manera infinita, el código quedaría de la siguiente manera:

const int led = 13; // definición de pin 13 el cual encenderá el led
void setup ()
{
  pinMode (led, OUTPUT);
}

// El led se encenderá durante un segundo y luego se apagará durante un segundo.
void loop () // el proceso se repetirá infinitamente.
{
  digitalWrite (led,HIGH);// enviamos un 1 al pin led
  delay (1000); // un retardo de 1 seg
  digitalWrite (led,LOW);//enviamos un 0 al pin led
  delay (1000);
}

 Variables

En cualquier lenguaje de programación utilizaremos variables para almacenar nuestra información, en el caso de arduino podemos utilizar los siguientes tipos de variables, y como es de esperarse la diferencia es la cantidad de memoria que puede utilizar cada tipo.

• Boolean: Es de tipo lógico los valores pueden ser 1 ó 0 como también puede ser true o false, este tipo de variable consume muy poca memoria porque utiliza 1 bit de almacenamiento.
• Byte: Permite almacenar 8 bits de datos que puede ser un número de 0 a 255.
• Int: Puede almacenar 2 byte de memoria que sería un entero con signo positivo o negativo que puede ser un número en el rango de -32,768 a 32,768.
• Unsigned: Permite manejar valores enteros sin utilizar signo, por ejemplo al declarar una variable entera esta posee 2 byte de memoria del cual 1 bit se utiliza para el signo ya sea negativo o positivo lo que deja 15 bits para el valor si vemos el número máximo permitido que seria 2^15 es igual a 32,768, si quitamos el signo con la palabra unsigned tendríamos el bit del signo disponible lo cual seria 2^16 que es igual a 65,536 como número máximo a almacenar, esta función aplica para variables tipo int, long, char.
• Long: Este tipo de variable utiliza 4 bytes de memoria que equivale a 32 bits de datos que puede ser un número en el rango de -2,147,483,648 a 2,147,483,648, si quitamos el signo el valor máximo sería igual a 4,294,967,295 que es un número muy grande.
• Char: Únicamente permite caracteres como por ejemplo ‘a’ ,’b’, ‘c’, etc… Solo permite una única letra y esta debe estar dentro de comillas ya sean simples o dobles.
• Float: Esta variable permite el uso de punto flotante de 6 a 7 dígitos a partir del punto.
• Array: Un array es una colección de variables, puede ser de cualquier tipo y por lo general se declara a la par del nombre de la variable ejemplo: int myInts[6] lo que significa que tenemos 6 variables con el mismo nombre, para acceder a una en especifico solo agregamos el índice en la posición deseada ejemplo: myInts[2] en este caso estamos utilizando la posición 2 del arreglo.

Existen más variables que podemos ver en la página de referencia, por lo general las mencionadas anteriormente son las más utilizadas.

Condicionales

Las condicionales o sentencias son instrucciones que permiten realizar una función o no en valor a la condición, en la programación de arduino disponemos de las condiciones propias de c las cuales son if, if..else, switch, la ventaja es que existen muchos información y ejemplos en internet por este motivo no entraré en detalle con este tema.

Bucles

Al igual que las condicionales en internet existe mucha información al respecto con este tema, en arduino tenemos las funciones while, for, do.. while, y goto. la sintaxis es similar a la del lenguaje c, y su uso es fácil de utilizar en la práctica.

Si bien es cierto que la programación en arduino es fácil de realizar, siempre debemos poseer los conocimientos basicos en programacion, mi intención en este artículo es de mencionar las funciones y palabras más utilizadas en arduino, también es cierto que aquí solo es una fracción de las que realmente existen, por este motivo es recomendable visitar la página oficial en la sección de referencias o dando click aquí, es considerado buena práctica revisar todas las funciones aunque no las utilicemos principio.

Aún hace falta ver mas funciones propias de arduino, pero tratare de explicarles con ejemplos prácticos en los siguientes artículos, porque algunas funciones son más fáciles de aprender en la práctica que en la teoría y también porque de esta manera avanzamos más rápido y llegar a aprender como realizar proyectos más complejos que es donde se pone mas emocionante todo lo aprendido.

La entrada Tutorial arduino – Estructura básica de programación aparece primero en Cronicas de un geek.

Pinguino es una placa electrónica que utiliza un microcontrolador pic como procesamiento principal, es similar a arduino en algunos aspectos y se puede programar con el lenguaje que utiliza arduino; no es 100% compatible porque existen algunas librerías que no funcionan correctamente y otras que no están disponible, en este enlace podemos ver que librerías están disponibles y cuales no.

En la página oficial del proyecto podemos descargar el entorno de desarrollo llamado Pinguino ide el cual esta disponible para Windows, Mac y linux, debo decir que mi sistema favorito es linux y la distribución que mas utilizo es debian de 64bits, en la cual es muy sencillo de instalar solo debes bajar el script y ejecutarlo con el comando sudo chmod +x installer.sh && sudo ./installer.sh luego nos mostrara una lista de opciones para instalar, es recomendable descargar los 2 compiladores que seria la opción 3 pues nunca se sabe cuando podemos utilizarlos, hasta este punto todo bien de hecho puede ejecutar el entorno y no veras ningún error, los problemas surgen al querer compilar tu programa, nos mostrara el siguiente error:

/lib/x86_64-linux-gnu/libc.so.6: version ‘GLIBC_2.14′ not found

/lib/x86_64-linux-gnu/libstdc++.so.6: version ‘GLIBCXX_3.4.15′ not found

Estos errores se muestran porque el compilador utiliza una versión más reciente de las disponibles, al tratar de actualizar las librerías del repositorio me sigue mostrando el mismo error, es porque Debian es un sistema estable y nunca sube a sus repositorios versiones no probadas correctamente pero en ocasiones son versiones de hace 2 años o más por este motivo es que sigue mostrando el mismo error, pero podemos solucionar el problema actualizando las librerías de los repositorios de desarrollo, en estos repositorios no existe garantía de éxito pero al parecer no hay ningún problema porque mi sistema sigue funcionando correctamente.

Lo primero que debemos hacer es añadir los repositorios experimentales editando nuestro fichero sources.list con el siguiente comando:

#sudo gedit /etc/apt/sources.list

Una vez abierto el archivo agregamos lo siguiente:

deb http://ftp.debian.org/debian experimental main
deb http://ftp.debian.org/debian sid main

Guardamos los cambios, ahora actualizamos la base de repositorios ejecutando el comando:

#sudo apt-get update

Luego actualizamos la librería libc.so.6 de los repositorios experimentales, puede que tome tiempo porque al parecer re compila varias dependencias, para hacerlo ejecutamos el siguiente comando:

#sudo apt-get -t experimental install libc6-dev

Para actuar la librería libstdc++.so.6 solo es necesario ejecutar la siguiente instrucción:

#sudo apt-get -t sid install libstdc++6

Por ultimo borra las lineas de los repositorios experimentales que agregaste en el archivo sources.list para que no dañes tu sistema al hacer una actualización y listo ya puedes intentar compilar tu código, deberás ver en pantalla la frase Compilation done!, lo que significa que funciona correctamente.

La entrada Cómo instalar pinguino IDE en debian 7 correctamente aparece primero en Cronicas de un geek.

Esta guía la realizo a base de experiencias propias en el desarrollo y en lo que considero ventajas en tiempos de entrega y situaciones donde la calidad es necesaria sin disponer de tiempo.

¿Por qué utilizar un framework css?

Esta sería la primera pregunta que debemos hacernos, en realidad con css puro podemos hacer cosas realmente increíbles, si bien css por si solo es fácil de utilizar en la práctica se puede volver realmente costo en términos de tiempo. Tomando por ejemplo hacer un menú superior con submenús o un menú lateral que sea desplegable, si comenzamos por lo más básico necesitamos primero definir la estructura en HTML, luego necesitamos realizar un bosquejo ó de preferencia el diseño de cómo debe verse una vez terminado, luego comenzar a maquetar hasta tener el css y HTML funcionando sin problemas, por último en algunos casos debemos realizar la animación con javascript o jquery que es mucho más fácil, una vez terminado todo, ya habremos tomado 1hr o mas de tiempo en lo que es solo una sección del sitio, aunque debo decir que existen personas muy hábiles que realizan esta tarea en menos de una hora y con detalles. Pero supongamos que no es nuestro caso,aquí es donde entran los frameworks la mayoria estan hechos para ahorrarnos tiempo y disponer de una librería de clases fáciles de utilizar, tomando el ejemplo anterior esta tarea nos tomaría 5 minutos en lo que buscamos la documentación y agregamos el código, casi siempre cuando son sitios para el cliente final, trabajamos con un diseño ya hecho, ya sea en illustrator o en photoshop aún así disponer como base un framework es recomendable en mi caso me permite solo agregar estilos donde se requiera y seguir la estructura sin problemas, esto nos ahorra tiempo y agrega una mejor calidad al sitio entre otra cosas.

¿Qué necesito saber para utilizar uno?

Antes de preguntar ¿cuál debo utilizar?, debemos de considerar que necesitamos saber para poder utilizar uno, principalmente debemos de conocer de preferencia css a un nivel intermedio y por supuesto HTML correctamente, recuerdo bien cuando trate de utilizar bootstrap (framework liberado por twitter) sin dominar css, me fue mal porque no sabía como colocar correctamente un div a la par de otro, al no saber cómo funcionaban los grid en bootstrap se complico aun mas. Es recomendable que al menos domines términos como flotar contenedores, posiciones absolutas, relativas y z-index que seria colocar una capa sobre otra capa según su prioridad.

El segundo concepto que también es bueno comprender es el de la distribución en pantalla, un diseño fluido por lo general utiliza un contenedor central con un tamaño máximo de 960px que puede contener varios div en su interior, por ejemplo 12 contenedores que se les llamaría 12 columnas con un ancho de 80px cada uno, se utiliza 960px porque puede ser dividido dentro varios múltiplos de 2, lo más común es dividirlo dentro de 12 columnas y 16 columnas, de esta manera se puede tener un sidebar que utilice 3 columnas y el contenido que ocupe 9 columnas sin perder la fluidez en pantalla, en la imagen de abajo puedes ver como realizar una distribución de las columnas con foundation css.

¿Cual debo utilizar?

Considerando todo lo anterior aun así es difícil decidir cual utilizar, por lo que debemos de considerar otros aspectos basándonos en lo que nuestro proyecto necesita, los criterios más comunes son:

• Apariencia o estilo del framework.
• Que sea fácil de configurar.
• Si posee funciones javascript (opcional).
• Que posea documentación o ejemplos.
• Responsive (opcional).

Si analizamos bien los puntos anteriores primero debemos ver si el estilo que posee el framework se adapta a nuestro proyecto, por lo general se tiene un diseño con el cual trabajar, pero la apariencia es lo que al final el cliente va a apreciar por eso considero que es adecuado analizar bien cuál utilizar, la configuración en la mayoría de frameworks es fácil de hacer pero no esta de mas verificar bien, por ejemplo si se debe agregar muchas etiquetas HTML para hacer funcionar el componente o en algunos caso puede que también utilice javascript para generar las etiquetas, en la práctica debemos de modificar la estructura HTML por lo que esto lo considero también necesario porque podemos perder tiempo en encontrar donde hacer la modificación.

Javascript es tan necesario en la actualidad que nos permite realizar animaciones increíbles y utilizando jquery lo hace relativamente fácil, la mayoría de framework también disponen de una serie de componentes que utilizan javascript lo que los hace aún más potentes, y si necesitamos animaciones ¿porque no utilizarlas?.

También es necesario saber cómo funciona el framework, por eso es necesario tener la documentación a la mano, esto lo considero importante porque podemos llegar a pasar horas buscando como utilizar un componente o tratando de resolver un problema porque no sabemos como configurar correctamente el componente.

Por último, sabemos muy bien que los teléfonos inteligentes están por todas partes y no podemos ignorar que gran parte de los usuarios los utilizan para navegar, y que el framework sea responsive facilita enormemente el trabajo, casi siempre adaptar un sitio para que sea responsive es tedioso, pero tener un framework responsive es de gran ayuda.

Frameworks recomendados

Existe una gran cantidad de framework en internet, que es difícil probarlos todos a profundidad por eso dejaré una lista de los que yo considero útiles en la práctica.

• Foundation zurb
• Bootstrap css
• Gumby framework
• HTML kickstart
• Metro ui CSS

Espero que esta guía te sea de utilidad, si conoces alguno que quieras recomendar no dudes en comentar.

La entrada ¿Como escoger un Framework css correctamente? aparece primero en Cronicas de un geek.

• GET: Utilizaremos 2 consultas get para obtener información de la base de datos sobre los usuarios registrados, la primera para obtener un arreglo de todos los usuarios, y la segunda con un identificador obtendremos un arreglo de datos de un único usuario.
• POST: Con este método insertaremos usuarios a nuestro sistema o base de datos.
• PUT: Si tenemos el identificador de un usuario podemos hacer modificaciones a la base de datos, por lo que usaremos este método para poder hacerlo.
• DELETE: Por último utilizaremos este método para eliminar un usuario con su identificador.

Lo primero que necesitamos hacer es crear la base de datos, en este caso la haremos en SQL, asumiendo que sea desde consola, ingresando el siguiente código:

CREATE DATABASE restslim;
USE restslim;
CREATE TABLE usuarios (
  id int(11) NOT NULL AUTO_INCREMENT,
  username varchar(100) NOT NULL,
  password varchar(100) NOT NULL,
  description text,
  PRIMARY KEY (id)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8;

Una vez creada la base de datos y la tabla usuarios, el segundo paso es preparar la conexión a mysql, en php existen varios métodos para realizarlo como pueden ser funciones mysql (obsoleto desde la versión 5 de php), mysqli que recomienda el sitio oficial de php, y por último con un objeto de clases php PDO, aunque las 3 formas son válidas, utilizare la ultima opcion ya que a mi parecer es más fácil de utilizar y el uso de consulta preparas es muy simple.

Abrimos nuestro archivo index.php que configuramos anteriormente (ver de nuevo), de preferencia borramos el código innecesario y dejamos solo lo siguiente:

require 'Slim/Slim.php';
\Slim\Slim::registerAutoloader();
$app = new \Slim\Slim();

En la siguiente linea agregamos la función para poder realizar la conexión a la base de datos:

/*
 *conexiónon a base de datos
 */
function PDOconnection()
{
	try{
		$connection = new PDO("mysql:host=localhost;Mibase=prueba_slim", "usuario", "password");
		$connection->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
	}
	catch(PDOException $error)
	{
		echo "Error PDOconnection: " . $error->getMessage();
	}
	return $connection;
}

Reemplaza el texto “mibase” por tu nombre de base de datos de igual manera el texto “usuario” y la “contraseña” por tu configuracion, y de esta manera ya tendremos la conexión a la base de datos, el siguiente paso es registrar las rutas en el objeto $app creado inicialmente.

En este punto comenzaremos a utilizar los métodos HTTP para obtener la lista de usuarios y los datos de un usuario en específico utilizando su id, en este caso haremos uso del método GET, para registrar una ruta en slim tipo GET, se utiliza el método con el mismo nombre quedando de la siguiente manera:

$app->get("/usuarios/", function() use($app)
{
	try{
		$connection = PDOconnection();
		$consulta = $connection->prepare("SELECT * FROM usuarios");
                $consulta->execute();
		$usuarios = $consulta->fetchAll();
		$connection = null;
		$app->response->headers->set("Content-type", "application/json");
		$app->response->status(200);
		$app->response->body(json_encode($usuarios));
	}
	catch(PDOException $error)
	{
		echo "Error PDOconnection: " . $error->getMessage();
	}
});

En el método se agrega el primer parámetro “nombre de la ruta” y luego se agrega una función o clase a utilizar en este caso utilizamos una función anónima que puede ser declarada como parámetro, como puedes darte cuenta creamos la conexión a la base de datos, y con la sentencia SQL realizamos la consulta de manera rápida, siempre debes de realizar la consulta dentro de un try/catch para evitar errores en ejecución. Por último recogemos los datos y los mostramos en formato json con la función json_encode().

Para obtener los datos de un usuario en especifico solo necesitamos tener el identificador de la base de datos y podremos realizar la consulta, en este caso pasamos el parámetro id a través de la ruta “/usuario/:id”, el texto “:id” slim lo reconoce como variable y lo podremos utilizar dentro de la función como se ve a continuación:

$app->get("/usuario/:id", function($id) use($app)
{
	try{
		$connection = PDOconnection();
		$consulta = $connection->prepare("SELECT * FROM usuarios WHERE id = ?");
                $consulta->bindParam(1, $id);
                $consulta->execute();
		$usuarios = $consulta->fetch();
		$connection = null;
		$app->response->headers->set("Content-type", "application/json");
		$app->response->status(200);
		$app->response->body(json_encode($usuarios));
	}
	catch(PDOException $error)
	{
		echo "Error PDOconnection: " . $error->getMessage();
	}
});

Para utilizar el parámetro ”:id” declarado en la ruta, debemos incluir dentro de la función el parámetro con el mismo nombre. En la sentencia SQL utilizamos el signo ? para referirnos a un parámetro variable que desconocemos, esto se conoce como sentencias preparadas, puedes utilizar este signo para referirte a los parámetros que desees solo debes respetar el orden al ingresarlos, y con el método “bindParam(1, $id)” reemplazamos el signo por la variable.

Para insertar usuarios hacemos uso del método POST que es utilizado para enviar información de manera más discreta, el código a utilizar seria asi:

$app->post("/usuarios/", function() use($app)
{
	$usuario = $app->request->post("username");
	$password = $app->request->post("password");
	$description = $app->request->post("description");

	try{
		$connection = PDOconnection();
		$db = $connection->prepare("INSERT INTO usuarios VALUES(null, ?, ?, ?)");
		$db->bindParam(1, $usuario);
		$db->bindParam(2, $password);
		$db->bindParam(3, $description);
		$db->execute();
		$lastid = $connection->lastInsertId();
		$connection = null;
		$app->response->headers->set("Content-type", "application/json");
		$app->response->status(200);
		$app->response->body(json_encode($lastid));
	}
	catch(PDOException $error)
	{
		echo "Error PDOconnection: " . $error->getMessage();
	}
});

Como puedes notar, con el método request->post(“nombre_de_lparametro”) obtenemos el valor de cada variable, y utilizando sentencias preparadas insertamos cada valor en nuestra base de datos, y como respuesta mostramos un 1 en caso de haberse agregado los datos con éxito.

Para actualizar los datos de un usuario existente en la base de datos, solo es necesarios el id, utilizamos el método PUT realizamos las modificaciones, el código necesarios es el siguiente:

$app->put("/usuarios/", function() use($app)
{
	$usuario = $app->request->put("username");
	$password = $app->request->put("password");
	$description = $app->request->put("description");
        $id = $app->request->put("id");

	try{
		$connection = PDOconnection();
		$db = $connection->prepare("UPDATE usuarios SET username = ?, password = ?, description = ? WHERE id = ?");
		$db->bindParam(1, $usuario);
		$db->bindParam(2, $password);
		$db->bindParam(3, $description);
		$db->bindParam(4, $id);
		$db->execute();
		$connection = null;
		$app->response->headers->set("Content-type", "application/json");
		$app->response->status(200);
		$app->response->body(json_encode(array("update" => 1)));
	}
	catch(PDOException $error)
	{
		echo "Error PDOconnection: " . $error->getMessage();
	}
});

El código es similar al método POST la diferencia es básicamente la consulta SQL que ahora es “update” en lugar de “insert”.

Si necesitamos eliminar un usuarios, utilizamos el método DELETE utilizando el id del usuarios para referirnos a él en la base de datos, de igual forma que en el método GET también pasamos el id a través de la url, el codigo quedaria de esta manera:

$app->delete("/usuarios/:id", function($id) use($app)
{
	try{
		$connection = PDOconnection();
		$db = $connection->prepare("DELETE FROM usuarios WHERE id = ?");
		$db->bindParam(1, $id);
		$db->execute();
		$connection = null;
		$app->response->headers->set("Content-type", "application/json");
		$app->response->status(200);
		$app->response->body(json_encode(array("delete" => 1)));
	}
	catch(PDOException $error)
	{
		echo "Error PDOconnection: " . $error->getMessage();
	}
});

Si todo salio bien, mostramos un 1 como confirmación, y por último agregamos la linea “$app->run();” para poner a correr la aplicación.

Una vez finalizado la configuración en slim debemos probar si todo esta funcionado correctamente, lo cual explicaré en la próxima entrada para no hacer muy largo el artículo.

La entrada Rest ful api con slim php – rutas y mysql aparece primero en Cronicas de un geek.

las ventajas de utilizar un servicio RESTful es que podemos utilizar un formato ligero de objetos Javascript llamado JSON, el cual nos permite tener diferentes aplicaciones en distintos lenguajes que pueden interactuar entre sí, gracias a la flexibilidad del protocolo, y con el aumento de aplicaciones móviles es común que las bases de datos y en algunos casos la capacidad de procesamiento la realiza un servidor en la nube y no el teléfono, un ejemplo podría ser el de crear una aplicación en Android para un blog en WordPress, si queremos mostrar una lista de nuestros últimos artículos de manera personalizada, lo ideal sería recoger los datos del servidor y mostrarlos en una lista o en secciones, incluso el plugin jetpack permite el acceso de tu blog a través de su api json sin crearla nosotros lo que lo hace aún mas fácil, mas adelante haré un tutorial de como hacerlo pero por ahora supongamos que no tenemos la api y tenemos que hacerla de forma manual.

Se puede crear un api RESTful en varios lenguajes, en Ruby, PHP o Java por ejemplo, lo que nos da más opciones para escoger, en este caso por flexibilidad y facilidad de uso utilizaremos php y el micro framework slim el cual nos agiliza el tiempo de desarrollo y entre sus ventajas podemos mencionar:

1. Manejo de métodos HTTP estándar y personalizados
2. Configuración sencilla
3. Manejo de rutas
4. Manejo de plantillas para vistas
5. Es software libre.

Métodos HTTP utilizados en RESTful

HTTP es un protocolo de transferencias usado en Internet, la mayoría de navegadores sólo utilizan los métodos GET y POST para realizar transferencias dejando de lado los otros métodos (para ver todos lo métodos y su explicación da click aqui ). CRUD es el acrónimo utilizado para referirse a las funciones de Crear, Obtener, Actualizar y Borrar (Create, Read, Update, Delete en inglés), es lo que básicamente haremos con slim utilizando los métodos http para hacerlo, la función de cada método es la siguiente:

• GET: utilizado para obtener información (visibles en la url en el navegador).
• POST: utilizado para insertar información.
• PUT: utilizado para para actualizar datos.
• DELETE: utilizado para eliminar datos.

Existen otros métodos en el protocolo http que no usaremos aquí y cabe mencionar que esta es la utilización conocida como RESTful.

Instalación de slim

Primero debes descargar el código, existen dos formas y la más recomendada es por medio de composer lo único que necesitas para hacerlo es agregar en el archivo composer.json.

{
"require": {
"slim/slim": "2.*"
}
}

y ejecutamos php composer.phar install desde la consola (también agregare a la lista un tutorial de composer), y la segunda opción es de manera manual que simplemente bajas la última versión del código que puedes descargar aquí, una vez descargado el código, dentro de la carpeta creas un archivo llamado index.php en el caso de haber hecho la descarga a través de composer agrega el siguiente código:

require 'vendor/autoload.php';

si lo descargaste manual solo necesitas incluir la carpeta slim y en el archivo index.php agregamos el siguiente código:

require 'Slim/Slim.php';
\Slim\Slim::registerAutoloader();

Para iniciar la clase utilizamos lo siguiente:

$app = new \Slim\Slim();

y de esta manera ya tenemos todo listo para comenzar a agregar nuestras funciones, como prueba de que todo esta funcionando podemos agregar el siguiente ejemplo:

require 'Slim/Slim.php';
\Slim\Slim::registerAutoloader();
// GET route
$app->get(
    '/',
    function () {
        $template = <<<EOT
<!DOCTYPE html>
    <html>
        <head>
            <meta charset="utf-8"/>
            <title>Test de funcionamiento</title>
        </head>
        <body>
            <h1>Slim funciona perfectamente</h1>
        </body>
    </html>
EOT;
        echo $template;
    }
);
$app->run();

Si vemos en pantalla el mensaje “Slim funciona perfectamente” es porque todo esta funcionado bien. Para no hacer mas largo el tutorial dejaré hasta aquí este primer artículo, en la próxima entrada hablaré sobre las rutas y conexión a mysql, lo cual nos será de utilidad en muchas formas, si te gusto el articulo no olvides en comentar.

La entrada Cómo crear un api RESTful con slim php – introducción aparece primero en Cronicas de un geek.