Étiquette : Arduino

1 Circuit d’alimentation

J’utilise une batterie type auto de 40Ah, ça dure un bon moment. Pour alimenter mon circuit qui fonctionne en 5V, un convertisseur à haut rendement de type LM2596 délivre une tension ajustable avec un débit de 2A. C’est plus qu’il n’en faut.

Pour la surveillance de la tension batterie, il est nécessaire d’ajouter un pont diviseur destiné à abaisser la tension batterie variable de 12 à 14v à une valeur compatible avec l’entrée analogique de l’Atmega qui est de 5V maxi. Ceci est réalisé par un pont diviseur composé de 2 résistances de 24000 ohms et 10000 ohms.

Ceci donne un rapport de 14 / (24+10) * 10 = 4.12V , tension maximale compatible avec l’entrée de mesure analogique de l’Atmega.

2 Croquis ou sketch Arduino

Il gère les fonctions suivante :

• gestion du module interface HX711 avec la cellule de charge
• mémorisation de la valeur de la tare en mémoire EEPROM avec possibilité de réinitialiser par appuis sur un bouton
• interface avec un capteur de température Dallas DS18B20
• dialogue avec le module émetteur récepteur radio NRF24L01
• enclenchement périodique d’une séquence de mesure de poids
• surveillance du poids de la ruche
• transmission de la valeur de poids périodique ou sur variation rapide de poids.

Scketch Arduino en cours d’évolution à copier coller dans un nouveau projet sur l’IDE Arduino.

Attention, il est nécessaire d’installer les librairies MySensors.h, HX711.h, One Wire.h, DallasTemperature.h et Vcc.h qui ne sont pas installées par défaut dans l’IDE Arduino.

/*  Sketch pour la création d'une balance connectée à usage apiculture
    Une cellule de charge à jauge de contrainte de gamme de mesure 75kg
    est insérée sous la ruche dont on veut surveiller le poids.
    Un module HX711 spécialisé pour les ponts de mesure converti le signal
    analogique en information digitales.
    Une sonde Dallas DS18B20 sert de capteur de température ambiante.
    Un module radio 2.4 Ghz NRF24L01 transmet les informations suivant le
    protocole MySensors.
    Un module Arduino Pro Mini constitue le coeur du système
    La valeur de la tare est enregistrée dans la mémoire EEPROM de l'Arduino
    Un bouton permet de réinitialiser la tare.
*/

// Enable debug prints : debug trames MySensors
//#define MY_DEBUG

// Enable and select radio type attached
#define MY_RADIO_NRF24
#define MY_NODE_ID 182        // Sets a static id for a node

// Definitions des paramètres application
#define DebugProg
#define SN "Balance api v2"    // nom du scketch MySensors
#define SV "26/08/2016"       // version du sckletch

#include <SPI.h>
#include <MySensors.h>
#include "HX711.h"
#include <EEPROM.h>
#include <DallasTemperature.h>
#include <OneWire.h>
#include <Vcc.h>

// Definition des connexions E/S
const int analogInPin = A5; // Analog pin the voltage divider is attached to
const int BOUTON = 2;            // bouton de reset tare actif niveau bas
const int ONE_WIRE_BUS = 3;        // Pin where dallase sensor is connected
const int DOUT2 = 5;            // Pin data HX711 num 2
const int CLK2 = 6;                // Pin clock HX711 num 2
const int DOUT1 = 7;            // Pin data HX711 num 1
const int CLK1 = 8;                // Pin clock HX711 num 1

// Identifiants MySensors
const int ID_TEMP = 0;
const int ID_POIDS = 1;
const int ID_BatPcnt = 2;
const int ID_BATT = 3;
const int ID_TARE = 4;

const int GAIN = 128;            // gain amplificateur HX711
const float calibration_factor = 461; // coefficient de calibration : 10g / unité
const uint16_t SLEEP_TIME = 60 / 15; // tempo envoi en secondes

// Tension mini en-dessous de laquelle la batterie doit être rechargée :
const float VccMin   = 12;  // Vcc mini 11V batterie déchargée
const float VccMax   = 13.6;  // Vcc Maximum 14V batterie complètement chargée
const float R1 = 24000;     // Voltage divider R1 (Ohm)
const float R2 = 10000;     // Voltage divider R2 (Ohm)
const float VccCorrection = 4.98 / 5.16; // Vcc multimetre / Vcc mesuré par l'Arduino

// Déclaration des variables
boolean receivedConfig = false;
boolean metric = true;
boolean envoiTare = true;    // pour envoyer la valeur de la tare au reset
uint8_t battLoop = 10;       // pour envoi tension batterie dès le reset
uint16_t seconde = 0;        // compteur seconde pendule
int oldBatteryPcnt = 0;
long lastPoids = 0;
long tare;

// Déclaration des objets
OneWire oneWire(ONE_WIRE_BUS);          // pour capteur de temperature DS18B20
DallasTemperature sensors(&oneWire);    // pour librairie Dallas
Vcc vcc(VccCorrection);                 // pour mesure tension d'alimentation
HX711 scale1(DOUT1, CLK1, GAIN);        // pour module HX711 n°1
//HX711 scale2(DOUT2, CLK2, GAIN);        // pour module HX711 n°2

// Déclaration des messages MySensors
MyMessage msgTemp(ID_TEMP, V_TEMP);            // type V_TEMP pour temperature
MyMessage msgPoids(ID_POIDS, V_WEIGHT);    // type V_WEIGHT au lieu de V_VAR1
MyMessage msgBAT(ID_BATT, V_VOLTAGE);        // type V_VOLTAGE au lieu de V_VAR2
MyMessage msgTare(ID_TARE, V_VAR3);            // type V_VAR3 pour la tare HX711

//***********************************************************************************
//***** Code d'initialisation à faire avant demarrage de MySensors *****
//***********************************************************************************
void before() {
  // This will execute before MySensors starts up
}

//************************************************************************************
//*****   Fonction de presentation du noeud    *****
//************************************************************************************
void presentation() {
  // Send the sketch version information to the gateway and Controller
  sendSketchInfo(SN, SV);

  // présentation identifiants MySensors et type de données
  present(ID_TEMP, V_TEMP);
  present(ID_POIDS, V_WEIGHT);
  present(ID_BATT, V_VOLTAGE);
  present(ID_TARE, V_VAR3);

  metric = getConfig().isMetric;
}

//**********************************************************************************
//*****     FONCTION SETUP = Code d'initialisation générale du programme       *****
//**********************************************************************************
void setup() {
  Serial.begin(115200);                    //standard serial
  delay(200);

  digitalWrite(BOUTON, HIGH);   // active résistance de pullup interne

  Serial.println();
  Serial.print(SN);
  Serial.print(" - ");
  Serial.println(SV);

  sensors.begin();                            // init capteur de température DS18B20
  // Fetch the number of attached temperature sensors
  int numSensors = sensors.getDeviceCount();
#ifdef DebugProg
  Serial.print(numSensors);
  Serial.println(F(" DS18B20 trouvé"));
#endif

#ifdef DebugProg
  long zero_factor = scale1.read_average();  //Get a baseline reading
  Serial.print(F("Zero factor: "));
  Serial.println(zero_factor);
#endif

  // forçage valeur de la tare
  //tare = 664120;              // ancienne tare
  //EEPROMWritelong(EEPROM_LOCAL_CONFIG_ADDRESS, tare);

  scale1.power_up();            // pour alimenter la cellule de charge
  scale1.set_scale(calibration_factor);        // Adjust to this calibration factor
  tare = EEPROMReadlong(EEPROM_LOCAL_CONFIG_ADDRESS); // recupere valeur tare en EEPROM
  scale1.set_offset(tare);                // initialise la tare
  scale1.power_down();

#ifdef DebugProg
  Serial.print(F("Init tare depuis EEPROM = "));
  Serial.println(tare);
#endif

  check_batt();
  seconde = 0;
}

//************************************************************************************
//*****             FONCTION mesure tension batterie                            ******
//************************************************************************************
float tension_batt() {
  // mesure de Vcc
  float Vcc = vcc.Read_Volts();

  // read the analog in value:
  int sensorValue = analogRead(analogInPin);

  // Serial.println(sensorValue); // for debug / calibration
  float v_pin = Vcc * sensorValue / 1023.;
  float v_bat = v_pin / (R2 / (R1 + R2));
#ifdef DebugProg
  Serial.print(F("Tension batterie: Vcc:"));
  Serial.print(Vcc);              // affiche Vcc
  Serial.print(F(" v_pin:"));
  Serial.print(v_pin);            // affiche tension sortie diviseur tension
  Serial.print(F(" Vbatt= "));
  Serial.println(v_bat);          // affiche tension batterie calculée
#endif

  return (v_bat);
}

//************************************************************************************
//*****    FONCTION controle tension batterie   ******
//************************************************************************************
void check_batt()
{
  // mesure de Vcc
  //float batteryVolt = vcc.Read_Volts();
  float batteryVolt = tension_batt();
  /*
    #ifdef DebugProg
    Serial.print(F("Tension batterie = "));
    Serial.println(batteryVolt);
    #endif
  */
  // calcul du % de charge batterie
  float batteryPcnt = 100 * ((batteryVolt - VccMin) / (VccMax - VccMin));

  sendBatteryLevel(batteryPcnt);            // envoi % batterie
  oldBatteryPcnt = batteryPcnt;
  send(msgBAT.set(batteryVolt, 2));            // et tension avec 2 décimales
}

//************************************************************************************
//*****    FONCTION reception messages NRF24L01   ******
//************************************************************************************
void incomingMessage(const MyMessage &message) {
  Serial.print(F("reception Message: "));
  Serial.print(message.sensor);
  Serial.print(F(" msg-type: "));
  Serial.println(message.type);

  int value = 0;
  if (message.type == V_VAR3) {
    tare = atol( message.data);
    scale1.set_offset(tare);                // parametre la valeur de la tare
    saveState(ID_TARE, tare);                // memorise la tare en eprom
    send(msgTare.set(value) );                // retourne la valeur de la tare à Jeedom
#ifdef DebugProg
    Serial.print(F("Reception tare Jeedom ="));
    Serial.println(tare);
#endif
  }
}
//************************************************************************************
// This function will write a 4 byte (32bit) long to the eeprom at
// the specified address to address + 3.
//************************************************************************************
void EEPROMWritelong(int address, long value)
{
  //Decomposition from a long to 4 bytes by using bitshift.
  //One = Most significant -> Four = Least significant byte
  byte four = (value & 0xFF);
  byte three = ((value >> 8) & 0xFF);
  byte two = ((value >> 16) & 0xFF);
  byte one = ((value >> 24) & 0xFF);

  //Write the 4 bytes into the eeprom memory.
  EEPROM.write(address, four);
  EEPROM.write(address + 1, three);
  EEPROM.write(address + 2, two);
  EEPROM.write(address + 3, one);
}

//************************************************************************************
// This function will return a 4 byte (32bit) long from the eeprom
// at the specified address to address + 3.
//************************************************************************************
long EEPROMReadlong(long address)
{
  //Read the 4 bytes from the eeprom memory.
  long four = EEPROM.read(address);
  long three = EEPROM.read(address + 1);
  long two = EEPROM.read(address + 2);
  long one = EEPROM.read(address + 3);

  //Return the recomposed long by using bitshift.
  return ((four << 0) & 0xFF) + ((three << 8) & 0xFFFF) + ((two << 16) & 0xFFFFFF) + ((one << 24) & 0xFFFFFFFF);
}

//**********************************************************************************
//*****  Fonction Msure de poids  *****
//**********************************************************************************
long Mesure() {
  scale1.power_up();
  long mesureP = -scale1.get_units(20);
  scale1.power_down();

#ifdef DebugProg
  Serial.print("Poids = ");
  Serial.println(mesureP);
#endif

  return (mesureP);
}

//**********************************************************************************
//*************** FONCTION LOOP = Boucle sans fin = coeur du programme *************
//**********************************************************************************
void loop() {
  long Poids = Mesure();
  if (abs(lastPoids - Poids) > 10) {
    send(msgPoids.set(Poids));
    lastPoids = Poids;
  }

  // Surveillance du bouton de reset tare
  // tempo 1 seconde
  for (uint8_t i = 0; i < 118; i++) {
    if (digitalRead(BOUTON) == LOW) {
      scale1.power_up();
      scale1.tare(10);               //Reset the scale to 0
      tare = scale1.get_offset();    // lit la valeur de la tare
      scale1.power_down();
      EEPROMWritelong(EEPROM_LOCAL_CONFIG_ADDRESS, tare);

#ifdef DebugProg
      Serial.print(F("Reset tare = "));
      Serial.println(tare);
#endif
      envoiTare = true;             // pour envoi tare à Jeedom
    }
    sleep(100);                     // pour tempo en ms
  }

  seconde += 3;
  /*
    #ifdef DebugProg
    Serial.print("Tempo ");
    Serial.print(seconde);
    Serial.print(' ');
    #endif
  */

  // envoi tare à Jeedom si reset Arduino ou réinitialisation tare
  if (envoiTare) {
    send( msgTare.set(tare) );
    envoiTare = false;
    sleep(1000);                    // tempo 1 seconde
  }

  if (seconde >= SLEEP_TIME) {
    // Fetch temperatures from Dallas sensors
    sensors.requestTemperatures();
    float temperature =
      static_cast<float>
      (static_cast<int>
       ((getConfig().isMetric ?
         sensors.getTempCByIndex(0) :
         sensors.getTempFByIndex(0)) * 10.)) / 10.;
#ifdef DebugProg
    Serial.print(F("Temperature = "));
    Serial.println(temperature, 1);
#endif

    if ( temperature > -30.0)   // elimine valeur erronnées
      send(msgTemp.set(temperature, 1));

    send(msgPoids.set(Poids));
    lastPoids = Poids;
    seconde = 0;

    // test batterie toutes les 10 minutes
    battLoop++;
    if (battLoop >= 10) {
      check_batt();
      battLoop = 0;
      envoiTare = true;
    }
  }
}

Vous pouvez ajouter ou supprimer les // en début de paramètre pour activer ou désactiver les fonctions de debug sur la console.

//#define MY_DEBUG // Enable and select radio type attached

//#define DebugProg

Les valeurs de résistance sont à modifier en fonction du pont diviseur que vous avez mesuré.

const float R1 = 24000;     // Voltage divider R1 (Ohm)
const float R2 = 10000;     // Voltage divider R2 (Ohm)

Au sujet de la librairie Vcc, cette fonction sert à apporter les compensations dues aux écarts de tension d’alimentation de l’Atmega. Elle n’est pas indispensable si vous ne recherchez pas une grande précision