:::: MENU ::::

La evolución: Local Storage & Session Storage

¡Hola programadores!
Como ya dije hace un tiempo, me niego a poner el cartelito de las cookies, pero bueno, luego en la práctica no es para nada necesario y en realidad… si os quedáis hasta abajo, veréis que en este tema, no influye.

Sea como fuere, no vengo a hablar de esto, si no de la evolución de la web. Y es que Local Storage y Session Storage (aunque personalmente desprecio completamente la segunda), nos permite ver hacia dónde apunta el desarrollo web, y es que estas no pueden ser accedidas por el servidor.

¿Qué significa esto?
Muy fácil: así como las cookies son accedidas por el servidor, normalmente, ya que se mandan junto a las cabeceras, para controlar el logueo de los usuarios; el Local Storage, que no es más que un objeto en JavaScript en el cual podemos guardar strings, u objetos (si contamos que podemos hacer uso de funciones como stringify o parse de JSON), que es almacenado en el navegador al igual que las cookies, no puede ser leído ni se envía mediante las cabeceras al servidor.
Esto último implica que tenemos que usar JavaScript sí o sí para poder interactuar con dichos objetos, de esa forma esto marca una tendencia hacia tener un cliente que muestra la web a base de pequeños datos, como pueden ser objetos JSON, XML (que ya va quedando obsoleto…) u otros métodos como la utilización de node.js, en lugar de que sea el servidor que pre-procese el HTML añadiéndole el contenido.
Obviamente con cookies ya se podía hacer esto, permitiendo además que el servidor leyera directamente de ellas la información que necesitaba para identificar al usuario, pero que las nuevas tecnologías como es LocalStorage apunten a evitarlo, implica y marca una tendencia a seguir.

¿Es mejor?
En caso de usar node.js/websockets, no nos va a afectar, puesto que podíamos leer las cookies desde JavaScript con el objeto docmuent.cookie, pero eso reduce en un pequeñísimo porcentaje la carga de la web, puesto que no tiene que enviar las cookies mediante las cabeceras.
Si usamos PHP puro, podemos olvidarnos, pero lo que sí que podemos hacer, al igual que antes (solo que ahora creando la necesidad implícita de transferir los tokens de las sesiones mediante el método get o post en una petición ajax, y siendo esto una práctica que utilizan servicios como Habbo Hotel para cargar, por ejemplo, las notícias) es enviar con ajax, como he mencionado anteriormente, una petición al servidor, adjuntando también un token, y que este nos devuelva todos los datos necesarios para la web, que además serán colocados con JavaScript.
Con esto último, reduciremos considerablemente el tiempo de carga de nuestra web, o como mínimo el de repuesta del servidor, ya que una vez servido el HTML y los scripts por primera vez, no necesitaremos obtenerlo de nuevo para cambiar su contenido, puesto que podremos hacerlo con solo obtener objetos JSON (u otras maneras) y reemplazando el contenido de elementos por otros, como por ejemplo un campo de nombre de usuario.
No solo, además, podremos cambiar solo el contenido en cuanto a texto, sino que podremos también cambiar el HTML, implicando así que podremos cargar páginas distintas en una sola página, y gracias a funciones como ‘location.pathname.replace’, podremos incluso cambiar la dirección en la barra de direcciones, de forma que si un usuario copia un link al visualizar una foto y se lo pasa a otra persona, podremos cargar la foto directamente al cargar la página (como ya hace twitter o facebook).

Por supuesto, para proyectos pequeños en los cuales la carga del servidor no sea tan importante (ya que obviamente la diferencia será de milisegundos, y que si solo se ve una página será contraproducente), no necesitamos usar dicha nueva tecnología, que además de ser más tediosa y larga a la hora de desarrollar, también aumenta la carga en el navegador, mucho más que una simple página estática en HTML puro, de forma que si hacemos un pequeño blog o una web de empresa, con ni tan solo un millón de visitas mensual, no recomiendo hacerlo bajo ningún concepto.

Entonces… ¿Cookies o LocalStorage?
Fácil, como he aclarado en el párrafo anterior, según el tamaño del proyecto, cargar el cliente en exceso y/o si la carga del servidor no importa, usar LocalStorage es contraproducente. En cambio, si es un gran proyecto como Twitter o Facebook, entonces, usar el cliente como base para cargar toda la web puede ser la mejor opción. Por ende, yo usaría cookies si queremos tirar de servidor y LocalStorage si de JavaScript va la película.
A excepción de si usamos PHP, entonces usar LocalStorage no vale la pena del todo, de cualquier forma vamos a transferir los datos al servidor mediante cabeceras (ojo, si que nos puede servir para controlar qué datos le enviamos, y además, recordemos que si los datos son sensibles o solo se requieren para el funcionamiento temporal de la web, puede ser mejor usar LocalStorage).
Y sí, eso último que acabo de decir se hace posible con LocalStorage, pues este nos permitirá almacenar parámetros como el color de fondo que preferimos u otros detalles (incluso que pueden ser asignados por el servidor al iniciar sesión) y así no tener que cargarlos cada vez, reduciendo una petición al servidor por cambio/carga nueva de página.

Por ende, y contando que cada uno tiene sus pros y sus contras y que no nos vamos a saltar el cartelito de las cookies (puesto que este también es regulado por la famosa ‘ The Cookie Law’), va a depender del caso el hecho de usar uno u otro.

Para los que reclamen por la seguridad: ambos son IGUAL de seguros en cuanto a que el cliente los puede leer y modificar con tan solo la consola JavaScript, pero las cookies se enviarán al servidor en las cabeceras, mientras que el LocalStorage/SessionStorage permanece en el navegador si no lo enviamos nosotros con JavaScript.

Espero que os haya servido de ayuda esta pequeña reflexión.
¡Un saludo a todos!


Ensaïmada numérica, el bot que las resuelve

Pues sí queridos amigos,
Un año y medio después he vuelto y os traigo el post que tanto prometí.
En este caso se trata de un pequeño proyecto de PHP que resuelve las ensaïmadas numéricas (sí, con diéresis, que por algo estamos en Mallorca).
Una ensaïmada numérica es un circuito Hamiltoniano, matemáticamente hablando. En este caso es una tabla de 10×10 en cuyas celdas encontramos todos los valores del 1 al 100 ordenados de una forma específica.
Para empezar, colocamos el valor ‘1’ en cualquiera de las celdas que tiene la tabla, sin importar ningún factor, puro azar. A posteriori, tenemos que proseguir rellenando la tabla incrementando de uno en uno el valor que tenemos, y podemos ir distribuyéndolo de forma diagonal, horizontal y vertical, es decir, podemos ir rellenando hacia arriba, abajo, los lados y diagonal, pero siempre dejando un espacio en diagonal y dos en horizontal o vertical, de forma que sería: 1xx2 (siendo x espacios libres), o en diagonal solo uno. No vale “rebotar” o “atravesar” las paredes, y si deja de haber posiciones libres, no se puede continuar, simplemente hay que empzar con una tabla nueva (o volver atrás en la actual).

Para resolver este problema he optado por fuerza bruta y puro azar en vez de recursividad por pura pereza, pero es posible hacerlo con recursividad, y de hecho no sería demasiado difícil (así que… probablemente tendréis el proyecto modificado en un futuro).

Este programa ha sido realizado en PHP, y se recomienda abrir tantas instancias de este como núcleos/hilos tenga el procesador, para acelerar el proceso. En un futuro os lo traeré en C# y/o Java y con multithreading, de forma que podréis ahorraros el trabajo de abrir múltiples instancias.

Para que funcione, debéis crear una carpeta llamada ‘soluciones’ en la raíz del programa y dentro crear un archivo llamado ‘ultima.txt’. En dicha carpeta se guardarán las soluciones en formato HTML con tablas.

Aquí tenéis un ejemplo de ensaïmada numérica generada por el programa:

Resultado al azar del programa

Resultado al azar del programa

He aquí el código: (pastebin también disponible)

<?php
/* Hecho por Martín Durán – www.maduranma.com */

echo “Buscando soluciones…\n”;
$intentos = 0;
while(true)
{
// Todos los números a 0 (para tener algo, si no ya se borrará)
for($d = 1; $d <= 100; $d++)
$r[$d] = 0;

// ¿Dónde ponemos el 1?
$intentos++;
$rs = rand(1,100);
$r[$rs] = 1;
$l = $rs; // Definimos que la última posición es dónde está el uno, hasta un futuro muy cercano

$can = true; // Para que el while continue

while($can)
{
// Obtenemos el número de posición horizontal
if(strlen($l) > 1)
$h = (substr($l, -1) == 0) ? 10 : substr($l, -1);
else
$h = $l;

// Obtenemos el número según el vertical
if(strlen($l) > 1)
if($l == 100)
$v = 10;
else
$v = ($h == 10) ? substr($l, 0, 1) : substr($l, 0, 1) + 1;
else
$v = 1;

// Ponemos que todos los valores del array $m sean true, para comprobarlos luego
for($c = 1; $c <= 8; $c++)
$m[$c] = 1;

// — Movimientos horizontales —
if($h == 8 || $h == 9 || $h == 10 || (($l + 3 > 100) ? true : (($r[$l + 3] != 0) ? true : false)))
$m[1] = 0;

if($h == 1 || $h == 2 || $h == 3 || (($l – 3 < 1) ? true : (($r[$l – 3] != 0) ? true : false)))
$m[5] = 0;

// — Movimientos verticales —
if($v == 8 || $v == 9 || $v == 10 || (($l + 30 > 100) ? true : (($r[$l + 30] != 0) ? true : false)))
$m[3] = 0;

if($v == 1 || $v == 2 || $v == 3 || (($l – 30 < 1) ? true : (($r[$l – 30] != 0) ? true : false)))
$m[7] = 0;

// — Movimiento arriba derecha —
if($h == 9 || $h == 10 || $v == 1 || $v == 2 || (($l – 18 < 1) ? true : (($r[$l – 18] != 0) ? true : false)))
$m[8] = 0;

// — Movimiento arriba izquierda —
if($h == 1 || $h == 2 || $v == 1 || $v == 2 || (($l – 22 < 1) ? true : (($r[$l – 22] != 0) ? true : false)))
$m[6] = 0;

// — Movimiento abajo derecha —
if($h == 9 || $h == 10 || $v == 9 || $v == 10 || (($l + 22 > 100) ? true : (($r[$l + 22] != 0) ? true : false)))
$m[2] = 0;

// — Movimiento abajo izquierda —
if($h == 1 || $h == 2 || $v == 9 || $v == 10 || (($l + 18 > 100) ? true : (($r[$l + 18] != 0) ? true : false)))
$m[4] = 0;

$cm = null;
$cm = array();
foreach($m as $ia => $ib)
if($ib == 1)
$cm = array_merge($cm, array($ia));

// Comprobamos que han salido movimientos
if(($cm != null) ? count($cm) >= 1 : false)
$fm = array_rand($cm); // Movimiento elegido
else
$can = false; // Aquí paramos

if($can)
foreach($cm as $ba => $bb)
if($ba == $fm)
$fm = $bb;

// Nos movemos (si podemos)
if($can)
switch($fm)
{
case 1:
$nl = ($l) + 3;
$r[$nl] = $r[$l] + 1;
$l = $nl;
break;

case 2:
$nl = ($l) + 22;
$r[$nl] = $r[$l] + 1;
$l = $nl;
break;

case 3:
$nl = ($l) + 30;
$r[$nl] = $r[$l] + 1;
$l = $nl;
break;

case 4:
$nl = ($l) + 18;
$r[$nl] = $r[$l] + 1;
$l = $nl;
break;

case 5:
$nl = ($l) – 3;
$r[$nl] = $r[$l] + 1;
$l = $nl;
break;

case 6:
$nl = ($l) – 22;
$r[$nl] = $r[$l] + 1;
$l = $nl;
break;

case 7:
$nl = ($l) – 30;
$r[$nl] = $r[$l] + 1;
$l = $nl;
break;

case 8:
$nl = ($l) – 18;
$r[$nl] = $r[$l] + 1;
$l = $nl;
break;

default:
echo ‘<script>alert(\’error\’);</script>’;
$can = false;
break;
}
}

if($r[$l]  == 100)
{
$nombre_fichero = ‘soluciones/ultima.txt’;
$gestor = fopen($nombre_fichero, ‘r’);
$contenido = fread($gestor, 11);
fclose($gestor);
$contenido = $contenido + 1;
$fp = fopen(‘soluciones/ultima.txt’, ‘w’);
fwrite($fp, $contenido);
fclose($fp);

$d = ”;
$d .= ‘<!DOCTYPE html>
<head>
<title>Soluci&oacute;n ‘ . $contenido . ‘ del circuito Hamiltoniano – Ensaimada num&eacute;rica</title>
</head>
<body style=”margin:3 0;”>
<center>
<table border=”1″ style=”font-size: 57pt;text-align: center; border: 2px solid black;” cellpadding=”2″ cellspacing=”0″>’;
for($a = 1; $a <= 10; $a++)
{
$d .= “\n\t\t\t\t<tr>”;
for($b = 1; $b <= 10; $b++)
{
$d .= “\n\t\t\t\t\t<td width=\”90\” height=\”75\” style=\”height: 89px; text-align: center; border: 2px solid black;\” >”;
$d .= ($r[(($a-1)*10)+$b] == 0) ? “\n\t\t\t\t\t\t&nbsp;” : (“\n\t\t\t\t\t\t” . $r[(($a-1)*10)+$b]);
$d .= “\n\t\t\t\t\t</td>”;
}
$d .= “\n\t\t\t\t</tr>”;
}
$d .= “\n\t\t\t</table>”;
echo “Sol. $contenido encontrada y guardada. Intentos: $intentos”;
$intentos = 0;
echo “\nBuscando soluciones…\n”;
$fp = fopen(‘soluciones/’ . $contenido . ‘.html’, ‘w’);
fwrite($fp, $d);
fclose($fp);
}
}
?>

P.D: He dejado un problema de optimización en los IFs para ver si alguien es capaz de encontrarlo, es simplemente que hay algo que no hace falta que esté. Quien lo encuentre se lleva una camiseta gratis :P


Cómo crear una Base de Datos de Hashes

¡Muy buenas amantes de la informática!
Bueno, la verdad es que ya hace siglos hice un generador de Hashes que generaba hashes en MD5 siguiendo un orden específico, el orden en cuestión era como el Excel (A, B… AZ, BA… ZZ, AAA..) pero incluyendo números y caracteres que se ponen comunmente en las contraseñas: ªº\|!@”#~$%&/()=’?

Ese generador iba metiendo todas las contraseñas en una base de datos con su respectivo hash MD5, de forma que si buscaba el hash en cuestión en la base de datos me lo devolvía desencriptado (por decirlo de alguna forma, puesto que realmente no se puede hacer eso, pero si conseguir una coincidencia a fuerza bruta, que además son infinitamente múltiples en todos los casos posibles).

El código es sencillo y os lo dejo a todos para que lo aprovechéis. En un principio hice una versión para MySQL y luego una versión Flat File. Ambos son de uso recomendado en SSDs o dispositivos de almacenamiento flash por que en discos duros es muuuuy lento y tedioso.

Código Flat File (Pastebin para mejor formato)

$c = ‘ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789ªº\\|!@”#~$%&/()=\’?’;
$k = strlen($c);
function c($n)
{
global $k, $c;
$s = ”;
$r = 1;
$b = $n;
while($b > pow($k, $r))
$b -= pow($k, $r++);
for($i = 0; $r > $i; $i++)
$s = substr($c, ($n/pow($k,$i)-1)%$k, 1) . $s;
return $s;
}

$x = scandir(‘C:\\txt’);
if($x[count($x)-1] == ‘..’)
$i = 0;
else
$i = count($x)-2;
echo number_format($i, 0, ‘.’, ‘.’);
while(true)
{
$i++;
$m = c($i);
$alg = hash_algos();
$sb = ”;
$sa = ”;
foreach(hash_algos() as $b => $al)
$sa .= hash($al, $m) . ((count(hash_algos()) > ($b + 1)) ? ‘ ‘ : ”);
file_put_contents(‘C:\\txt\\’ . $i, $m . ‘ ‘ . $sa);
if($i%1000 == 0)
echo “\n” . number_format($i, 0, ‘.’, ‘.’);
}

Código para MySQL (Pastebin para mejor formato)

$x = mysqli_connect(‘127.0.0.1’, ‘root’, ‘contraseña’, ‘db’);
$c = ‘ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789ªº\\|!@”#~$%&/()=\’?’;
$k = strlen($c);
function c($n)
{
global $k, $c;
$s = ”;
$r = 1;
$b = $n;
while($b > pow($k, $r))
$b -= pow($k, $r++);
for($i = 0; $r > $i; $i++)
$s = substr($c, ($n/pow($k,$i)-1)%$k, 1) . $s;
return $s;
}
$q = mysqli_query($x, ‘SELECT id FROM hashes ORDER BY id DESC LIMIT 1’);
if(mysqli_num_rows($q) == 0)
$i = 0;
else
{
$p = mysqli_fetch_assoc($q);
$i = $p[‘id’];
}
echo number_format($i, 0, ‘.’, ‘.’);
while(true)
{
$i++;
$m = c($i);
$alg = hash_algos();
$sb = ”;
$sa = ”;
foreach(hash_algos() as $b => $al)
{
$sb .= ‘, `’ . $al . ‘`’;
$sa .= ‘\” . hash($al, $m) . ((count(hash_algos()) > ($b + 1)) ? ‘\’,’ : ‘\”);
}
mysqli_query($x, ‘INSERT INTO hashes (`value`’ . $sb . ‘) VALUES (\” . mysqli_real_escape_string($x, $m) . ‘\’, ‘ . $sa . ‘)’);
if($i%100 == 0)
echo “\n” . number_format($i, 0, ‘.’, ‘.’);
}

El SQL que debéis hacer para crear la tabla es tan fácil como ejecutar un script con un foreach en el cual por cada valor de hash_algos() (función que viene en PHP para obtener un array que nos indica todos los tipos de hashes disponibles) cree una fila varchar 255 y listo. En cualquier caso, aquí lo tenéis:

CREATE TABLE IF NOT EXISTS `hashes` (
`id` int(11) NOT NULL,
`value` varchar(255) NOT NULL,
`md2` varchar(255) NOT NULL,
`md4` varchar(255) NOT NULL,
`md5` varchar(255) NOT NULL,
`sha1` varchar(255) NOT NULL,
`sha224` varchar(255) NOT NULL,
`sha256` varchar(255) NOT NULL,
`sha384` varchar(255) NOT NULL,
`sha512` varchar(255) NOT NULL,
`ripemd128` varchar(255) NOT NULL,
`ripemd160` varchar(255) NOT NULL,
`ripemd256` varchar(255) NOT NULL,
`ripemd320` varchar(255) NOT NULL,
`whirlpool` varchar(255) NOT NULL,
`tiger128,3` varchar(255) NOT NULL,
`tiger160,3` varchar(255) NOT NULL,
`tiger192,3` varchar(255) NOT NULL,
`tiger128,4` varchar(255) NOT NULL,
`tiger160,4` varchar(255) NOT NULL,
`tiger192,4` varchar(255) NOT NULL,
`snefru` varchar(255) NOT NULL,
`snefru256` varchar(255) NOT NULL,
`gost` varchar(255) NOT NULL,
`gost-crypto` varchar(255) NOT NULL,
`adler32` varchar(255) NOT NULL,
`crc32` varchar(255) NOT NULL,
`crc32b` varchar(255) NOT NULL,
`fnv132` varchar(255) NOT NULL,
`fnv1a32` varchar(255) NOT NULL,
`fnv164` varchar(255) NOT NULL,
`fnv1a64` varchar(255) NOT NULL,
`joaat` varchar(255) NOT NULL,
`haval128,3` varchar(255) NOT NULL,
`haval160,3` varchar(255) NOT NULL,
`haval192,3` varchar(255) NOT NULL,
`haval224,3` varchar(255) NOT NULL,
`haval256,3` varchar(255) NOT NULL,
`haval128,4` varchar(255) NOT NULL,
`haval160,4` varchar(255) NOT NULL,
`haval192,4` varchar(255) NOT NULL,
`haval224,4` varchar(255) NOT NULL,
`haval256,4` varchar(255) NOT NULL,
`haval128,5` varchar(255) NOT NULL,
`haval160,5` varchar(255) NOT NULL,
`haval192,5` varchar(255) NOT NULL,
`haval224,5` varchar(255) NOT NULL,
`haval256,5` varchar(255) NOT NULL
) ENGINE=InnoDB AUTO_INCREMENT=486089 DEFAULT CHARSET=utf8;

ALTER TABLE `hashes`
ADD PRIMARY KEY (`id`), ADD UNIQUE KEY `value` (`value`), ADD KEY `md2` (`md2`), ADD KEY `md4` (`md4`), ADD KEY `md5` (`md5`), ADD KEY `sha1` (`sha1`), ADD KEY `sha224` (`sha224`), ADD KEY `sha256` (`sha256`), ADD KEY `sha384` (`sha384`), ADD KEY `sha512` (`sha512`), ADD KEY `ripemd128` (`ripemd128`), ADD KEY `ripemd160` (`ripemd160`), ADD KEY `ripemd256` (`ripemd256`), ADD KEY `ripemd320` (`ripemd320`), ADD KEY `whirlpool` (`whirlpool`), ADD KEY `tiger128,3` (`tiger128,3`), ADD KEY `tiger160,3` (`tiger160,3`), ADD KEY `tiger192,3` (`tiger192,3`), ADD KEY `tiger128,4` (`tiger128,4`), ADD KEY `tiger160,4` (`tiger160,4`), ADD KEY `tiger192,4` (`tiger192,4`), ADD KEY `snefru` (`snefru`), ADD KEY `snefru256` (`snefru256`), ADD KEY `gost` (`gost`), ADD KEY `gost-crypto` (`gost-crypto`), ADD KEY `adler32` (`adler32`), ADD KEY `crc32` (`crc32`), ADD KEY `crc32b` (`crc32b`), ADD KEY `fnv132` (`fnv132`), ADD KEY `fnv1a32` (`fnv1a32`), ADD KEY `fnv164` (`fnv164`), ADD KEY `fnv1a64` (`fnv1a64`), ADD KEY `joaat` (`joaat`), ADD KEY `haval128,3` (`haval128,3`), ADD KEY `haval160,3` (`haval160,3`), ADD KEY `haval192,3` (`haval192,3`), ADD KEY `haval224,3` (`haval224,3`), ADD KEY `haval256,3` (`haval256,3`), ADD KEY `haval128,4` (`haval128,4`), ADD KEY `haval160,4` (`haval160,4`), ADD KEY `haval192,4` (`haval192,4`), ADD KEY `haval224,4` (`haval224,4`), ADD KEY `haval256,4` (`haval256,4`), ADD KEY `haval128,5` (`haval128,5`), ADD KEY `haval160,5` (`haval160,5`), ADD KEY `haval192,5` (`haval192,5`), ADD KEY `haval224,5` (`haval224,5`), ADD KEY `haval256,5` (`haval256,5`);

Espero que os sirva de ayuda para vuestros proyectos,
Saludos :B


maduranma’s Stresser – Generador de estrés para el procesador

Hola lectores,
Estaba en clase y me plateé qué haría falta para petar la CPU del ordenador que teníamos, así que básicamente hice un programa en C# que calculaba los cosenos de 69 (por la naturaleza del número…) infinitamente (con un bucle while), y abriendo uno por núcleo de dicho procesador conseguías ponerlo al 100% (que además con la de años que tienen y contando que en su vida se han limpiado, se han puesto a 90-100 grados los jodios…).

Código del programa absurdo

Código del programa de clase (absurdamente fácil)

Después he decicido hacer algo útil, y puesto que ya he visto programas que hacen esto, de hecho hice un tutorial en mi canal de como hacer un test de estrés (que básicamente sirve para ver la temperatura cuando le estás metiendo caña al procesador), pero el programa que usé lo encontré por internet, y tenías que abrir un programa por núcleo, y eso nos lo podríamos ahorrar si simplemente lo hubieran hecho con varios threads en C# mismamente, así que, he decidido hacerlo yo en media horita o así y me ha quedado algo bastante cuqui, por ello he decidido publicar el resultado en este blog, por supuesto será Open Source, y si veo que tiene “éxito” supongo que lo actualizaré y una posible mejora en un futuro sería añadir abajo la temperatura de todos los cores (más o menos como SpeedFan, que es un buen complemento a usar con mi programa actualmente).

Speed Fan, para ver la temperatura de la CPU

Speed Fan, para ver la temperatura de la CPU

Aún teniendo propuestas las mejoras mencionadas anteriormente, el programa cumple perfectamente con su función, y solo requiere .NET Framework 3.5 (que viene instalado por defecto desde Windows 7, y sigue siendo compatible con Windows Vista con una simple actualización). Cabe mencionar que con cualquier versión posterior también sirve.

Mi programa (maduranma's Stresser)

Mi programa (maduranma’s Stresser)

Descargar_ICONODescargas

 Descargar versión 1.0.1Directa | Mediafire | Mega.co.nz


Curso Arduino – I.Encender y apagar un LED

Hola lectores,
Bueno, cómo no sabía muy bien cómo aprovechar mi blog he decidido usarlo también para publicar algunos cursos por escrito de diferentes lenguajes y cosas relacionadas con electrónica, así que hoy empezamos con el primer ‘capítulo’ de este Cursillo de Arduino.

Para hacer un LED que se encienda o se apague con un botón se necesitan saber algunos conceptos básicos que explicaré a continuación y que nos podrán servir para otro tipo de circuitos, así como el sistema del LED para hacer una lámpara con un relé, o cualquier tipo de encendido/apagado con un botón.

Necisitarás
1x LED (de cualquier color)
1x Resistencia 220Ω (Rojo-Rojo-Marrón)
1x Resistencia 10KΩ (Marrón-Negro-Naranja)
5x Cables
1x Botón

El circuito
En este caso el circuito es muy básico, vamos a usar una protoboard para mayor comodidad. Como siempre conectaremos los 5V del Arduino al positivo de la proto y la tierra (GND) del Arduino al negativo de la protoboard (como vemos abajo en la imágen).

A continuación conectaremos un LED entre dos tiras de la protoboard. En el ánodo conectaremos un cable que irá hasta el pin 10 del Arduino y en el cátodo una resistencia que va al negativo de la protoboard.
Al final, para conectar el botón, usaremos una resistencia de 10k para evitar un cortocircuito que pueda dañar nuestro Arduino, cabe mencionar que sin ella podríamos quemarlo, además de producir una falla de modo que no podamos usar dicho botón. Para conectarlo procederemos situándolo entre dos tiras opuestas de la protoboard. En la tira de arriba pondremos un cable directo a 5V, y en la de abajo conectaremos la resistencia de 10K al negativo de la protoboard y otro cable al pin 8 de nuestro Arduino.

De esta forma ya hemos terminado nuestro circuito, debería quedarnos tal que así:

El código
El código para este simple circuito nos servirá para aprender las consecuencias del rebote de un botón y de esa forma evitarlo para futuros circuitos con un simple código y además de ello como hacer que cualquier componente electrónico se encienda/apague con tan solo un 'click' (en el botón).

Lo primero que debemos hacer es definir los pines del botón y del LED (para que sea más fácil cambiarlos en un futuro).

Ahora debemos definir tres enteros (int) que usaremos más adelante.

La variable encender sirve para saber si encender o apagar el LED cada loop.

La variable anterior es para saber la última pulsación cual fué sin contar el rebote.

La variable estado sirve para saber el estado actual del botón pasado el retraso del rebote.

Una vez definidas las variables que usaremos en el código, definimos el void setup, que como sabéis es esencial en el Sketch y es donde se suele definir de que tipo es un pin (entrada o salida).

Ojo, no se puede definir fuera del setup puesto que este sirve para ejecutar funciones iniciales, fuera se pueden definir funciones, pero no ejecutarlas, al igual que no se puede poner int algo = funcion(algo); (por poner un ejemplo).

Definimos el pin del LED como salida y el del botón como entrada.

Para continuar creamos el void loop, que es una función que se repite eternamente durante la ejecución del Arduino.
En el interior colocaremos esto:

Y con esto concluimos el código. Creo que lo que más cabe destacar es el tema de los rebotes de los botones. No es un sistema ideal antirebote, los hay mejores, pero sirve perfectamente para evitarlo y no deberíamos tener problemas con ello, ya veis que con un simple delay es suficiente.

Vídeo

Cómo sabéis, en mi canal tengo un curso de Arduino en vídeo (sin terminar), así que sí queréis experimentar más y no queréis esperar podéis ver todos los vídeos aquí :)

Espero que os haya gustado el primer ‘capítulo’ del curso de Arduino, nos vemos en el próximo post :)


Páginas:12