Site web par SMS : Différence entre versions
(→Présentation) |
(→Fichiers Rendus) |
||
| (5 révisions intermédiaires par 3 utilisateurs non affichées) | |||
| Ligne 1 : | Ligne 1 : | ||
| + | <include nopre noesc src="/home/pedago/pimasc/include/video-MailSMS-iframe.html" /> | ||
| + | __TOC__ | ||
| + | <br style="clear: both;"> | ||
| + | |||
== Présentation == | == Présentation == | ||
| + | |||
=== cahier des charges === | === cahier des charges === | ||
==== Objectif : ==== | ==== Objectif : ==== | ||
| Ligne 574 : | Ligne 579 : | ||
==== Partie Android ==== | ==== Partie Android ==== | ||
| − | + | Simulations avec des envois manuels de SMS au téléphone pour tester tout les cas et vérifier la stabilité du système. | |
| + | Rajout de quelques "garde-fous" en cas d'erreur d'envoi de SMS de la part de l'arduino. | ||
==== Partie Arduino ==== | ==== Partie Arduino ==== | ||
| Ligne 582 : | Ligne 588 : | ||
=== Séance 25 (02/05/13) === | === Séance 25 (02/05/13) === | ||
* Réalisation de la Vidéo de notre projet et finalisation du Wiki | * Réalisation de la Vidéo de notre projet et finalisation du Wiki | ||
| + | |||
| + | == Fichiers Rendus == | ||
| + | |||
| + | * Code de l'Arduino : [[Fichier:SMSMAIL_Code_Arduino.zip]] | ||
| + | * Rapport de projet : [[Fichier:Chalaux Vincenti SMSMail.pdf]] | ||
| + | * Sources de l'application Android : [[Fichier:Vincenti SMSMail Sources Android.zip]] | ||
Version actuelle datée du 21 mai 2013 à 21:18
Sommaire
- 1 Présentation
- 2 Avancement du Projet
- 2.1 Séance 1 (04/02/13)
- 2.2 Séance 2 (07/02/13)
- 2.3 Séance 3 (11/02/13)
- 2.4 Séance 4 (14/02/13)
- 2.5 Séance 5 (25/02/13)
- 2.6 Séance 6 (27/02/13)
- 2.7 Séance 7 (28/02/13)
- 2.8 Séance 8 (04/03/13)
- 2.9 Séance 9 (06/03/13)
- 2.10 Séance 10 (07/03/13)
- 2.11 Séance 11 (11/03/13)
- 2.12 Séance 12 (13/03/13)
- 2.13 Séance 13 (18/03/13)
- 2.14 Séance 14 (20/03/13)
- 2.15 Séance 15 (21/03/13)
- 2.16 Séance 16 (25/03/13)
- 2.17 Séance 17 (27/03/13)
- 2.18 Séance 18 (28/03/13)
- 2.19 Séance 19 (03/04/13)
- 2.20 Séance 20 (04/04/13)
- 2.21 Séance 21 (08/04/13)
- 2.22 Séance 22 (10/04/13)
- 2.23 Séance 23 (11/04/13) et Vacances
- 2.24 Séance 24 (29/04/13)
- 2.25 Séance 25 (02/05/13)
- 3 Fichiers Rendus
Présentation
cahier des charges
Objectif :
Réaliser une plateforme permettant un accès à des services web simples uniquement par SMS.
Description :
La consultation de site internet ou la lecture de courriel est devenue monnaie courante sur téléphone. Ces services peuvent être fortement limités lorsque la couverture réseau est faible ou à l'étranger (coût de la connexion). Ce projet propose de réaliser une application Android permettant de lire ses courriels ou accéder à des sites tels que twitter uniquement par le biais de SMS. Il conviendra :
- de mettre en oeuvre un module GSM compatible Arduino qui recevra et transmettra les SMS de et vers un téléphone mobile,
- réaliser une application client sous Android.
Choix techniques : matériel requis
Afin de rendre le système portable nous avons décidé de rajouter une difficulté et faire le traitement en embarqué sur l'arduino. L'arduino se connectera donc à internet seul et le système n'aura besoin d'aucun ordinateur.
- Un Téléphone Android
- Un Arduino
- Un Shield Ethernet compatible Arduino
- Un Shield SD
- Un Module GSM
Avancement du Projet
Séance 1 (04/02/13)
Partie Android
Début le lecture de tutoriels Android. Le tuto le plus complet et accessible pour tous niveaux : Le site du zéro
Liste des points important, l'application doit :
- Envoyer / recevoir des SMS
- Masquer l'utilisation de ces SMS, rendre la communication invisible
- Stocker des données / les traiter
Remarque : il est important de minimiser l'envoi de SMS.
Partie Arduino
- Prise en main du sujet
- Etude de la documentation du module TM2 GSM/GPRS de chez TELTONIKA, modem fourni par le service info pour le projet.
- Etude de la platine EasyGsm de chez MikroElectronika, support de connection pour le module TM2 et son Antenne
Séance 2 (07/02/13)
Partie Android
Objectifs :
- Envoyer/recevoir des SMS
- Créer les premières "Activités", les vues, de l'application.
Envoi de SMS : Deux tutos utiles mobiforge (anglais) et tutomobile (français). L'envoie de SMS est géré entièrement par la librairie Android.
Réception de SMS : Voir le cours du Site du Zéro et/ou vogella (anglais) Utilisation de la classe BroadcastReceiver.
Remarque de conception : Un BroadcastReceiver peut être instancié soit dynamiquement dans une activité Android, soit par le système. Dans un cas ces deux objets Java peuvent interagir par appel de méthode, dans l'autre cas non. Cependant l'avantage de lancer de BroadcastReceiver par le système est que celui ci existera même si l'application n'est pas lancée. Ainsi le système peut recevoir des SMS même si l'utilisateur n'a pas lancé l'application et même s'il n'utilise pas son téléphone.
Partie Arduino
- 1er communication "à la main" à l'aide des commandes AT avec le module GSM grâce à un adaptateur TTL/RS232 (Module <--> PC) bricolé à base d'un MAX232.
- 1er Communication avec la carte SIM (B&You) insérée dans le module. Nous arrivons à nous identifier avec le code PIN mais l'identification ne reste que quelques secondes. Nous suspectons un problème d'alimentation car la documentation nous apprend que le module passe automatiquement en recherche de réseau après que l'on ai rentré le Code PIN et consomme ainsi plus de courant qu'au repos.
.
Séance 3 (11/02/13)
Partie Android
La création des activités (vues) Android avance, cependant petite difficulté pour passer d'une vue à une autre. Bon tuto trouvé ici.
L'organisation proposé est la suivante :
- Vue 1 connexion, protection par mot de passe, choix du numéro de téléphone de l'Arduino
- Vue 2 liste de services, lecture et écriture de mails ?
- Vue 3 liste des mails reçus
- Vue 4 lecture d'un mail
Partie Arduino
- Mesure de la Consommation du module : 30mA au repos / 200mA en recherche de réseau
- Test des différentes sources d'alimentation disponibles en salle E306.
- Problèmes : Brancher le module directement sur la sortie 5V de l'Arduino n'est pas suffisant. Utiliser un transformateur secteur n'est pas très pratique
- Solution trouvée ! : Utiliser un autre port USB que celui qui permet la programmation de l'Arduino pour alimenter le module. Indentification PIN Stable.
- 1er envoie de SMS !
Séance 4 (14/02/13)
Partie Android
Développement en quelques heures d'une application autonome.
L'application joue seule à un jeu de "Plus ou Moins". Elle génère un nombre aléatoire. Elle envoie (à elle même) des estimations (par dichotomie) par SMS. Elle récupère les SMS reçus, analyse les estimations et répond par "+ ou -" Etc...
Ce test rapide m'a permis de tester le fonctionnement en totale autonomie des classes de réception et d’envoi de SMS.
Remarque : l'envoie se fait dans l'activité et le BroadcastReceiver est instancié dans l'activité.
Objectif à venir :
- Créer un Service lié à l'envoi de SMS capable de construire les messages en parallèle.
- Trouver comment faire communiquer des activités, des services et des BroadcastReceiver.
Partie Arduino
- On essai de faire communiquer le module GSM avec un PC à travers un Arduino UNO (pour commencer).
- Problèmes : Utiliser les broches RX/TX de l'Arduino n'est pas viable si l'on veut envoyer une commande et visualiser correctement le resultat. Utiliser d'autres broches et la librairie Software Serial fournie de base avec l'IDE Arduino ne comporte par définition aucun élément Hardware comme par exemple les buffers d'emission/reception, on risque donc de perdre des données.
- Solution trouvée ! : Utiliser un Arduino Mega 2530 qui comporte 3 vraies UART supplémentaires. On aura donc Serial0 (Arduino <--> PC) et Serial1 (Arduino <--> Module GSM).
Séance 5 (25/02/13)
Partie Android
Test de configurations différentes pour le BroadCaster, avec des tests d’interaction avec une activité courante. Problème : pour un BroadCaster indépendant, il n'y a pas de solution simple pour connaître quelle activité est affiché à l'écran.
Beaucoup de recherche miracle sur internet sans succès. Finalement une remise en question de la conception de l'application est nécessaire pour trouver une méthode efficace qui permet aux activités affichés à l'écran de s’actualiser dès la réception de SMS.
Partie Arduino
- Detarmination des commandes AT utiles au projet.
AT : Renvoie simplement OK
AT+CPIN : Permet fournir le Code PIN de la carte SIM au module
AT+COPS : Permet de slecttionner un operateur
AT+CMGF : Permet de choisir le mode d'envoie des SMS (ici mode TEXT)
AT+CMGS : Permet d'envoyer un SMS
AT+CMGR : Permet de lire un SMS dans la mémoire de la SIM en précisant son Id
AT+CMGD : Permet de supprimer un SMS dans la méméoire
- Implémentation d'une fonction dans l'arduino pour faire le lien entre les liaisons séries. (RX sur S0 --> TX sur S1 et inversement)
void GSM_Terminal_Command()
- 1er envoie de SMS à travers l'Arduino Mega !
Hello World !
Séance 6 (27/02/13)
Partie Android
Pause dans la partie SMS.
Nouvel objectif : stoker les mails.
Après plusieurs recherches, la solution la plus adapté est l'utilisation de base de données. Cette fonctionnalité est déjà proposé par Android. Trois classes sont nécessaires :
- une classe abstraite (DAOBase). Elle implémente les fonctions d'appel de création, destruction, et d'ouverture de la base de donnée. Cette classe permet également de gérer des versions de base de donnée.
- Une classe (DataBaseHandler) qui hérite de SQLiteOpenHelper.
Elle implémente les fonctions de création et destruction des tables. Toutes les requêtes de création sont écrite dans cette classe.
- La classe principale (MailReceivedDAO) qui hérite de la classe abstraite précédente. Elle implémente toute les fonctions de manipulation de la base de donnée. Toutes les requêtes liées sont implémenté dans cette classe.
Partie Arduino
- Implémentation de toutes les primitives nécessaires à la commande du module GSM par l'Arduino liées au commandes AT.
void GSM_Init_PIN(char * pin);
void GSM_Init_NET();
void GSM_Send_SMS(char * tel,char * mess);
void GSM_Read_SMS(int num, int disp);
void GSM_Del_SMS(int num);
void GSM_Clear_SIM();
Séance 7 (28/02/13)
Partie Android
Toute la séance est passé à la conception de la base de donnée. Voici le schéma UML en fin de séance :
Rédaction des requêtes suivantes :
- Table d'identification
MAIL_IDENTIFICATION_CREATE : création de la table de correspondance ID interne - ID externe mail
MAIL_IDENTIFICATION_DROP : suppression de la table de mail
GET_ID_BY_POP : donne l'ID interne associé à l'ID externe
GET_POP_BY_ID : l'inverse de la précédente
IDENTIFY_LASTEST : renvoie le dernier lien en fonction de l'ID interne
- Table des mails :
MAIL_RECEIVED_CREATE : création de la table
MAIL_RECEIVED_DROP : suppression
SELECT_THIS_MAIL : récupère toutes les valeurs d'un mail en fonction de l'ID interne
SELECT_BY_DOWNLOADED : retourne la liste des mails en fonction de leur valeur de téléchargement.
SELECT_LASTEST : retourne tout les mails classé par ID, avec une valeur minimum de téléchargement en donnée.
Partie Arduino
- On continu de travailler sur void GSM_Read_SMS(int num, int disp) afin de bien extraire le numéro de l'expéditeur et le message d'après ce que le module nous renvoi.
- Mise en forme des données affichées dans le terminal ( "[ Service : Time Code ] Message" )
Séance 8 (04/03/13)
Partie Android
Création des fonctions d'utilisation des requêtes. Une unique fonction par requête et une unique requête par fonction. Ces fonctions servent à ajouter, supprimer, modifier,lire les mails. Mais également récupérer des listes de mails récents en fonction de leur état de téléchargement.
Cette séance a également été consacré à l'utilisation de l'objet ListView avec des bases de données, qui permet d'afficher de façon automatique des listes de structures fixes en fonction de layout prédéfinis (voir cursor_row).
Partie Arduino
- Etude de différentes librairies permettant d'utiliser un TIMER avec l'Arduino. Candidat retenu : "SimpleTimer" (http://playground.arduino.cc/Code/SimpleTimer)
- Etude du Protocol Mail,POP3, Header...
Ci-dessous les commandes POP3 utiles au projet
(Source : http://irp.nain-t.net/doku.php/180pop3:020_commandes)
NOOP : Permet de garder la connexion active en ne faisant rien
USER : Commande pour rentrer le login
PASS : Commande pour rentrer le password
UIDL : Affiche le tableau de correspondance Num/Id
RETR n : Affiche le message complet de numéro n
TOP n x : Affiche l'entête et les x premières lignes du mail n
QUIT : Ferme la connexion
Séance 9 (06/03/13)
En Commun
- Mise en Place du Protocol Android ---> Arduino ( "#Commande%Argument&" )
#P%n& : Commande de PING où n est un entier que l'arduino doit renvoyer
#D%n& : Demande des Id des n derniers mails recus
#H%id1+id2+id3...+idn& : Demande des Headers des mails correspondant aux différents id
#M%id& : Demande du Corps du Mail correspondant à l'id en argument
#T%id& : Envoi dans l'ordre de tout les id des mails plus récents que l'id en argument.
#V%(0 ou 1)& : Permet à l'application Android d'indiquer si elle va envoyer des requetes
ou si l'arduino doit lui même scruter les nouveaux mails
sans jamais recevoir d'accusé ("Mode Etrangé" ou Economique)
Partie Android
Suite au travail en commun, cette séance a été consacré à l'implémentation dans la base de donnée des tests de latence (Ping).
- Lite des requêtes rajoutées :
PING_CREATE
PONG_DROP
PING_GET_ALL : récupère tout les champs à partir d'un ID donné
PING_GET_PING : récupère tout les champs excepté l'ID
PING_LASTEST_NOTNULL : récupère la dernière clé interne d'une ligne dont tout les champs sont non nul.
SELECT_PING : récupère toutes les lignes classées par ID.
PING_LASTEST : récupère le dernier ID interne utilisé.
Toute les fonctions liés ont été rajoutées, j'ai également créé la classe Java Ping.
Partie Arduino
- Implémentation des fonctions d'interprétation du contenu des SMS (Execution des Commandes)
void GSM_Com_Execute();
Séance 10 (07/03/13)
Partie Android
Toute la séance est consacré au débug des fonctions de la base de donnée ainsi que la création de vues pour les tester.
Partie Arduino
- Test du Parsing SMS et de toutes les commandes (sans appelle de fonction de traitement)
- 1ers tests de la partie réseau du Shield Ethernet Arduino
- 1ers tests de la partie Carte SD du Shield Ethernet Arduino
Séance 11 (11/03/13)
Partie Android
Début de la gestion de la partie envoi de SMS : un service est créé, il reçoit des types de requête et envoi les SMS. Il reçoit les requêtes par intent, sous forme de chaine de caractère dans le champ "Instruction".
Partie Arduino
- Test de differentes solutions de traitement des données du serveur POP3. Structure,Variables Globales, Carte SD...
- Solution retenue : ne pas utiliser la carte SD et traiter les données dès leur arrivée.
Séance 12 (13/03/13)
Partie Android
Ajout du menu de préférence. Ce menu permet de choisir les options suivantes :
- Entrée du numéro de l'Arduino (sous forme +33xxxxxxxx)
- Test constant de latence (rajout d'une requête de latence pour chaque SMS envoyé)
- Blocage d'envoi de SMS. Cette option permet de passer en mode étranger
- Cache les SMS à la réception. Ainsi tout les SMS reçu ne seront pas lues par les autres applications
- Alerte visuelle d'envoi et de réception de SMS
Partie Arduino
- Implémentation des Fonctions de Connection/Deconnection au serveur de Mail POP3
void ETH_Init(int config);
void POP3_Connect(char * login, char * pass, int config);
void POP3_Disconnect();
Séance 13 (18/03/13)
Partie Android
Un problème se pose : Comment actualiser automatiquement une vues dès la réception d'un SMS de l'arduino ? Sachant que le BroadCastReceiver est créé indépendamment des vues.
Suite à cette constatation, une classe abstraite d'où hérite toutes les activités (la partie Java des vues) est créé. Permetant de factoriser du code, et également d'y créer une fonctionnalité.
- Toutes les vues permettent d'afficher le menu des options à partir du bouton android dédié.
- Toutes les vues créent une instance d'un autre BroadCastReceiver (voir la classe BroadcastRefresh). il est initialisé avec une priorité inférieure au BroadCastReceiver principal. Quand un SMS à été traité entièrement par celui ci, le BroadcastRefresh appelle la méthode d'actualisation de la vue qui l'a instancié.
Remarque : tout est fait pour que seul la vue visible à l'écran instancie un Broadcaster (pour limiter l'utilisation des ressources du téléphone).
Partie Arduino
- Implémentation des Primitives permetant de récupérer la liste des Id des messages (UIDL), L'entete d'un message et le corps.
- Dans cette 1er version tout est sauvegardé dans des structures ou des tableaux de charactères tout en essayant d'optimiser la place des données en RAM.
- Rq : Ces fonctions sont appelés pour chaque Mail
void POP3_Head(int n);
void POP3_Mess(int n);
void POP3_UIDL();
.
Séance 14 (20/03/13)
Partie Android
Finalisation de la conception du logiciel. Voici le schéma des vues de l'application :
Partie Arduino
- Implémentation des fonctions de conversion Num <-> Id, où Num est le numéro du message dans la liste, c'est ce qui est utilisé dans les commandes TOP ou RETR du protocol POP3 alors que l'Id est une chaîne de caractère qui l'identifie de façon unique.
char * POP3_NumToId(int n);
int POP3_IdtoNum(char id[100]);
Séance 15 (21/03/13)
Partie Android
Mise en place d'un algorithme qui permet de lire un nombre quelconque de commande à partir d'un même SMS. Ainsi toutes commandes peuvent être concaténé, l'objectif est de rendre l'outil plus souple et plus générique.
Ce choix est fait dans l'optique de rendre possible la réponse aux tests de latence dans les mêmes SMS que les commandes.
Partie Arduino
- Implémentation d'un fonction très importante.
int POP3_Extract_File(char *cmp,char fin);
Elle permet à partir d'une source de données brutes suite à la récupération de l'entête, du corps, ou autre... de détecter des mots clés et de récupérer la chaîne de caractère située entre ce mot clé et la fin de la ligne (ou délimiteur perso). Le principe est celui du fenêtrage. Puisque l'on lit les données du module ethernet caractère par caractère on rempli un tableau par la fin et on décale à chaque fois vers le haut. Quand le tableau contient le mot recherché on enregistre en tant que résultat tout la suite de la ligne.
- Rq : Toutes les manipulations de chaînes de caractères sont réalisées grâces au fonction de la librairie "String" standard du C et disponible sur Arduino
(Liste des fonctions : http://fr.wikipedia.org/wiki/String.h).
Séance 16 (25/03/13)
Partie Android
Implantation des boutons de recherche de nouveaux message, téléchargement de nouveau message et téléchargement des entêtes en fonction de l'état de la base de donnée. Exemple : si la base est vide, l'application demande les cinq derniers mails, sinon elle demande tout les suivants après un certain ID.
Partie Arduino
- Integration de POP3_Extract_File() dans des fonctions permettant l'analyse de l'entête et du corps une fois ceux ci enregistrés par les fonctions vu précédement.
void POP3_Read_Top(int n); void POP3_Read_Mess(int n);
Séance 17 (27/03/13)
Partie Android
Idem que la séance précédente, fin de la création des vues et débug.
Partie Arduino
- Realisation avec Altium du Typon du PCB permetant de relier le module à l'Arduino comme un Sheld standard.
Séance 18 (28/03/13)
En Commun
- Mise en place du Protocol Arduino --> Android
pong%n : Reponse au PING
L%id1+id2+id3+... : Renvoi des Id demandés
E%id%auteur%cc1;cc2;cc3;...%date%objet%type : Envoi de l'Entête demandée
C%id%corp : Envoi du Corps de mail demandé
NO : Indique qu'il n'y a pas de nouveaux mails
Partie Android
Modification du service d'envoi de SMS ainsi que des vues pour correspondre au protocole.
Partie Arduino
- Implementation des fontions mettant en forme les données et permettant l'envoi d'un id, d'une entête et d'un corps à l'application android
void Send_Head(char * id);
void Send_Mess(char * id);
.
Séance 19 (03/04/13)
Partie Android
Choix graphique : présentation de l'application par "tuiles" proches de windows 8, sous le principe suivant :
Des cases carrées monochromes, un texte blanc centré, et une image bouton.
Rajout de la vue "test de connexion", qui permet de visualiser la liste des requêtes de latence, avec les résultats s'il y a en a.
Partie Arduino
- A partir des primitives implémentées à la séance précédente, on créé les fonctions correspondant aux ordres possibles provenant de l'application android
void Send_LastN(int n); // Envoie les Id des n derniers mails
void Send_AllId(char *id); // Envoie les Id de tout les mails plus recent que l'id en paramètre
Séance 20 (04/04/13)
Partie Android
Test par envoi de SMS manuel de l'application et débug.
Partie Arduino
- Recuparation du PCB auprès du service electronique, perçage des trous, mise en place des connecteurs
Séance 21 (08/04/13)
Partie Android
Modification de BroadCast pour convertir les encodages ISO pour les objets des mails et UTF-8 pour le corp.
Partie Arduino
- Refonte des fonctions d'enregistrement et d'analyse des données POP3 et GSM. Utiliser des structures et des tableaux de caractères s'ai avéré mal adapté quand il a fallu prendre en compte de grandes quantités de données.
Nous avons donc utilisé le Slot Carte SD disponible sur le Shield Ethernet Arduino
Refonte des fonctions suivantes :
void POP3_Head(int n);
void POP3_Mess(int n);
void POP3_UIDL();
int POP3_Extract_File(char *cmp,char fin);
void GSM_Rx(int disp);
void GSM_Read_SMS(int num, int disp);
- Creation de fonctions liées à la gestions de la carte SD cachant l'utilisation de librairie SD Arduino
(Source : http://arduino.cc/en/Reference/SD)
void F_Init(); // Initialise la Carte SD
void F_Open_R(int fc,char *name); // Ouvre un fichier en Lecture
void F_Open_W(int fc,char *name); // Ouvre un fichier en Ecriture
void F_Close(int fc); // Ferme un fichier indiqué par son descripteur
void F_Display(int fc,char * name); // Affiche le contenu d'un fichier dans le terminal
Séance 22 (10/04/13)
En Commun
- Nous avons réalisé que le module GSM n'accepté pas de messages de plus de 160 caractères ce qui pose vite problème concernant le corps du mail ou même dans certains cas pour les envois d'entêtes. Nous avons donc decidé de modifier le protocal Arduino --> Android de la façon suivante en tenant compte de la fragmentation
## : En debut de chaque SMS si non fragmentation
#id;num;size# : En debut de chaque SMS si fragmentation
Avec :
id : Un entier quelconque mais différent pour chaque message en cours de fragmentation
num : Un entier de 0 à size-1 correspndant à la partie de message en cours d'envoie
size : Un entier entre 02 et 99 correspondant au nombre total de parties
Partie Android
Suite au travail en commun, création des tables de fragmentation des SMS. Création des fonctions et leurs requêtes :
PART_CREATE
PART_DROP
PART_GET_BY_ID récupère toutes les parties en fonction de l'ID du SMS.
Implémentation du recollage des parties dans le BroadcastReceiver.
Voici le nouveau schéma UML :
Partie Arduino
- Implementation d'une fonction permetant à partir d'un fichier texte de le découper en plusieurs parties de 155 caractères (entêtes de fragmentation incluses) et de les envoyer au fur et à mesure de la lecture.
void Send_Cut(int fc, char * name, char * head);
- Modification des fonctions d'envoi pour tenir compte de la fragmentation
void Send_Head(char * id);
void Send_Mess(char * id);
void Send_LastN(int n);
void Send_AllId(char *id);
Séance 23 (11/04/13) et Vacances
Partie Android
- Tests en fonctionnement actif (envoi/réception à haute fréquence).
- Finalisation de la partie graphique.
- Correction de problèmes mineurs.
Partie Arduino
- On continue de travailler sur le "Parsing" des Entêtes et du Corps afin de gerer des types de Mails différents tels que le Text/Plain, le Multipart/Alternative et le Text/Html.
- Rq : Le traitement est loin d'être exhaustif mais permet déjà de traiter les cas principaux. Un parsing plus avancé serait necessaire en cas de commercialisation de l'application
- Identification du type d'encodage des caractères
- Finalisation de l'envoi fragmenté
Séance 24 (29/04/13)
- Tests et Fusions
Partie Android
Simulations avec des envois manuels de SMS au téléphone pour tester tout les cas et vérifier la stabilité du système. Rajout de quelques "garde-fous" en cas d'erreur d'envoi de SMS de la part de l'arduino.
Partie Arduino
- Modifications dans tout le code selon les bugs detectés
- Implémentation de "Gardes fous" et détections de certaines erreurs (Erreur de Parsing, Erreur de Connexion POP3, ...)
Séance 25 (02/05/13)
- Réalisation de la Vidéo de notre projet et finalisation du Wiki
Fichiers Rendus
- Code de l'Arduino : Fichier:SMSMAIL Code Arduino.zip
- Rapport de projet : Fichier:Chalaux Vincenti SMSMail.pdf
- Sources de l'application Android : Fichier:Vincenti SMSMail Sources Android.zip
