Module Gladys-Radio / radioemitter / serial


#1

Bonjour,

J’ai un peu de mal à comprendre le module Gladys-radio et ses compatibilités ou non avec les autres modules.

  1. il est dit qu’il faut l’installer Gladys-radio, il n’est pas présent dans le store, doit-on le cloner et ensuite l’installer ? J’ai l’impression qu’il est déjà inclus dans Gladys de base ?
    Il y a t’il une configuration spécifique clé à ajouter (RADIO_tty --> UBS ? )

  2. Sur mon arduino qui va me servir à piloter mes prises entre autre j’ai aussi des capteurs T° humidité qualité de l’air et poussière de branchés. J’ai utilisé pour se faire le module avancé serial réalisé par @isokar isokar-patch-1 et suivi le tutoriel réalisé par @piznel TUTO
    Ce module est-il compatible avec le module gladys-radio ou le module radioemitter ?
    Dans le git de gladys -radio il est dit “(and had serial module installed), you need to uninstall”
    Ce qui reviendrait à dire que Gladys-radio est incompatible avec cette solution pour échanger des données ?

J’ai l’impression qu’il m’est impossible d’émettre quoi que ce soit avec ce module, la réception elle est bonne.

Si vous avez des informations idées je suis preneur !


#2

Bonjour à toi,
Le module Serial officiel (celui du store) ou celui d’isokar fonctionne bien avec le module Radio Emitter (celui du store)

La procédure à suivre dans ton cas est donc

  • Installer le module serial d’isokar.
  • Installer le module RadioEmitter (celui du store)
  • Redémarrer Gladys
  • Connecter ton arduino
  • Aller dans module, et cliquer sur le bouton bleu “configuration” du module serial d’isokar.

Ca devrait fonctionner si ton programme est correct :slight_smile:


#3

Bonjour ForzAguanno,

Bonne nouvelle, j’ai suivi la procédure que tu décrits puis en mettant un code simple (juste le pilotage du 433MHz) cela fonctionne très bien.
Merci :+1:

J’ai ensuite ajouté mes codes d’acquisition et de transfert pour mes capteurs de température humidité qualité de l’air et particule.
Après cet ajout le pilotage des mes prises via mes périphériques ne fonctionnait plus. Au final il s’avère que dans la loop() j’ai besoin d’utiliser la fonction pulsein() pour l’acquisition des informations liées au capteur de particule Grove Dust sensor

Cette fonction doit bien ralentir le programme et le pilotage de mes prise devient donc plus ou moins aléatoire.

Ne voyant pas vraiment de solution à ce problème je pense donc déporter ce capteur sur un autre arduino
et envoyer les informations via du 433MHz.

Merci de ton aide.

Nicolas


#4

Tu peux copier ton code ici si tu veux, je ne pourrai surement pas t’aider mais peut être que d’autres ici pourront.


#5

Effectivement on sait jamais :slight_smile:
Par contre j’ai du mal à afficher clairement du code ici


#6

Quand tu copie colle ton code tu as des balises qui ressemble un peu a ça《 》ou tu dois cliquer dessus


#7

Ha oui je n’avais pas compris comment ça marchais ! :crazy_face::+1: merci !
La partie incriminée dans loop() :slight_smile:

     //lancement de l'aquisition pour le capteur de particules cette ligne pose probleme pour le pilotage des 433
      duration = pulseIn(dust_pin, LOW);
      lowpulseoccupancy = lowpulseoccupancy + duration;

      if ((millis() - starttime) > sampletime_ms) //si le temps d'aquisition est dépassé
      {
        ratio = lowpulseoccupancy / (sampletime_ms * 10.0); // Integer percentage 0=>100
        concentration = 1.1 * pow(ratio, 3) - 3.8 * pow(ratio, 2) + 520 * ratio + 0.62; // using spec sheet curve
        lowpulseoccupancy = 0;
        starttime = millis();
      }

Tout le code au cas ou … :

#include “DHT.h” // Librairie des capteurs DHT
#include “AirQuality.h”
#include “Arduino.h”
#include <ArduinoJson.h>
#include <RCSwitch.h>

#define DHTPIN 3 // Changer le pin sur lequel est branché le DHT

#define DHTTYPE DHT11 // DHT 11
//#define DHTTYPE DHT22 // DHT 22 (AM2302)
//#define DHTTYPE DHT21 // DHT 21 (AM2301)

struct sensorData { // Création du type "sensorData pour enregistrer les mesures.
int id;
float valeur;
};

int devicetype_id_temp = 7; // id du devicetype de gladys “température”
int devicetype_id_humi = 6; // id du devicetype de gladys “Humidité”
int devicetype_id_air = 8; // id du devicetype de gladys “air quality”
int devicetype_id_dust = 9; // id du devicetype de gladys “Dust sensor”

unsigned long startMillis; // référence temps
unsigned long currentMillis; // temps actuel
const unsigned long period = 60000; // le temps en millisecondes entre 2 mesures

AirQuality airqualitysensor; //déclaration du capteur de qualité de l’air
int current_quality = -1; // valeur de la qualité de l’air

//pour plus d’information sur le capteur de particule voir http://wiki.seeedstudio.com/Grove-Dust_Sensor/
int dust_pin = 4; //le capteur de particule est branché sur la pin 4
unsigned long duration; //acquisition du capteur de particule
unsigned long starttime; //date du début de l’aquisition
unsigned long sampletime_ms = 30000;//durée de l’aquisition 30s ;
unsigned long lowpulseoccupancy = 0; //Lowpulseoccupancy" represents the Low Pulse Occupancy Time(LPO Time) detected in given 30s. Its unit is microseconds.
float ratio = 0; //“Ratio” reflects on which level LPO Time takes up the whole sample time.
float concentration = 0; //“Concentration” is a figure that has a physical meaning. It is calculated from the characteristic graph below by using the LPO time.

#define SENSORDATA_JSON_SIZE (JSON_OBJECT_SIZE(2)) // Variable indiquant la taille du buffer qui sera utilisé pour manipuler le JSON

DHT dht(DHTPIN, DHTTYPE); // Création d’un objet dht, de type DHT11, dont le pin “data” est branché sur le pi

RCSwitch mySwitch = RCSwitch();

void SendRadioCode(long code)
{
mySwitch.send(code, 24);
}

// Serial buffer
String command = “”;

// End of command marker
char endMarker = ‘%’;

/*

  • Execution de la fonction demandée par par Gladys via le port Serie
    */
    void executeFunction(String json_data)
    {
    StaticJsonBuffer<200> jsonBuffer;
    JsonObject& v = jsonBuffer.parseObject(json_data);
    //on décompose la chaine de cartère
    if ( v[“function_name”] == String(“SendRadioCode”) )
    {
    SendRadioCode(v[“code”]);
    }
    }

/**

  • Reception de la communication et stockage dans une variable string
    */
    void serialEvent() {
    //lit toutes les données (vide le buffer de réception)
    char last_readed_char = Serial.read();
    if ( last_readed_char == endMarker )
    {
    executeFunction(command);
    command = “”;
    }
    else
    {
    command += last_readed_char;
    }
    }

//Initilisation des différents composants
void setup() {

// Open serial communications and wait for port to open:
Serial.begin(9600);

// Receiver is connected on Arduino Pin #2
mySwitch.enableReceive(0);

// Transmitter is connected to Arduino Pin #10
mySwitch.enableTransmit(10);

// Optional set pulse length.
mySwitch.setPulseLength(310);

// Optional set protocol (default is 1, will work for most outlets)
mySwitch.setProtocol(1);

// Optional set number of transmission repetitions.
mySwitch.setRepeatTransmit(15);

airqualitysensor.init(14); //initilisation du capteur de qualité de l’air
pinMode(dust_pin, INPUT); //atribution du capteur de particule
dht.begin(); // Initialisation du capteur température humidité
startMillis = millis(); //Enregistre le temps actuel en milliseconde (c’est à dire le temps en milliseconde depuis que le programme à démarré)

delay(1000);
}

void loop()
{
//Lecture du réseau 433MHz
if (mySwitch.available())
{
int value = mySwitch.getReceivedValue();

if (value == 0)
{
  Serial.print("Unknown encoding");
} 
else
{
  Serial.print("{\"action\":\"received\",\"value\":");
  Serial.print( mySwitch.getReceivedValue() );
  Serial.println("}");
}
delay(200); 
mySwitch.resetAvailable();

}

//Lectures des capteurs Humidité température et qualité de l’air puis envoie des informations sérialisées
currentMillis = millis(); // enregistre le “temps” actuel
if (currentMillis - startMillis >= period) //Test si le temps entre les 2 valeurs est >= à la période
{
sensorData dataT; // Objet pour l’enregistrement de la température
sensorData dataH; // Objet pour l’enregistrement de l’humidité
sensorData dataA; // Objet pour l’enregistrement de l’air quality
sensorData dataD; // Objet pour l’enregistrement des poussières

// Lecture du taux d'humidité
float h = dht.readHumidity();

// Lecture de la température en °C
float t = dht.readTemperature();

// Lecture Qualité de l'air
current_quality = airqualitysensor.slope();


// Stop le programme et renvoie un message d'erreur si le capteur ne renvoie aucune mesure
if (isnan(h) || isnan(t) )
{
  Serial.println("Echec de lecture DHT");
}
else
{

  // Message JSON température
  dataH.id = devicetype_id_humi;
  dataH.valeur = h;
  serialize(dataH);

  // Message JSON humidité
  dataT.id = devicetype_id_temp;
  dataT.valeur = t;
  serialize(dataT);

}

// Message JSON ait quality
dataH.id = devicetype_id_air;
dataH.valeur = current_quality;
serialize(dataH);

// Message JSON dust sensor
dataH.id = devicetype_id_dust;
dataH.valeur = concentration;
serialize(dataH);



startMillis = currentMillis; //IMPORTANT enregistre comme temps de référence celui de la dernière mise à jour.
Serial.println("OK");

}

//lancement de l’aquisition pour le capteur de particules cette ligne pose probleme pour le pilotage des 433
duration = pulseIn(dust_pin, LOW);
lowpulseoccupancy = lowpulseoccupancy + duration;

if ((millis() - starttime) > sampletime_ms) //si le temps d’aquisition est dépassé
{
ratio = lowpulseoccupancy / (sampletime_ms * 10.0); // Integer percentage 0=>100
concentration = 1.1 * pow(ratio, 3) - 3.8 * pow(ratio, 2) + 520 * ratio + 0.62; // using spec sheet curve
lowpulseoccupancy = 0;
starttime = millis();
}

}

void serialize(sensorData &data)
{

StaticJsonBuffer<SENSORDATA_JSON_SIZE> jsonBufferSerialize;
JsonObject& root = jsonBufferSerialize.createObject();
root[“devicetype”] = data.id;
root[“value”] = data.valeur;
root.printTo(Serial); // Impression du JSON sur le serial
Serial.println(""); // permet de séparer les JSON
}

ISR(TIMER2_OVF_vect)
{
if (airqualitysensor.counter == 122) //set 2 seconds as a detected duty
{

airqualitysensor.last_vol = airqualitysensor.first_vol;
airqualitysensor.first_vol = analogRead(A0);
airqualitysensor.counter = 0;
airqualitysensor.timer_index = 1;
//PORTB=PORTB^0x20;

}
else
{
airqualitysensor.counter++;
}
}