Mandar/recibir SMS con nokia viejo

[pastito]

Estimados foristas (o foreros):

Tengo tirado desde hace años un celular viejo... un Nokia 5070, de esos tipo ladrillito... que son prácticamente indestructibles.

Un día me empezó a picar el bichito de si se podría usar con un microcontrolador, para enviar/recibir SMS, para
la aplicación que sea... por ejemplo una alarma casera. O abrir la puerta del garage remotamente... es decir, lo que
sea que se les ocurra manejar a distancia.

Hace poco me cambié a Arduino, simplemente porque adoro linux y tengo todas las herramientas, pero esto que
escribo es aplicable a PIC también.

Empecé a buscar en internet primero si valía la pena comprar el GSM shield. Pero me di cuenta que primero
está el problema de las bandas... la mayoría de los que se venden son de 900Mhz y en argentina tenemos 850Mhz
para Movistar... pocos tienen 4 bandas. Y los costos son prohibitivos... arriba de los US$60 para un shield de 4
bandas decente.

Así es que empecé a mirar mi viejito Nokia con cariño... busqué información en internet el resulta que debajo
de la batería tiene un conector de 4  contactos desde donde se puede tener acceso al FBUS. Pero... no me gustaba
tener que destripar el celular, soldarlo y perder la batería (porque estorbarían los cables)...

Buscando en eBay, contré esto:
Black CA-53 USB Data Cable CA53 for Nokia N70 N73 N80 6133 E6 3300 3250 9300

Por US$1.50 con envío incluido desde la China... lo compré hace 20 días y llegó ayer.

Lo corté al medio, guardé la parte del USB y me quedé con el conector que va al celular...
(a propósito la parte del USB tiene un chip adaptador de USB a serial que usaré en algún otro proyecto!)
la misma tiene 4 cables, que mapeándolos con un tester son: Ground,  FBUS Tx, FBUS Rx y USB.

Miré por internet y todos los proyectos tienen un MAX232... pero pensé... para qué adaptar a 5V una señal de 3,3V
si mi microcontrolador tiene serial de 3,3V también? Así es que lo conecté derecho viejo: Tx -> Rx, Rx-> Tx y ground
a ground del arduino.

Es muy simple. Aquí hay una foto:



Encontré un proyecto similar aqui y hay un proyecto de linux para Nokia que se llama gnokii (ñoqui?)
en el que hay explicación del protocolo completo e implementación en C.

Escribí un programa de test súper simple (nótese que el FBUS corre a 115200 bauds):

Código: [Seleccionar]


void write_nokia (int letra) {
  Serial1.write (letra);
}

void init_nokia() {
  int i;
 
  // Esperar un segundo a estabilizar
  delay (1000);
 
  // Enviar 128 veces 0x55 para habilitar el FBUS
  for (i = 0; i < 128; ++i) {
    write_nokia (0x55);
  }

  // Enviar peticion de version
  //  1E 00 0C D1 00 07 00 01 00 03 00 01 60 00 72 D5
  write_nokia (0x1E);
  write_nokia (0x00);
  write_nokia (0x0C);
  write_nokia (0xD1);
  write_nokia (0x00);
  write_nokia (0x07);
  write_nokia (0x00);
  write_nokia (0x01);
  write_nokia (0x00);
  write_nokia (0x03);
  write_nokia (0x00);
  write_nokia (0x01);
  write_nokia (0x60);
  write_nokia (0x00);
  write_nokia (0x72);
  write_nokia (0xD5);
}

void setup() {
  Serial.begin(9600);
  Serial1.begin(115200);
  init_nokia();
}

void loop() {
  // leer del serial 1 y mandarlo al serial 0
  if (Serial1.available()) {
    int inByte = Serial1.read();
    Serial.write(inByte);
    //Serial.print (inByte, HEX);
    //Serial.print (" ");
  }
}

Cual sería mi sorpresa que al abrir la consola serial tenía mi respuesta!!!

Código: [Seleccionar]

4V 04.22
24-05-07                                                                           
RM-167                                                                     
(c) Nokia.           Fzҕ

Funciona!!! Ahora es cuestión de, con tiempo, desenredar las tramas y escribir un software para controlarlas.

Quiero compartir este proyecto porque no sólo funciona con el 5070, sino con casi cualquier celular Nokia
viejo que tenga FBUS, incluso si no tiene el conector externo como el mío, se puede soldar los cables en el
conector que está debajo de la batería...

Calculo que varios foristas pueden inspirarse en esta simple solución y aportar ideas / código para desarrollar
por completo este proyecto. Esta toda la información disponible y por US$1.50 podemos dar uso a nuestros
viejos celulares para utilizarlo como con un microcontrolador y nuestra imaginación para darle un buen uso.


Un abrazo y agradeceré comentarios!
Pastito

[jonathanPIC888]

Muy interesante el proyecto, yo estoy trabajando con el SIM900, que es de 4 bandas y la placa de desarrollo original de SIMCOM que me salió U$S125. Voy a ver si me consigo un Nokia viejo como para hacer algunas pruebas, mientras tanto voy a pedir el cable a Ebay.

[pastito]

Muy interesante el proyecto, yo estoy trabajando con el SIM900, que es de 4 bandas y la placa de desarrollo original de SIMCOM que me salió U$S125. Voy a ver si me consigo un Nokia viejo como para hacer algunas pruebas, mientras tanto voy a pedir el cable a Ebay.

Estoy trabajando en rutinas C para empaquetar las tramas. Ya tengo algo... a medida que avance las voy a ir publicando aquí.


Saludos

[AKENAFAB]

Muhy bueno el proyecto.

Te seguiré leyendo!

Saludos!!

[pastito]

Estuve trabajando en código para empacar el texto de 7 bits en 8. No es tan simple como parece, pero aquí está y funciona correctamente.

La teoría es la siguiente. Si tenemos la cadena "Hola mundo"

Código: [Seleccionar]

Bin:  01001000  01101111  01101100  01100001  00100000  01101101  01110101  01101110  01100100  01101111
Char: H         o         l         a         " "       m         u         n         d         o
Hex:  48        6f        6c        61        20        6d        75        6e        64        6f

Como tenemos 7 bits en cada letra (nótese que cada byte empieza en 0) entonces hacemos lo siguiente:

Tomamos el ultimo bit de la letra siguiente. En este caso "o". Para obtener ese bit en un byte temporal, simplemente enmascaramos con 00000001 y usamos & (AND), mismo que preserva lo que venía donde tenemos 1 en la máscara y si hay 0, descarta lo demás. En este caso como se trata de la "o" el resultado es:

01101111 & 0000001 = 0000001

Una vez que tenemos esto, nótese que es el bit menos significativo de "o" pero tiene que transformase en el más significativo de la primera letra, o sea "H". Entonces le aplicamos desplazamiento a la izquierda (SHIFT LEFT) de 7 posiciones, para mover ese bit de la ultima a la primera posición.

0000001 << 7 = 1000000

Una vez que tenemos esto, se lo sumamos a "H", y nos queda empacado:

01001000 + 10000000 =  11001000

Después tenemos que hacer un desplazamiento a la derecha de 1 caracter (SHIFT RIGHT) a la "o", para deshacernos de este bit, puesto que ya lo hemos agregado a la letra anterior. Es decir que o es 01101111 pero como el último bit ya lo usamos, hacemos:

01101111 >> 1 = 00110111.

Después seguimos por empacar la o, para lo cual hacemos lo mismo que con la H. O sea que tomamos el caracter siguiente, o la "l", pero esta vez en vez del último bit, tomamos los dos últimos bits (aplicamos máscara de 00000011) y después el desplazamiendo a la derecha será obviamente de 2 posiciones, puesto que tenemos 2 bits usados.

Esto se repite, tomando en cuenta que en un momento al llegar a 8 iteraciones, el byte original de la derecha está vacío, lógicamente tenemos que saltarlo porque no contiene más información útil y continuar con el siguiente.

El resultado de la cadena empaquetada sería entonces:

Código: [Seleccionar]

Bin: 11001000 00110111 00111011 00001100 01101010 11010111 11011101 11100100 00110111
Dec: 200      55       59       12       106      215      221      228      55
Hex: c8       37       3b       c        6a       d7       dd       e4       37

Este es el código que importa, donde la cadena test[] es el texto a enviar y empacado[] es el empaquedado de 7 bits en 8:

Código: [Seleccionar]

  int i = 0, j = 0, k = 7;
  largo = strlen(test);

  for (i = 0; i < largo; i++) {
    if (k > 0) {
      temp = (test[i+1] & mascara[j+1]) << k;
      empacado[i] = test[i] + temp;
      test[i+1] = test[i+1] >> j+1;
     }
    
    ++j;
    --k;

    if (k == -1) {
      k = 7;
      j = 0;
    }

Este es el programa en C (gcc) que escribí para testearlo. Imprime el caracter, el hexadecimal y el binario para estar seguros de que funciona correctamente.

Código: [Seleccionar]

#include <stdio.h>
#include <limits.h>
#include <string.h>


void print_bits (unsigned char byte) {
  int i;
  unsigned char mask = 1;
  unsigned char bits[8];

  for (i = 0; i < 8; i++) {
    bits[i] = (byte >> i) & mask;
  }

  printf ("Char: %c - Hex: %0x - Decimal: %d\n", byte, byte, byte);

  printf ("Val: ");
  for (i = 7; i >= 0; i--) {
    printf ("%d",bits[i]);
  }
  printf ("\n\n");
}


int main (void) {
  int largo, i, j = 0, k =7;
  unsigned char x,y, res, temp;
  
  char test[] = "Hola mundo";
  char empacado[200];
  char mascara[] = {0, 1, 3, 7, 15, 31, 63, 127, 255};
  
  printf ("\n");

  for (i = 0; i < strlen(test); i++) {
    print_bits (test[i]);
  }

  printf ("\n--------Empacado------------\n\n");

  largo = strlen(test);

  for (i = 0; i < largo; i++) {
    if (k > 0) {
      temp = (test[i+1] & mascara[j+1]) << k;
      empacado[i] = test[i] + temp;
      
      test[i+1] = test[i+1] >> j+1;
      print_bits (empacado[i]);
    }
    
    ++j;
    --k;

    if (k == -1) {
      k = 7;
      j = 0;
    }
  }

  return 0;
}

Una vez solucionado esto, en el próximo post voy a comenzar a empaquetar la trama para enviar un SMS...

Espero comentarios, opiniones y correcciones o sugerencias... si se les ocurre un código más fino que a mi...


Saludos