FablabSU

Outils pour utilisateurs

Outils du site

Vous êtes ici: Accueil » wiki » tutoriels » ateliers » wireless
wiki:tutoriels:ateliers:wireless

Table des matières

Atelier : Communication sans fils

Séance 2 : RfDuino

Exemple 1 : 

#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);
}

Exemple 2 : 

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");
}

GZLL Host : 

#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;
}

GZLL Device : 

#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));
  }
}

Exercice : Améliorer le PMCbot en le rendant contrôlable par l'application SBBLEController 

#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);
  }
}

Exemples de projets utilisants RfDuino :

Séance 1 : NRF24L01

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 : 

//////////////////////////////////////////////////
// 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);
}

Device : 

//////////////////////////////////////////////////
// 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);
}
Exercice 2 : Joystick

Host: 

//////////////////////////////////////////////////
// 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);
}

Device: 

//////////////////////////////////////////////////
// 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);
}

Exemple de projet réalisé avec un NRF24L01 : Analyseur de spectre du pauvre

wiki/tutoriels/ateliers/wireless.txt · Dernière modification: 2016/09/11 13:15 (modification externe)

Outils de la page

Sauf mention contraire, le contenu de ce wiki est placé sous les termes de la licence suivante : CC Attribution-Share Alike 4.0 International
CC Attribution-Share Alike 4.0 International Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki