Sommaire

1 Présentation générale du projet
2 Avancement du projet
3 Premier prototype
4 Références
- 4.1 Datasheets
- 4.2 Documentation (Liens utiles)
5 Rapport du PFE

Présentation générale du projet

Contexte du projet

L'internet des objets est un domaine en pleine croissance qui permet entre autres d'établir des interactions entre des utilisateurs et des objets connectables.

Les domaines d'applications sont diverses et variées: du contrôle des chauffages dans nos maisons en passant par les smart cities,ou encore le tracking des marchandises,..on y retrouve des dispositifs intelligents tels que des capteurs, des interfaces de communication avec d'autres dispositifs,.. Aujourd'hui plusieurs équipements embarqués voient le jour, cependant les protocoles de communication n'évoluent pas autant, entraînant donc une forte consommation d'énergie, un besoin énorme en termes de mémoire, réseau,..

Semtech,une entreprise grenobloise, crée en 19 un modem radio LoRa adapté aux besoins des objets connectés et offre une technologie de communication à faible consommation d'énergie, une longue portée(pouvant aller jusqu'à 15 km),un débit faible,..

L'actuelle main mise du privé sur les réseaux IP n'est pas forcément une bonne chose pour Internet.

Objectif du projet

L'objectif du projet est de réaliser un module autonome connectable sur une box Internet permettant de relier deux sites avec une connexion longue distance.

Cahier de charges

Le projet se déroulera en deux phases. Nous utiliserons 2 technologies: L'ethernet et la communication par radio fréquences.

Nous réaliserons d'abord un premier prototype construit autour d'un AtMega328P, d'une carte Ethernet (avec un micro-contrôleur Microchip ENC28J60), et d'un modem radio LoRa. Un connecteur USB est prévu pour l'alimentation.

Ensuite, nous réaliserons un deuxième prototype sur la base d'un module MBED équipé d'un microcontroleur 32 bits à processeur ARM Cortex M3 , du même modem LoRa.

Nous avons choisi ce processeur pour :

le fait qu'un module Ethernet PHY soit intégré; qui opère au niveau de la couche physique du modèle OSI et met en œuvre la partie de la couche physique Ethernet du 1000BASE-T, 100BASE-TX, et les normes 10BASE-T.

la vitesse du processeur très élevée,

Présence de plusieurs périphériques série

En ce qui concerne l'environnement de développement,le compilateur MBED permet d'écrire des programmes en C++ qui peuvent être compilés en ligne.

Nous comptons également utiliser le protocole PoE (Power over Ethernet) pour l'alimentation par le port Ethernet, prévoir un protocole de communication pour la transmission des paquets Ethernet par LoRa.

Suivi du projet

Semaine 1 (19/09)	Réunions avec l'encadrant de projet / Définition des objectifs / Recherche bibliographique
Semaine 2 (26/09)
Semaine 3 (03/10)
Semaine 4 (11/10)	Etablissement de la liste du matériel
Semaine 5(18/10)	Etablissement de la liste du matériel
Semaine 6(25/10)	Recherche de la librairie C pour le SX1276
Semaine 7(31/10)	Réalisation des schematics pour la carte1 et création des bibliothèques des composants

Planning prévisionnel

Fichier:Planning .pdf

La recherche et la documentation

Microcontrôleur Atmega328p

Atmega328p est un mono-puce microcontrôleur.

Carte Réseau

Qu'est-ce qu'une carte réseau?

La carte réseau (appelée Network Interface Card en anglais et notée NIC) constitue l'interface entre l'ordinateur et le câble du réseau. La fonction d'une carte réseau est de préparer, d'envoyer et de contrôler les données sur le réseau.

Pour préparer les données à envoyer, la carte réseau utilise un transceiver qui transforme les données parallèles en données séries. Chaque carte dispose d'une adresse unique, appelée adresse MAC, affectée par le constructeur de la carte, ce qui lui permet d'être identifiée de façon unique dans le monde parmi toutes les autres cartes réseau.

Quel est le rôle d'une carte réseau?

Une carte réseau sert d'interface physique entre l'ordinateur et le câble. Elle prépare pour le câble réseau les données émises par l'ordinateur, les transfère vers un autre ordinateur et contrôle le flux de données entre l'ordinateur et le câble. Elle traduit aussi les données venant du câble et les traduit en octets afin que l'Unité Centrale de l'ordinateur les comprenne. Ainsi une carte réseau est une carte d'extension s'insérant dans un connecteur d'extensions (slot).

Qu'est-ce qu'une carte réseau Ethernet?

La plupart des cartes réseau destinées au grand public sont des cartes Ethernet. Elles utilisent comme support de communication des paires torsadées (8 fils en cuivre), disposant à chaque extrémité de prises RJ45.

Les trois standards Ethernet (norme 802.3) les plus courants correspondent aux trois débits les plus fréquemment rencontrés : 1.Le 10Base-T permet un débit maximal de 10 Mbit/s. Le câble RJ45 peut alors mesurer jusqu'à une centaine de mètres et seuls 4 des 8 fils sont utilisés. 2.Le 100Base-TX permet un débit maximal de 100 Mbit/s. Il est également appelé Fast Ethernet et est désormais supporté par la quasi-totalité des cartes réseau. Comme pour le 10Base-T, le câble RJ45 peut alors mesurer jusqu'à une centaine de mètres et seuls 4 des 8 fils sont utilisés. 3.Le 1000Base-T permet un débit maximal de 1 000 Mbit/s. Il est également appelé Gigabit Ethernet et se démocratise rapidement. Pour que le réseau fonctionne correctement, le câble RJ45 peut toujours mesurer jusqu'à 100 m, mais doit être de bonne qualité. Cette fois, les 8 fils sont utilisés.

Ethernet Module ENC28J60

Pour la suite de notre projet, il faut une bonne connaissance du module ENC28J60.

Avancement du projet

Souder la carte Ethernet

Liste du matériel

Matériel	Quantité requise	Quantité disponible	A commander	Commentaires
Premier prototype (à base d'un AtMega328P)
Partie Ethernet
Résistances 49.9Ω	10	10	10	Farnell [1]
Résistances 270Ω	10	10	10	Farnell [2]
Résistances 2.32kΩ	10	10	10	Farnell [3]
Capacités polarisation 10µF	10	10	10	Mouser [4]
Capacités 0.1µF	10	10	10	Farnell [5]
Capacités 20pF	10	10	10	Farnell [6]
Capacités 1µF	10	10	10	Farnell [7]
Puce Électronique ENC28J60SP	3	3	3	Farnell [8]
Régulateur MCP1702Z	3	3	3	Mouser [9]
Régulateur de tension LD1117AV33	3	3	3	Mouser [10]
Connecteur SI-50196-F	3	3	3	Digi-Key [11]
Filtre BL01RN1A	3	3	3	Farnell [12][13]
Quartz ECSS250XM	2	2	2	Mouser [14]
Partie Arduino
Micro-contrôleur de type ATMEGA328P	3	3	3	Farnell [15]
Quartz FA238 16MHz	3	3	3	Farnell [16]
Résistance 1MΩ +/- 5%	5	5	5	Farnell [17]
Résistance 1KΩ	5	5	5	Farnell [18]
Resistances 470Ω	10	10	10	Farnell [19]
Capacité 100nF	10	10	10	Farnell [20]
Capacité 4.7uF	5	5	5	Farnell [21]
Capacité 10uF	5	5		Farnell [22]
Interrupteur	2	2	2	Mouser [23]
Embase USB	2	2	2	Farnell [24]
FTDI FT232 BASIC	3	3	3	Farnell [25] MOUSER [26]
Diode	5	5	5	Farnell [27]
Regulateur 78ADJ LDO Tension fixe	3	3	3	Farnell [28]
LED yellow	3	3	3	Farnell [29]
LED orange	3	3	3	Farnell
LED green	3	3	3	Farnell [30]
LED blue	3	3	3	Farnell [31]
Partie LoRa
Module radio de type RF-LORA-868-SX1276	4	4	4	Mouser [32]
Capacités 10uF	10	10	10	Farnell [33]
Capacités 100nF	20	20	20	Farnell [34]
	20	20	20	Farnell [35]
Capacités 15pF	10	10	10	Farnell [36]
Capacités 10nF	10	10	10	Farnell [37]
Capacités 1.5pF	10	10	10	Farnell [38]
Capacités 33pF	10	10	10	Farnell [39]
Capacités 4.7pF	10	10	10	Farnell [40]
Capacités 1.2pF	10	10	10	Farnell [41]
Capacités 1.8pF	10	10	10	Farnell [42]
	10	10	10	Farnell [43]
Capacités 1nF	10	10	10	Farnell [44]
Inductance 33nH	10	10	10	Farnell [45]
Inductance 6.2nH (0402)	10	10	10	Farnell [46]
Inductance 10nH	10	10	10	Farnell [47]
Resistances 1KΩ	10	10	10	Farnell [48]
Quartz 32MHz(16pF)	10	10	10	Farnell [49]
Regulateur PE4259	5	5	5	Digi-Key [50] Farnell[51]
Deuxième prototype (à base d'un ARM-3 Cortex)
Autres cartes
32u4 RFM95 LoRa Radio - 868 or 915 MHz	2	2	2	Adafruit [52]
Prototype carte developpement MBED	2	2	2	[53]
Kit Board developpement MBED	2	2	2	[54]

Liste du matériel

Fichier:NEWListe du matériel-IMA5-PFE19.ods

Premier prototype

La carte est composée de 3 parties principales : partie Ethernet, partie uC AtMega328P , partie LoRa.

Le rôle du micro-contrôleur est de traiter les informations qui lui parviennent , interfacer et contrôler les communications entre les périphériques.

La partie LoRa est gérée par un émetteur-recepteur SX1276 doté d'un modem LoRa de chez Semtech offrant une communication longue portée. Cette communication repose sur le principe de la modulation à étalement de spectre.

Qu'est ce qu'une modulation à étalement de spectre LoRa?

Le modem LoRa utilise une technique exclusive de modulation du spectre étalé opérant dans la bande de fréquences ISM. Cette technique est plus résistante aux interférences et au bruit dans la bande.

La modulation LoRa repose sur le même principe que la modulation DSSS( Direct Sequence Spread Spectrum) qui consiste donc à générer de la redondance d’information à chaque envoi d’une séquence de bits. Ainsi les bits reçus qui n’utilisent pas le même codage seront rejetés (dont les signaux d’interférence ou le bruit). Le récepteur peut ainsi reconnaître l’émetteur. Dans la modulation LoRa, l'étalement de spectre est obtenu en générant un signal qui varie continuellement en fréquence et occupe toute la bande passante.

// schéma

Alimentation

Pour fonctionner la carte a besoin d'alimentation.La carte fonctionnant sous une tension de 5V ,il a été convenu qu'elle sera alimentée via un port USB.

Interfaçage

Les périphériques reliés au microcontrôleur communiqueront avec ce dernier via la liaison SPI. Le bus SPI est un bus série synchrone constitué de 4 signaux logiques. SCK,MOSI,SS générés par le maître et MISO généré par l'esclave. Le maître s'occupe de la communication. Plusieurs esclaves peuvent communiquer sur le même bus à condition qu'il y ait une ligne de sélection dédiée à chaque esclave.

NB : Le uC AtMEGA328P ne disposant que d'une seule ligne de sélection SS nous sommes confrontés au problème de liaison d' un périphérique supplémentaire. Solution: Nous allons donc configurer un I/O comme un SS afin d'avoir autant de SS que de périphériques esclaves.

Fonctionnement de l'interface SPI du SX1278 :

La communication est simultanée entre un maître et un esclave. Le maître génère l'horloge et sélectionne un esclave. A chaque coup d'horloge , le maître transmet un bit à l'esclave.

MOSI est généré par le maître sur le front descendant de SCK et est échantillonné par l'esclave sur le front montant de SCK tandis que MISO est généré par l'esclave sur le bord descendant de SCK.

Le transfert est déclenché lorsque NSS est à l'état bas . MISO est alors en haute impédance lorsque NSS est à l'état haut.

Le premier octet envoyé est l'octet d'adresse. Il comprend:

 * Un bit wnr, 1 pour l'accès en écriture et 0 pour l'accès en lecture.
 * suivi de 7 bits d'adresse(MSB en premier).

Le deuxième octet est un octet de données, soit envoyé sur MOSI par le maître en cas d'accès en écriture ou reçu par le maître sur MISO en cas d'accès en lecture. L'octet de données est transmis MSB en premier.

Les octets de traitement peuvent être envoyés sur MOSI (pour accès en écriture) ou reçus sur MISO (pour accès en lecture) sans un front montant du NSS et renvoyer l'adresse.

La transmission de la trame se termine lorsque NSS passe à l'état haut.

Pendant l'accès en écriture, l'octet transféré de l'esclave au maître sur la ligne MISO est la valeur de l'écriture avant l'opération d'écriture.

Transmission d'une trame SPI LoRa en mode simple accès

Machine d'états

Réalisation des cartes PCB

La carte PCB

Depuis quelques séances, nous avons commencé à réaliser notre carte PCB qui contient la partie Ethernet , Microcontrôleur et LoRa à l'aide du logiciel Altium. Dans un premier temps nous avons d'abord réalisé les librairies Altium des composants dont nous ne disposons pas. La réalisation des librairies consiste en 2 étapes : schématique et empreinte. Il s'agit donc des composants tels que : le chip SX1276, régulateur PE4259 et le connecteur SI-50196-F.

Voici leurs schématiques et footprints :

Schematique de Lora SX1276
Schematique de connecteur SI-50196-F
Schématique de régulateur PE4259

Footprint de connecteur SI-50196-F
Footprint de régulateur PE4259

Il conviendra de préciser que quelques librairies utilisées sont disponibles et téléchargeables sur le site d'Altium Designer et peuvent être installées sur le logiciel Altium de l'école.
http://techdocs.altium.com/display/ADOH/Download+Libraries

Cependant nous avons eu un problème du connecteur, puisque normalement pour les autres composants les pistes sont reliés avec les composants qui sont autours sur le schématique et le routage. Mais après avoir vu la carte que nous avons, pour la partie du connecteur il faut créer une cadre pour fixer la place du connecteur sur la carte PCB.

Parallèlement nous avons réalisé la première étape de la conception d'une carte électronique : la réalisation de la schématique. Ci-dessous les schématiques des différentes parties de la carte

Ethernet_Sch
AT328P.PNG_Sch
RF_LoRa.PNG_Sch

Très vite, nous avons entamé la deuxième étape de la conception : le routage. En raison des contraintes de temps, nous allons d'abord produire la partie RF_LoRa afin de pouvoir avancer sur la partie programmation.

Routage du PCB

Le routage consiste à déterminer la route des signaux d'alimentation qui vont relier les composants entre eux et à placer les composants sur la carte. La carte a été conçue en respectant quelques contraintes de conception dimensionnelles :

*la valeurs théoriques de conception sont *largeur des pistes = *,
* l'angle entre les pistes ne doit pas être droit, 
*la carte est en double face,

Réalisation de l'antenne

La carte nécessite une antenne pour la communication RF. En concevant la carte , nous avons désigné la piste reliée à l'antenne de telle sorte qu'elle soit adaptée à 50 ohms (afin d'éviter toute perte de puissance liée à la désadaptation). Nous avons donc utilisé le logiciel AppCAD en prenant en compte certains paramètres tels que le substrat utilisé, la fréquence de fonctionnement,..

La programmation

La carte sera programmée en langage C, langage de programmation modulaire.

Le langage a été choisi pour son caractère universel, sa rapidité, proche du langage machine permettant une programmation simple des microcontrôleurs,..

Partie LoRa

semaine 07/11/2016: Ecriture des fonctions d'écriture et de lecture de l'AtMega (digitalWrite() et digitalRead()) en C qui nous permettront d'écrire les fonctions d'écriture et de lecture SPI.

semaine 14/11/2016 : Ecriture des librairies LoRa et AtMega ainsi que des fichiers de compilation.

Le programme est subdivisé en 5 parties : partie configuration des entrées sorties, partie gestion de la liaison SPI , partie gestion de la modulation LoRa ainsi que les parties gérant les modules émetteurs et récepteurs de la communication RF (Client-Server). Le programme est compilable. Nous allons d'abord faire des tests basiques sur un Arduino et ensuite nous testerons sur les modules inAir9 de chez modtronix.

Partie Ethernet

Pour la partie Ethernet, dans un premier temps nous avons écrit deux petits programmes pour l'émetteur et le récepteur. Voici le code pour l'émetteur

#include <stdio.h>
#include <string.h>
#include <avr/io.h>
#include <util/delay.h>

#include "serial.h"
#include "spi.h"
#include "enc28j60.h"

#define MAX_PACKET     128
#define MAC_SIZE           6
#define TYPE_SIZE           2

unsigned char mac_sender[]={0x00,0x10,0x10,0x10,0x10,0x01};
unsigned char mac_receiver[]={0x00,0x10,0x10,0x10,0x10,0x02};
unsigned char packet_type[]={0x11,0x11};
unsigned char packet[MAX_PACKET];

int main(void])
{
init_printf();
spi_init();
enc28j60Init(mac_sender);
unsigned char version=enc28j60getrev();
printf("revision: %d\n",version);
memcpy(packet,mac_receiver,MAC_SIZE);
memcpy(packet+MAC_SIZE,mac_sender,MAC_SIZE);
memcpy(packet+2*MAC_SIZE,packet_type,2);
packet[2*MAC_SIZE+2]=0xaa;
packet[2*MAC_SIZE+3]=0xbb;
int len=2*MAC_SIZE+TYPE_SIZE+3;
unsigned char count=0;
while(1){
		packet[2*MAC_SIZE+4]=count++;
                enc28j60PacketSend(len,packet);
                printf("Packet send size=%d\n",len);
                _delay_ms(1000);
                }
		return 0;		
}

Et le code pour le récepteur

int main(void])
{
init_printf();
spi_init();
enc28j60Init(mac_receiver);
unsigned char version=enc28j60getrev();
printf("revision: %d\n",version);
while(1){
                int size=enc28J60PacketReceive(MAX_PACKET,packet);
                printf("Packet received size=%d\n",size);
                int i,col=0;
                for(i=2*MAC_SIZE+TYPE_SIZE;i<size;i++){
                     printf("%02x",packet[i]);
                     col++;
                     if(col==16){ printf("\n"); col=0);}
                     }
                if(col>0) printf"\n");
                _delay_ms(1000);
                }
		return 0;		
}

Ces deux codes permettent l'émetteur et le récepteur de communiquer entre eux.

La communication entre l'émetteur et le récepteur

Avec le minicom, nous avons bien observé les données qui sont envoyées par l'émetteur et les données qui sont reçues par le récepteur.

Dans un second temps,nous sommes allées un peu plus loin. Nous avons branché les cartes ethernet aux eeePC par câbles ethernet et nous avons aussi lié les Arduino en SPI. L'idée de cette manipulation est de permettre de réaliser

si un paquet est reçu par le ENC28j60 alors le recopier dans le tableau Ethernet
si un paquet est présent dans le tableau Ethernet, envoyer l'octet courant sur le port série
si un octet arrive sur le port série le stocker dans le tableau Serie
si le paquet dans le tableau Serie est complet, l'envoyer sur Ethernet

Donc nous avons écrit un code

int main(void)
{
init_printf();
spi_init();
enc28j60Init(mac_receiver); //enc28j60Init(mac_sender) pour l'émetteur
unsigned char version=enc28j60getrev();
printf("revision: %d\n",version);
while(1){
  if(nb_ethernet==0{
    nb_ethernet=enc28j60PacketReceiver(MAX_BYTES,packet_ethernet);
    if(nb_ethernet!=0) index_ethernet=0;
    }
  if(nb_ethernet>0){
    if(index_ethernet<nb_ethernet){
      unsigned char c=packet_ethernet[index_ethernet++];
      if(c==SLIP_END){ send_serial(SLIP_ESC); send_serial(SLIP_CODE_END); }
      else if(c==SLIP_ESC){ send_serial(SLIP_ESC); send_serial(SLIP_CODE_ESC); }
      else send_serial(c);
      }
    else{ send_serial(SLIP_END); nb_ethernet=0; } 
    }  
  if(serial_available()){
    unsigned char c=get_serial();
    if(c==SLIP_ESC){
      unsigned char code=get_serial();
      if(code==SLIP_CODE_END) packet_serial[nb_serial++]=SLIP_END;
      else if(code==SLIP_CODE_ESC) packet_serial[nb_serial++]=SLIP_ESC;
      }
    else if(c==SLIP_END){ enc28j60PacketSend(nb_serial,packet_serial); nb_serial=0; }
    else packet_serial[nb_serial++]=c;
    }
  }
}

Ensuite pour voir les transmissions des données, nous avons utilisé une commande

tcpdump -vvvv -n -Xe -ieth0

Cette commande permet de savoir le type et les contenues d'un packet. Quelques options importantes pour tcpdump

-n: tcpdump ne convertira pas les adresses et les numéros de ports en leurs noms.
-i nom_interface : permet de choisir l'interface d'écoute.
-v : permet d'afficher encore plus d'informations sur les paquets, il y a trois niveaux de verbosité.
-X : affiche les paquets en hexadécimal et en ASCII.

Donc sur le terminal nous avons eu

tcpdump: listening on eth0, link-type EN10MB (Ethernet), capture size 262144 bytes
11:16:32.102805 20:3d:20:30:78:30 > 4d:41:41:44:52:35, ethertype Unknown (0x0d0d), length 167: 
	0x0000:  0a4d 4141 4452 3420 3d20 3078 3130 0d0d  .MAADR4.=.0x10..
	0x0010:  0a4d 4141 4452 3320 3d20 3078 3130 0d0d  .MAADR3.=.0x10..
	0x0020:  0a4d 4141 4452 3220 3d20 3078 3130 0d0d  .MAADR2.=.0x10..
	0x0030:  0a4d 4141 4452 3120 3d20 3078 3130 0d0d  .MAADR1.=.0x10..
	0x0040:  0a4d 4141 4452 3020 3d20 3078 320d 0d0a  .MAADR0.=.0x2...
	0x0050:  7265 7669 7369 6f6e 3a20 360d 0aff ffff  revision:.6.....
	0x0060:  ffff ff5c b901 01ed ce08 0600 0108 0006  ...\............
	0x0070:  0400 015c b901 01ed ceac 1a4f 2100 0000  ...\.......O!...
	0x0080:  0000 00ac 1a4f fe00 0000 0000 0000 0000  .....O..........
	0x0090:  0000 0000 0000 0000 00                   .........
11:16:35.105084 5c:b9:01:01:ed:ce > ff:ff:ff:ff:ff:ff, ethertype ARP (0x0806), length 60: Ethernet (len 6), IPv4 (len 4), 
        Request who-has 172.26.79.254 tell 172.26.79.33, length 46
	0x0000:  0001 0800 0604 0001 5cb9 0101 edce ac1a  ........\.......
	0x0010:  4f21 0000 0000 0000 ac1a 4ffe 0000 0000  O!........O.....
	0x0020:  0000 0000 0000 0000 0000 0000 0000       ..............
11:16:36.102140 5c:b9:01:01:ed:ce > ff:ff:ff:ff:ff:ff, ethertype ARP (0x0806), length 60: Ethernet (len 6), IPv4 (len 4), 
        Request who-has 172.26.79.254 tell 172.26.79.33, length 46
	0x0000:  0001 0800 0604 0001 5cb9 0101 edce ac1a  ........\.......
	0x0010:  4f21 0000 0000 0000 ac1a 4ffe 0000 0000  O!........O.....
	0x0020:  0000 0000 0000 0000 0000 0000 0000       ..............
11:16:37.102128 5c:b9:01:01:ed:ce > ff:ff:ff:ff:ff:ff, ethertype ARP (0x0806), length 60: Ethernet (len 6), IPv4 (len 4), 
        Request who-has 172.26.79.254 tell 172.26.79.33, length 46
	0x0000:  0001 0800 0604 0001 5cb9 0101 edce ac1a  ........\.......
	0x0010:  4f21 0000 0000 0000 ac1a 4ffe 0000 0000  O!........O.....
	0x0020:  0000 0000 0000 0000 0000 0000 0000       ..............

Cependant nous avions un problème du passage d'un paquet ICMP. L'émetteur a essayé d'envoyer certaines types de paquet par exemple paquet ARP, paquet ICMP ... mais du coté de récepteur il n'a pas réussi à capter toutes les types de paquets.