On cherche à élaborer un système de communication pour une personne âgée pour qui la manipulation d’un smartphone peut être difficile à certains moments. Ce système devra être accroché sur un mur, il ne sera utilisé que pour lancer des appels GSM et non pour en recevoir.
Le principe sera d’appuyer simplement sur un bouton pour appeler une personne, seuls 3 boutons d’appel correspondant aux enfants de la personne âgée sont nécessaires, un quatrième bouton permettra de raccrocher.
Les boutons seront de taille conséquente afin d’y coller la photo du correspondant.
Matériel utilisé
Nous allons utiliser un shield GSM/GPRS qui embarque une puce SIM900 et qui sera relié à une carte Arduino Uno. Ses caractéristiques principales sont :
Compatibilité avec Arduino
- Appels et envoi de SMS, MMS
- Quad Band: 850; 900; 1800 et 1900 MHZ pour une compatibilité dans tous les pays sur les réseaux GSM
- 12 GPIOs
- Communication série avec l’Arduino, contrôle par simple envoi de commandes AT
- Gestion de la partie audio avec une prise micro et une prise haut parleur
Liste d’achats
- 1 Carte Arduino Uno
- 1 Shield GSM/GPRS
- 4 boutons-poussoirs
- 2 prises jack mâle 3,5mm
- 1 haut parleur d’impédance 8 ohms
- 1 capsule micro electret avec câble blindé
- 1 carte de prototypage à bandes de cuivre
- 1 alimentation 5V/2A
Montage électronique
Le schéma de montage pour les premiers tests est celui-ci :
Après soudure des connecteurs sur le shield pour le positionner sur la carte Arduino uno, les branchements sont simplifiés au seuls raccordement des boutons-poussoirs, directement sur le shield.
D’après la doc du shield, l’allumage se fait par appui sur un bouton poussoir durant 2 secondes, mais peut être réalisé par GPIO si l’on soude la connexion R13 de la carte. Notre système se voulant autonome il nous faut pouvoir l’allumer sans intervention manuelle, c’est donc cette solution qui sera utilisée.
Code Arduino
#include <SoftwareSerial.h>
SoftwareSerial SIM900(7, 8); // Liaison module GSM via pins 7 et 8 de l’Arduino
const int boutonStop = 10; // Pin du bouton pour raccrocher
const int bouton1 = 11; // Pin du bouton pour appeler personne 1
const int bouton2 = 12; // Pin du bouton pour appeler personne 2
const int bouton3 = 13; // Pin du bouton pour appeler personne 3
const int pinSIM900 = 9; // Pin pour allumer le module SIM900
int etatboutonStop = HIGH;
int etatbouton1 = HIGH;
int etatbouton2 = HIGH;
int etatbouton3 = HIGH;
// Paramétrage du debounce pour les boutons
long lastDebounceTime = 0;
long debounceDelay = 200;
char network_name[10] = " "; // on réserve une chêne de caractère pour le réseau
char c; // pour récupérer les réponses du module SIM900
////////////////////////////////////////////////////////////////////////////////////////////////////
// Intialisation
void setup() {
Serial.begin(115200); //Notre liaison série
pinMode(pinSIM900, OUTPUT);
digitalWrite(pinSIM900, LOW);
delay(1000);
pinMode(boutonStop, INPUT_PULLUP);
pinMode(bouton1, INPUT_PULLUP);
pinMode(bouton2, INPUT_PULLUP);
pinMode(bouton3, INPUT_PULLUP);
simInit();
checkOperator();
}
////////////////////////////////////////////////////////////////////////////////////////////////////
// Fonctions d’appel
void call1() {
SIM900.println("ATD 0033xxxxxxxxx;"); // Appelle la personne 1 via le numéro au format international
delay(100);
SIM900.println();
delay(30000); //On laisse un délai de 30s pour assurer quelques sonneries minimale sinon ça raccroche
}
void call2() {
SIM900.println("ATD 0033yyyyyyyyyy;"); // Appelle la personne 2 via le numéro au format international
delay(100);
SIM900.println();
delay(100);
SIM900.println();
delay(30000); //On laisse un délai de 30s pour assurer quelques sonneries minimale sinon ça raccroche
}
void call3() {
SIM900.println("ATD 0033zzzzzzzzz"); // Appelle la personne 3 via le numéro au format international
delay(100);
SIM900.println();
delay(30000); //On laisse un délai de 30s pour assurer quelques sonneries minimale sinon ça raccroche
}
////////////////////////////////////////////////////////////////////////////////////////////////////
// Fonction de raccrochage d’appel
void stopcall(){
SIM900.println("ATH"); // Fin de l'appel
Serial.println("Fin de l'appel");
}
////////////////////////////////////////////////////////////////////////////////////////////////////
// Fonction d’initialisation du shield
void simInit() {
digitalWrite(pinSIM900, HIGH); // Allume le module
Serial.println("On allume le module");
delay(5000); // Attente 5 secondes que le module s'allume
SIM900.begin(19200); // Arduino communique avec SIM900 GSM aune vitesse de 19200
// Réglages du module
SIM900.println("AT+CLVL=100"); // réglage du volume du haut parleur 0-100
simReply();
Serial.println("Volume à 100");
SIM900.println("AT+CMIC=0,15"); // réglage du gain micro 0-15
simReply();
delay(20000); // Attente 20 secondes pour rejoindre le réseau
}
//////////////////////////////////////////////////////////////////////////////////////////
// Fonction de récupération des réponses aux commandes envoyées au shield
void simReply() {
delay(500);
while (SIM900.available()) {
char c = SIM900.read();
if (c != '\n') Serial.write(c);
else Serial.print(" ");
delay(5);
}
Serial.println();
}
////////////////////////////////////////////////////////////////////////////////////////////////////
// Fonction de récupération du nom de l’opérateur réseau GSM
void checkOperator() {
SIM900.println("AT+COPS?"); //Opérateur
delay(100);
if (SIM900.find("\"")) { //Extraction du nom de l’opérateur
c = SIM900.read();
int u = 0;
while (c != '"' && u < 10) {
network_name[u] = c;
c = SIM900.read();
u++;
}
}
Serial.println("Réseau trouvé : ");
Serial.print(network_name);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
// Boucle principale
void loop() {
etatbouton1 = digitalRead(bouton1);
etatbouton2 = digitalRead(bouton2);
etatbouton3 = digitalRead(bouton3);
etatboutonStop = digitalRead(boutonStop);
//filtrage debounce
if ( (millis() - lastDebounceTime) > debounceDelay) {
if ((etatbouton1 == LOW)) {
Serial.println("Appel personne 1 en cours");
call1();
lastDebounceTime = millis(); //set the current time
}
if ((etatboutonPhi == LOW)) {
Serial.println("Appel personne 2 en cours");
call2();
lastDebounceTime = millis(); //set the current time
}
if ((etatboutonSyl == LOW)) {
Serial.println("Appel personne 3 en cours");
call3();
lastDebounceTime = millis(); //set the current time
}
if ((etatboutonStop == LOW)) {
Serial.println("On raccroche");
stopcall();
lastDebounceTime = millis(); //set the current time
}
delay(100);
}
}Quelques ajustements
Théoriquement nous devrions pouvoir alimenter la carte Arduino depuis la sortie 5V du shield, mais après vérification nous n’obtenons pas les 5V nécessaires. Nous décidons de relier directement les bornes d’alimentation du shield et de la carte Arduino afin d’alimenter les deux cartes.
Nous obtenons un fort grésillement dans le haut parleur, dû à une boucle de masse : après vérification la masse du connecteur du micro n’est pas directement reliée à la masse du circuit principal et se comporte donc comme une antenne qui capte les perturbations électromagnétiques et les injecte dans le signal. Nous rectifions ça en reliant les deux masses par un fil.
Construction de la boite
Nous modélisons et imprimons des extensions qui seront collées sur les boutons poussoir pour obtenir une surface d’appui de 30x20mm et y coller ensuite les photos des correspondants ou un adhésif pour symboliser la fonction raccrocher.
Aussi, nous modélisons et imprimons un support pour la capsule micro electret.
Nous imprimons également un support trouvé sur Thingiverse pour fixer plus facilement la carte Arduino dans la boite ainsi que des spacers pour fixer la plaque des boutons-poussoirs sur la façade.
Nous réalisons une boite en découpe laser dans de l’isorel de 3mm d’épaisseur.
Les boutons seront soudés sur la plaque de prototypage à bande de cuivre et fixée au dos de la façade avant
Quelques vis et écrous et le dispositif est assemblé !
Sources
L’ensemble des fichiers sources est disponible sur notre dépôt Framagit et accessible sous licence libre