Translate

miércoles, 16 de mayo de 2018

Botón de Xiaomi para conexión a Arduino

Hola,

Sois muchos los que os habéis interesado por el articulo del Arduino para activar las cámaras o la alarma de Xioami. Muchos sois los que me habéis peguntado por la modificación que hay que aplicarle al botón para sacar esos 2 cables y conectarlos al Arduino.



Pues bien, aquí os dejo los pasos a seguir para hacerlo.

Primero hay que desarmar el botón al completo dese la parte trasera hasta sacar la plaquita.



En esta placa es donde soldaremos 2 cables el lado del botón central. Exactamente en los puntos que os señalo en la imagen:


Aquí hay que soldar los cables:



Una vez soldados los cables, hay que montar de nuevo la placa en su carcasa:


Y en la tapa quitarle un trocillo para dejar hueco para que los cables salgan al exterior y no molesten en el hueco de la pila:


Es una operación sencilla que os puede llevar sobre unos 20 minutos aproximadamente.


Saludos

jueves, 19 de abril de 2018

Instalar Windows 10 Pro en Ordenador con Licencia Home en la BIOS

Últimamente estamos viendo un montón de marcas que nos venden los portátiles con la licencia de windows 10 grabada en la bios, y a la hora de instalar el windows 10 no deja elegir si queremos instalar la versión pro o la home. Directamente nos instalará la versión home.



Para poder hacer un USB de Windows 10 o DVD booteable que nos permita elegir la versión que queremos instalar y no coja la licencia de la BIOS debemos meterle a ese USB o DVD un archivo que nos permitirá ver este menú de selección.

Simplemente es el archivo ei.cfg. Os dejo los pasos a seguir.




PenDrive Booteable
Debeis ir a la herramienta oficial de Windows (Media Creation Tool) y crear un pendrive con ella. Un vez creado ese pendrive simplemente es ir a la carpeta x86/sources y a la carpeta x64/sources y dejar en ambas el archivo ei.cfg

Ese archivo que podemos crear con el bloc de notas debe contener simplemente 2 lineas:
[Channel]
Retail

DVD Booteable
Debéis ir a la herramienta oficial de Windows (Media Creation Tool) y crear una iso con ella. Un vez creada esa iso debéis ir a la carpeta sources y dejar en ella el archivo ei.cfg. Para modificar una ISO como esta debéis usar el programa Ultra ISO que podéis encontrar por internet.

Ese archivo que podemos crear con el bloc de notas debe contener simplemente 2 lineas:
[Channel]
Retail

Una vez tengáis un CD o Pendrive con esta deslimitación siempre os va a preguntar que versión queréis instalar.

lunes, 2 de abril de 2018

Arduino para activación de alarma automáticamente al llegar a casa

Muchos de nosotros tenemos alarma en casa, o sistemas de grabación o alguna tarea que queremos automatizar al llegar al domicilio o al irnos. Gracias a esos dispositivos conocidos como arduino esta tareas va a ser algo muy sencillo.

El articulo que hoy os dejo es un tutorial de construcción de un arduino para automatizar estas tareas.

Vamos a trabajar con un arduino mega, la verdad que por el tamaño del programa serviría el arduino one (el normal) pero va muy justo de memoria y me dió muchos problemas de estabilidad. Sin embargo lo probé con el arduino mega y no llega al 20% de ocupación del equipo y lo hace muy estable. Así que vamos a descartar la opción del arduino normal y vamos a escoger el mega directamente.



Así mismo precisaremos una tarjeta de red ethernet para este dispositivo, conocida como Arduino Ethernet Shield.

Además precisaremos un relé que será el que active físicamente la alarma o  lo que sea que queramos controlar.

Estos 3 dispositivos los podemos comprar en aliexpress en menos de 12€

Además de este material podría ser necesario una tarjeta micro SD si queréis enviar algún comando por red a algún servidor etc... y un led verde y uno rojo si queréis que se encienda una luz según el estado del dispositivo para que visualmente sepáis en que estado está... luego os lo explicaré mas en detalle.

El conexionado es sencillo, la tarjeta de red se monta encima del arduino y el relé tiene 3 pines. Dos son de alimentación que se cogerá directamente del arduino del pin de 5 voltios. Y el ultimo pin del relé es el de control que se conectará a una de las salidas digitales.





Como podéis observar le he puesto 2 leds para saber el estado del equipo. Y desde el relé he sacado 2 cables al botón de control inalámbrico de mi alarma. En esté caso la alarma es de XIOAMI pero sería aplicable a cualquier otra que tenga un botón o mando de activación donde poder puentear el botón de ON/OFF.

Podéis ver un vídeo de su funcionamiento:



La configuración que tiene es un clic para activar la larma y doble click para desactivarla. Pero podéis cambiar en el código del arduino esto dejar un click simple siempre o lo que preciseis.

Además comentar que he implementado también la opción de que envíe un archivo con un comando de msdos a un ftp. Esto es opcional y si no lo vais a usar es mejor comentar este código en el archivo del arduino. La idea es que además de la activación de la alarma físicamente podamos enviar algún comando a un servidor de red que lo ejecute. Yo dejo un archivo con el comando que quiero ejecutar en un FTP de un servidor de mi red interna de casa y en ese servidor tengo un programa que monitoriza continuamente la carpeta, en cuanto aparece en ella un archivo lo abre ejecuta su contenido y después lo borra de dicha carpeta. Así este pequeño programa va a interpretar todas las ordenes que provengan del arduino como si se tratase de comandos de msdos. Por ejemplo me sirve para dar orden a las cámaras de grabación de que comiencen a grabar o se muevan etc...

El código que he utilizado es este:
#include <ICMPPing.h>
#include <util.h>
#include <SD.h>
#include <SPI.h>
#include <Ethernet.h>
#include <avr/wdt.h>
#include <Arduino.h>

#define FTPWRITE

/* Parametros conexion a FTP */
IPAddress server(172, 16, 0, 2);
static char* User_of_FTP = "USER arduino_cams" ;
static char* Password = "PASS admin";
const int port = 21;


/* Parametros control */
#define OUPUT_PIN_LED_RED 8 // LED rojo, alarma conectada
#define OUPUT_PIN_LED_GREEN 9 // LED verde, alarma desconectada
#define OUPUT_PIN_ALARM 7 // Control del relé
int button_delay = 150; // Tiempo de espera de simulacion de doble click para el bonton inalambrico

/* Parametros internos del programa */
bool _FIRST_TIME_AWAY = true;
bool _FIRST_TIME_IN = true;
int resetPin = 2;
int counter = 0;
long long _time = 0;
char buffer [128];
char outBuf[128];
char outCount;
char* fileName = "file.txt";
String res ;
SOCKET pingSocket = 0;
File fh;
ICMPPing ping(pingSocket, (uint16_t)random(0, 255));
EthernetClient client;
EthernetClient dclient;

/* ----------------------------------------------------------------------------------------- */
/* ----------------------------------------------------------------------------------------- */
/* ----------------------------------------------------------------------------------------- */
void setup()
{
  pinMode(OUPUT_PIN_LED_RED, OUTPUT);
  pinMode(OUPUT_PIN_LED_GREEN, OUTPUT);
  pinMode(OUPUT_PIN_ALARM, OUTPUT);

  /* Siempre iniciamos con LED en verde y suponiendo alarma desactivada */
  digitalWrite(OUPUT_PIN_LED_GREEN, HIGH);
  digitalWrite(OUPUT_PIN_ALARM, HIGH);

  /* Pasamos el boton reset de arduino al reset de la ethernet */
  digitalWrite(2, HIGH);
  delay(200);
  pinMode(2, OUTPUT);
 
  /* Conexion a la tarjeta Ethernet*/
  Serial.begin(9600);
  digitalWrite(10,HIGH);

  /* Condiguracion de la SD */
  if(SD.begin(4) == 0)
  {
    Serial.println(F("Fallo en el inicio de la SD"));       
    digitalWrite(resetPin, LOW);
  }
  else
  {
    Serial.println(F("SD iniciada correctamente"));       
  }

  /* Levantamos la tarjeta Ethernet por DHCP*/
  byte mac[] = { 0x90, 0x89, 0x88, 0x88, 0x89, 0x90 }; // Se puede cambiar la mac del arduino cambiado estos parametros
  if (Ethernet.begin(mac) == 0)
  {
    Serial.println("Ha fallado el DHCP a la hora de asignar IPs");
    digitalWrite(resetPin, LOW);
  }
  digitalWrite(10,HIGH);
  delay(200);

  /* Impresion por pantalla de la IP recibida por DHCP */
  Serial.print("IP del arduino ");
  Serial.println(Ethernet.localIP());
}

/* ----------------------------------------------------------------------------------------- */
/* ----------------------------------------------------------------------------------------- */
/* ----------------------------------------------------------------------------------------- */
void loop()
{
  IPAddress ip_1( 172, 16, 0, 29 );              // IP 29 Android
  IPAddress ip_2( 172, 16, 0, 21 );              // IP 21 iPhone
  /* Se pueden añadir tantas ips como moviles a vigilar tengamos, habria que añadirlas tambien abajo en el if */
  IPAddress tester( 8, 8, 8, 8 );                // IP de test, solo activará la alarma si hay internet por si la wifi está caida o con mal funcionamiento evitamos activaciones inecesarias

  if((_ping(ip_1)) || (_ping(ip_2)))             // Ping a las ips definidas unas pocas lineas mas arriba ((_ping(ip_1)) || (_ping(ip_2)) || (_ping(ip_3)) || (_ping(ip_4)))
  {
     _time = millis();                           // Guardamos en la variable el tiempo actual en el que estamos
   
     Serial.println("Hay gente en casa...");     // Imprimimos en pantalla el mensaje
   
     if(_FIRST_TIME_IN)                          // Comprobamos que es la primera vez que hay alguien en casa
     {
        _FIRST_TIME_AWAY = true;                 // Reinicializamos la variable de primera vez que no hay nadie en casa a TRUE
        _FIRST_TIME_IN = false;                  // Reinicializamos la variable de primera vez que hay alguien en casa a FALSE
        digitalWrite(OUPUT_PIN_LED_GREEN, HIGH); // Encedemos el led Verde
        digitalWrite(OUPUT_PIN_LED_RED, LOW);    // Apagamos el led Rojo
        disarm_alarm();                          // Llamamos a la funciona de desactivar la alarma por rele
        res = "\"C:\\Script_Synology Surveillance Station Home Mode - Windows 10 32bits\\home_mode_on.bat\""; // Comando de activacion de alarma para grabacion de camaras
        Send_To_FTP(res);                        // Envio al FTP del comando anterior para su ejecución (Si no usamos FTP este punto se puede comentar)
     }
  } else if((millis()-_time > 420000) && (_ping(tester))) // Si el ping falla a todos los equipos para decir que no hay nadie en casa
  {                                                       // vamos a comprobar que no hay nadie durante x milisegundos (ej. 7 min = 420000)
                                                          // asi evitamos que por una breve desconexion del movil no se active la alarma
                                                          // y que además con la ip de test verificaremos que la red funciona bien y que internet no está caido                                                       
    Serial.println("No ha nadie en casa...");    // Imprimimos en pantalla el mensaje
 
    if(_FIRST_TIME_AWAY)                         // Comprobamos que es la primera vez que no hay nadie en casa
    {
      _FIRST_TIME_AWAY = false;                  // Reinicializamos la variable de primera vez que no hay nadie en casa a FALSE
      _FIRST_TIME_IN = true;                     // Reinicializamos la variable de primera vez que hay alguien en casa a TRUE
      digitalWrite(OUPUT_PIN_LED_RED, HIGH);     // Encedemos el led Rojo
      digitalWrite(OUPUT_PIN_LED_GREEN, LOW);    // Apagamos el led Verde
      arm_alarm();                               // Llamamos a la funciona de activar la alarma por rele
      res = "\"C:\\Script_Synology Surveillance Station Home Mode - Windows 10 32bits\\home_mode_off.bat\""; // Comando de desactivacion de alarma para grabacion
      Send_To_FTP(res);                          // Envio al FTP del comando anterior para su ejecución (Si no usamos FTP este punto se puede comentar)
    }
  }
  delay(2000);                                   // Esperamos 2 segundos para volver a iniciar el bucle
}

/* ----------------------------------------------------------------------------------------- */
/* ----------------------------------------------------------------------------------------- */
/* ----------------------------------------------------------------------------------------- */
bool Send_To_FTP(String payload)
{
  File dataFile = SD.open("file.txt", FILE_WRITE);
  if (dataFile)
  {
    dataFile.seek(0);
    for(int j=0; j<190; j++)
    {
      dataFile.print(" ");
    }
    dataFile.seek(0);
    dataFile.print(payload);
    dataFile.close();
    Serial.println("Archivo abierto y escrito correctamente en la SD");
    if(doFTP()){ Serial.println(F("FTP OK")); }
    else
    {
      Serial.println(F("Fallo de FTP"));
      digitalWrite(resetPin, LOW);
    }
  }
  else
  {
    Serial.println("Error abriendo file.txt");
    digitalWrite(resetPin, LOW);
  }
}

/* ----------------------------------------------------------------------------------------- */
/* ----------------------------------------------------------------------------------------- */
/* ----------------------------------------------------------------------------------------- */
bool _ping(IPAddress _target)
{
  bool ans = false;
  ICMPEchoReply echoReply = ping(_target, 1);
  if (echoReply.status == SUCCESS)
  {
    ans = true;
    Serial.print("El ping a la IP es OK - ");
    sprintf(buffer,
            "Respuesta num [%d] desde: %d.%d.%d.%d: bytes=%d time=%ldms TTL=%d",
            echoReply.data.seq,
            echoReply.addr[0],
            echoReply.addr[1],
            echoReply.addr[2],
            echoReply.addr[3],
            REQ_DATASIZE,
            millis() - echoReply.data.time,
            echoReply.ttl);
  }
  else
  {
    ans = false;
    sprintf(buffer, "El ping a la IP es KO - %d", echoReply.status);
  }
  Serial.println(buffer);
  return ans;
}


/* ----------------------------------------------------------------------------------------- */
/* ----------------------------------------------------------------------------------------- */
/* ----------------------------------------------------------------------------------------- */
void arm_alarm()
{
  digitalWrite(OUPUT_PIN_ALARM, LOW);
  delay(button_delay);
  digitalWrite(OUPUT_PIN_ALARM, HIGH);
}

/* ----------------------------------------------------------------------------------------- */
/* ----------------------------------------------------------------------------------------- */
/* ----------------------------------------------------------------------------------------- */
void disarm_alarm()
{
  digitalWrite(OUPUT_PIN_ALARM, LOW);
  delay(button_delay);
  digitalWrite(OUPUT_PIN_ALARM, HIGH);
  delay(button_delay);
  digitalWrite(OUPUT_PIN_ALARM, LOW);
  delay(button_delay);
  digitalWrite(OUPUT_PIN_ALARM, HIGH);
}

/* ----------------------------------------------------------------------------------------- */
/* ----------------------------------------------------------------------------------------- */
/* ----------------------------------------------------------------------------------------- */
byte doFTP()
{
  Serial.println("Iniciando subida al FTP...");
  #ifdef FTPWRITE
  fh = SD.open(fileName,FILE_READ);
  #else
  SD.remove(fileName);
  fh = SD.open(fileName,FILE_WRITE);
  #endif

  if(!fh)
  {
    Serial.println(F("Fallo al Abrir la SD"));
    return 0; 
  }

  #ifndef FTPWRITE
  if(!fh.seek(0))
  {
    Serial.println(F("Fallo Rewind"));
    fh.close();
    return 0; 
  }
  #endif

  Serial.println(F("SD abierta..."));

  if (client.connect(server,21)) {
    Serial.println(F("Comando de conexion"));
  }
  else {
    fh.close();
    Serial.println(F("Fallo en el comando de conexion"));
    return 0;
  }
  if(!eRcv()) return 0;
  client.println(F("USER arduino"));
  client.println(User_of_FTP);
  if(!eRcv()) return 0;
  client.println(Password);
  if(!eRcv()) return 0;
  client.println(F("SYST"));
  if(!eRcv()) return 0;
  client.println(F("Type I"));
  if(!eRcv()) return 0;
  client.println(F("PASV"));
  if(!eRcv()) return 0;
  char *tStr = strtok(outBuf,"(,");
  int array_pasv[6];
  for ( int i = 0; i < 6; i++)
  {
    tStr = strtok(NULL,"(,");
    array_pasv[i] = atoi(tStr);
  }
  unsigned int hiPort,loPort;
  hiPort = array_pasv[4] << 8;
  loPort = array_pasv[5] & 255;
  Serial.print(F("Data port: "));
  hiPort = hiPort | loPort;
  if (dclient.connect(server,hiPort))
  {
    Serial.println(F("Data connected"));
  }
  else
  {
    Serial.println(F("Data connection failed"));
    client.stop();
    fh.close();
    return 0;
  }
  #ifdef FTPWRITE
  client.print(F("STOR "));
  client.println(fileName);
  #else
  client.print(F("RETR "));
  client.println(fileName);
  #endif
  if(!eRcv())
  {
    dclient.stop();
    return 0;
  }

#ifdef FTPWRITE
  Serial.println(F("Writing"));

  byte clientBuf[128];
  int clientCount = 0;

  while(fh.available())
  {
    clientBuf[clientCount] = fh.read();
    clientCount++;

    if(clientCount > 127)
    {
      dclient.write(clientBuf,128);
      clientCount = 0;
    }
  }

  if(clientCount > 0) dclient.write(clientBuf,clientCount);

#else
  while(dclient.connected())
  {
    while(dclient.available())
    {
      char c = dclient.read();
      fh.write(c);   
      Serial.write(c);
    }
  }
#endif

  dclient.stop();
  Serial.println(F("Data disconnected"));

  if(!eRcv()) return 0;

  client.println(F("QUIT"));

  if(!eRcv()) return 0;

  client.stop();
  Serial.println(F("Command disconnected"));

  fh.close();
  Serial.println(F("SD closed"));
  return 1;
}

/* ----------------------------------------------------------------------------------------- */
/* ----------------------------------------------------------------------------------------- */
/* ----------------------------------------------------------------------------------------- */
byte eRcv()
{
  byte respCode;
  byte thisByte;
  while(!client.available()) delay(1);
  respCode = client.peek();
  outCount = 0;
  while(client.available())
  {
    thisByte = client.read(); 
    Serial.write(thisByte);
    if(outCount < 127)
    {
      outBuf[outCount] = thisByte;
      outCount++;   
      outBuf[outCount] = 0;
    }
  }
  if(respCode >= '4')
  {
    efail();
    return 0;
  }
  return 1;
}

/* ----------------------------------------------------------------------------------------- */
/* ----------------------------------------------------------------------------------------- */
/* ----------------------------------------------------------------------------------------- */
void efail()
{
  byte thisByte = 0;
  client.println(F("QUIT"));
  while(!client.available()) delay(1);
  while(client.available())
  {
    thisByte = client.read(); 
    Serial.write(thisByte);
  }
  client.stop();
  Serial.println(F("Comando de desconexion"));
  fh.close();
  Serial.println(F("Cierre de SD"));
  delay(20);
  digitalWrite(resetPin, LOW);
}

/* ----------------------------------------------------------------------------------------- */
/* ----------------------------------------------------------------------------------------- */
/* ----------------------------------------------------------------------------------------- */
void readSD()
{
  fh = SD.open(fileName,FILE_READ);
  if(!fh)
  {
    Serial.println(F("Fallo al abrir la SD"));
    return; 
  }
  while(fh.available())
  {
    Serial.write(fh.read());
  }
  fh.close();
}




viernes, 30 de marzo de 2018

Iniciar un script y vigilarlo que esté activo continuamente

Muchas veces utilizáis scripts que deben estar activos continuamente 24/7/365 bien sea realizando tareas o monitorizando algo.

El script que hoy os traigo se encarga de vigilar que determinado proceso esté activo y en el caso de que se cierre lo vuelve a abrir.

Es un proceso simple pero que viene muy bien en determinadas situaciones.



¿Como debéis manejar este vigilante? Pues muy sencillo, debéis crear un acceso directo a su .exe y ponerlo en el startup de windows (shell:startup). Donde tenéis el .exe encontrareis un starter.ini que es donde debéis configurar los programas que lanzará y vigilará que estén siempre activos.

[PROGRAMS]
prog1 = C:\Script_Pinger\pinger.exe
prog2 = C:\Script_Envio\PingIPandSendMail_Latest.exe
prog3 =


En cada una de las lineas debéis poner los programas a monitorizar, por cierto no tiene limite podéis ir añadiendo tantas lineas como preciséis utilizar.
prog4 =
prog5 =
prog6 =

Lo he programado en 2 versiones, una de ellas abre los programas en ventana normal y la otra les aplica la propiedad de abrirlos minimizados para que no molesten y solo se vean en la barra inferior. Tal vez este último sea el mas útil, pero os dejo ambos para su descarga:
- Iniciar y Vigilar programas en ventana minimizada:
https://drive.google.com/open?id=1mXcPcc6FpNLPbwmD9G6XKFJiCNI9_l1-

Espero que os sirva para vuestros equipos

Saludos

sábado, 17 de marzo de 2018

Programa para Activar una alarma/camaras cuando te vas de casa...

Hoy os traigo un sencillo programa pero que os puede ser muy útil.

Su funcionamiento es muy simple, vigila continuamente una lista de IPs que le pongáis en el fichero de configuración. En dicho fichero debéis poner las IPs de los móviles de la gente que vive en el domicilio. Para que funcione correctamente lo mejor es que en el router pongáis reglas según la mac del dispositivo y asignéis siempre a los móviles unas ips fijas en casa.



El caso es que este programa va a vigilar dichas IPs y cuando en casa no quede ninguna de ellas ejecutará un comando de MS-DOS en windows. Es decir, ese comando puede ser lo que necesitéis, activación de alarmas, activación de grabación de cámaras, movimiento de cámaras a una posición determinada, etc... incluso si lo unís con el programa que pusimos hace unos días para NAS synology os podrá dar mucho juego (http://www.blog.spyfly.es/2018/01/synology-surveillance-station-home-mode.html).

En el momento que alguno de los móviles regresa al domicilio y el programa detecta que responde a alguna de la lista de IPs envía otro comando, que seria el desactiva la alarma, para la grabación, etc...

De esta manera no precisáis poner y quitar las alarmas cuando entráis o salís de casa, todo se hará de forma automática con tu móvil, ya que este se conecta a la wifi de vuestra casa en cuanto estáis cerca de ella.

El fichero de configuración es sencillo:

[SETTINGS]
ip_list = 172.16.0.29,172.16.0.21 (Aquí se pone las ips de los móviles)
people_home = "C:\Script\home_mode_on.bat" (Comando a ejecutar cuando hay gente en casa)
home_alone = "C:\Script\home_mode_off.bat" (Comando a ejecutar cuando todos se van de casa)
time_to_repeat = 1 (La tarea se repite cada 1 minutos)
times_for_home_alone = 3 (Tiene que darse el caso de que existan 3 intentos fallidos para que se reconozca que el móvil no está en casa, para que no existan falsas alarmas de que por alguna perdida de paquetes inicié la alarma)
num_pings = 40 (Es el num de paquetes con el que se ejecuta el ping, lo normal suelen ser 4 pero lo he subido hasta 40 porque los móviles no suelen estar siempre conectados a la wifi, para ahorrar energía solo se conectan cada x segundos y aumentando a 40 paquetes estará un buen rato comprobando el ping y así detectará el móvil aunque se desconecte de vez en cuando)
allowUnreachable = False (Parámetro de desarrollo, no usar ni cambiar)

El programa os lo podéis descargar de aquí:
https://drive.google.com/open?id=1bJ2A97FXOWwDdzraHM1UJwNTBmj76MTy

Y usarlo donde preciséis...
No olvidéis contarnos que se os ocurre y en que situaciones utilizareis este programa.

domingo, 11 de marzo de 2018

Enviar Mail al Ejecutar un archivo .exe

Hola, aquí os dejo un pequeño script que se encarga de enviar un mail a la ejecución de un archivo .exe

Para que os puede servir, pues por ejemplo para ponerlo en el inicio de un ordenador y saber aquí si alguien lo enciende cuando vosotros no estáis. O si debe estar siempre encendido y alguien lo reinicia, etc..



La verdad es que la funcionalidad es sencilla pero aplicaciones todas las que se os ocurran.

Hay un archivo de configuración donde debéis poner los datos del mail que uséis para los avisos de este tipo. Los mails se mandan a la misma cuenta desde la que se envían y en el asunto se puede especificar lo que se quiera configurándolo en el archivo config.

Podéis bajarlo de aquí:
https://drive.google.com/open?id=1S7mC_LbRphyHxzssdwgJn2DqsvpGost9

y usarlo donde preciseis

sábado, 24 de febrero de 2018

Manual Extraer TOKEN de un producto XIAOMI para usar su API desde Android (Sin Root)

1. Habilitar en el dispositivo Android el modo desarrollador y la depuración USB y conectarlo al Ordenador

Descomprimir
Ir por el cmd de Windows al directorio donde hemos descomprimido el SDK Platform Tools y ejecutar adb backup -noapk com.xiaomi.smarthome -f backup.ab
En el dispositivo Android aceptar la copia de seguridad sin meterle password


Se crear un archivo en esa misma ruta que se llama bakckup.ab (Unos 30 megas)
Y en el dispositivo Android sale un mensaje de que la copia es correcta
3.       Descargar ADB Backup Extractor (https://sourceforge.net/projects/adbextractor/)
Descomprimirlo
Copiar el archivo de la copia de seguridad bakckup.ab a la carpeta recién descomprimida donde se ecuentra el archivo abe.jar (ADB Backup Extractor\android-backup-tookit\android-backup-extractor\android-backup-extractor-20180203-bin)
Ir a esa misma ruta desde el CMD de Windows y ejecutar
java.exe -jar abe.jar unpack backup.ab backup.tar
se creará un archivo en esa misma ruta que se llama backup.tar (unos 50 megas)
4.       Descomprimir el archivo backup.tar y veremos que aparece la base de datos miio2.db de la APP de xioami en la ruta backup\apps\com.xiaomi.smarthome\db
5.       Instalamos el programa DB Browser para SQLite (http://sqlitebrowser.org/) y lo abrimos. Arrastramos la BBDD a este programa y se abrirá.
Vamos a la pestaña ejecutar SQL y en la ventana pegamos el sig texto:
select token from devicerecord where localIP is "172.16.0.51"
Le damos al PLAY

Y en la ventana inferior nos muestra el TOKEN, podemos copiarlo con el raton.
NOTA: En lugar de sacar solo un token podemos sacar todos los de la SQL según su ip en una tabla con:
select token, localIP from devicerecord
Copiando todas las filas y las columnas podréis pegarlo en un Excel y contar que es de 32 caracteres para aseguraros de que es lo que buscáis.
En el Excel podéis contar el número de caracteres con =LARGO(A2)


viernes, 23 de febrero de 2018

Extraer TOKEN de un producto XIAOMI para usar su API desde IOS (Sin JailBreak)


1.       Hacer copia de seguridad del iphone con itunes en mono no cifrado


2.       Instalar el programa iBackup Viewer (http://www.imactools.com/iphonebackupviewer/)
Abrir el iBackup Viewer y seleccionar la última copia de seguridad (No debe tener un candado en ella)
Seleccionar estructura RAW


Seleccionar estructura de directorio


Buscar la carpeta: AppDomain-com.xiaomi.mihome, dentro tiene las carpetas library y Documents. En la derecha seleccionaremos Documents y la exportamos a nuestro PC (Por ejemplo al escritorio)


Nos crea la carpeta com.xiaomi.mihome que dentro tiene la Documents
Buscamos dentro de Documents el archivo xxxxxxxxxxxxx_mihome.sqlite (donde xxxxx es el núm. de ID de mi cuenta de Xioami que aparece en la parte de perfil de la APP de mi home)
3.       Instalamos el programa DB Browser para SQLite (http://sqlitebrowser.org/) y lo abrimos. Arrastramos la BBDD a este programa y se abrirá.
Vamos a la pestaña ejecutar SQL y en la ventana pegamos el sig texto:
select ZTOKEN from ZDEVICE where ZLOCALIP is "172.16.0.51"
Le damos al PLAY


Y en la ventana inferior nos muestra el TOKEN, podemos copiarlo con el raton.
NOTA: En lugar de sacar solo un token podemos sacar todos los de la SQL según su ip en una tabla con:
select ZTOKEN,ZLOCALIP from ZDEVICE
Copiando todas las filas y las columnas podréis pegarlo en un Excel.
Las versiones viejas de la app Mi HOME devuelve un token de 32 caracteres. Ese es el token que buscáis. Mientras que las apps nuevas de MI HOME devuelven en este caso un token de 96 caracteres, es un token cifrado que requiere hacer un paso extra.
En el Excel podéis contar el número de caracteres con =LARGO(A2)
4.       Vete a la URl http://aes.online-domain-tools.com/
Y para cada token que precises podrás descomprimirlo desde ella. Solo has de configurarla así:

** Input type: text
Input text (hex): your 96 character key
Selectbox Plaintext / Hex: Hex
Function: AES
Mode: ECB
Key (hex): 00000000000000000000000000000000
Selectbox Plaintext / Hex: Hex





Y en la parte inferior nos mostrará el token de 32 caracteres que buscamos. Aparece abajo en el cuadro de la derecha las 2 primeras líneas.



Podéis pegarlo es un TXT y luego al Excel y contar que es de 32 caracteres para aseguraros de que es lo que buscáis.

Si buscas otras opciones para sacar el token como por ejemplo un ios con jailbreak, un android, etc... no dejes de visitar el link https://github.com/jghaanstra/com.xiaomi-miio/blob/master/docs/obtain_token.md

Saludos

sábado, 17 de febrero de 2018

Programa de monitorizacion de equipos siempre encendidos

Posiblemente muchos de vosotros tengáis en vuestra RED de casa o de empresa equipo que siempre deben mantenerse encendidos. Me vienen por ejemplo a la mente equipos como:
- Camaras IP de vigilancia
- Grabadores de Camaras
- NAS
- Arduinos de monitorización
- Servidores
- Equipos de compartir impresoras o escaners
- Controles de infrarrojos
- Routers o puntos de accceso
- Equipos de mineria
Y cualquier cosa similar.



Pues aquí os dejo un programa de cosecha propia que se encargará de monitorizar este tipo de equipos y en el caso de que alguno esté mas de X minutos caído te mandará un correo electrónico.

Funciona bajo windows sin problema.

Seguirá enviando cada X minutos continuamente un mail hasta lo que volváis a encender.

Lo que hace el programa es hacer ping a esos equipos y si detecta X intentos de ping sin respuesta a  es cuando envía el mail. Para ello los equipos deben tener siempre la misma IP bien por que tengan IP fija o por que en el DHCP del router siempre se les asigna la misma por su MAC.

El programa lo podéis bajar de aquí:

https://drive.google.com/open?id=1xDfdLyT2UbSv7GEh5zUtzX0ukkxmWGnz

Y para ponerlo a funcionar solo debéis configurar el archivo config.ini del cual os dejo un ejemplo de como podría ser su configuración.

[SETTINGS]
name = IntelStickPiso_IPsSiempreOnApagadas
ip_list =172.16.0.49,172.16.0.48,172.16.0.41,172.16.0.40,172.16.0.36,172.16.0.35,172.16.0.34,172.16.0.33,172.16.0.32,172.16.0.31,172.16.0.27,172.16.0.25,172.16.0.20,172.16.0.18,172.16.0.17,172.16.0.16,172.16.0.15,172.16.0.14,172.16.0.13,172.16.0.12,172.16.0.11
time_to_repeat = 5
times_for_home_alone = 3
num_pings = 3
allowUnreachable = False
user = xxxxxxxxxxxxxxxxx@gmail.com
pass = xxxxxxxxxxxxxxxxx
smtp = smtp.gmail.com
port = 465
ssl = yes

* name será lo que se manda en el asunto junto con la IP caída.
* ip_list es la lista de IPs a vigilar que deben estar siempre encendidas
* time_to_repeat es el tiempo en minuto que espera el script hasta volver a ejecutarse
* times_for_home_alone es el num de intentos para determinar que un equipo está caído y no generar falsas alarmas
* num_pings es el num de paquetes que se utilizan en cada ping, 3 es lo habitual pero se puede subir si es necesairo
*allowUnreachable no utilizar es una variable usada en el desarrollo, no tiene ningún uso.

Llamad al .exe en el inicio de windows. Para esto debéis abrir la ventana de ejecutar (Win+R) y escribir shell:startup. Se os abrirá la carpeta de inicio de Windows y debéis crear en ella un acceso directo al .exe del programa. Así se llamará en el arranque de windows.



sábado, 27 de enero de 2018

Synology Surveillance Station Home Mode desde comando API

Si eres un poseedor de un equipo NAS de Synology que utilizas para grabación de cámaras IP con el complemento Surveillance Station tal vez quieras activar o desactivar el home mode desde algún ordenador, o similar...

 

Home mode por defecto solo se puede activar desde la página web de propio NAS o con la APP desde un móvil con geovalla. Yo probé y geovalla no va demasiado bien, en mi caso entraba en casa y no activaba el home mode.Se supone que Geovalla sirve para activar y desactivar home mode cuando se entra y se sale de casa... Así que me decidí a activarlo y desactivarlo externamente pero no encontraba forma alguna... hasta que vi que existe una API con la que poder comunicar ordenes de este estilo.

 

Sin mas ni mas me puse a crear un pequeño script que sirviese para activar o desactivar home mode con la ejecución de un simple .exe Os dejo el programa para su descarga, veréis que está compuesto por 3 archivos, un .ini de configuración y 2 .exe para activar y desactivar el home mode. Funciona bajo windows sin problema.

32 bits: https://drive.google.com/open?id=15iJ80YqO4PSP8w3qVjZ9aDnp12uxvM6_
64 bits: https://drive.google.com/open?id=1rtOmhavcja3eySdcyh_FwlVZA_5s-SkA


Si tenéis dudas podéis preguntar lo que necesitéis.