Hacer llamada mediante linea fija(rj11) con arduino

Hola, soy nuevo en arduino y me gustaria saber si es posible realizar llamadas mediante una linea convencional de telefono fijo(rj11) con arduino??
He visto muchos casos pero todos con modulos GSM o WiFi, ninguno con linea fija, el mayor inconveniente que encuentro con las llamadas GSM es el mantener con saldo no vencido un chip ya que serian llamadas muy esporádicas debido a que se pretende solo como servicio de alarma en caso de una eventualidad en un site

Su publicacion se MUEVE a su ubicacion actual ya que es mas adecuada.

Si, poder se puede aunque la circuitería que deberías agregar puede ser algo complicada según sean tus conocimientos de electrónica.
Lo más simple sería generar los pulsos de discado si la central de la compañía telefónica los admite, de lo contrario debes recurrir a más circuitería para generar los tonos DTMF.
Habría que investigar si hay alguna/s librería/s que faciliten la tarea del lado del código.

Te sugiero que busques con Google "arduino phone dialer" o algo similar, seguramente vas a tener buenos resultados.

Saludos

Primero agradecer la ayuda!
Si, esa busqueda ya me guió por mejores resultados, aunque ya veo que es un poco más complicado de lo que tenía presupuestado y sin agregar que hay algunos temas legales en el uso de dispositivos no certificados sobre las lineas fijas.
Ahora lo q se me ocurre es basarme en algún telefono de marca ya hecho y simular las pulasiones de las teclas mediante arduino para realizar la llamada, conoces algún proyecto referente a este punto ?

Aca tienes un tutorial que pueda servirte.
Enfócate en el MT8870D que es el integrado que hace todas las funciones. mas alla que el tutorial usa un viejo telefono como teclado, puedes implementarlo desde el monitor serie y ahi tienes cómo hacerlo.
https://www.instructables.com/My-old-phone-arduino-phonoduino/

Muchas gracias Surbyte
En efecto, creo que ese proyecto me sirve de base para lo que pretendo.
He encontrado algunas diferencias, por ejemplo en ese proyecto las pulsaciones de cada una de las teclas aterriza el pin correspondiente(digamos al presionar el # 1 ese pin se aterriza a tierra), teniendo así todos los números uno de los dos polos(extremos o no se como llamarlos) en común que es la tierra.
En mi caso, el teléfono fijo no funciona igual, aca el # 1 cierra circuito con otro pin de otro #, digamos; uno de los 2 polos que conforman el # 5. Ya no tienen cada uno de los numeros un polo en común que es la tierra en el otro proyecto y.....
Ps en eso estoy, viendo como lo solvento
Desafortunadamente mis conocimientos en electrónica no son suficientes pero lo que si es que estoy aprendiendo mucho y es algo para agadecer, así que les hago llegar mis mas sinceros agradecimientos por su apoyo

Creo que no comprendiste la idea.
El proyecto gira entorno al DTMF decoder IC (M-8870) y en el código se ve una opción que te permite digitar un número terminado por una , y podras hacer la llamada


int key0 = 16;
int key1 = 6;
int key2 = 12;
int key3 = 9;
int key4 = 5;
int key5 = 15;
int key6 = 10;
int key7 = 14;
int key8 = 13;
int key9 = 18;
int keyStar = 17;
int keyOk = 11;
int keyClear = 3;
int keyDown = 4;
int keyUp = 8;
int keyOff = 2;
int keyHash = 19;

int pressTime = 100;
int pressDelay = 300;
int holdTime = 1000;
int typeTime = 100;
int typeDelay = 400;

int value[16] = {16,6,12,9,5,15,10,14,13,18,17,11,3,4,8,2};
char number[12];
char massegeChar[160];
int count = 0;
int numCount = 0;
int charDelay = 300;
int numberState = 0;
void setup() {                
  // initialize the digital pin as an output.
  for(int i=2; i<20; i++)
     pinMode(i, OUTPUT);

Serial.begin(9600);
holdClear();

}

// the loop routine runs over and over again forever:
void loop() {
   while (Serial.available()>0){
        char character = Serial.read();
         if(character == '*'){   
           sentSMS();
           count = 0;
           numCount = 0;
           numberState = 0;
           }
        if(character == ':'){
          numberState = 1;
          numCount = 0;
          //delay(10);
        }
        if(numberState == 1){
         number[numCount] = character;
         numCount++;
        }
        if(numberState == 0){
         massegeChar[count] = character;
         count++;
        }  
        if(character == '#'){
           count = 0;
           numberState = 0;
        }
      }

}

void pressDigit(int digit){
   digitalWrite(value[digit], HIGH);  // press digit from 0 to 9
   delay(pressTime);
   digitalWrite(value[digit],LOW);
   delay(pressDelay);
}

void pressOk(){
   digitalWrite(keyOk, HIGH);  // press ok
   delay(pressTime);
   digitalWrite(keyOk,LOW);
   delay(pressDelay);
}

void pressClear(){
   digitalWrite(keyClear, HIGH);  // press clear
   delay(pressTime);
   digitalWrite(keyClear,LOW);
   delay(pressDelay);
}

void pressStar(){
   digitalWrite(keyStar, HIGH);  // press star
   delay(pressTime);
   digitalWrite(keyStar,LOW);
   delay(pressDelay);
}

void pressUp(){
   digitalWrite(keyUp, HIGH);  // press up
   delay(pressTime);
   digitalWrite(keyUp,LOW);
   delay(pressDelay);
}

void pressDown(){
   digitalWrite(keyDown, HIGH);  // press down
   delay(pressTime);
   digitalWrite(keyDown,LOW);
   delay(pressDelay);
}

void pressHash(){
   digitalWrite(keyHash, HIGH);  // press hash
   delay(pressTime);
   digitalWrite(keyHash,LOW);
   delay(pressDelay);
}

void pressOff(){
   digitalWrite(keyOff, HIGH);  // press off
   delay(pressTime);
   digitalWrite(keyOff,LOW);
   delay(pressDelay);
}

void holdOff(){
   digitalWrite(keyOff, HIGH);  // hold off
   delay(holdTime);
   digitalWrite(keyOff,LOW);
   delay(pressDelay);
}

void holdClear(){
   digitalWrite(keyClear, HIGH);  // press clear
   delay(holdTime);
   digitalWrite(keyClear,LOW);
   delay(pressDelay);
}

void typeA(){
  digitalWrite(key2, HIGH);
  delay(typeTime);
  digitalWrite(key2, LOW);
  delay(typeDelay);
}
void typeB(){
  typeA();
  typeA();
}
void typeC(){
  typeA();
  typeA();
  typeA();
}
void typeD(){
  digitalWrite(key3, HIGH);
  delay(typeTime);
  digitalWrite(key3, LOW);
  delay(typeDelay);
}
void typeE(){
  typeD();
  typeD();
}
void typeF(){
  typeD();
  typeD();
  typeD();
}
void typeG(){
  digitalWrite(key4, HIGH);
  delay(typeTime);
  digitalWrite(key4, LOW);
  delay(typeDelay);
}
void typeH(){
  typeG();
  typeG();
}
void typeI(){
  typeG();
  typeG();
  typeG();
}
void typeJ(){
  digitalWrite(key5, HIGH);
  delay(typeTime);
  digitalWrite(key5, LOW);
  delay(typeDelay);
}
void typeK(){
  typeJ();
  typeJ();
}
void typeL(){
  typeJ();
  typeJ();
  typeJ();

}
void typeM(){
  digitalWrite(key6, HIGH);
  delay(typeTime);
  digitalWrite(key6, LOW);
  delay(typeDelay);
}
void typeN(){
  typeM();
  typeM();
}
void typeO(){
  typeM();
  typeM();
  typeM();
  
}
void typeP(){
  digitalWrite(key7, HIGH);
  delay(typeTime);
  digitalWrite(key7, LOW);
  delay(typeDelay);
}
void typeQ(){
  typeP();
  typeP();
}
void typeR(){
  typeP();
  typeP();
  typeP();

}
void typeS(){
  typeP();
  typeP();
  typeP();
  typeP();
}
void typeT(){
  digitalWrite(key8, HIGH);
  delay(typeTime);
  digitalWrite(key8, LOW);
  delay(typeDelay);
}
void typeU(){
  typeT();
  typeT();
  typeT();
}
void typeV(){
  typeT();
  typeT();
  typeT();
  
}
void typeW(){
  digitalWrite(key9, HIGH);
  delay(typeTime);
  digitalWrite(key9, LOW);
  delay(typeDelay);
}
void typeX(){
  typeW();
  typeW();
}
void typeY(){
  typeW();
  typeW();
  typeW();
 
}
void typeZ(){
  typeW();
  typeW();
  typeW();
  typeW();
}
void space(){
  digitalWrite(key0, HIGH);
  delay(typeTime);
  digitalWrite(key0, LOW);
  delay(typeDelay);

}
void sentSMS(){
 holdClear();

 holdClear();
 pressOk();
 pressOk();
 pressOk();
 for(int i = 0; i< 160; i++){
   switch(massegeChar[i]){
     case 'A':
     case 'a':
     typeA();
     delay(charDelay);
     break;
     
     case 'B':
     case 'b':
     typeB();
     delay(charDelay);
     break;
   
     case 'C':
     case 'c':
     typeC();
     delay(charDelay);
     break;
     
     case 'D':
     case 'd':
     typeD();
     delay(charDelay);
     break;
     
     case 'E':
     case 'e':
     typeE();
     delay(charDelay);
     break;
     
     case 'F':
     case 'f':
     typeF();
     delay(charDelay);
     break;
     
     case 'G':
     case 'g':
     typeG();
     delay(charDelay);
     break;
     
     case 'H':
     case 'h':
     typeH();
     delay(charDelay);
     break;
     
     case 'I':
     case 'i':
     typeI();
     delay(charDelay);
     break;
     
     case 'J':
     case 'j':
     typeJ();
     delay(charDelay);
     break;
     
     case 'K':
     case 'k':
     typeK();
     delay(charDelay);
     break;
     
     case 'L':
     case 'l':
     typeL();
     delay(charDelay);
     break;
    
     case 'M':
     case 'm':
     typeM();
     delay(charDelay);
     break;
     
     case 'N':
     case 'n':
     typeN();
     delay(charDelay);
     break;
     
     case 'O':
     case 'o':
     typeO();
     delay(charDelay);
     break;
     
     case 'P':
     case 'p':
     typeP();
     delay(charDelay);
     break;
     
     case 'Q':
     case 'q':
     typeQ();
     delay(charDelay);
     break;
     
     case 'R':
     case 'r':
     typeR();
     delay(charDelay);
     break;
     
     case 'S':
     case 's':
     typeS();
     delay(charDelay);
     break;
     
     case 'T':
     case 't':
     typeT();
     delay(charDelay);
     break;
     
     case 'U':
     case 'u':
     typeU();
     delay(charDelay);
     break;
     
     case 'V':
     case 'v':
     typeV();
     delay(charDelay);
     break;
     
     case 'W':
     case 'w':
     typeW();
     delay(charDelay);
     break;
     
     case 'X':
     case 'x':
     typeX();
     delay(charDelay);
     break;
     
     case 'Y':
     case 'y':
     typeY();
     delay(charDelay);
     break;
     
     case 'Z':
     case 'z':
     typeZ();
     delay(charDelay);
     break;
     
     case ' ':
     space();
     break;
   }
  delay(300);
 }
  pressOk();
  pressOk();
  callNumber();
}

void callNumber(){
  for(int i=1; i<12; i++){
    pressDigit(number[i]-'0');  // number[i] - '0' is for converting character into intiger
  }
 pressOk();
 holdClear();
 holdClear();
}

image

Aclaro, para mi al programa le falta mucho trabajo pero es un comienzo.

Si intervienes el aparato se pierde la homologación, si eso realmente te preocupa.
Piensa que no solo tienes que intervenir el teclado, también la horquilla.

Encontré un proyecto muchísimo más simple

Fíjate que el autor lo hizo justamente para no intervenir el aparato.
El arduino genera los tonos a través de un parlante que coloca junto al micrófono del teléfono.
Todavía quedaría el tema de la conexión/desconexión de la línea, yo pondría un relé ya que no creo que genere algún problema legal.

Saludos

Sí, creo que tienes razón, supongo al escuchar que se tenía que intervenir la línea esquivé la idea :slight_smile:
Estoy por terminar la idea de digitar los números a través de relevadores ya que hay diferencia con el proyecto del celular porque mi teléfono fijo no comparte tierra en común en cada uno de los dígitos.

En la segunda etapa del proyecto intentaré hacerlo así como me lo propones, ya hasta adquirí el modulo, utilizandolo para identificar los tonos ya que entiendo en ese esquema podría esperar una respuesta desde el teléfono que recibe la llamada, digamos que digitas un número y como respuesta realizas una acción, como colgar la línea y darse por enterado.
Agradezco inmensamente la ayuda!!

Oohhh, interesante!!!
Creo q tengo ya varias alternativas, debido al trabajo es poco lo q le puedo dedicar, ojalá me dé el tiempo para explorarlas y ver cual me es mas factible.

Lo de abrir y cerrar la linea creo q ya lo tengo resuelto a través de unos relevadores

Muchas gracias por las ideas!!!

Hola, buenos días!
Tengo una situación con el proyecto actual, recordarles que mis conocimientos en electrónica son muy básicos :slight_smile:
En un ambiente controlado el proyecto parece funcionar aceptablemente, estoy utilizando un sensor W1209 de temperatura, el cual activa un relay al rebasar cierto límite preprogramado de temperatura. Se supone le envío 5v desde mi arduino uno y al activarse el sensor(W1209) el relay me regresa esos 5v que estoy sensando en la entrada analógica A0, según lo que he investigado, esos 5v equivalen a un valor de 1024 en A0, hasta ahí todo bien; pero una vez que lo trasladé al SITE e instalé el cableado, la llamada se ejecuta sola, sin que el sensor de temperatura se haya activado(el relay haya cerrado el circuito), pareciera que en el ambiente se producen los 5v por obra del espíritu santo. Estuve mandando las mediciones de A0 a la consola para ver los valores y si notaba que me daba diferentes lecturas desde 0 hasta 800(equivalente a casi 4v) o poquito mas, pero una vez instalado y cableado me da los 1023 y eso activa la alarma. Alguien me puede dar una pista de porque sucede eso, y como solventarlo ??
Como siempre mi agradecimiento desde yá por la ayuda brindada
Saludos!

De algun modo lees el estado del RELE con el A0 del arduino.
Si hay 5V eso serán 1023.
Por lo visto te esta faltando un cable de GND porque cuando las lecturas parecen que se mueven solas es por esa razón.

Moderador:
No entiendo que tiene que ver el W1209 con Arduino y con este hilo.
Siempre digo que hay que agotar el tema. Ahora si el sensor de temperatura o termostato forma parte de tu proyecto que luego hará la llamada no digo nada, pero no lo has explicado.

Si el relé solo interrumpe una línea de 5V (la que envías al pin del micro) no es necesario que lo leas de forma analógica, la señal va a tener 0 o 5V, o sea LOW/HIGH, entonces lo lees directamente con digitalRead().
Recuerda poner una resistencia de 10K a masa en el pin para fijar el estado bajo (LOW) cuando el relé está abierto sino detectas ruido.

Saludos

Gracias! Surbyte
Una disculpa :face_with_hand_over_mouth:. Sí, en efecto, el W1209 forma parte del proyecto. Lo hice con la intención de tener visualmente la temperatura del SITE ya que este sensor tiene display, también permite programar la activación de un relay al alcanzar cierto umbral preprogramado, que es lo que uso para regresar los 5v que envío del arduino uno; osea no estoy trabajando el sensor directamente, este modulo(W1209) simplemente me permite activar un relay y listo.

Aaahhhhh, perfecto!
Sí, es correcto, el relé solo interrumpe los 5v así como lo mencionas. Vale, lo intentaré con lectura digital.
Creo que es justo lo que me estaba faltando, fijar ese pin a tierra mediante la resistencia que mencionas(que no tenia idea ni de el valor siquiera) y creo también que es algo de lo que menciona Surbyte con respecto a que me hace falta un cable a GND.
Me supongo que al hacer esta fijación a tierra mediante esta resistencia de 10K evito el ruido y esas lecturas aleatorias que tengo, cierto ?
Mis conocimientos en electrónica son insuficientes y si uds no me lo dicen hubiera creído que fijar ese pin a tierra con una resistencia dañaría el micro, pero que bueno que me orientan...

Espero poder subir un video pronto del proyecto ya funcionando

Muchas gracias también gatul!!!!

Si, claro, si no ponés una referencia a masa, la entrada queda "flotando" y detecta ruido.

Saludos

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.