jueves, 19 de marzo de 2015

Timbre con arduino, sensor capasitivo y relay

bueno pues les dejo este pequeño proyecto que me encargaron, por si a alguno le ayuda en algo, el material utilizado es un relevador de un canal, un sensor touch capasitivo, un arduino y un timbre comercial inalambrico. si el sensor es tocado durante 3 segundos y se deja de tocar, el timbre se activa si son mas o menos segundos no se activa. El código es muy sencillo:


int senPin=12;
int swPin=8;
int ledCount=9;
int value=0;
int salida=0;
        int ledpw=10;
void setup(){ 
pinMode(senPin,INPUT); 
pinMode(ledPin,OUTPUT); 
pinMode(ledCount,OUTPUT);
  Serial.begin(9600);
      digitalWrite(ledpw.HIGH);

}
void loop(){  
value= digitalRead(senPin);  
  if (value==1){ 
  delay(600);   
salida=salida + 1; 
  digitalWrite(ledCount,HIGH); 
  Serial.print((int)salida); 
  digitalWrite(ledCount,LOW); 
  Serial.print("\n"); 
}  
  if (salida > 3){ 
salida=0; 
}   
delay (600); 
if (salida == 3  && value ==0)
{   
digitalWrite(swPin,HIGH); 
  Serial.print("Timbrando \n");
    delay(2000); 
  digitalWrite(swPin,LOW); 
  Serial.print("apagado \n"); 
  salida=0;  }    
}


video



video

lunes, 6 de octubre de 2014

Tablet China a5mid infotmic imapx15 q8/q88/Q8NEW (rom+tool)

Les comento que me compre una tablet china muy barata, pero después de intentar flashearla directamente con el comando dd en modo recovery y no prendió mas XD así que me di a la tarea de resucitarla.
Lo primero que hice fue abrirla para verle las tripas y saber con que me enfrentaba.
Lo único que encontré fue que tenia un procesador imapx15 de infotmic y un puerto serial
(supongo que para conectarle un bluetooth a algun otro chunche) y al ver que tenia un puerto serial me emocione y me apresure a soldar unos cables para conectarla a mi puerto serial con un adaptador que hice con un chip max232N. Con lo cual logre ver que daba signos de vida, pues prendieron los leds que indican comunicacion.
Abrí cutecom para ver si podía obtener una shell (según leí en google se podía obtener una shell de u-boot) pero nunca logre atinarle al baud rate, por lo cual abandone ese camino.
Haciendo un uso exhaustivo de google y después de haber probado todo phoenix card, uberoid, también copie y pegue miles de archivos de firmwares en la sd, y nada dio resultado.
Hasta que por fin logre encontrar una tool llamada "IUW burning tools" y logre gravar en la sd un firmware para una tablet y88

http://www.tabletexpress.com/index.php?option=com_content&view=category&layout=blog&id=10&Itemid=107

en esta pagina se encuentra el firmware y la herramienta(pc-tool) yo descargue
el "Y88-HY-4.3-201406"
Pero al flashearla me encontré con un android que solo se veía 1/4 aproximadamente de la pantalla, lo cual la hacia inutilizable pues lo que se veia en la pantalla no coincidía con el punto que estaba tocando en el touchscreen, por lo que pensé que debía ser un firmware equivocado, así que seguí buscando mas firmwares, pues ahora ya sabia que tenían que ser en formato .ius (infotmic update sistem) y me encontré con esto

http://ublaze.ru/forum/topic1291.html

un foro en ruso que con ayuda del traductor de google logre extraer otro firmaware y una herramienta similar a la del primer link, grave el firmware y otra vez no prendió, pero después de darle una re-leída a todo el post encontré esto:


para hacer la pantalla táctil, debe seleccionar las opciones de los parámetros touchscreen.exist, ts.model, ts.screen presentar items.itm

Según lo que leí a algunos no les funcionaba el touchscreen, lo cual se soluciona editando el archivo items.itm (con la tool del primer link se pueden extraer los archivos de las imagenes.ius)
Así que pensé, si se puede modificar el archivo para hacer funcionar el touch, puede que exista una opción para modificar la pantalla, y si efectivamente, existe la opción y en el firmware del primer link esta configurado para una pantalla de 10 pulgadas ( la mía es de 7 ).
Ahora solo tenia que encontrar el modelo de mi pantalla.
Seguí buscando y encontré esto:

http://www.envizendigital.com/index.php/products/con/id/70




Operating System Version: Android 4.1
Processor: INFOTMIC IMAPX15 Cortex A5@1.2GHZ
Display: 7-inch Multi-touch Screen (800*480)
Internal Flash Memory: 4GB
RAM: 512MB
Memory Expansion: Expandable with TF (SD) card (up to 32 GB)
Wireless Connectivity: Wireless N Wi-Fi (802.11b/g/n)
G-Sensor: Accelerometer, Automatic Orientation
Cameras: 0.3MP for both front and rear
Ports: Micro USB Port; DC-IN Jack ; Earphone Jack ; Micro TF Card Slot ; HDMI output
Battery: 3.7V/2500mAh

Download

User Manual
V7023D Upgrade Firmware
V7023D Upgrade Tool
V7023D Upgrade Guide


por fin encontré un fabricante de la misma tablet que proporciona un firmware y una tool para flashearla, la misma que en las demás webs pero otra versión.
Intente nuevamente flashearla sin éxito, asta ahora el único firmware que "funciono" fue el primero, pero ahora tenia un archivo items.itm con la configuración para mi tablet, intente cambiando directamente el archivo pero no funciono, pues aparentemente están echos para versiones diferentes de la tool, por lo cual extraje y modifique el del primer firmware (Y88-HY-4.3-201406) en esta parte


# InfoTM Display System
ids.pixformat       888
ids.default         lcd
ids.acm             60
lcd.model           HSD070IDW1_800x480
lcd.port            ids.0
lcd.cable           888
lcd.rgb             bgr
lcd.power.v33        pads.119

mas concreta mente cambie lo que tenia la opción

lcd.model           HSD070IDW1_800x480

Quedando así funcional para mi pantalla, ahora disfruto de un android 4.3 en mi tablet casi completamente funcional, lo único que no funciona son las cámaras, pero bueno tampoco es que me pierda de mucho (Cameras: 0.3MP for both front and rear )

Así que después de mi odisea les puedo compartir el firmware ya arreglado por si tienen una de estas tablets.






El procedimiento es muy sencillo, y se hace desde windows.
Para apagar la tablet ay que dejar el botón power presionado por 15 segundos
Se abre el ejecutable de la tool IUW.exe y aparece en chino, se cambia el idioma en la ultima opción de los menús de arriba, una vez en ingles, se abre el archivo 4.3_fixed.ius y nos aparecen los archivos que contiene le damos click al boton  "Make BurnDisc" lo cual gravara los archivos en una tarjeta microSD ( los datos que contenga la sd se perderán ) 
Cuando termine extraemos de manera segura nuestra microsd.
Con la tablet apagada se mete la microSD y se enciende la tablet y después de unos 5 minutos nos pide extraer la SD y se reinicia.
Y así logre disfrutar nuevamente de mi tablet.
Saludos y ojala le sea de utilidad a alguien esta información.


jueves, 11 de septiembre de 2014

Si la vida tuviera terminal (Humor Linuxero)

Si la vida pudiera ser manejada desde una terminal linux, abría muchas cosas que podríamos hacer sin tanto problema.
por ejemplo:

¿ No encuentras tus llaves?  tranquilo mira

ls  | grep llaves
Listo aquí estan.

o si tu auto no enciende

chmod +x tsuru_negro

Y prende al llavaso.

Si tu madre te tiene harto pidiéndote que limpies tu habitación. !Fácil!

clear
Todo limpio en un santiamén.

¿tienes que mudarte de casa? pffff pan comido

mv /home/darkspark/* /newhome/darkspark/ 
listo y sin cargar nada !bitch¡

¿Llego tu madre mientras estabas viendo tu colección de porno?  ¡no ay problema!

mv porno* ~/bajo_mi_cama/.porno*
 y todo el porno se iría bajo la cama, y aunque se asomaran por debajo, quedaría oculto. Genial¿no?. Aun que si realmente tu madre no supiera ya, donde escondes tu porno bastaría con que hiciera un

ls -la
Insisto, solo si realmente tu madre no supiera donde la escondes.


¿O si un ladrón quiere robarte tu auto?

chown ladron:lacras tsuru_negro 
y aunque lo agarráramos infraganti

sudo chown ladron:lacras tsuru_negro
 ¡Vale madre! ni las manitas podríamos meter.

!Y cualquiera podría multiplicar la comida como Jesús con un script super simple¡

for ($i=0;$i<=10000;$i++){cat pescado > pecado.$i;}

!BOOM¡ Chingo de pescado para todos. Lo del convertir el agua en vino si estaría mas cabron, pero bueno debe haber una forma... ¿no?

y para los que quisieran suicidarse por que creen que no ay vida mas allá de windows

exit





jueves, 17 de julio de 2014

De lo digital a lo material [LockPicking]

Bueno para no tener abandonado mi blog, Me gustaría compartir con ustedes una idea que me a rondando por la cabeza en los últimos meses.
Y como el titulo lo dice, esta es solo la teoría mas adelante y si el tiempo me lo permite, publicare los resultados.
Bueno, la idea surge a partir de que compre una impresora 3D (una Mendel Max 1.5).


Con estas impresoras es posible imprimir casi cualquier cosa, limitándonos solamente por nuestra imaginación y claro esta por nuestra habilidad de manejar algún software de diseño 3D como Blender (que es el que yo uso XD) pero de igual manera podemos encontrar paginas donde ay un sin fin de diseños que podemos bajar para imprimirlos directamente como thingiverse, y mejor aun de manera gratuita.
Bueno al grano.
La idea es imprimir una llave para abrir algún candado, solo seria necesario una fotografías de dicha llave como esta:




Ahora con nuestra fotografía, podemos diseñar la llave con el software 3D, para después imprimirla.
Solo quedaría probar la teoría y verificar que nuestra llave impresa funcione.
Saludos.



Actualización:

Bueno pues dejo el vídeo de la conclusión. Saludos.




viernes, 23 de agosto de 2013

Control remoto con arduino, wrt54g y android

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 3 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:

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

cd /opt
y descargamos el instalador con el comando

wget http://wd.mirmana.com/prep_optware

lo ejecutamos con

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

 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:

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


nvram set http_lanport=81
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

htttp://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

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


/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

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 )


cd /opt/share/www
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.


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


// If one keypress results in multiple codes being output, then
// change in IRremoteInt.h:
// #define _GAP 50000

#include

int RECV_PIN = 11;
IRrecv irrecv(RECV_PIN);
decode_results results;

void setup()
{
  Serial.begin(9600);
  irrecv.enableIRIn(); // Start the receiver
}

int c = 1;

void dump(decode_results *results) {
  int count = results->rawlen;
  Serial.println(c);
  c++;
  Serial.println("For IR Scope: ");
  for (int i = 1; i < count; i++) {
 
    if ((i % 2) == 1) {
      Serial.print("+");
      Serial.print(results->rawbuf[i]*USECPERTICK, DEC);
    }
    else {
      Serial.print(-(int)results->rawbuf[i]*USECPERTICK, DEC);
    }
    Serial.print(" ");
  }
  Serial.println("");
  Serial.println("For Arduino sketch: ");
  Serial.print("unsigned int raw[");
  Serial.print(count, DEC);
  Serial.print("] = {");
  for (int i = 1; i < count; i++) {
 
    if ((i % 2) == 1) {
      Serial.print(results->rawbuf[i]*USECPERTICK, DEC);
    }
    else {
      Serial.print((int)results->rawbuf[i]*USECPERTICK, DEC);
    }
    Serial.print(",");
  }
  Serial.print("};");
  Serial.println("");
  Serial.print("irsend.sendRaw(raw,");
  Serial.print(count, DEC);
  Serial.print(",38);");
  Serial.println("");
  Serial.println("");
}

void loop() {
  if (irrecv.decode(&results)) {
    dump(&results);
    irrecv.resume(); // Receive the next value
  }
------------------------------------------------------------------------------------------------------------


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í:


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í:


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í:


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.

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

#include
#include
SoftwareSerial blueToothSerial(6, 5);
//Inicia la definicion de las varables con los codigos del control remoto
IRsend irsend;
unsigned int vol_up[36] = {
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,};
unsigned int vol_do[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,200,550,250,200,200,400,250,200,200,400,200,};
unsigned int ch_up[36] = {
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,};
unsigned int ch_do[36] = {
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,};
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,};
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,};
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,};
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,};
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,};
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,};
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,};
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,};
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,};
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,};
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,};
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,};
//Terminamos de definir las variables


int RECV_PIN = 11; //el pin 11 recive la señal del receptor infrarojo
IRrecv irrecv(RECV_PIN);
decode_results results;
void setup()
{
Serial.begin(9600);
irrecv.enableIRIn(); // Start the receiver
blueToothSerial.begin(9600);
}
void loop()
{
char test;
while(1){
if(blueToothSerial.available()){
test = blueToothSerial.read();
ddwrt( test );
}
else if (Serial.available()){
test=Serial.read();
ddwrt(test);
}
}
}



void ddwrt(char test)
{
if( test == '1')
{
Serial.write("numero 1\n");
uno();
}
else if( test == '2')
{
Serial.write("numero 2\n");
dos();
}
else if ( test == '3' )
{
Serial.write("numero 3\n");
tres();
}
else if( test == '4' ){
Serial.write("numero 4\n");
cuatro();
}
else if( test == '5' ){
Serial.write("numero 5\n");
cinco();
}
else if( test == '6' ){
Serial.write("numero 6\n");
seis();
}
else if( test == '7' ){
Serial.write("numero 7\n");
siete();
}
else if( test == '8' ){
Serial.write("numero 8\n");
ocho();
}
else if( test == '9' ){
Serial.write("numero 9\n");
nueve();
}
else if( test == 'z' ){
Serial.write("z\n");
zero();
}
else if( test == 'o' ){
Serial.write("o\n");
power();
}
else if( test == 'l' ){
Serial.write("l\n");
last();
}
else if( test == 'u' ){
Serial.write("u\n");
chanmas();
}
else if( test == 'd' ){
Serial.write("d\n");
chanmenos();
}
else if( test == 'v' ){
Serial.write("v\n");
volmas();
}
else if( test == 'm' ){
Serial.write("m\n");
volmenos();
}
}
//insertamos el codigo para enviar las variables
void uno(){
irsend.sendRaw(un,36,38);
delay(40);
irsend.sendRaw(un,36,38);
delay(40);
irsend.sendRaw(un,36,38);
delay(40);
}
void dos(){
irsend.sendRaw(dot,36,38);
delay(40);
irsend.sendRaw(dot,36,38);
delay(40);
irsend.sendRaw(dot,36,38);
delay(40);
}
void tres(){
irsend.sendRaw(tre,36,38);
delay(40);
irsend.sendRaw(tre,36,38);
delay(40);
irsend.sendRaw(tre,36,38);
delay(40);
}

void cuatro(){
irsend.sendRaw(cua,36,38);
delay(40);
irsend.sendRaw(cua,36,38);
delay(40);
irsend.sendRaw(cua,36,38);
delay(40);
}
void cinco(){
irsend.sendRaw(cin,36,38);
delay(40);
irsend.sendRaw(cin,36,38);
delay(40);
irsend.sendRaw(cin,36,38);
delay(40);
}
void seis(){
irsend.sendRaw(sei,36,38);
delay(40);
irsend.sendRaw(sei,36,38);
delay(40);
irsend.sendRaw(sei,36,38);
delay(40);
}
void siete(){
irsend.sendRaw(sie,36,38);
delay(40);
irsend.sendRaw(sie,36,38);
delay(40);
irsend.sendRaw(sie,36,38);
delay(40);
}
void ocho(){
irsend.sendRaw(och,36,38);
delay(40);
irsend.sendRaw(och,36,38);
delay(40);
irsend.sendRaw(och,36,38);
delay(40);
}
void nueve(){
irsend.sendRaw(nue,36,38);
delay(40);
irsend.sendRaw(nue,36,38);
delay(40);
irsend.sendRaw(nue,36,38);
delay(40);
}
void zero(){
irsend.sendRaw(z,36,38);
delay(40);
irsend.sendRaw(z,36,38);
delay(40);
irsend.sendRaw(z,36,38);
delay(40);
}
void power(){
irsend.sendRaw(po,36,38);
delay(40);
irsend.sendRaw(po,36,38);
delay(40);
irsend.sendRaw(po,36,38);
delay(40);
}
void last(){
irsend.sendRaw(las,36,38);
delay(40);
irsend.sendRaw(las,36,38);
delay(40);
irsend.sendRaw(las,36,38);
delay(40);
}
void volmas(){
irsend.sendRaw(vol_up,36,38);
delay(40);
irsend.sendRaw(vol_up,36,38);
delay(40);
irsend.sendRaw(vol_up,36,38);
delay(40);
}
void volmenos(){
irsend.sendRaw(vol_do,36,38);
delay(40);
irsend.sendRaw(vol_do,36,38);
delay(40);
irsend.sendRaw(vol_do,36,38);
delay(40);
}
void chanmas(){
irsend.sendRaw(ch_up,36,38);
delay(40);
irsend.sendRaw(ch_up,36,38);
delay(40);
irsend.sendRaw(ch_up,36,38);
delay(40);
}
void chanmenos(){
irsend.sendRaw(ch_do,36,38);
delay(40);
irsend.sendRaw(ch_do,36,38);
delay(40);
irsend.sendRaw(ch_do,36,38);
delay(40);
}
--------------------------------------------------------------------------------------------------------------------


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.






jueves, 18 de julio de 2013

Grabador De TV

bueno les dejo este pequeño script para grabar video desde nuestra capturadora de video, espero les sea de utilidad.

Dependencias:

Perl-Tk
Mplayer



#!perl

##################
#
# This file was automatically generated by ZooZ.pl v1.2
# on Wed Jul 17 16:49:56 2013.
# Project: VideoGrab
# File:    /root/ZooZ-1.2/video.zooz
#
##################

#
# Headers
#
use strict;
use warnings;

use Tk ;
use Tk::ProgressBar;
#
# Global variables
#
my (
     # MainWindow
     $MW,

     # Hash of all widgets
     %ZWIDGETS,
    );

#
# User-defined variables (if any)
#
my $audio = undef;

my $estado = "Detenido";

my $audios= undef;

my $dispoaudio= undef;



my $desition;
######################
#
# Create the MainWindow
#
######################

$MW = MainWindow->new;

######################
#
# Load any images and fonts
#
######################
ZloadImages();
ZloadFonts ();



# Widget archivoF isa Labelframe
$ZWIDGETS{'archivoF'} = $MW->Labelframe(
   -takefocus => 0,
   -text      => 'Archivo',
  )->grid(
   -row    => 0,
   -column => 0,
   -sticky => 'ew',
  );

# Widget archivoL isa Label
$ZWIDGETS{'archivoL'} = $ZWIDGETS{archivoF}->Label(
   -takefocus => 0,
   -text      => "Nombre del Archivo\n(Sin extencion)",
  )->grid(
   -row    => 0,
   -column => 0,
  );

# Widget archivoE isa Entry
$ZWIDGETS{'archivoE'} = $ZWIDGETS{archivoF}->Entry(
   -exportselection => 1,
  )->grid(
   -row    => 1,
   -column => 0,
  );

# Widget deviceF isa Labelframe
$ZWIDGETS{'deviceF'} = $MW->Labelframe(
   -takefocus => 0,
   -text      => 'Dispositivo',
  )->grid(
   -row    => 1,
   -column => 0,
   -sticky => 'ew',
  );

# Widget deviceL isa Label
$ZWIDGETS{'deviceL'} = $ZWIDGETS{deviceF}->Label(
   -text => 'Seleccione un Dispositivo',
  )->grid(
   -row    => 0,
   -column => 0,
  );

# Widget dev_list isa Listbox
$ZWIDGETS{'dev_list'} = $ZWIDGETS{deviceF}->Listbox(
   -exportselection => 1,
   -height          => 4,
   -setgrid         => 0,
  )->grid(
   -row    => 1,
   -column => 0,
  );

# Widget accionF isa Labelframe
$ZWIDGETS{'accionF'} = $MW->Labelframe(
   -takefocus => 0,
   -text      => 'Acciones',
  )->grid(
   -row        => 2,
   -column     => 0,
   -columnspan => 2,
   -sticky     => 'ew',
  );

# Widget ButtonStart isa Button
$ZWIDGETS{'ButtonStart'} = $ZWIDGETS{accionF}->Button(
   -command => 'main::start',
   -text    => 'Grabar',
  )->grid(
   -row    => 0,
   -column => 0,
   -padx   => 20,
  );

# Widget ButtonStop isa Button
$ZWIDGETS{'ButtonStop'} = $ZWIDGETS{accionF}->Button(
   -command => 'main::stop',
   -text => 'Detener',
  )->grid(
   -row    => 0,
   -column => 1,
   -padx   => 20,
  );

# Widget ButtonExit isa Button
$ZWIDGETS{'ButtonExit'} = $ZWIDGETS{accionF}->Button(
   -command => 'main::exit',
   -text    => 'Salir',
  )->grid(
   -row    => 0,
   -column => 2,
   -padx   => 20,
  );

# Widget audioF isa Labelframe
$ZWIDGETS{'audioF'} = $MW->Labelframe(
   -takefocus => 0,
   -text      => 'Audio',
  )->grid(
   -row    => 0,
   -column => 1,
   -sticky => 'ew',
  );

# Widget audioL isa Label
$ZWIDGETS{'audioL'} = $ZWIDGETS{audioF}->Label(
   -takefocus => 0,
   -text      => 'Seleccione Una Opcion',
  )->grid(
   -row        => 0,
   -column     => 0,
   -columnspan => 2,
  );

# Widget ossB isa Radiobutton
$ZWIDGETS{'ossB'} = $ZWIDGETS{audioF}->Radiobutton(
   -command            => 'main::audio',
   -highlightthickness => 1,
   -indicatoron        => 1,
   -state              => 'normal',
   -takefocus          => 0,
   -text               => 'OSS',
   -value              => 1,
   -variable           => \$audio,
  )->grid(
   -row    => 1,
   -column => 0,
  );

# Widget alsaB isa Radiobutton
$ZWIDGETS{'alsaB'} = $ZWIDGETS{audioF}->Radiobutton(
   -command     => 'main::audio',
   -indicatoron => 1,
   -text        => 'Alsa',
   -value       => 2,
   -variable           => \$audio,
  )->grid(
   -row    => 1,
   -column => 1,
  );

# Widget estadoF isa Labelframe
$ZWIDGETS{'estadoF'} = $MW->Labelframe(
   -text => 'Estado',
  )->grid(
   -row    => 1,
   -column => 1,
   -sticky => 'nsew',
  );



# Widget estadoL isa Label
$ZWIDGETS{'estadoL'} = $ZWIDGETS{estadoF}->Label(
   -text         => 'Label3',
   -textvariable => \$estado,
  )->grid(
   -row    => 1,
   -column => 0,
  );

  
my $devices=`ls /dev | grep video`;
my @dev=split("\n" , $devices);
$ZWIDGETS{'dev_list'}->insert('end',@dev);
###############
#
# MainLoop
#
###############

MainLoop;

#######################
#
# Subroutines
#
#######################

sub ZloadImages {
}

sub ZloadFonts {
}

sub audio {

}

sub start {

my $archivo = $ZWIDGETS{'archivoE'}->get();


if ($archivo eq ""){
   $MW->messageBox(-type=>"ok", -message=>"Escriba el nombre del archivo");
   goto start;
   
   }
   

if ($audio eq 0){
   $MW->messageBox(-type=>"ok", -message=>"Seleccione una opcion de audio");
   goto start;
   }
   


my $dev=$ZWIDGETS{'dev_list'}->get($ZWIDGETS{'dev_list'}->curselection( ));


if ($dev =~ "Error"){
$MW->messageBox(-type=>"ok", -message=>"Seleccione un dispositivo de captura");
goto start;
}
 
if ($audio==1){
     $audios="adevice=/dev/dsp";
     $dispoaudio="OSS";
     }
elsif($audio==2){
$audios="alsa:adevice=hw.0";
$dispoaudio="ALSA";
}
my $rewrite=`ls ~`;
my $final="$dispoaudio-$archivo.avi";

if ($rewrite =~ "$final"){
 $desition=$MW->Dialog(-title => 'Error', 
 -text => "El archivo $final ya existe, desea sobreescribirlo?", 
 -default_button => 'No', -buttons => [ 'Si', 'No'], 
 -bitmap => 'question' )->Show( );
 if ($desition eq "No"){
goto start;
}
 
 
 
 
 }
grabar:

system("xterm -e mencoder -tv driver=v4l2:width=768:height=576:norm=NTSC:device=/dev/$dev:$audios:forceaudio:immediatemode=0 -ovc lavc -lavcopts vcodec=mpeg4:vbitrate=9000 -oac mp3lame -lameopts cbr:br=64 -o ~/$final tv:// &");
$estado="Grabando";
sleep (10);
system ("mplayer ~/$final &");
     
start:

}

sub stop {
system ("killall mencoder ; killall mplayer");
$estado="Detenido";
}

sub exit {
$MW->destroy;
}