P19 Relai Ethernet Lora : Différence entre versions

De Wiki de Projets IMA
(→‎Qu'est ce qu'une modulation à étalement de spectre?)
(→‎La programmation)
 
(130 révisions intermédiaires par 2 utilisateurs non affichées)
Ligne 90 : Ligne 90 :
  
 
[[Fichier:ce.jpg|300px|center|Carte Ethernet]]
 
[[Fichier:ce.jpg|300px|center|Carte Ethernet]]
 +
 +
=====Module ENC28J60=====
 +
Pour la suite de notre projet, il faut une bonne connaissance du module ENC28J60. La puce enc28j60 est Microship présente le premier controleur Ethernet 10BASE-T(10Mbits/s) reference ENC28J60 se laissant facilement piloter via un bus SPI(Serial Programming Interface) par un microcontroleur et ne comportant que 28 broches pour un boitier au format DIL.
 +
Ce contrôleur Ethernet dispose d'un module MAC et PHY intégrés et de 8ko de mémoire tampon permettant de minimiser la complexité de la mise en oeuvre et le coût. Les applications visées sont : la VoIP, l'automation industrielle, l'automation de bâtiment, l'instrumentation, la sécurité et la domotique.
 +
Jusqu'à lors, on ne trouvait sur le marché que des contrôleurs Ethernet tels que le RTL8019AS de Realtek. Ce circuit n'existait qu'au format CMS (boitier PQFP) composé d'une centaine de broches dont le tiers étaient destinées au bus de communication parallèle (adresses et données). Bref, sa mise en oeuvre était pour le moins ardue que ce soit sur le plan du routage du circuit imprimé que pour la soudure du composant.
 +
Ainsi, grâce à son faible nombre de broches faciles à souder, le ENC28J60 permet une intégration sensiblement facilité dans votre réseau domestique en lui couplant un microcontrôleur afin de piloter les fonctionnalités Ethernet. Disponible en boitier DIL (DIP), il reste la solution la moins chère pour la mise en oeuvre d'un projet connecté au réseau Ethernet.
 +
Il y a 7 sections de fonctionnalités pour ENC28J60.
 +
*1). Un Interface SPI : un canal de communication entre le contrôleur hôte et l’ENC28J60.
 +
*2). Les registres de control : contrôle et surveille l’ENC28J60.
 +
*3). Un buffer RAM avec doubles ports : reçoit et transmet des paquets de données.
 +
*4). Un arbitre : contrôle l’accès du buffer RAM quand des demandes sont faites de DMA, transmet et reçoit des blocs.
 +
*5). Un interface bus : interprète des données et des commandes reçues via l’interface SPI.
 +
*6). Un module MAC(Medium Access Control) : implémente IEEE 802.3 qui conforme MAC logique.
 +
*7). Un module PHY (Physical Layer) : code et décode des données analogiques qui sont présentées sur l’interface à paire torsadée.
 +
Le dispositif contient aussi d’autres blocs de supports, tel que l’oscillator, régulateur de tension et la logique de commande du système.
 +
<center>
 +
{|
 +
| [[Fichier:ether.png|thumb|upright=2|L'intérieure d'enc28j60]]
 +
|}
 +
</center>
 +
Il y a trois types de registres pour enc28j60: controller registre, ethernet registre et mac registre. Pour voir comment fonctionne le registre, cela contient 2+2+2 étapes, c'est à dire que l'écriture de registre et la lecture de registre, l'écriture de buffer et la lecture de buffer, l'écriture de registre PHY et la lecture de registre PHY.
  
 
=Avancement du projet=
 
=Avancement du projet=
Ligne 441 : Ligne 462 :
 
=== Qu'est ce qu'une modulation à étalement de spectre LoRa? ===
 
=== Qu'est ce qu'une modulation à étalement de spectre LoRa? ===
  
−
Le modem LoRa utilise une technique exclusive de modulation du spectre étalé. Cette technique est plus résistante aux interférences et au bruit  dans la bande.
+
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.
 
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. La bande de fréquence
+
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 ===
 
=== Alimentation ===
Ligne 458 : Ligne 477 :
 
Solution: Nous allons donc configurer un I/O comme un SS afin d'avoir autant de SS que de périphériques esclaves.
 
Solution: Nous allons donc configurer un I/O comme un SS afin d'avoir autant de SS que de périphériques esclaves.
  
−
Fonctionnement :  
+
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.
 
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.
  
 
[[Fichier:Liaison_Maitre-esclave.jpg|500px|center|Carte Ethernet]]
 
[[Fichier:Liaison_Maitre-esclave.jpg|500px|center|Carte Ethernet]]
 +
 +
Transmission d'une trame SPI LoRa en mode simple accès
 +
 +
[[Fichier:Simple_access_lora.jpg|Transmission trame SPI LoRa|500px|center]]
 +
 +
=== Machine d'états===
 +
 +
 +
  
 
===Réalisation des cartes PCB===
 
===Réalisation des cartes PCB===
 
====La carte 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.  
 
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.  
 
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.  
Ligne 496 : Ligne 542 :
 
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.
 
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.
  
−
<gallery style="margin: 0 auto;">
+
====Routage du PCB====
−
Fichier:
+
----
−
</gallery>
+
 
 +
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,
 +
 
 +
[[Fichier:CartePCB.PNG‎|500px|center|PCB de la carte]]
 +
 
 +
==== 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,..
 +
[[Fichier:Sonia.png‎|500px|center|Design de l'antenne]]
 +
 
 +
 
 +
==== Réalisation de la carte sur Fritzing ====
 +
----
 +
 
 +
N'ayant pas pu finir la réalisation de la carte sur Altium, nous avons donc décidé de la faire sur Fritzing ( plus simple d'utilisation, puisque la plupart des packages sont déjà disponibles dans la librairie)
 +
 
 +
[[Fichier:Carte_fritzing.jpg|500px|center|Carte_projet]]
 +
 
 +
 
 +
Après avoir soudé tous les composants sur la carte, nous avons réalisé quelques tests pour voir si tous les étages sont fonctionnels.
 +
Pour l'instant, seul l'étage "Alimentation" est fonctionnel. On peut avoir une Led orange témoin allumée.
 +
 
 +
Par la suite, nous vérifierons si :  
 +
 
 +
*La carte est reconnue comme port série (FTDI)
 +
*Si l'ENC28J60  et le SX1276 fonctionnent correctement
 +
*Si le micro-contrôleur AtMega328P arrive à gérer les 2 périphériques.
 +
 
 +
[[Fichier:Carte_soudée.jpg|500px|center|Carte_projet]]
  
 
====La programmation====
 
====La programmation====
−
La carte sera programmée en langage C.  
+
----
−
Avantages :  
+
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,..
 +
 +
*<span style="color:green"> Partie LoRa </span> <br/>
 +
----
 +
 
 +
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.
 +
 
 +
Après avoir retranscrit les bibliothèques en C, nous avons tenté de faire un test. On s'est vite rendu compte que les fonctions SPI étaient mal écrites, elles ont été réécrites en utilisant les registres SPI de l'AtMega328P.
 +
Nous avons également réalisé 3  ponts diviseurs permettant de fournir des tensions supportables par les broches du modem LoRa avec des résistances de 220 Ω.
 +
 
 +
Pour la réalisation de la carte, nous utiliserons un adaptateur de niveaux.
 +
 
 +
[[Fichier:Txb.jpg|thumb|center|Adaptateur de signaux|300px]]
 +
 
 +
Après configurations des registres pour la modulation LoRa, nous avons alors écrit le code pour gérer l'émission et la réception.
 +
 
 +
 
 +
---- Module Server (chargé de l'émission)
 +
----
 +
 
 +
Les registres sont configurés en mode 'Sleep'.  Ensuite on remplit le buffer FIFO des données à transmettre.
 +
Pour effectuer une transmission,il faut d'abord faire une demande du mode de transmission (en d'autres mots configurer le registre des modes du sx1276), car lorsque la transmission est effectuée le sx1276 se met automatiquement en mode sleep.
 +
A la fin de la transmission, l'interruption TXDone est levée.
 +
 
 +
Voici le code :
 +
 
 +
int main() {
 +
        mode                    = 0x01;
 +
        Freq_Sel                = 0x00;
 +
        Power_Sel              = 0x00;
 +
        Lora_Rate_Sel          = 0x01;
 +
        BandWide_Sel            = 0x08;
 +
        Fsk_Rate_Sel            = 0x00;
 +
        init_printf();
 +
        spi_init();
 +
        setup();
 +
        printf("####################\nLoRa-Server\n####################\n");
 +
        sx1276_Config();
 +
        int T = 84;
 +
        int loopCnt = 0;
 +
        unsigned char paquet[T];
 +
        unsigned char fragment[MAX_FRAGMENT+1];
 +
        unsigned char m=0;
 +
        unsigned char inc;
 +
        unsigned char i;
 +
        int left;
 +
        while(1)
 +
        {
 +
                for (i=0;i<T;i++) paquet[i] = (0x61 + i+ loopCnt);
 +
                sx1276_Mode();
 +
                left=T;
 +
                inc=0;
 +
                while(1){
 +
                        if(left>=MAX_FRAGMENT) m=MAX_FRAGMENT; else m=left;
 +
                        left=left-m;
 +
                        for(i=0;i<m;i++){
 +
                                fragment[i] = paquet[i+inc*MAX_FRAGMENT];
 +
                        }
 +
                        inc++;
 +
                        fragment[m] = ((left<=0)?0x40:0x00)|inc;
 +
                        sx1276_LoRaEntryTx(m+1);
 +
                        sx1276_LoRaTxPacket(fragment,m+1);
 +
                        //digitalWrite(led,1);
 +
                        _delay_ms(50);
 +
                        //printf("Messages being transmitted\n");
 +
                        for (i=0;i<m+1;i++){
 +
                                printf("%02x ",fragment[i]);
 +
                                if(i%16==15) printf("\n");
 +
                        }
 +
                        printf("\n");
 +
                        if(left<=0) break;
 +
                        digitalWrite(led, 0);
 +
                        loopCnt++;
 +
                        //printf(".............................\n");
 +
                      }
 +
        }
 +
return 0;
 +
}
 +
 
 +
 
 +
 
 +
 
 +
---- Module Client (chargé de la réception)
 +
----
 +
 
 +
De la même manière que pour l'émetteur, nous configurons le mode de reception continu.Lorsqu'un paquet est reçu, une interruption RxDone est levée et la pile FIFO peut être remplie.
 +
 
 +
 
 +
int main() {
 +
  mode                  = 0x01;
 +
  Freq_Sel              = 0x00;
 +
  Power_Sel            = 0x00;
 +
  Lora_Rate_Sel        = 0x01;
 +
  BandWide_Sel          = 0x08;
 +
  Fsk_Rate_Sel          = 0x00;
 +
  init_printf();
 +
  spi_init();
 +
  setup();
 +
  BlinkLed();
 +
  printf("\n\nHello I am LoRa Client\nWaiting for RX packet\n");
 +
  sx1276_Config();
 +
  sx1276_LoRaEntryRx(MAX_FRAGMENT+1);
 +
  unsigned char trameEthernet[MAX_ETHERNET];
 +
while(1) {
 +
    unsigned char packet_size;
 +
    unsigned char taille=0;
 +
    unsigned char fragment[MAX_FRAGMENT+1];
 +
    unsigned char i=0;
 +
    unsigned char j=0;
 +
    //sx1276_infos();
 +
        if((packet_size=sx1276_LoRaRxPacket(fragment))!=0){
 +
        unsigned char var=fragment[packet_size-1];
 +
        unsigned char num_packet = (var&0x3F);
 +
        unsigned char dernier_frag = (var&0xC0);
 +
        int previous=(num_packet-1)*MAX_FRAGMENT;
 +
        printf("%d %d\n ",previous,packet_size);
 +
        for(i=0;i<packet_size-1;i++) trameEthernet[previous+i]=fragment[i];
 +
        if (dernier_frag==0x40){
 +
                taille = previous+packet_size;
 +
                printf("trame Ethernet (%d) : \n",taille);
 +
        if (dernier_frag==0x40){
 +
                taille = previous+packet_size;
 +
                printf("trame Ethernet (%d) : \n",taille);
 +
                for (j=0; j<taille; j++) {
 +
                        printf("%02x ",trameEthernet[j]);
 +
                        if(j%16==15) printf("\n");
 +
                        }
 +
                printf("\n");
 +
        }
 +
      }
 +
}
 +
return 0;
 +
}
 +
 
 +
 
 +
Cependant, la modulation LoRa dépend fortement du facteur d'étalement, de la bande passante, et des données à envoyer. Le facteur d'étalement SF= 6 (spread factor) nécessite une configuration particulière des registres.
  
−
///En même de faire notre carte PCB, nous avons aussi réfléchit à propos des programmations de la carte Ethernet , de la carte microcontroleur et de la carte Lora.
+
NB : En mode LoRa, le nombre maximal d'octets qui peut être envoyé est de 255 octets. Ceci nous a conduit à fragmenter les paquets à envoyer(ou recevoir). Les données seront ensuite assemblés à la réception (côté Ethernet).
  
−
<span style="color:green">Partie Ethernet  </span>
 
  
  
−
<span style="color:green">Partie LoRa </span> <br/>
+
----Fragmentation des paquets LoRa
 +
----
 +
 
 +
Nous avons été confrontées au problème de taille maximale que pouvait transmettre le LoRa (nettement inférieure à la taille maximale du paquet Ethernet, pouvant aller jusqu’à 1500 octets).
 +
 
 +
Le principe est de stocker les fragments de paquets Ethernet (<255 octets) jusqu’à la reconstitution complète du paquet initial.
 +
 
 +
Principe:
 +
 
 +
Lorsque le client reçoit un paquet, il examine le dernier octet :
 +
 
 +
▪ si IF = 0 : il ne s’agit pas du dernier fragment. Le client stocke le paquet dans un tableau( file d’attente de tous les paquets)
 +
 
 +
▪ si IF = 1 : le client place le paquet en fin de file du tableau.
 +
 +
Le client considère la file d'attente complète quand il a placé le premier et le dernier fragment et tous les fragments intermédiaires vérifiés par leur numéro de fragment.
 +
 
 +
 
 +
 
 +
------------Résultats des tests
 +
------------
 +
 
 +
Sur le minicom série, on peut voir qu'on reçoit les paquets du module1 envoyés par le module2.
 +
 
 +
 
 +
<center>
 +
{|
 +
|[[Fichier:Loraemission.png|thumb|upright=1|Emission|400px]]
 +
|[[Fichier:Lorareception.png|thumb|upright=1|Reception|450px]]
 +
|}
 +
</center>
 +
 
 +
 
 +
 
 +
 
 +
*<span style="color:green">Partie Ethernet  </span>
 +
----
 +
 
 +
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
 +
<pre>
 +
#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;
 +
}
 +
</pre>
 +
Et le code pour le récepteur
 +
<pre>
 +
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;
 +
}
 +
</pre>
 +
Ces deux codes permettent l'émetteur et le récepteur de communiquer entre eux.
 +
 
 +
[[Fichier:communication.jpg|400px|center|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.
 +
 
 +
Ensuite nous avons développé notre idée. Voici une image pour mieux expliqué comment cela fonctionne.
 +
<center>
 +
[[Fichier:Untitled drawing.jpg|400px|thumb|center|Objectif du second prototype]]
 +
</center>
 +
 
 +
La carte ethernet1 doit arriver à recevoir des paquets ethernet du PC1 par la liaison série. Ensuite elle doit envoyer ces paquets à Arduino1 via SPI. Après l'Arduino1 va envoyer ces paquets par TX et RX. Une fois qu'Arduino2 reçoit ces paquet, il doit être capable d'envoyer des paquets à la carte ethernet2. Au final la carte ethernet2 doit envoyer toutes des données reçues à PC2. La transmission doit être bidirectionnel.
 +
Pour réussir ce but, nous avons divisé le travail en deux partie. Dans un premier temps, nous avons programmé une carte comme serveur et l'autre carte comme client. Et nous devions réaliser des taches marquées ci-dessous:
 +
 
 +
* 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
 +
 
 +
Lorsque nous envoyons des paquets via TX/RX donc ceux sont des paquets SLIP. Pour analyser des paquets, il faut chercher le début et la fin de la trame. Le protocole SLIP modifie le paquet IP de la manière suivante
 +
 
 +
* ajout d'un octet END afin de séparer les différents paquets
 +
* si l'octet END est présent dans le paquet, il est remplacé par une séquence de deux octets ESC et ESC_END
 +
* si l'octet ESC est présent dans le paquet, il est remplacé par une séquence de deux octets ESC et ESC_ESC
 +
* une variante du protocole peut commencer et finir les paquets par l'octet END
 +
 
 +
<center>
 +
[[Fichier:slip.png|400px|thumb|center|Les valeurs des octets modifiées sont les suivantes]]
 +
</center>
 +
 
 +
Basé sur ce protocole, nous avons donc écrit le code ci-dessous 
 +
<pre>
 +
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;
 +
    }
 +
  }
 +
}
 +
</pre>
 +
 
 +
Ensuite pour visualiser les transmissions des données, nous avons utilisé une commande
 +
<pre>
 +
tcpdump -vvvv -n -Xe -ieth0
 +
</pre>
 +
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
 +
<pre>
 +
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      ..............
 +
</pre>
 +
Même si nous avons eu des message sur le port d'écoute mais 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.
 +
 
 +
Après avoir étudié le datasheet d'enc28j60, nous avons bien résolu ce problème par ajouter le registre ERXFCON dans la librairie d'enc28j60. Selon son datasheet, ce registre permets de filtrer des paquets que nous recevons. Dans la fonction qui initialise enc28j60, nous avons donc écrit
 +
<pre>
 +
enc28j60Write(ERXFCON,0x60)
 +
</pre>
 +
 
 +
0x60 veut dire que nous mettons le 6ème et 5ème bit de ce registre en 1 et cela permet de laisser passer toutes les types de paquets.
 +
Nous avons ainsi réessayé ces deux cartes avec la nouvelle librairie et des nouveaux codes. Enfin nous avons réussit à envoyer et à recevoir des paquets ICMP et les autres genres de paquets ARP, IPV4...Nous avons refait la manipulation et nous avions des informations comme-suit
 +
 
 +
<center>
 +
{|
 +
|[[Fichier:t1.jpg|thumb|upright=1|manipulation]]
 +
|[[Fichier:m1.jpg|thumb|upright=1|tcpdump]]
 +
|[[Fichier:m2.jpg|thumb|upright=1|tcpdump]]
 +
|[[Fichier:m3.jpg|thumb|upright=1|ping]]
 +
|}
 +
</center>
 +
 
 +
Voici le code pour cette partie
 +
<pre>
 +
int main(void)
 +
{
 +
init_serial(115200);
 +
enc28j60Init(mac);
 +
output_init();
 +
while(1){
 +
  if(nb_ethernet==0){
 +
    nb_ethernet=enc28j60PacketReceive(MAX_BYTES,packet_ethernet);
 +
    if(nb_ethernet!=0){ index_ethernet=0; output_set(7,1); }
 +
    }
 +
  if((nb_ethernet>0)&&(serial_tx_available())){
 +
    if(index_ethernet<nb_ethernet){
 +
      output_set(6,1);
 +
      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);
 +
      output_set(6,0);
 +
      }
 +
    else{ send_serial(SLIP_END); nb_ethernet=0; output_set(7,0); }
 +
    } 
 +
  if(serial_rx_available()){
 +
    output_set(5,1);
 +
    unsigned char c=get_serial();
 +
    output_set(5,0);
 +
    if(c==SLIP_ESC){
 +
      output_set(5,1);
 +
      unsigned char code=get_serial();
 +
      output_set(5,0);
 +
      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;
 +
    }
 +
  }
 +
}   
 +
</pre>
 +
 
 +
Ensuite nous avons passé en deuxième partie, au lieu d'enregistrer des paquets dans la mémoire d'Arduino nous voulions directement utiliser enc28j60 pour envoyer et recevoir des données. Pour cela nous avons changé un peu la fonction dans la librairie. A la place d'appeler la fonction '''enc28j60PacketSend(unsigned int len,unsigned char* packet)''' nous écrivions trois autres fonctions qui permettent initialiser le buffer, écrire un octet sur buffer et finalise envoyer cet octet.Voici ces 3 fonctions
 +
<pre>
 +
//Function that initializes the Send Buffer
 +
int sendlen;
 +
void enc28j60InitializeSend(void)
 +
{
 +
// Set the write pointer to start of the transmit buffer area
 +
enc28j60Write(EWRPTL, TXSTART_INIT);
 +
enc28j60Write(EWRPTH, TXSTART_INIT>>8);
 +
sendlen = 0;
 +
enc28j60WriteByteSend(0x00);
 +
}
 +
</pre>
 +
<pre>
 +
//Function that writes un octet in the buffer
 +
 
 +
void enc28j60WriteByteSend(unsigned char byte)
 +
{
 +
enc28j60WriteOp(ENC28J60_WRITE_BUF_MEM, 0, byte);
 +
sendlen++;
 +
}
 +
</pre>
 +
<pre>
 +
//Function that finalizes the sending of the byte
 +
 
 +
void enc28j60FinalizeSend(void)
 +
{
 +
// Set the TXND pointer to correspond to the packet size given
 +
        enc28j60Write(ETXNDL, (TXSTART_INIT+sendlen));
 +
        enc28j60Write(ETXNDH, (TXSTART_INIT+sendlen)>>8);
 +
// send the contents of the transmit buffer onto the network
 +
        enc28j60WriteOp(ENC28J60_BIT_FIELD_SET, ECON1, ECON1_TXRTS);
 +
 
 +
}
 +
</pre>
 +
 
 +
Donc dans le code main, nous avons écrit
 +
<pre>
 +
int main(void)
 +
{
 +
init_serial(115200);
 +
enc28j60Init(mac);
 +
enc28j60InitializeSend();
 +
output_init();
 +
while(1)
 +
{
 +
if(nb_ethernet==0)
 +
{
 +
nb_ethernet=enc28j60PacketReceive(MAX_BYTES,packet_ethernet);
 +
if(nb_ethernet!=0)
 +
{
 +
index_ethernet=0;
 +
output_set(7,1);
 +
}
 +
        }
 +
if((nb_ethernet>0)&&(serial_tx_available()))
 +
{
 +
if(index_ethernet<nb_ethernet)
 +
{
 +
output_set(6,1);
 +
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);
 +
output_set(6,0);
 +
}
 +
else{send_serial(SLIP_END); nb_ethernet=0; output_set(7,0);}
 +
}
 +
if(serial_rx_available())
 +
{
 +
output_set(5,1);
 +
unsigned char c=get_serial();
 +
output_set(5,0);
 +
if(nb_serial==0) enc28j60InitializeSend();
 +
if(c==SLIP_ESC)
 +
{
 +
output_set(5,1);
 +
unsigned char code=get_serial();
 +
output_set(5,0);
 +
if(code==SLIP_CODE_END)
 +
{
 +
enc28j60WriteByteSend(SLIP_END);
 +
nb_serial++;
 +
}
 +
else if(code==SLIP_CODE_ESC)
 +
{
 +
enc28j60WriteByteSend(SLIP_ESC);
 +
nb_serial++;
 +
}
 +
        }
 +
else if(c==SLIP_END)
 +
{
 +
 +
enc28j60FinalizeSend();
 +
nb_serial=0;
 +
}
 +
else { enc28j60WriteByteSend(c); nb_serial++; }
 +
}
 +
}
 +
}
 +
</pre>
 +
Et cela marche aussi.
 +
<center>
 +
{|
 +
|[[Fichier:ping.jpg|thumb|upright=2|ping]]
 +
|[[Fichier:tcpdump.jpg|thumb|upright=2|tcpdump]]
 +
|}
 +
</center>
 +
 
 +
Nous avons aussi remplacé la fonction '''enc28j60PacketReceive(unsigned int maxlen, unsigned char* packet)''' par 3 fonctions.
 +
La première fonction permet d'initialiser le buffer de recevoir et voir s'il y a un paquet est reçu.
 +
<pre>
 +
//Function that initializes the receive buffer
 +
unsigned int enc28j60PacketReceive(void)
 +
{
 +
uint16_t rcvlen;
 +
        uint16_t rxstat;
 +
 +
// check if a packet has been received and buffered
 +
if(enc28j60Read(EPKTCNT)==0)
 +
{
 +
return(0);
 +
}
 +
 +
// set the read pointer to the start of the received packet
 +
enc28j60Write(ERDPTL, (NextPacketPtr));
 +
enc28j60Write(ERDPTH, (NextPacketPtr)>>8);
 +
 +
// read the next packet pointer
 +
NextPacketPtr = enc28j60ReadOp(ENC28J60_READ_BUF_MEM,0);
 +
NextPacketPtr |= enc28j60ReadOp(ENC28J60_READ_BUF_MEM,0)<<8;
 +
 
 +
// read the packet length
 +
rcvlen = enc28j60ReadOp(ENC28J60_READ_BUF_MEM,0);
 +
rcvlen |= enc28j60ReadOp(ENC28J60_READ_BUF_MEM,0)<<8;
 +
 +
// read the receive status
 +
rxstat = enc28j60ReadOp(ENC28J60_READ_BUF_MEM,0);
 +
rxstat = enc28j60ReadOp(ENC28J60_READ_BUF_MEM,0)<<8;
 +
 +
return(rcvlen);
 +
}
 +
</pre>
 +
 
 +
La seconde fonction permets de lire un seul octet dans un paquet
 +
<pre>
 +
unsigned char enc28j60ByteRead(void)
 +
{
 +
 
 +
return enc28j60ReadOp(ENC28J60_READ_BUF_MEM,0);
 +
 +
}
 +
</pre>
 +
 
 +
La troisième fonction permets de libérer le buffer
 +
<pre>
 +
void enc28j60FreeMemory(void)
 +
{     
 +
// move the RX read pointer to the start of the next received packet
 +
// this frees the memory we just read out
 +
enc28j60Write(ERXRDPTL, (NextPacketPtr));
 +
enc28j60Write(ERXRDPTH, (NextPacketPtr)>>8);
 +
enc28j60WriteOp(ENC28J60_BIT_FIELD_SET,ECON2,ECON2_PKTDEC);
 +
}
 +
</pre>
 +
 
 +
Donc le code principal est
 +
<pre>
 +
int main(void)
 +
{
 +
init_serial(115200);
 +
enc28j60Init(mac);
 +
enc28j60InitializeSend();
 +
output_init();
 +
while(1)
 +
{
 +
if(nb_ethernet==0)
 +
{
 +
//nb_ethernet=enc28j60PacketReceive(MAX_BYTES,packet_ethernet);
 +
nb_ethernet=enc28j60PacketReceive();
 +
if(nb_ethernet!=0)
 +
{
 +
index_ethernet=0;
 +
output_set(7,1);
 +
}
 +
        }
 +
if((nb_ethernet>0)&&(serial_tx_available()))
 +
{
 +
if(index_ethernet<nb_ethernet)
 +
{
 +
output_set(6,1);
 +
unsigned char c=enc28j60ByteRead(); 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);
 +
output_set(6,0);
 +
}
 +
else
 +
{
 +
send_serial(SLIP_END); nb_ethernet=0; output_set(7,0);
 +
enc28j60FreeMemory();
 +
}
 +
}
 +
if(serial_rx_available())
 +
{
 +
output_set(5,1);
 +
unsigned char c=get_serial();
 +
output_set(5,0);
 +
if(nb_serial==0) enc28j60InitializeSend();
 +
if(c==SLIP_ESC)
 +
{
 +
output_set(5,1);
 +
unsigned char code=get_serial();
 +
output_set(5,0);
 +
if(code==SLIP_CODE_END)
 +
{
 +
enc28j60WriteByteSend(SLIP_END);
 +
nb_serial++;
 +
}
 +
else if(code==SLIP_CODE_ESC)
 +
{
 +
enc28j60WriteByteSend(SLIP_ESC);
 +
nb_serial++;
 +
}
 +
        }
 +
else if(c==SLIP_END)
 +
{
 +
enc28j60FinalizeSend();
 +
nb_serial=0;
 +
}
 +
else { enc28j60WriteByteSend(c); nb_serial++; }
 +
}
 +
}
 +
}
 +
</pre>
 +
 
 +
Avec toutes ces modifications, ces deux cartes Ethernet peuvent communiquer entre eux.
 +
<center>
 +
{|
 +
|[[Fichier:ping1.jpg|thumb|upright=1.5|ping]]
 +
|[[Fichier:tcpdump1.jpg|thumb|upright=1.5|tcpdump]]
 +
|[[Fichier:communication1.jpg|thumb|upright=1.5|tcpdump]]
 +
|}
 +
</center>
 +
 
 +
*<span style="color:green">Partie Ethernet+LoRa </span>
 +
----
 +
Pour cette partie, nous essayons de mettre toutes les cartes ensemble: enc28j60+arduino+LoRa afin de réaliser la réussite de la transmission et la réception des paquets Ethernet. Cependant, nous avons rencontré deux problèmes principaux
 +
* Le choix de CS d'Arduino
 +
* La correspondance de la taille du paquet
 +
1). Pour le premier problème, des fonctions de SPI sont déjà définies par les fonctions dans la librairie de l'enc28j60, au lieu d'utiliser des fonctions définies nous avons appelé directement la fonction '''spi_init()''' dans le répertoire SPI du LoRa. Ensuite nous avons changé le pin de CS de l'enc28j60 pour que les deux cartes puissent travailler une après l'autre. 
 +
 
 +
2). Lorsque la longueur d'un paquet Ethernet peut atteindre 1500 octets mais la longueur maximal d'un paquet d'être enregistré dans le buffer du LoRa ne fait que 255 octets, donc nous avions le problème de correspondance de la taille du paquet. Pour résoudre ce problème nous avons fait la fragmentation. Nous avons créé un tableau de 64 octets, ensuite nous avons remplit ce tableau octet par octet. Le dernier octet est réservé pour dire le numéro du fragment et vérifier si c'est la fin du paquet.Quant à la réception, le récepteur doit recevoir des fragments en ordre. Une fois qu'il loupe un fragment, le récepteur va s'arrêter de capter des paquets et attend l'arrivée de nouveau paquet .
 +
<center>
 +
{|
 +
|[[Fichier:fragment.jpg|thumb|upright=2|Fragments du paquet]]
 +
|}
 +
</center>
 +
Après bien avoir étudié des caratères de module LoRa SX1276 et la carte Ethernet réseau ENC28J60, pour leur faire communiquer nous avons écrit un algorithme
 +
<pre>
 +
Boucle
 +
    Si pas de paquet Ethernet en stock Alors
 +
      tenter de lire un paquet Ethernet pour le mettre en stock
 +
    FSi
 +
    Si pas de réception en cours Alors
 +
      Si paquet Ethernet en stock Alors
 +
        envoyer un fragment LoRA
 +
        Si dernier fragment Alors
 +
          libérer la mémoire du paquet Ethernet
 +
          attendre un paquet LoRa un temps raisonnable
 +
        Fsi
 +
      Sinon
 +
        Si un paquet Ethernet vient d'être reçu par LoRa Alors
 +
          envoyer un paquet LoRa de taille 1
 +
      FSi
 +
    Fsi
 +
    Si pas d'envoi en cours et paquet LoRa reçu Alors
 +
      Si paquet est un fragment (taille > 1) Alors
 +
        stocker le fragment dans le tampon d'envoi Ethernet
 +
        Si dernier fragment Alors
 +
          envoyer le paquet sur Ethernet
 +
        FSi
 +
      FSi
 +
    FSi
 +
  FinBoucle
 +
</pre>
 +
En suite nous avons interprété cet algorithme en langage C
 +
<pre>
 +
while(1)
 +
        {
 +
                if(nb_ethernet==0)
 +
                {
 +
                        nb_ethernet = enc28j60PacketReceive();
 +
                        if(nb_ethernet>0 && nb_ethernet<=MAX_ETHERNET)
 +
                        {
 +
                                index_ethernet = 0;
 +
                                num_frag = 0;
 +
                                output_set(5,1);
 +
                        }
 +
                        else nb_ethernet=0;
 +
                }
 +
#ifdef VERBOSE
 +
                printf("num=%d nb_ethernet=%d\n",num,nb_ethernet);
 +
                _delay_ms(100);
 +
#endif
 +
                if(num<0)
 +
                {
 +
                        if(nb_ethernet>0)
 +
                        {
 +
                                int i;
 +
                                num=-1; rxmode=0;
 +
                                if(index_ethernet < nb_ethernet)
 +
                                {
 +
                                        for(i=0;(i<MAX_FRAGMENT) && (index_ethernet<nb_ethernet);i++)
 +
                                        {
 +
                                                unsigned char c = enc28j60ByteRead();
 +
                                                index_ethernet++;
 +
                                                packet_lora[i]=c;
 +
                                        }
 +
                                        if(index_ethernet < nb_ethernet) packet_lora[i]=0x00;
 +
                                        else packet_lora[i]=0x80;
 +
                                        packet_lora[i] |= num_frag++;
 +
#ifdef DEBUG
 +
                                        printf("ether=%d/%d num_frag=%02x taille=%d\n",index_ethernet,nb_ethernet,packet_lora[i],i+1);
 +
#endif
 +
                                        sx1276_LoRaEntryTx();
 +
                                        output_set(4,1);
 +
                                        sx1276_LoRaTxPacket(packet_lora,i+1);          //transmission from LoraServer
 +
                                        sx1276_LoRaTxReady();
 +
                                        output_set(4,0);
 +
                                        if(index_ethernet >= nb_ethernet)
 +
                                        {
 +
                                                nb_ethernet = 0;
 +
                                                enc28j60FreeMemory();
 +
                                                output_set(5,0);
 +
                                                /* Attendre un paquet LoRa un temps raisonnable */
 +
                                                unsigned char test=0;
 +
                                                sx1276_LoRaEntryRx();
 +
                                                rxmode=1;
 +
                                                for(i=0;i<MAX_WAIT/GRAIN_WAIT;i++){
 +
                                                        test=sx1276_LoRaRxTest();
 +
                                                        if(test) break;
 +
                                                        _delay_ms(GRAIN_WAIT);
 +
                                                        }
 +
                                                if(test){
 +
#ifdef DEBUG
 +
                                                        printf("Got answer!\n");
 +
#endif
 +
                                                        }
 +
                                        }
 +
                                        else _delay_ms(10);
 +
                                }
 +
                        }
 +
                        else{
 +
                                if(num==-2){
 +
                                        unsigned char c=0;
 +
#ifdef DEBUG
 +
                                        printf("Send void packet\n");
 +
#endif
 +
                                        sx1276_LoRaEntryTx();
 +
                                        sx1276_LoRaTxPacket(&c,1);
 +
                                        sx1276_LoRaTxReady();
 +
                                        num=-1;
 +
                                }
 +
                        }
 +
                }
 +
                if(index_ethernet<=0 || nb_ethernet==0){
 +
                        if(!rxmode) sx1276_LoRaEntryRx();
 +
                        rxmode=1;
 +
                        }
 +
                if(rxmode && (nb_received=sx1276_LoRaRxPacket(packet_received,MAX_FRAGMENT+1))>0)      //receptionfrom LoraClient
 +
                {
 +
                        unsigned char header=packet_received[nb_received-1];
 +
#ifdef DEBUG
 +
                        printf("rec=%d h=%02x\n",nb_received,header);
 +
#endif
 +
                        if (nb_received>1)
 +
                        {
 +
                                int j;
 +
                                if(num>=0 && (header&0x7f)!=num+1) num=-1;
 +
                                else{
 +
                                        if(num<0) num=-1;
 +
                                        if((header&0x7f)==0x00)
 +
                                        {
 +
                                                enc28j60InitializeSend();
 +
                                                output_set(6,1);
 +
                                        }
 +
                                        for(j=0;j<nb_received-1;j++) enc28j60WriteByteSend(packet_received[j]);
 +
                                        if((header&0x80)==0x00) num++;
 +
                                        else {
 +
#ifdef DEBUG
 +
                                                printf("Ether sending num=%d\n",num);
 +
#endif
 +
                                                num=-2;
 +
                                                enc28j60FinalizeSend();
 +
                                                output_set(6,0);
 +
                                                }
 +
                                        }
 +
                        }
 +
                        rxmode=0;
 +
#ifdef DEBUG
 +
                        printf("num=%d\n",num);
 +
#endif
 +
                }
 +
        }
 +
}
 +
</pre>
 +
 
 +
Nous avons effectué des tests avec un module LoRa et une carte réseau chaque coté, nous avons réussit à envoyer des paquets icmp et des paquets arp.
 +
<center>
 +
{|
 +
|[[Fichier:0001.jpg|thumb|upright=0.75|manipulation]]
 +
|[[Fichier:0002.jpg|thumb|upright=0.75|tcpdump+ping]]
 +
|[[Fichier:0003.jpg|thumb|upright=0.75|tcpdump]]
 +
|[[Fichier:0004.jpg|thumb|upright=0.75|minicom]]
 +
|}
 +
</center>
  
 
= Références =
 
= Références =
Ligne 532 : Ligne 1 440 :
  
 
Carte MBED : http://elmicro.com/en/mbed-nxp-lpc1768.html
 
Carte MBED : http://elmicro.com/en/mbed-nxp-lpc1768.html
 +
 +
https://github.com/2xs/smews/tree/develop/targets/Arduino_ethernet/drivers
 +
 +
= Rapport du PFE =
 +
 +
Rapport intermédiaire
 +
 +
[[Fichier:Rapport_intermédiairePFE19_Chen_Nduwayo.pdf]]
 +
 +
Rapport final
 +
 +
[[Fichier:Rapport_PFE19_CHEN_NDUWAYO.pdf]]
 +
 +
=Programme du projet=
 +
[[Fichier:Bridge.zip]]
 +
 +
=Vidéo demonstration du projet=
 +
 +
[[Media:test.mp4]]

Version actuelle datée du 27 février 2017 à 11:15

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.

Schématique de l'objectif du projet

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

Planning du projet

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.

Carte Ethernet
Module ENC28J60

Pour la suite de notre projet, il faut une bonne connaissance du module ENC28J60. La puce enc28j60 est Microship présente le premier controleur Ethernet 10BASE-T(10Mbits/s) reference ENC28J60 se laissant facilement piloter via un bus SPI(Serial Programming Interface) par un microcontroleur et ne comportant que 28 broches pour un boitier au format DIL. Ce contrôleur Ethernet dispose d'un module MAC et PHY intégrés et de 8ko de mémoire tampon permettant de minimiser la complexité de la mise en oeuvre et le coût. Les applications visées sont : la VoIP, l'automation industrielle, l'automation de bâtiment, l'instrumentation, la sécurité et la domotique. Jusqu'à lors, on ne trouvait sur le marché que des contrôleurs Ethernet tels que le RTL8019AS de Realtek. Ce circuit n'existait qu'au format CMS (boitier PQFP) composé d'une centaine de broches dont le tiers étaient destinées au bus de communication parallèle (adresses et données). Bref, sa mise en oeuvre était pour le moins ardue que ce soit sur le plan du routage du circuit imprimé que pour la soudure du composant. Ainsi, grâce à son faible nombre de broches faciles à souder, le ENC28J60 permet une intégration sensiblement facilité dans votre réseau domestique en lui couplant un microcontrôleur afin de piloter les fonctionnalités Ethernet. Disponible en boitier DIL (DIP), il reste la solution la moins chère pour la mise en oeuvre d'un projet connecté au réseau Ethernet. Il y a 7 sections de fonctionnalités pour ENC28J60.

  • 1). Un Interface SPI : un canal de communication entre le contrôleur hôte et l’ENC28J60.
  • 2). Les registres de control : contrôle et surveille l’ENC28J60.
  • 3). Un buffer RAM avec doubles ports : reçoit et transmet des paquets de données.
  • 4). Un arbitre : contrôle l’accès du buffer RAM quand des demandes sont faites de DMA, transmet et reçoit des blocs.
  • 5). Un interface bus : interprète des données et des commandes reçues via l’interface SPI.
  • 6). Un module MAC(Medium Access Control) : implémente IEEE 802.3 qui conforme MAC logique.
  • 7). Un module PHY (Physical Layer) : code et décode des données analogiques qui sont présentées sur l’interface à paire torsadée.

Le dispositif contient aussi d’autres blocs de supports, tel que l’oscillator, régulateur de tension et la logique de commande du système.

L'intérieure d'enc28j60

Il y a trois types de registres pour enc28j60: controller registre, ethernet registre et mac registre. Pour voir comment fonctionne le registre, cela contient 2+2+2 étapes, c'est à dire que l'écriture de registre et la lecture de registre, l'écriture de buffer et la lecture de buffer, l'écriture de registre PHY et la lecture de registre PHY.

Avancement du projet

Souder la carte Ethernet

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.

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.

Carte Ethernet

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

Transmission trame SPI LoRa

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,
PCB de la carte

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,..

Design de l'antenne


Réalisation de la carte sur Fritzing

N'ayant pas pu finir la réalisation de la carte sur Altium, nous avons donc décidé de la faire sur Fritzing ( plus simple d'utilisation, puisque la plupart des packages sont déjà disponibles dans la librairie)

Carte_projet


Après avoir soudé tous les composants sur la carte, nous avons réalisé quelques tests pour voir si tous les étages sont fonctionnels. Pour l'instant, seul l'étage "Alimentation" est fonctionnel. On peut avoir une Led orange témoin allumée. 

Par la suite, nous vérifierons si :
  • La carte est reconnue comme port série (FTDI)
  • Si l'ENC28J60 et le SX1276 fonctionnent correctement
  • Si le micro-contrôleur AtMega328P arrive à gérer les 2 périphériques.
Carte_projet

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.

Après avoir retranscrit les bibliothèques en C, nous avons tenté de faire un test. On s'est vite rendu compte que les fonctions SPI étaient mal écrites, elles ont été réécrites en utilisant les registres SPI de l'AtMega328P. Nous avons également réalisé 3 ponts diviseurs permettant de fournir des tensions supportables par les broches du modem LoRa avec des résistances de 220 Ω.

Pour la réalisation de la carte, nous utiliserons un adaptateur de niveaux.

Adaptateur de signaux

Après configurations des registres pour la modulation LoRa, nous avons alors écrit le code pour gérer l'émission et la réception.


Module Server (chargé de l'émission)

Les registres sont configurés en mode 'Sleep'. Ensuite on remplit le buffer FIFO des données à transmettre. Pour effectuer une transmission,il faut d'abord faire une demande du mode de transmission (en d'autres mots configurer le registre des modes du sx1276), car lorsque la transmission est effectuée le sx1276 se met automatiquement en mode sleep. A la fin de la transmission, l'interruption TXDone est levée.

Voici le code :

int main() { 

       mode                    = 0x01;
       Freq_Sel                = 0x00;
       Power_Sel               = 0x00;
       Lora_Rate_Sel           = 0x01;
       BandWide_Sel            = 0x08;
       Fsk_Rate_Sel            = 0x00;
       init_printf();
       spi_init();
       setup();
       printf("####################\nLoRa-Server\n####################\n");
       sx1276_Config();
       int T = 84;
       int loopCnt = 0;
       unsigned char paquet[T];
       unsigned char fragment[MAX_FRAGMENT+1];
       unsigned char m=0;
       unsigned char inc;
       unsigned char i;
       int left;
       while(1)
       {
               for (i=0;i<T;i++) paquet[i] = (0x61 + i+ loopCnt);
               sx1276_Mode();
               left=T;
               inc=0;
               while(1){
                       if(left>=MAX_FRAGMENT) m=MAX_FRAGMENT; else m=left;
                       left=left-m;
                       for(i=0;i<m;i++){
                               fragment[i] = paquet[i+inc*MAX_FRAGMENT];
                       }
                       inc++;
                       fragment[m] = ((left<=0)?0x40:0x00)|inc;
                        sx1276_LoRaEntryTx(m+1);
                       sx1276_LoRaTxPacket(fragment,m+1);
                       //digitalWrite(led,1);
                       _delay_ms(50);
                       //printf("Messages being transmitted\n");
                       for (i=0;i<m+1;i++){
                               printf("%02x ",fragment[i]);
                               if(i%16==15) printf("\n");
                       }
                       printf("\n");
                       if(left<=0) break;
                       digitalWrite(led, 0);
                       loopCnt++;
                       //printf(".............................\n");
                      }
       }

return 0; }



Module Client (chargé de la réception)

De la même manière que pour l'émetteur, nous configurons le mode de reception continu.Lorsqu'un paquet est reçu, une interruption RxDone est levée et la pile FIFO peut être remplie.


int main() { 

 mode                  = 0x01;
 Freq_Sel              = 0x00;
 Power_Sel             = 0x00;
 Lora_Rate_Sel         = 0x01;
 BandWide_Sel          = 0x08;
 Fsk_Rate_Sel          = 0x00;
 init_printf();
 spi_init();
 setup();
 BlinkLed();
 printf("\n\nHello I am LoRa Client\nWaiting for RX packet\n");
 sx1276_Config();
 sx1276_LoRaEntryRx(MAX_FRAGMENT+1);
 unsigned char trameEthernet[MAX_ETHERNET];
while(1) {
   unsigned char packet_size;
   unsigned char taille=0;
   unsigned char fragment[MAX_FRAGMENT+1];
   unsigned char i=0;
   unsigned char j=0;
   //sx1276_infos();
       if((packet_size=sx1276_LoRaRxPacket(fragment))!=0){
       unsigned char var=fragment[packet_size-1];
       unsigned char num_packet = (var&0x3F);
       unsigned char dernier_frag = (var&0xC0);
       int previous=(num_packet-1)*MAX_FRAGMENT;
       printf("%d %d\n ",previous,packet_size);
       for(i=0;i<packet_size-1;i++) trameEthernet[previous+i]=fragment[i];
       if (dernier_frag==0x40){
               taille = previous+packet_size;
               printf("trame Ethernet (%d) : \n",taille);
       if (dernier_frag==0x40){
               taille = previous+packet_size;
               printf("trame Ethernet (%d) : \n",taille);
               for (j=0; j<taille; j++) {
                       printf("%02x ",trameEthernet[j]);
                       if(j%16==15) printf("\n");
                       }
               printf("\n");
       }
     }
}

return 0; }


Cependant, la modulation LoRa dépend fortement du facteur d'étalement, de la bande passante, et des données à envoyer. Le facteur d'étalement SF= 6 (spread factor) nécessite une configuration particulière des registres.

NB : En mode LoRa, le nombre maximal d'octets qui peut être envoyé est de 255 octets. Ceci nous a conduit à fragmenter les paquets à envoyer(ou recevoir). Les données seront ensuite assemblés à la réception (côté Ethernet).


Fragmentation des paquets LoRa

Nous avons été confrontées au problème de taille maximale que pouvait transmettre le LoRa (nettement inférieure à la taille maximale du paquet Ethernet, pouvant aller jusqu’à 1500 octets).

Le principe est de stocker les fragments de paquets Ethernet (<255 octets) jusqu’à la reconstitution complète du paquet initial.

Principe:

Lorsque le client reçoit un paquet, il examine le dernier octet :

▪ si IF = 0 : il ne s’agit pas du dernier fragment. Le client stocke le paquet dans un tableau( file d’attente de tous les paquets)

▪ si IF = 1 : le client place le paquet en fin de file du tableau.

Le client considère la file d'attente complète quand il a placé le premier et le dernier fragment et tous les fragments intermédiaires vérifiés par leur numéro de fragment.


Résultats des tests

Sur le minicom série, on peut voir qu'on reçoit les paquets du module1 envoyés par le module2.


Emission
Reception



  • 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.

Ensuite nous avons développé notre idée. Voici une image pour mieux expliqué comment cela fonctionne.

Objectif du second prototype

La carte ethernet1 doit arriver à recevoir des paquets ethernet du PC1 par la liaison série. Ensuite elle doit envoyer ces paquets à Arduino1 via SPI. Après l'Arduino1 va envoyer ces paquets par TX et RX. Une fois qu'Arduino2 reçoit ces paquet, il doit être capable d'envoyer des paquets à la carte ethernet2. Au final la carte ethernet2 doit envoyer toutes des données reçues à PC2. La transmission doit être bidirectionnel. Pour réussir ce but, nous avons divisé le travail en deux partie. Dans un premier temps, nous avons programmé une carte comme serveur et l'autre carte comme client. Et nous devions réaliser des taches marquées ci-dessous:

  • 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

Lorsque nous envoyons des paquets via TX/RX donc ceux sont des paquets SLIP. Pour analyser des paquets, il faut chercher le début et la fin de la trame. Le protocole SLIP modifie le paquet IP de la manière suivante

  • ajout d'un octet END afin de séparer les différents paquets
  • si l'octet END est présent dans le paquet, il est remplacé par une séquence de deux octets ESC et ESC_END
  • si l'octet ESC est présent dans le paquet, il est remplacé par une séquence de deux octets ESC et ESC_ESC
  • une variante du protocole peut commencer et finir les paquets par l'octet END
Les valeurs des octets modifiées sont les suivantes

Basé sur ce protocole, nous avons donc écrit le code ci-dessous 

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 visualiser 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       ..............

Même si nous avons eu des message sur le port d'écoute mais 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.

Après avoir étudié le datasheet d'enc28j60, nous avons bien résolu ce problème par ajouter le registre ERXFCON dans la librairie d'enc28j60. Selon son datasheet, ce registre permets de filtrer des paquets que nous recevons. Dans la fonction qui initialise enc28j60, nous avons donc écrit 

enc28j60Write(ERXFCON,0x60)

0x60 veut dire que nous mettons le 6ème et 5ème bit de ce registre en 1 et cela permet de laisser passer toutes les types de paquets. Nous avons ainsi réessayé ces deux cartes avec la nouvelle librairie et des nouveaux codes. Enfin nous avons réussit à envoyer et à recevoir des paquets ICMP et les autres genres de paquets ARP, IPV4...Nous avons refait la manipulation et nous avions des informations comme-suit

manipulation
tcpdump
tcpdump
ping

Voici le code pour cette partie 

int main(void)
{
init_serial(115200);
enc28j60Init(mac);
output_init();
while(1){
  if(nb_ethernet==0){
    nb_ethernet=enc28j60PacketReceive(MAX_BYTES,packet_ethernet);
    if(nb_ethernet!=0){ index_ethernet=0; output_set(7,1); }
    }
  if((nb_ethernet>0)&&(serial_tx_available())){
    if(index_ethernet<nb_ethernet){ 
      output_set(6,1);
      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);
      output_set(6,0);
      } 
    else{ send_serial(SLIP_END); nb_ethernet=0; output_set(7,0); } 
    }  
  if(serial_rx_available()){
    output_set(5,1);
    unsigned char c=get_serial();
    output_set(5,0);
    if(c==SLIP_ESC){
      output_set(5,1);
      unsigned char code=get_serial();
      output_set(5,0);
      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 nous avons passé en deuxième partie, au lieu d'enregistrer des paquets dans la mémoire d'Arduino nous voulions directement utiliser enc28j60 pour envoyer et recevoir des données. Pour cela nous avons changé un peu la fonction dans la librairie. A la place d'appeler la fonction enc28j60PacketSend(unsigned int len,unsigned char* packet) nous écrivions trois autres fonctions qui permettent initialiser le buffer, écrire un octet sur buffer et finalise envoyer cet octet.Voici ces 3 fonctions 

//Function that initializes the Send Buffer
int sendlen;
void enc28j60InitializeSend(void)
{
	// Set the write pointer to start of the transmit buffer area
	enc28j60Write(EWRPTL, TXSTART_INIT);
	enc28j60Write(EWRPTH, TXSTART_INIT>>8);
	sendlen = 0;
	enc28j60WriteByteSend(0x00);
}

//Function that writes un octet in the buffer

void enc28j60WriteByteSend(unsigned char byte)
{
	enc28j60WriteOp(ENC28J60_WRITE_BUF_MEM, 0, byte);
	sendlen++;
}

//Function that finalizes the sending of the byte

void enc28j60FinalizeSend(void)
{
	// Set the TXND pointer to correspond to the packet size given
        enc28j60Write(ETXNDL, (TXSTART_INIT+sendlen));
        enc28j60Write(ETXNDH, (TXSTART_INIT+sendlen)>>8);		
	// send the contents of the transmit buffer onto the network
        enc28j60WriteOp(ENC28J60_BIT_FIELD_SET, ECON1, ECON1_TXRTS);

}

Donc dans le code main, nous avons écrit 

int main(void)
{
init_serial(115200);
enc28j60Init(mac);
enc28j60InitializeSend();
output_init();
while(1)
 {
	if(nb_ethernet==0)
	{
		nb_ethernet=enc28j60PacketReceive(MAX_BYTES,packet_ethernet);
		if(nb_ethernet!=0)
		{
			index_ethernet=0;
			output_set(7,1);
		}
        }
	if((nb_ethernet>0)&&(serial_tx_available()))
	{
		if(index_ethernet<nb_ethernet)
		{
			output_set(6,1);
			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);
			output_set(6,0);
		}
		else{send_serial(SLIP_END); nb_ethernet=0; output_set(7,0);}
	}
	if(serial_rx_available())
	{
		output_set(5,1);
		unsigned char c=get_serial();
		output_set(5,0);
		if(nb_serial==0) enc28j60InitializeSend(); 
		if(c==SLIP_ESC)
		{
			output_set(5,1);
			unsigned char code=get_serial();
			output_set(5,0);
			if(code==SLIP_CODE_END) 
			{	
				enc28j60WriteByteSend(SLIP_END);
				nb_serial++;
			}
			else if(code==SLIP_CODE_ESC) 
			{
				enc28j60WriteByteSend(SLIP_ESC);
				nb_serial++;
			}
        	}
		else if(c==SLIP_END)
		{
	 		
			enc28j60FinalizeSend();
			nb_serial=0;
		}
		else { enc28j60WriteByteSend(c); nb_serial++; }
	}
 }
}

Et cela marche aussi.

ping
tcpdump

Nous avons aussi remplacé la fonction enc28j60PacketReceive(unsigned int maxlen, unsigned char* packet) par 3 fonctions. La première fonction permet d'initialiser le buffer de recevoir et voir s'il y a un paquet est reçu. 

//Function that initializes the receive buffer
unsigned int enc28j60PacketReceive(void)
{
	uint16_t rcvlen;
        uint16_t rxstat;
	
	// check if a packet has been received and buffered
	if(enc28j60Read(EPKTCNT)==0) 
	{
		return(0);
	}
	
	// set the read pointer to the start of the received packet
	enc28j60Write(ERDPTL, (NextPacketPtr));
	enc28j60Write(ERDPTH, (NextPacketPtr)>>8);
	
	// read the next packet pointer
	NextPacketPtr = enc28j60ReadOp(ENC28J60_READ_BUF_MEM,0);
	NextPacketPtr |= enc28j60ReadOp(ENC28J60_READ_BUF_MEM,0)<<8;

	// read the packet length
	rcvlen = enc28j60ReadOp(ENC28J60_READ_BUF_MEM,0);
	rcvlen |= enc28j60ReadOp(ENC28J60_READ_BUF_MEM,0)<<8;
	
	// read the receive status
	rxstat = enc28j60ReadOp(ENC28J60_READ_BUF_MEM,0);
	rxstat = enc28j60ReadOp(ENC28J60_READ_BUF_MEM,0)<<8;
	
	return(rcvlen);	
}

La seconde fonction permets de lire un seul octet dans un paquet 

unsigned char enc28j60ByteRead(void)
{

	return enc28j60ReadOp(ENC28J60_READ_BUF_MEM,0);
		
}

La troisième fonction permets de libérer le buffer 

void enc28j60FreeMemory(void)
{       
	// move the RX read pointer to the start of the next received packet
	// this frees the memory we just read out
	enc28j60Write(ERXRDPTL, (NextPacketPtr));
	enc28j60Write(ERXRDPTH, (NextPacketPtr)>>8);
	enc28j60WriteOp(ENC28J60_BIT_FIELD_SET,ECON2,ECON2_PKTDEC);
}

Donc le code principal est 

int main(void)
{
init_serial(115200);
enc28j60Init(mac);
enc28j60InitializeSend();
output_init();
while(1)
 {
	if(nb_ethernet==0)
	{
		//nb_ethernet=enc28j60PacketReceive(MAX_BYTES,packet_ethernet);
		nb_ethernet=enc28j60PacketReceive();
		if(nb_ethernet!=0)
		{
			index_ethernet=0;
			output_set(7,1);
		}
        }
	if((nb_ethernet>0)&&(serial_tx_available()))
	{
		if(index_ethernet<nb_ethernet)
		{
			output_set(6,1);
			unsigned char c=enc28j60ByteRead(); 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);
			output_set(6,0);
		}
		else
		{
			send_serial(SLIP_END); nb_ethernet=0; output_set(7,0);
			enc28j60FreeMemory(); 
		}
	}
	if(serial_rx_available())
	{
		output_set(5,1);
		unsigned char c=get_serial();
		output_set(5,0);
		if(nb_serial==0) enc28j60InitializeSend(); 
		if(c==SLIP_ESC)
		{
			output_set(5,1);
			unsigned char code=get_serial();
			output_set(5,0);
			if(code==SLIP_CODE_END) 
			{	
				enc28j60WriteByteSend(SLIP_END);
				nb_serial++;
			}
			else if(code==SLIP_CODE_ESC) 
			{
				enc28j60WriteByteSend(SLIP_ESC);
				nb_serial++;
			}
        	}
		else if(c==SLIP_END)
		{
			enc28j60FinalizeSend();
			nb_serial=0;
		}
		else { enc28j60WriteByteSend(c); nb_serial++; }
	}
 }
}

Avec toutes ces modifications, ces deux cartes Ethernet peuvent communiquer entre eux.

ping
tcpdump
tcpdump
  • Partie Ethernet+LoRa

Pour cette partie, nous essayons de mettre toutes les cartes ensemble: enc28j60+arduino+LoRa afin de réaliser la réussite de la transmission et la réception des paquets Ethernet. Cependant, nous avons rencontré deux problèmes principaux

  • Le choix de CS d'Arduino
  • La correspondance de la taille du paquet

1). Pour le premier problème, des fonctions de SPI sont déjà définies par les fonctions dans la librairie de l'enc28j60, au lieu d'utiliser des fonctions définies nous avons appelé directement la fonction spi_init() dans le répertoire SPI du LoRa. Ensuite nous avons changé le pin de CS de l'enc28j60 pour que les deux cartes puissent travailler une après l'autre.

2). Lorsque la longueur d'un paquet Ethernet peut atteindre 1500 octets mais la longueur maximal d'un paquet d'être enregistré dans le buffer du LoRa ne fait que 255 octets, donc nous avions le problème de correspondance de la taille du paquet. Pour résoudre ce problème nous avons fait la fragmentation. Nous avons créé un tableau de 64 octets, ensuite nous avons remplit ce tableau octet par octet. Le dernier octet est réservé pour dire le numéro du fragment et vérifier si c'est la fin du paquet.Quant à la réception, le récepteur doit recevoir des fragments en ordre. Une fois qu'il loupe un fragment, le récepteur va s'arrêter de capter des paquets et attend l'arrivée de nouveau paquet .

Fragments du paquet

Après bien avoir étudié des caratères de module LoRa SX1276 et la carte Ethernet réseau ENC28J60, pour leur faire communiquer nous avons écrit un algorithme 

Boucle
    Si pas de paquet Ethernet en stock Alors
      tenter de lire un paquet Ethernet pour le mettre en stock
    FSi
    Si pas de réception en cours Alors
      Si paquet Ethernet en stock Alors
        envoyer un fragment LoRA
        Si dernier fragment Alors
          libérer la mémoire du paquet Ethernet
          attendre un paquet LoRa un temps raisonnable
        Fsi
      Sinon
        Si un paquet Ethernet vient d'être reçu par LoRa Alors
          envoyer un paquet LoRa de taille 1
      FSi
    Fsi
    Si pas d'envoi en cours et paquet LoRa reçu Alors
      Si paquet est un fragment (taille > 1) Alors
        stocker le fragment dans le tampon d'envoi Ethernet
        Si dernier fragment Alors
          envoyer le paquet sur Ethernet
        FSi
      FSi
    FSi
  FinBoucle

En suite nous avons interprété cet algorithme en langage C 

while(1)
        {
                if(nb_ethernet==0)
                {
                        nb_ethernet = enc28j60PacketReceive();
                        if(nb_ethernet>0 && nb_ethernet<=MAX_ETHERNET)
                        {
                                index_ethernet = 0;
                                num_frag = 0;
                                output_set(5,1);
                        }
                        else nb_ethernet=0;
                }
#ifdef VERBOSE
                printf("num=%d nb_ethernet=%d\n",num,nb_ethernet);
                _delay_ms(100);
#endif
                if(num<0)
                {
                        if(nb_ethernet>0)
                        {
                                int i;
                                num=-1; rxmode=0;
                                if(index_ethernet < nb_ethernet)
                                {
                                        for(i=0;(i<MAX_FRAGMENT) && (index_ethernet<nb_ethernet);i++)
                                        {
                                                unsigned char c = enc28j60ByteRead();
                                                index_ethernet++;
                                                packet_lora[i]=c;
                                        }
                                        if(index_ethernet < nb_ethernet) packet_lora[i]=0x00;
                                        else packet_lora[i]=0x80;
                                        packet_lora[i] |= num_frag++;
#ifdef DEBUG
                                        printf("ether=%d/%d num_frag=%02x taille=%d\n",index_ethernet,nb_ethernet,packet_lora[i],i+1);
#endif
                                        sx1276_LoRaEntryTx();
                                        output_set(4,1);
                                        sx1276_LoRaTxPacket(packet_lora,i+1);           //transmission from LoraServer
                                        sx1276_LoRaTxReady();
                                        output_set(4,0);
                                        if(index_ethernet >= nb_ethernet)
                                        {
                                                nb_ethernet = 0;
                                                enc28j60FreeMemory();
                                                output_set(5,0);
                                                /* Attendre un paquet LoRa un temps raisonnable */
                                                unsigned char test=0;
                                                sx1276_LoRaEntryRx();
                                                rxmode=1;
                                                for(i=0;i<MAX_WAIT/GRAIN_WAIT;i++){
                                                        test=sx1276_LoRaRxTest();
                                                        if(test) break;
                                                        _delay_ms(GRAIN_WAIT);
                                                        }
                                                if(test){
#ifdef DEBUG
                                                        printf("Got answer!\n");
#endif
                                                        }
                                        }
                                        else _delay_ms(10);
                                }
                        }
                        else{
                                if(num==-2){
                                        unsigned char c=0;
#ifdef DEBUG
                                        printf("Send void packet\n");
#endif
                                        sx1276_LoRaEntryTx();
                                        sx1276_LoRaTxPacket(&c,1);
                                        sx1276_LoRaTxReady();
                                        num=-1;
                                }
                        }
                }
                if(index_ethernet<=0 || nb_ethernet==0){
                        if(!rxmode) sx1276_LoRaEntryRx();
                        rxmode=1;
                        }
                if(rxmode && (nb_received=sx1276_LoRaRxPacket(packet_received,MAX_FRAGMENT+1))>0)       //receptionfrom LoraClient
                {
                        unsigned char header=packet_received[nb_received-1];
#ifdef DEBUG
                        printf("rec=%d h=%02x\n",nb_received,header);
#endif
                        if (nb_received>1)
                        {
                                int j;
                                if(num>=0 && (header&0x7f)!=num+1) num=-1;
                                else{
                                        if(num<0) num=-1;
                                        if((header&0x7f)==0x00)
                                        {
                                                enc28j60InitializeSend();
                                                output_set(6,1);
                                        }
                                        for(j=0;j<nb_received-1;j++) enc28j60WriteByteSend(packet_received[j]);
                                        if((header&0x80)==0x00) num++;
                                        else {
#ifdef DEBUG
                                                printf("Ether sending num=%d\n",num);
#endif
                                                num=-2;
                                                enc28j60FinalizeSend();
                                                output_set(6,0);
                                                }
                                        }
                        }
                        rxmode=0;
#ifdef DEBUG
                        printf("num=%d\n",num);
#endif
                }
        }
}

Nous avons effectué des tests avec un module LoRa et une carte réseau chaque coté, nous avons réussit à envoyer des paquets icmp et des paquets arp.

manipulation
tcpdump+ping
tcpdump
minicom

Références

Datasheets

Fichier:Datasheet cartereseau.pdf

Fichier:Datasheet lora.pdf

Micro-controleur Atmega328p: http://www.atmel.com/Images/Atmel-42735-8-bit-AVR-Microcontroller-ATmega328-328P_datasheet.pdf

Documentation (Liens utiles)

https://learn.adafruit.com/adafruit-feather-32u4-radio-with-lora-radio-module/downloads

Schematic du module radio : http://modtronix.com/prod/imod/inair9/inair9_r1_sch.pdf

Schematic du mbed : https://developer.mbed.org/media/uploads/chris/lpc1768-refdesign-schematic.pdf

Carte MBED à base de microprocesseur ARM Cortex-3 : http://www.rennes.supelec.fr/ren/perso/jweiss/microp/mbed/mbed.php/

Carte MBED : http://elmicro.com/en/mbed-nxp-lpc1768.html

https://github.com/2xs/smews/tree/develop/targets/Arduino_ethernet/drivers

Rapport du PFE

Rapport intermédiaire

Fichier:Rapport intermédiairePFE19 Chen Nduwayo.pdf

Rapport final

Fichier:Rapport PFE19 CHEN NDUWAYO.pdf

Programme du projet

Fichier:Bridge.zip

Vidéo demonstration du projet

Media:test.mp4

Récupérée de « https://projets-ima.plil.fr/mediawiki/index.php?title=P19_Relai_Ethernet_Lora&oldid=39741 »