comment
IRC Chat
play_arrow
Este sitio utiliza cookies propias y de terceros. Si continúa navegando consideramos que acepta el uso de cookies. OK Más Información.

[Tutorial] Control remoto con arduino, wrt54g y android

  • 2 Respuestas
  • 3646 Vistas

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado DarkSpark

  • *
  • Underc0der
  • Mensajes: 67
  • Actividad:
    0%
  • Reputación 0
    • Ver Perfil
    • el blog de darkspark
« en: Agosto 23, 2013, 03:10:46 pm »
Debido a que la compañía con la que tengo contratada la televisión de paga, quería cobrar una tarifa extra cada mes, por ponerme otro decodificador. Decidí buscar la manera de evitarme este gasto, la respuesta me la dio una pequeña placa electrónica llamada arduino. En conjunto con un router Linksys wrt54g y mi teléfono celular con android.
La idea es poder cambiar de canal  en el decodificador sin tener que ir al cuarto donde este se encuentra.
Por medio de dos interfaces diferentes, una pagina web alojada en el wrt54g y también por medio de una aplicación para android utilizando el bluetooth para enviar las señales. Las 2 funcionan independientemente de la otra, osea que podrán seguir este tutorial ya sea para solo la interfaz web o solo para la app de android. o para ambas. Por la misma razón este tutorial estará dividido en 2 partes.


WRT54G

para esta parte necesitaremos lo siguiente:

* un router linksys wrt54g ,obviamente , ¿quien esta escribiendo este tutorial?  Previamente flasheado con DD-WRT
* una tarjeta SD no mayor a 2G ( mas grande puede que no nos la reconozca )
* un cable IDE que ya no nos sirva ( separaremos 7 cables )
* cautin y soldadura
* una tira de pin-headers (opcional pues podemos soldar cables directamente) como estos:



*mucha paciencia

Empezaremos por  particionar nuestra tarjeta SD. Para esto podemos utilizar Gparted. Necesitamos al menos 2 particiones ya que el router nos montara la primera partición en /mmc durante el arranque y no podremos utilizarla para nuestro propósito. En mi caso utilice 3 particiones, la primera de 100Mb formateada con ext2, la segunda de 64Mb formateada como SWAP y la tercera el resto de la tarjeta formateada con ext2.
Una vez que tengamos nuestra SD particionada, procedemos a soldar los 7 cables extraídos del cable IDE.
Adjunto una imagen para poder consultar los pines posteriormente:





Ya teniendo nuestros cables soldados a la tarjeta SD,abrimos el router ( pueden buscar en Internet como abrirlo )
Una vez abierto procederemos a ubicar los puntos donde soldaremos los cables,estos puntos pueden variar dependiendo la version de nuestro router, en mi caso es V2.0 por lo que los pines se ubican en los siguientes puntos:


el primero CS ( chip select ) se encuentra en el led DMZ



Los siguientes tres puntos se encuentran en un pequeño componte ( RP3 ) con 6 pequeñas patas muy cerca de uno de los chips mas grandes, el primero DI ( data input ) es la primera patita del lado izquierdo, el segundo CLK ( clock ) es la segunda pata del lado derecho y el tercero  DO ( data output ) es la tercer pata del lado derecho:





Los últimos 3 puntos se encuentran en el puerto serial que también utilizaremos para comunicarnos con el arduino.
el primero GND ( tierra ) puede ser cualquiera de los dos ultimos pines del puerto serial ( pines 9 y 10 ) en los que conectaremos los cables 3 y 6. Por ultimo VDD que es el pin 1 del puerto serial ( el único cuadrado )



Antes de cerrar nuestro router, procedemos a soldar los pin-headers al puerto serial en los pines 3 y 5 que son Tx y Tr respectivamente y el pin 9 que es tierra ( solo necesitamos esos tres para poder crear una conexión serial con el arduino ).
Para verificar que la tarjeta SD fue reconocida correctamente por el router podemos prenderlo y prestar atención al led DMZ, si durante el arranque parpadea quiere decir que la detecto, y si tenemos suerte no tendremos que modificar nada en la interfaz web del router. para verificar que realmente esta activada la SD, accedemos a la interfaz web de DD-WRT y nos vamos al apartado de Administración.
Activamos el uso de MMC/SD y ponemos los pines GPIO en manual para configurarlos de la siguiente manera:



Una ves configurado esto, reiniciamos el router para verificar que todo este bien, para esto nos debe aparecer la cantidad de Mb libres y en uso. Y aprovechamos para activar el servidor SSH para poder instalar optware en nuestra tarjeta SD.
En la misma pestaña de Administracion le damos click a la pestaña Diagnostico, y en el cuadro de texto ponemos el siguiente comando:

Código: Text
  1. mount /dev/mmc/disk0/part3

con esto nos montara automáticamente nuestra partición en /opt, en mi caso es la 3.
reiniciamos el router y verificamos que la partición se monto, entrando al router por SSH y ejecutando el comando "df"




Es hora de instalar OPTware. Nos ubicamos en el directorio /opt con el comando

Código: Text
  1. cd /opt

y descargamos el instalador con el comando

Código: Text
  1. wget http://wd.mirmana.com/prep_optware

lo ejecutamos con

Código: Text
  1. sh  prep_optware

En este punto podemos descansar un rato, pues la instalación tardara algún tiempo.
NOTA: El router debe tener acceso a Internet para poder descargar lo necesario.

Una vez finalizada la instalación de OPTware reiniciamos el router y esperamos uno o dos minutos para darle tiempo a OPTware de cargar y procedemos a instalar nuestro servidor web para montar la pagina que controlara al arduino.

Ejecutamos el comando

Código: Text
  1. ipkg list | grep http



Como pueden ver, e subrayado el paquete que nos interesa, es un servidor web con soporte para PHP que es el lenguaje que utilizaremos para mandar las ordenes al arduino.
Lo instalamos con el comando:

Código: Text
  1. ipkg install php-thttpd

Una vez instalado necesitamos cambiar de puerto a la interfaz web de DD-WRT al puerto 81 para poder montar nuestro servidor en el puerto 80, esto se logra fácilmente con los comandos

Código: Text
  1. nvram set http_lanport=81
  2. nvram commit

Reiniciamos nuevamente el router y verificamos que la interfaz web cambio de puerto, abriendo en nuestro navegador web la dirección del router

http://192.168.1.1:81

Antes de iniciar nuestro servidor vamos a configurarlo, editando el archivo "/opt/etc/thttpd.conf"  ya sea con vi o podemos instalar nano ( ipkg install nano ).
Modificamos la opción

Código: Text
  1. dir=/opt/share/www

para ubicar la raiz de nuestro servidor en el lugar donde queramos, en mi caso la deje en donde viene por default.
guardamos los cambios y ahora si es tiempo de ejecutar nuestro servidor con el comando

Código: Text
  1. /opt/etc/init.d/S80thttpd start

 Ahora es tiempo de crear nuestro index, podemos hacerlo de varias maneras, con vi o nano por SSH, o como lo hice yo, lo edite en la PC para después mandarlo al router por SSH.

Descargar archivo index.php+imagenes

Contenido del archivo index.php



Descargamos las imágenes y el index. Procedemos a subir los archivos al router con el comando en la PC

Código: Text
  1. scp /ruta/del/archivo/web.zip root@192.168.1.1:/opt/share/www

Una vez copiado al router por SSH descomprimimos el archivo web.zip con el comando
( por SSH )

Código: Text
  1. cd /opt/share/www
  2. unzip web.zip


Entramos en el navegador a nuestra nueva web y veremos algo como esto:





Y con esto terminamos la parte del router.

Andoid

Para esta parte solo necesitamos un navegador web.
Bueno para crear nuestra app necesitamos entrar a appinventor con una cuenta google

http://appinventor.mit.edu/

creamos un nuevo proyecto y añadimos lo que necesitemos.
Solo ay que arrastrar lo que queremos de la columna "Palette"  a la columna "Viewer".



Es importante señalar que añadí el modulo para cliente bluetooth. Una vez tengamos todo lo que necesitamos le damos click en "open block editor" nos descargara un archivo el cual ejecutamos con  con iced tea.
Les dejo la captura de mis blocks



Lo importante es el botón de conectar. Como se puede observar en la imagen, cree una variable global llamada MAC con el mac adress de del dispositivo bluetooth al que nos vamos a conectar ( el que ira conectado al arduino ).
También podemos ver como configure el botón para conectarnos, los demás botones son solo envió de texto que procesaremos con el arduino.
Una vez terminada nuestra app podemos descargar la app a la pc, obtener el código QR para descargarla con el teléfono o bien conectar el teléfono a la pc e instalar la app directamente.
( podría dejarles el link de mi app pero solo funciona para mi bluetooth )

Arduino

Para esta parte necesitaremos lo siguiente:

* Una placa arduino ( yo tengo la UNO-R3 ) y su cable usb
* Un modulo bluetooth para arduino
* El resto de nusetros pin-headers ( opcional )
* Un receptor infrarojo
* Un led emisor infrarojo
* Una placa tipo protoboard como cualquiera de estas ( opcional )
* Soldadura y cautin ( opcional )
* Cable delgado
* El control remoto del aparato que vamos a controlar
* El programa ( IDE ) para crear sketch de arduino
* Las librerias IRremote para arduino

Vamos a armar nuestro circuito de la siguiente manera:



Explico mas o menos las conexiones por si no se aprecia bien en la imagen.

del lado izquierdo tenemos el receptor infrarojo, que se conecta a negativo y positivo respectivamente y el pin de salida se conecta al pin 11 del arduino.

Al centro en la parte superior tenemos el modulo bluetooth que se conecta a negativo y positivo respectivamente, Tx y Rx se conectan a los pines 5 y 6 del arduino respectivamente.

Por ultimo a la derecha tenemos el emisor infrarojo, el pin negativo del diodo se conecta a tierra y el positivo al pin 3 del arduino.

Ya tenemos nuestro circuito armado, ahora vamos a averiguar los códigos de las teclas del control remoto, para eso utilizaremos este sketch que encontré por la red.


------------------------------------------------------------------------------------------------------------


Código: Text
  1. // If one keypress results in multiple codes being output, then
  2. // change in IRremoteInt.h:
  3. // #define _GAP 50000
  4.  
  5. #include
  6.  
  7. int RECV_PIN = 11;
  8. IRrecv irrecv(RECV_PIN);
  9. decode_results results;
  10.  
  11. void setup()
  12. {
  13.   Serial.begin(9600);
  14.   irrecv.enableIRIn(); // Start the receiver
  15. }
  16.  
  17. int c = 1;
  18.  
  19. void dump(decode_results *results) {
  20.   int count = results->rawlen;
  21.   Serial.println(c);
  22.   c++;
  23.   Serial.println("For IR Scope: ");
  24.   for (int i = 1; i < count; i++) {
  25.  
  26.     if ((i % 2) == 1) {
  27.       Serial.print("+");
  28.       Serial.print(results->rawbuf[i]*USECPERTICK, DEC);
  29.     }
  30.     else {
  31.       Serial.print(-(int)results->rawbuf[i]*USECPERTICK, DEC);
  32.     }
  33.     Serial.print(" ");
  34.   }
  35.   Serial.println("");
  36.   Serial.println("For Arduino sketch: ");
  37.   Serial.print("unsigned int raw[");
  38.   Serial.print(count, DEC);
  39.   Serial.print("] = {");
  40.   for (int i = 1; i < count; i++) {
  41.  
  42.     if ((i % 2) == 1) {
  43.       Serial.print(results->rawbuf[i]*USECPERTICK, DEC);
  44.     }
  45.     else {
  46.       Serial.print((int)results->rawbuf[i]*USECPERTICK, DEC);
  47.     }
  48.     Serial.print(",");
  49.   }
  50.   Serial.print("};");
  51.   Serial.println("");
  52.   Serial.print("irsend.sendRaw(raw,");
  53.   Serial.print(count, DEC);
  54.   Serial.print(",38);");
  55.   Serial.println("");
  56.   Serial.println("");
  57. }
  58.  
  59. void loop() {
  60.   if (irrecv.decode(&results)) {
  61.     dump(&results);
  62.     irrecv.resume(); // Receive the next value
  63.   }
  64. }

------------------------------------------------------------------------------------------------------------

lo cargamos al arduino y con el control remoto presionamos alguna tecla, lo que buscamos son 2 cosas, la variable que contiene el código que queremos enviar, que se ve mas o menos así:

Código: Text
  1. unsigned int raw[36] = {450,250,200,200,200,550,250,350,250,350,250,200,200,250,200,250,200,250,200,550,200,550,200,400,200,550,250,200,200,250,200,250,200,400,200,};

en algún editor de texto como kwrite o gedit guardamos las variables que vamos a utilizar pero las modificamos para que queden mas o menos así:

Código: Text
  1. unsigned int uno[36] = {450,250,200,200,200,550,250,350,250,350,250,200,200,250,200,250,200,250,200,550,200,550,200,400,200,550,250,200,200,250,200,250,200,400,200,};

en este caso presione el botón 1 y a la variable le asigne el nombre "uno". Esto se logra  sustituyendo "raw" por el nombre que le queremos poner.

ahora buscamos el código para enviar las señales almacenadas en nuestras variables. Se ve mas o menos así:

Código: Text
  1. irsend.sendRaw(raw,36,38);

Y al igual que con nuestras variables solo modificamos "raw" y ponemos el nombre de la variable que queremos enviar.
Ya que tenemos todos los datos necesarios. Vamos a cargar un nuevo sketch.

--------------------------------------------------------------------------------------------------------

Código: Text
  1. #include
  2. #include
  3. SoftwareSerial blueToothSerial(6, 5);
  4. //Inicia la definicion de las varables con los codigos del control remoto
  5. IRsend irsend;
  6. unsigned int vol_up[36] = {
  7. 450,250,150,250,200,550,250,350,200,400,250,200,200,250,200,250,200,250,200,550,200,550,200,400,200,550,200,250,200,400,200,250,200,250,200,};
  8. unsigned int vol_do[36] = {
  9. 450,250,200,250,200,550,200,400,200,400,200,250,200,200,200,250,200,250,200,550,200,550,200,400,200,550,250,200,200,400,250,200,200,400,200,};
  10. unsigned int ch_up[36] = {
  11. 450,250,200,250,200,550,200,400,200,400,200,250,200,250,200,250,150,250,200,550,200,550,250,400,200,550,200,250,200,550,200,250,200,250,150,};
  12. unsigned int ch_do[36] = {
  13. 450,250,200,250,200,550,200,400,200,400,200,250,200,250,150,300,150,250,200,250,200,550,200,400,200,550,200,250,200,550,200,250,200,400,200,};
  14. unsigned int un[36] = {450,250,200,200,200,550,250,350,250,350,250,200,200,250,200,250,200,250,200,550,200,550,200,400,200,550,250,200,200,250,200,250,200,400,200,};
  15. unsigned int dot[36] = {450,250,200,250,200,550,200,400,200,400,200,250,200,200,200,300,150,250,200,250,200,550,200,400,200,550,200,250,200,250,200,250,200,550,200,};
  16. unsigned int tre[36] = {450,250,200,250,200,550,200,400,200,400,200,250,200,250,200,250,150,250,200,550,250,500,250,350,250,550,200,250,200,250,200,200,200,750,200,};
  17. unsigned int cua[36] = {500,200,200,250,200,550,200,400,200,400,200,250,250,200,200,250,200,200,200,250,200,550,200,400,200,550,250,200,200,250,200,400,200,250,200,};
  18. unsigned int cin[36] = {450,250,200,250,200,550,200,400,200,400,200,250,200,250,200,200,200,250,200,550,200,550,250,350,250,550,200,250,200,200,200,400,200,400,200,};
  19. unsigned int sei[36] = {450,250,200,250,200,550,200,400,200,400,200,250,200,250,200,250,150,250,200,250,200,550,200,400,200,550,250,200,200,250,200,400,200,550,200,};
  20. unsigned int sie[36] = {450,250,200,200,200,550,250,350,250,350,250,200,200,250,250,250,150,250,200,550,200,550,200,400,200,550,250,200,200,250,200,400,200,700,250,};
  21. unsigned int och[36] = {450,250,200,250,200,550,200,400,200,400,200,250,200,250,200,200,200,250,200,250,200,550,200,400,200,550,200,250,200,250,200,550,200,250,200,};
  22. unsigned int nue[36] = {450,250,200,250,200,550,200,400,200,400,200,250,200,200,200,250,200,250,200,550,200,550,200,400,250,550,200,250,200,200,200,550,250,350,250,};
  23. unsigned int z[36] = {450,250,200,250,200,550,200,400,200,400,200,250,200,250,150,250,200,250,200,250,200,550,200,400,200,550,200,250,200,250,200,250,200,200,200,};
  24. unsigned int po[36] = {500,200,200,250,200,550,200,400,200,400,200,250,200,250,200,250,200,200,250,500,250,550,200,400,200,550,200,250,200,250,200,700,200,250,250,};
  25. unsigned int las[36] = {450,250,200,250,200,550,200,400,200,400,200,250,200,200,200,250,200,250,200,250,200,550,200,400,200,550,200,250,200,250,200,550,200,550,200,};
  26. //Terminamos de definir las variables
  27.  
  28.  
  29. int RECV_PIN = 11; //el pin 11 recive la señal del receptor infrarojo
  30. IRrecv irrecv(RECV_PIN);
  31. decode_results results;
  32. void setup()
  33. {
  34. Serial.begin(9600);
  35. irrecv.enableIRIn(); // Start the receiver
  36. blueToothSerial.begin(9600);
  37. }
  38. void loop()
  39. {
  40. char test;
  41. while(1){
  42. if(blueToothSerial.available()){
  43. test = blueToothSerial.read();
  44. ddwrt( test );
  45. }
  46. else if (Serial.available()){
  47. test=Serial.read();
  48. ddwrt(test);
  49. }
  50. }
  51. }
  52.  
  53.  
  54.  
  55. void ddwrt(char test)
  56. {
  57. if( test == '1')
  58. {
  59. Serial.write("numero 1\n");
  60. uno();
  61. }
  62. else if( test == '2')
  63. {
  64. Serial.write("numero 2\n");
  65. dos();
  66. }
  67. else if ( test == '3' )
  68. {
  69. Serial.write("numero 3\n");
  70. tres();
  71. }
  72. else if( test == '4' ){
  73. Serial.write("numero 4\n");
  74. cuatro();
  75. }
  76. else if( test == '5' ){
  77. Serial.write("numero 5\n");
  78. cinco();
  79. }
  80. else if( test == '6' ){
  81. Serial.write("numero 6\n");
  82. seis();
  83. }
  84. else if( test == '7' ){
  85. Serial.write("numero 7\n");
  86. siete();
  87. }
  88. else if( test == '8' ){
  89. Serial.write("numero 8\n");
  90. ocho();
  91. }
  92. else if( test == '9' ){
  93. Serial.write("numero 9\n");
  94. nueve();
  95. }
  96. else if( test == 'z' ){
  97. Serial.write("z\n");
  98. zero();
  99. }
  100. else if( test == 'o' ){
  101. Serial.write("o\n");
  102. power();
  103. }
  104. else if( test == 'l' ){
  105. Serial.write("l\n");
  106. last();
  107. }
  108. else if( test == 'u' ){
  109. Serial.write("u\n");
  110. chanmas();
  111. }
  112. else if( test == 'd' ){
  113. Serial.write("d\n");
  114. chanmenos();
  115. }
  116. else if( test == 'v' ){
  117. Serial.write("v\n");
  118. volmas();
  119. }
  120. else if( test == 'm' ){
  121. Serial.write("m\n");
  122. volmenos();
  123. }
  124. }
  125. //insertamos el codigo para enviar las variables
  126. void uno(){
  127. irsend.sendRaw(un,36,38);
  128. delay(40);
  129. irsend.sendRaw(un,36,38);
  130. delay(40);
  131. irsend.sendRaw(un,36,38);
  132. delay(40);
  133. }
  134. void dos(){
  135. irsend.sendRaw(dot,36,38);
  136. delay(40);
  137. irsend.sendRaw(dot,36,38);
  138. delay(40);
  139. irsend.sendRaw(dot,36,38);
  140. delay(40);
  141. }
  142. void tres(){
  143. irsend.sendRaw(tre,36,38);
  144. delay(40);
  145. irsend.sendRaw(tre,36,38);
  146. delay(40);
  147. irsend.sendRaw(tre,36,38);
  148. delay(40);
  149. }
  150.  
  151. void cuatro(){
  152. irsend.sendRaw(cua,36,38);
  153. delay(40);
  154. irsend.sendRaw(cua,36,38);
  155. delay(40);
  156. irsend.sendRaw(cua,36,38);
  157. delay(40);
  158. }
  159. void cinco(){
  160. irsend.sendRaw(cin,36,38);
  161. delay(40);
  162. irsend.sendRaw(cin,36,38);
  163. delay(40);
  164. irsend.sendRaw(cin,36,38);
  165. delay(40);
  166. }
  167. void seis(){
  168. irsend.sendRaw(sei,36,38);
  169. delay(40);
  170. irsend.sendRaw(sei,36,38);
  171. delay(40);
  172. irsend.sendRaw(sei,36,38);
  173. delay(40);
  174. }
  175. void siete(){
  176. irsend.sendRaw(sie,36,38);
  177. delay(40);
  178. irsend.sendRaw(sie,36,38);
  179. delay(40);
  180. irsend.sendRaw(sie,36,38);
  181. delay(40);
  182. }
  183. void ocho(){
  184. irsend.sendRaw(och,36,38);
  185. delay(40);
  186. irsend.sendRaw(och,36,38);
  187. delay(40);
  188. irsend.sendRaw(och,36,38);
  189. delay(40);
  190. }
  191. void nueve(){
  192. irsend.sendRaw(nue,36,38);
  193. delay(40);
  194. irsend.sendRaw(nue,36,38);
  195. delay(40);
  196. irsend.sendRaw(nue,36,38);
  197. delay(40);
  198. }
  199. void zero(){
  200. irsend.sendRaw(z,36,38);
  201. delay(40);
  202. irsend.sendRaw(z,36,38);
  203. delay(40);
  204. irsend.sendRaw(z,36,38);
  205. delay(40);
  206. }
  207. void power(){
  208. irsend.sendRaw(po,36,38);
  209. delay(40);
  210. irsend.sendRaw(po,36,38);
  211. delay(40);
  212. irsend.sendRaw(po,36,38);
  213. delay(40);
  214. }
  215. void last(){
  216. irsend.sendRaw(las,36,38);
  217. delay(40);
  218. irsend.sendRaw(las,36,38);
  219. delay(40);
  220. irsend.sendRaw(las,36,38);
  221. delay(40);
  222. }
  223. void volmas(){
  224. irsend.sendRaw(vol_up,36,38);
  225. delay(40);
  226. irsend.sendRaw(vol_up,36,38);
  227. delay(40);
  228. irsend.sendRaw(vol_up,36,38);
  229. delay(40);
  230. }
  231. void volmenos(){
  232. irsend.sendRaw(vol_do,36,38);
  233. delay(40);
  234. irsend.sendRaw(vol_do,36,38);
  235. delay(40);
  236. irsend.sendRaw(vol_do,36,38);
  237. delay(40);
  238. }
  239. void chanmas(){
  240. irsend.sendRaw(ch_up,36,38);
  241. delay(40);
  242. irsend.sendRaw(ch_up,36,38);
  243. delay(40);
  244. irsend.sendRaw(ch_up,36,38);
  245. delay(40);
  246. }
  247. void chanmenos(){
  248. irsend.sendRaw(ch_do,36,38);
  249. delay(40);
  250. irsend.sendRaw(ch_do,36,38);
  251. delay(40);
  252. irsend.sendRaw(ch_do,36,38);
  253. delay(40);
  254. }

--------------------------------------------------------------------------------------------------------------------


Lo cargamos al arduino, y ya tenemos todo listo, ponemos el emisor infrarrojo
frente al aparato que controlaremos.



y con un cable largo lo conectamos al arduino, yo utilice la linea telefónica que no utilizo.









ya teniendo todo armado, solo es cuestión de probar, en mi caso el router lo tengo como repetidor wifi de mi modem 2wire que es e que me provee de Internet. así que solo tengo que conectarme a la red wifi del router y presionar algún botón para probar.
En el caso del teléfono tenemos que vincular el bluetooth directamente desde los ajustes de android, y después ejecutar nuestra app para cambiar de canal.


FUENTE http://elblogdedarkspark.blogspot.mx/2013/08/control-remoto-con-arduino-wrt54g-y.html
« Última modificación: Noviembre 11, 2014, 06:17:32 pm por ANTRAX »

Conectado ANTRAX

  • *
  • Administrator
  • Mensajes: 5409
  • Actividad:
    16.67%
  • Reputación 33
  • ANTRAX
    • Ver Perfil
    • Underc0de
    • Email
  • Skype: underc0de.org
  • Twitter: @Underc0de
« Respuesta #1 en: Agosto 23, 2013, 03:16:35 pm »
Terrible aporteeeeeeee!!!
muy muy buenoooo!!


Desconectado Striker

  • *
  • Underc0der
  • Mensajes: 10
  • Actividad:
    0%
  • Reputación 0
  • Informatica Forense
    • Ver Perfil
« Respuesta #2 en: Agosto 24, 2013, 08:30:13 pm »
Uff men te lucistes jajaja  ;D muy completo todo me encanto este tutorial aun no le he podido descrubir un solo error en esta publicacion
muy bueno ¡

 

¿Te gustó el post? COMPARTILO!



Crea tu Medidor de Humedad con Conexion a Android --Hagalo Usted Mismo--

Iniciado por rreedd

Respuestas: 3
Vistas: 2494
Último mensaje Abril 12, 2016, 03:32:38 pm
por EPSILON
Tutorial Raspberry Pi - Cómo crear un punto de acceso WiFi

Iniciado por Stiuvert

Respuestas: 3
Vistas: 2342
Último mensaje Noviembre 04, 2017, 06:04:24 am
por Stiuvert
Arduino + Snap4Arduino "Hola Mundo"

Iniciado por Riojas

Respuestas: 1
Vistas: 1869
Último mensaje Febrero 19, 2017, 09:31:50 pm
por rreedd
Arduino + Snap4Arduino "Juego PONG" [Parte1]

Iniciado por Riojas

Respuestas: 0
Vistas: 1364
Último mensaje Febrero 24, 2017, 04:59:07 pm
por Riojas
Arduino + Snap4Arduino "Juego PONG" [Parte2]

Iniciado por Riojas

Respuestas: 0
Vistas: 1122
Último mensaje Marzo 03, 2017, 07:07:08 pm
por Riojas