====== Atelier : Communication sans fils ======

====Séance 2 : RfDuino====

  * [[http://files.rfdigital.com/rfduino.quick.start.guide.pdf|Installer RfDuino (Win & MacOS)]]
  * [[http://www.rfduino.com/download-rfduino-library/index.html|Télécharger RfDuino]]
  * [[http://pmclab.fr/dokuwiki/doku.php?id=wiki:tutoriels:rfduino-linux|Installer RfDuino sous linux]]
  * [[http://files.rfdigital.com/rfduino.ble.programming.reference.pdf|Documentation RfDuino]]

Exemple 1 :
<code=cpp>
#include <RFduinoBLE.h>

#define led 3
#define button 5

void setup() {
  RFduinoBLE.deviceName = "PMClab";
  RFduinoBLE.advertisementData = "test";
  
  RFduinoBLE.txPowerLevel = +4;
  
  RFduinoBLE.begin();
  
  pinMode(led, OUTPUT);
  pinMode(button, INPUT);
}

void RFduinoBLE_onConnect() {
  for (int i=0 ; i<3 ; i++) {
    digitalWrite(led, HIGH);
    delay(200);
    digitalWrite(led, LOW);
    delay(200);
  }
}

void RFduinoBLE_onDisconnect() {
  digitalWrite(led, LOW);
}

void RFduinoBLE_onReceive(char *data, int len) {
  if (data[0])
    digitalWrite(led, HIGH);
  else
    digitalWrite(led, LOW);
}

int debounce_time = 10;
int debounce_timeout = 100;

int debounce(int state) {
  int start = millis();
  int debounce_start = start;
  
  while (millis() - start < debounce_timeout)
    if (digitalRead(button) == state) {
      if (millis() - debounce_start >= debounce_time)
        return 1;
    }
    else
      debounce_start = millis();

  return 0;
}

int delay_until_button(int state) {
  if (state)
    RFduino_pinWake(button, HIGH);
  else
    RFduino_pinWake(button, LOW);
    
  do
    RFduino_ULPDelay(INFINITE);
  while (! debounce(state));
  
  if (RFduino_pinWoke(button)) {
    RFduino_resetPinWake(button);
  }
}

void loop() {
  delay_until_button(HIGH);
  RFduinoBLE.send(1);
  
  delay_until_button(LOW);
  RFduinoBLE.send(0);
}

</code>

Exemple 2 :
<code=cpp>
void setup() {
  Serial.begin(9600);
}

void loop() {
  RFduino_ULPDelay( SECONDS(1) );
  
  float temp = RFduino_temperature(CELSIUS);
  
  Serial.print("Temperature : ");
  Serial.print(temp);
  Serial.println(" deg C");
}
</code>

GZLL Host :
<code=cpp>
#define  MAX_DEVICES  3

#include <RFduinoGZLL.h>

void setup() {
  Serial.begin(57600);
  
  RFduinoGZLL.begin(HOST);  
}

int rssi_total[MAX_DEVICES];
int rssi_count[MAX_DEVICES];

char closest_device = 0;

int collect_samples = 0;

void RFduinoGZLL_onReceive(device_t device, int rssi, char *data, int len) {
  if (device > MAX_DEVICES)
    return;
  
  if (collect_samples) {
    rssi_total[device] += rssi;
    rssi_count[device]++;
  }
  
  RFduinoGZLL.sendToDevice(device, closest_device);
}

void loop() {
  int i;
  
  for (i = 0; i < MAX_DEVICES; i++) {
    rssi_total[i] = 0;
    rssi_count[i] = 0;
  }

  collect_samples = 1;

  delay(1000);
  
  collect_samples = 0;

  int average[MAX_DEVICES];
 
  for (i = 0; i < MAX_DEVICES; i++) {
    if (rssi_count[i] == 0)
      average[i] = -128;
    else
      average[i] = rssi_total[i] / rssi_count[i];
    Serial.print("Average RSSI of device ");
    Serial.print(i);
    Serial.print(" is ");
    Serial.println(average[i]);
  }
  Serial.println();
  
  int closest = 0;
  for (i = 1; i < MAX_DEVICES; i++)
    if (average[i] > average[closest])
      closest = i;

  closest_device = closest;
}
</code>

GZLL Device : 
<code=cpp>
#include <RFduinoGZLL.h>

device_t role = DEVICE0;

int led = 3;

void setup() {
  pinMode(led, OUTPUT);

  RFduinoGZLL.txPowerLevel = 0;
  RFduinoGZLL.begin(role);
}

void loop() {
  delay(200);
  RFduinoGZLL.sendToHost(NULL, 0);
}

void RFduinoGZLL_onReceive(device_t device, int rssi, char *data, int len) {
  if (len > 0) {
    device_t closest_device = (device_t)data[0];
    digitalWrite(led, (role == closest_device));
  }
}
</code>

Exercice : Améliorer le [[http://pmclab.fr/dokuwiki/doku.php?id=wiki:projets:pmcbot|PMCbot]] en le rendant contrôlable par l'application [[https://itunes.apple.com/us/app/sbblecontroller/id730642938?mt=8|SBBLEController]]

<code=cpp>
#include <RFduinoBLE.h>

#define M1_AVANT 2
#define M1_ARRIERE 3
#define M2_AVANT 4
#define M2_ARRIERE 5
 
int vitesse = 0;
int angle = 0;
void setup() {
  pinMode(M1_AVANT, OUTPUT);
  pinMode(M1_ARRIERE, OUTPUT);
  pinMode(M2_AVANT, OUTPUT);
  pinMode(M2_ARRIERE, OUTPUT);
 
  RFduinoBLE.deviceName = "PMCbot";
  RFduinoBLE.advertisementData = "v2";
  
  RFduinoBLE.begin();
}


void RFduinoBLE_onDisconnect() {
  vitesse = 0;
  angle = 0;
}

void RFduinoBLE_onReceive(char *data, int len) {
  vitesse = (data[3]-128)/2;
  angle = (data[2]-128)/3;
}

void loop() {
  int vG = vitesse + angle;
  int vD = vitesse - angle;
 
  if (vG>0) {
    analogWrite(M1_AVANT, vG);
    digitalWrite(M1_ARRIERE, 0);  
  } else {
    digitalWrite(M1_AVANT, 0);
    analogWrite(M1_ARRIERE, -vG);
  }
 
  if (vD>0) {
    analogWrite(M2_AVANT, vD);
    digitalWrite(M2_ARRIERE, 0);  
  } else {
    digitalWrite(M2_AVANT, 0);
    analogWrite(M2_ARRIERE, -vD);
  }
}
</code>

Exemples de projets utilisants RfDuino :
  * [[http://pmclab.fr/dokuwiki/doku.php?id=wiki:projets:smartphone-geiger|OpenGeiger]]
  * [[http://pmclab.fr/dokuwiki/doku.php?id=wiki:projets:pmcbot|PMCbot]]

====Séance 1 : NRF24L01====

  * [[http://www.airspayce.com/mikem/arduino/RadioHead/RadioHead-1.39.zip|Library RadioHead]]
  * [[https://drive.google.com/?authuser=0#folders/0B86xqpNCRFPEa3FvMFgwQVpTTWM|Ressources]] :
    * RFBase.zip : Projet arduino à compléter, contiens la library
  * [[http://www.airspayce.com/mikem/arduino/RadioHead/classRH__NRF24.html#a4691264dc9777295211a8a15157e6743|Documentation]]

Câblage : 

  * NRF24L01 → Arduino
  * 1 GND → GND
  * 2 VCC → 3.3V
  * 3 CE → D8
  * 4 CSN → D10
  * 5 SCK → D13
  * 6 MOSI → D11
  * 7 MISO → D12
  * 8 IRQ → N/A

== Exercice 1 ==

Host : 
<code=cpp>
//////////////////////////////////////////////////
// Atelier : Communication sans fils - Séance 1 //
//////////////////////////////////////////////////

// Importation de la librarie :
#include <SPI.h>
#include "RH_NRF24.h"

// Création d'une instance représentant le module :
RH_NRF24 nrf24;

void setup() {
  // Ouverture du port série
  Serial.begin(9600);
  while (!Serial);
 
  // Initialisation du module
  if (!nrf24.init()) {
    Serial.println("Impossible d'initialiser le module");
    while (true);
  }
  // Paramétrage du module :
  if (!nrf24.setRF(RH_NRF24::DataRate250kbps, RH_NRF24::TransmitPowerm18dBm)) {
    Serial.println("Impossible de parametrer le module");
    while (true);
  }
 
  Serial.println("NRF24L01 Ok");
  
  nrf24.setChannel(42);
  nrf24.setModeTx();
}
 
void loop() {
  uint8_t data[] = "Hello World!";
  nrf24.send(data, sizeof(data));
  nrf24.waitPacketSent();
  
  delay(1000);
}
</code>

Device :
<code=cpp>
//////////////////////////////////////////////////
// Atelier : Communication sans fils - Séance 1 //
//////////////////////////////////////////////////

// Importation de la librarie :
#include <SPI.h>
#include "RH_NRF24.h"

// Création d'une instance représentant le module :
RH_NRF24 nrf24;

void setup() {
  // Ouverture du port série
  Serial.begin(9600);
  while (!Serial);
 
  // Initialisation du module
  if (!nrf24.init()) {
    Serial.println("Impossible d'initialiser le module");
    while (true);
  }
  // Paramétrage du module :
  if (!nrf24.setRF(RH_NRF24::DataRate250kbps, RH_NRF24::TransmitPowerm18dBm)) {
    Serial.println("Impossible de parametrer le module");
    while (true);
  }
 
  Serial.println("NRF24L01 Ok");
  
  nrf24.setChannel(42);
  nrf24.setModeRx();
}
 
void loop() {
  if (nrf24.available()) {
    uint8_t buf[RH_NRF24_MAX_MESSAGE_LEN];
    uint8_t len = sizeof(buf);
    if (nrf24.recv(buf, &len)) {
      Serial.println((char*)buf);
    } else {
      Serial.println("Recv failed.");
    }
  }
  delay(100);
}
</code>

== Exercice 2 : Joystick ==

Host:
<code=cpp>
//////////////////////////////////////////////////
// Atelier : Communication sans fils - Séance 1 //
//////////////////////////////////////////////////

// Exemple : Une télécommande simple avec un joystick

// Importation de la librarie :
#include <SPI.h>
#include "RH_NRF24.h"

// Création d'une instance représentant le module :
RH_NRF24 nrf24;

struct JoystickData {
  float x;
  float y;
} data;

void setup() {
  // Ouverture du port série
  Serial.begin(9600);
  while (!Serial);
 
  // Initialisation du module
  if (!nrf24.init()) {
    Serial.println("Impossible d'initialiser le module");
    while (true);
  }
  // Paramétrage du module :
  if (!nrf24.setRF(RH_NRF24::DataRate250kbps, RH_NRF24::TransmitPowerm18dBm)) {
    Serial.println("Impossible de parametrer le module");
    while (true);
  }
 
  Serial.println("NRF24L01 Ok");
  
  nrf24.setChannel(42);
  nrf24.setModeTx();
}
 
void loop() {
  data.x = analogRead(0);
  data.y = analogRead(1);
  nrf24.send((const uint8_t*)&data, sizeof(data));
  delay(100);
}
</code>

Device:
<code=cpp>
//////////////////////////////////////////////////
// Atelier : Communication sans fils - Séance 1 //
//////////////////////////////////////////////////

// Importation de la librarie :
#include <SPI.h>
#include "RH_NRF24.h"

// Création d'une instance représentant le module :
RH_NRF24 nrf24;

struct JoystickData {
  float x;
  float y;
} data;

void setup() {
  // Ouverture du port série
  Serial.begin(9600);
  while (!Serial);
 
  // Initialisation du module
  if (!nrf24.init()) {
    Serial.println("Impossible d'initialiser le module");
    while (true);
  }
  // Paramétrage du module :
  if (!nrf24.setRF(RH_NRF24::DataRate250kbps, RH_NRF24::TransmitPowerm18dBm)) {
    Serial.println("Impossible de parametrer le module");
    while (true);
  }
 
  Serial.println("NRF24L01 Ok");
  
  nrf24.setChannel(42);
  nrf24.setModeRx();
}
 
void loop() {
  if (nrf24.available()>=sizeof(data)) {
    uint8_t len = sizeof(data);
    nrf24.recv((uint8_t*)&data, &len);
    Serial.print("X=");
    Serial.println(data.x);
    Serial.print("Y=");
    Serial.println(data.y);
    Serial.println();
  }
  delay(100);
}
</code>

Exemple de projet réalisé avec un NRF24L01 : [[http://pmclab.fr/dokuwiki/doku.php?id=wiki:projets:spectrumanalyserdiy|Analyseur de spectre du pauvre]]