TEMPERATURES SANS FILS et stockage sur SD

Les cartes Arduino, les platines

TEMPERATURES SANS FILS et stockage sur SD

Message non lude pierre33 » Mar 17 Déc 2013 22:30

Bonjour à tous,

Projet : plusieurs sondes de températures DS18B20 qui émettent en RF 433
1 récepteur RF 433 sur une carte arduino uno et un shield SD (l'ensemble alimenté par pile).
Emission par 1/2 heure et récupération des données sur la carte sd.

Pour l'émetteur sans fil je me suis inspiré du blog de idleman avec ce schéma (il faut rajouter la résistance 4.7 k entre le rouge et jaune de la sonde de température).
ImageImage

J'ai trouvé différents codes mais rien pour mon exemple précis .Je pense que ce sujet est certainement abordé quelques part.
J'ai besoin d'aide pour le code du recepteur et celui de l'emetteur ( je pense que pour l'emetteur celui d'idleman est bien mais son recepteur est un raspberry).

Ci-dessous le code emetteur
Code: Tout sélectionner
/*
 * Code pour construction d'une sonde de temperature "maison", récupère une temperature et l'envois sur la fréquence de 433 mhz
 * Fréquence : 433.92 mhz
 * Protocole : Ridle (Radio Idle, protocole customisé basé sur home easy)
 * Licence : CC -by -sa
 * Matériel associé : Atmega 328 (+résonateur associé) + emetteur RF AM 433.92 mhz + capteur DS18B20 + led d'etat + résistance 4.7 kohms
 * Auteur : Valentin CARRUESCO  aka idleman (idleman@idleman.fr - http://blog.idleman.fr)
 */
 
#include <OneWire.h>
#include <DallasTemperature.h>

//La sonde de température DS18B20 est branchée au pin 10 de l'atmega
#define TEMPERATURE_PIN 10
//L'émetteur radio 433 mhz est branché au pin 9 de l'atmega
#define TRANSMITTER_PIN 9

//Tableaud de stockage du signal binaire à envoyer
bool bit2[26]={};             


// On crée une instance de la classe oneWire pour communiquer avec le materiel on wire (dont le capteur ds18b20)
OneWire oneWire(TEMPERATURE_PIN);
//On passe la reference onewire à la classe DallasTemperature qui vas nous permettre de relever la temperature simplement
DallasTemperature sensors(&oneWire);

//Fonction lancée à l'initialisation du programme
void setup(void)
{
  //On definis les logs à 9600 bauds
  Serial.begin(9600);
  //On initialise le capteur de temperature
  sensors.begin();
  //On définis le pin relié à l'emetteur en tant que sortie
  pinMode(TRANSMITTER_PIN, OUTPUT);   
}

//Fonction qui boucle à l'infinis
void loop(void)
{

  //Lancement de la commande de récuperation de la temperature
  sensors.requestTemperatures();
  //Affichage de la temparature dans les logs
  Serial.println(sensors.getTempCByIndex(0)); 
  //Conversion de la temperature en binaire et stockage sur 7 bits dans le tableau bit2
  itob(sensors.getTempCByIndex(0),7);
  //Envois du signal radio comprenant la temperature (on l'envois 5 fois parce qu'on est pas des trompettes :p, et on veux être sûr que ça recoit bien)
  int i=0;
  for(i=0; i<5;i++)
  {
    transmit();
    delayMicroseconds(666);   
  }
  //delais de 5sc avant le prochain envois
  delay(5000);
}

//Fonction de tansmission radio
void transmit()
{
 
  // On envois 2 impulsions 1->0 avec un certain delais afin de signaler le départ du siganl( verrou de départ)
  //Initialisation radio à 1
  digitalWrite(TRANSMITTER_PIN, HIGH);
  delayMicroseconds(275);     
  //Verrou 1
  digitalWrite(TRANSMITTER_PIN, LOW);
  delayMicroseconds(9900);     
  digitalWrite(TRANSMITTER_PIN, HIGH);
  //Pause entre les verrous 
  delayMicroseconds(275);     
  //Verrou 2
  digitalWrite(TRANSMITTER_PIN, LOW);   
  delayMicroseconds(2675);
  // End on a high
  digitalWrite(TRANSMITTER_PIN, HIGH);
 
 //On envois les 8 bits stockés dans le tableau bit2
 int i;
 for(i=0; i<8;i++)
 {
    sendPair(bit2[i]);
 }
 
 //On envois le code de la sonde (1010 = code 10)
 sendPair(true);
 sendPair(false);
 sendPair(true);
 sendPair(false);
 
 //On envois un verrou de fin pour signaler la fin du signal :)
  digitalWrite(TRANSMITTER_PIN, HIGH);   
  delayMicroseconds(275);     
  digitalWrite(TRANSMITTER_PIN, LOW); 
 
}
 
//Fonction d'envois d'un bit pure (0 ou 1)
void sendBit(boolean b) {
  if (b) {
    digitalWrite(TRANSMITTER_PIN, HIGH);
    delayMicroseconds(310);   //275 orinally, but tweaked.
    digitalWrite(TRANSMITTER_PIN, LOW);
    delayMicroseconds(2500);  //1225 orinally, but tweaked.
  }
  else {
    digitalWrite(TRANSMITTER_PIN, HIGH);
    delayMicroseconds(310);   //275 orinally, but tweaked.
    digitalWrite(TRANSMITTER_PIN, LOW);
    delayMicroseconds(1000);   //275 orinally, but tweaked.
  }
}
 
//Fonction d'envois d'un bit codé en manchester (0 = 01 et 1 = 10)
void sendPair(boolean b) {
  if(b)
  {
    sendBit(true);
    sendBit(false);
  }
  else
  {
  sendBit(false);
  sendBit(true);
  }
}
 
//fonction de conversion d'un nombre décimal "integer" en binaire sur "length" bits et stockage dans le tableau bit2
void itob(unsigned long integer, int length)

  int positive;
  if(integer>0){
   positive = true;
   Serial.println("positif ");
 }else{
  positive = false;
   Serial.println("negatif ");
 }
  //needs bit2[length]
  // Convert long device code into binary (stores in global bit2 array.)
 for (int i=0; i<length; i++){
   if ((integer / power2(length-1-i))==1){
     integer-=power2(length-1-i);
     bit2[i]=1;
   }
   else bit2[i]=0;
 }
 //Définit le signe (+ ou -)
 if(positive){
   bit2[length]=1;
 }else{
   bit2[length]=0;
 }
}

//Calcule 2^"power"
unsigned long power2(int power){   
 unsigned long integer=1;         
 for (int i=0; i<power; i++){     
   integer*=2;
 }
 return integer;
}


Merci pour votre aide
pierre33

Messages: 2
Inscription: Mar 19 Nov 2013 22:01
pierre33
 
Messages: 3
Inscription: Mar 19 Nov 2013 22:01

Re: TEMPERATURES SANS FILS et stockage sur SD

Message non lude Paphio20 » Ven 27 Déc 2013 10:29

Bonjour
Essai ça....
Emetteur 433 mhz
#include <VirtualWire.h> // inclusion de la librairie VirtualWire
#include <SHT1x.h>
#include <DallasTemperature.h>
#include <OneWire.h>
#define ONE_WIRE_BUS 47
#define TEMPERATURE_PRECISION 12
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
DeviceAddress T1;//Temperature de controle serre/
DeviceAddress T2;//Temperature exterieur/
DeviceAddress T3;//Temperature depart chaudiere/
DeviceAddress T4;//Temperature retour chaudiere/
#undef int
#undef abs
#undef double
#undef float
#undef round
#undef round
float S0; //T1 Temperature de controle serre/
float S1; //T2 Temperature exterieur/
float S2; //T3 Temperature depart chaudiere/
float S3; //T4 Temperature retour chaudiere/
//-----------------------------------------------------------------
#define dataPin 7
#define clockPin 8
SHT1x sht1x(dataPin, clockPin);
float temp_c;
float humidity;
const int ledPin = 13;
//-------------------------------Ph Metre-----------------------------------------------
//#define SensorPin 0 //pH meter Analog output to Arduino Analog Input 0
//#define Offset 0.00 //deviation compensate
//unsigned long int avgValue; //Store the average value of the sensor feedback
//float phValue;
//----------------------------------------------------------------------------------
void Debuggeur1()
{
Serial.println();
Serial.println("Dallas Temperature IC Control Library ");
sensors.begin();
Serial.print("Locating devices...");
Serial.print("Found ");
Serial.print(sensors.getDeviceCount(), DEC);
Serial.println(" devices.");
Serial.print("Parasite power is: ");
if (sensors.isParasitePowerMode()) Serial.println("ON");
else Serial.println("OFF");
if (!sensors.getAddress(T1, 0)) Serial.println("Impossible de trouver l'adresse de la sonde T1");
if (!sensors.getAddress(T2, 1)) Serial.println("Impossible de trouver l'adresse de la sonde T2");
if (!sensors.getAddress(T3, 2)) Serial.println("Impossible de trouver l'adresse de la sonde T3");
if (!sensors.getAddress(T4, 3)) Serial.println("Impossible de trouver l'adresse de la sonde T4");
sensors.requestTemperatures();
Serial.print("T1 = Temperature de controle de la serre : ");
printAddress(T1);
Serial.print(" -- ");
printTemperature(T1);
Serial.println();
Serial.print("T2 = Temperature exterieur : ");
printAddress(T2);
Serial.print(" -- ");
printTemperature(T2);
Serial.println();
Serial.print("T3 = Temperature depart chaudiere : ");
printAddress(T3);
Serial.print(" -- ");
printTemperature(T3);
Serial.println();
Serial.print("T4 = Temperature retour chaudiere : ");
printAddress(T4);
Serial.print(" -- ");
printTemperature(T4);
Serial.println();
Lecture();
}
//------------------------------------------------------------
void printAddress(DeviceAddress deviceAddress)
{
for (uint8_t i = 0; i < 8; i++)
{
if (deviceAddress[i] < 16) Serial.print("0");
Serial.print(deviceAddress[i], HEX);
}
}
//-----------------------------------------------------------
void printTemperature(DeviceAddress deviceAddress)
{
float tempC = sensors.getTempC(deviceAddress);
Serial.print("Temp C: ");
Serial.print(tempC);
}
//-------------------------------------------------------------
void printResolution(DeviceAddress deviceAddress)
{
Serial.print("Resolution: ");
Serial.print(sensors.getResolution(deviceAddress));
Serial.println();
}
//---------------------------------------------------------------
void printData(DeviceAddress deviceAddress)
{
Serial.print("Device Address: ");
printAddress(deviceAddress);
Serial.print(" ");
printTemperature(deviceAddress);
Serial.println();
}
//-----------------------------------------------------------------
void Lecture()
{
sensors.requestTemperatures();
S0 = sensors.getTempC(T1);//Temperature de controle de la serre
S1 = sensors.getTempC(T2);//Temperature exterieur
S2 = sensors.getTempC(T3);//Temperature depart chaudiere
S3 = sensors.getTempC(T4);//Temperature retour chaudiere
}
//-----------------------------------------------------------------
/*
//void PhMetre()
//{
// int buf[10]; //buffer for read analog
// for(int i=0;i<10;i++) //Get 10 sample value from the sensor for smooth the value
// {
// buf[i]=analogRead(SensorPin);
// delay(10);
// }
// for(int i=0;i<9;i++) //sort the analog from small to large
// {
// for(int j=i+1;j<10;j++)
// {
// if(buf[i]>buf[j])
// {
// int temp=buf[i];
// buf[i]=buf[j];
// buf[j]=temp;
// }
// }
// }
// avgValue=0;
// for(int i=2;i<8;i++) //take the average value of 6 center sample
// avgValue+=buf[i];
// phValue=(float)avgValue*5.0/1024/6; //convert the analog into millivolt
// phValue=3.5*phValue+Offset; //convert the millivolt into pH value
// delay(800);
//}
*/
//----------------------------------------------------------------------
void setup() // Fonction setup()
{
sensors.begin();
Serial.begin(9600); // Initialisation du port série pour avoir un retour sur le serial monitor
Serial.println("Tuto VirtualWire"); // Petit message de bienvenue
vw_setup(2000);
vw_set_tx_pin(10);
Debuggeur1();
}
//---------------------------------------------------------------
void loop()
{
Lecture();
// PhMetre();
digitalWrite(ledPin, true);
delay(250);
digitalWrite(ledPin, false);
String stringToTransmit;
// Read temperature and humidity
temp_c = sht1x.readTemperatureC();
humidity = sht1x.readHumidity();
// Transmission temperature ambiante
char chrBufferTp1[10];
String temperature =String(dtostrf(temp_c, 2, 1, chrBufferTp1));
stringToTransmit += temperature;
// Transmission humidite ambiante
char chrBufferHumidity[10];
String humidity =String(dtostrf(sht1x.readHumidity(), 2, 1, chrBufferHumidity));
stringToTransmit += humidity;
// Transmission temperature controle serre
char chrBufferTemCon[10];
String TempCon =String(dtostrf(S0, 2, 1, chrBufferTemCon));
stringToTransmit += TempCon;
// Transmission temperature exterieur
char chrBufferTemExt[10];
String TempExt =String(dtostrf(S1, 2, 1, chrBufferTemExt));
stringToTransmit += TempExt;
// Transmission temperature Depart chaudiere
char chrBufferTemDep[10];
String TempDep =String(dtostrf(S2, 2, 1, chrBufferTemDep));
stringToTransmit += TempDep;
// Transmission temperature Retour chaudiere
char chrBufferTemRet[10];
String TempRet =String(dtostrf(S3, 2, 1, chrBufferTemRet));
stringToTransmit += TempRet;
// Transmission PhMetre
// char chrBufferPhMetre[10];
// String Ph_Metre =String(dtostrf(phValue, 2, 2, chrBufferPhMetre));
// stringToTransmit += Ph_Metre;

char strBufferToTransmit[VW_MAX_MESSAGE_LEN];
stringToTransmit.toCharArray(strBufferToTransmit, VW_MAX_MESSAGE_LEN);
vw_send((uint8_t *)strBufferToTransmit, strlen(strBufferToTransmit));
vw_wait_tx();
Serial.println(stringToTransmit);
digitalWrite(ledPin, true);
delay(250);
digitalWrite(ledPin, false);
delay(5000); // verification toute les 5 secondes
}

//------------------------------------------------------------------------------------------------------------

Recepteur 433 Mhz
void Recepteur()
{
// myGLCD.loadBitmap(300,30,16,16,"reseau.raw");
// delay(1000);
if (vw_get_message(buf, &buflen)) // Non-blocking
{
int i;
//-----------------------------------------------------------------------------------
char TempAmb[buflen];
memset(TempAmb, '\0', sizeof(TempAmb));
strncpy(TempAmb, (char *)buf , buflen - 20);
Temp_Amb = atof ( TempAmb );

char HumiAmb[buflen];
memset(HumiAmb, '\0', sizeof(HumiAmb));
strncpy(HumiAmb, (char *)buf + 4, buflen - 16);
Humi_Amb = atof ( HumiAmb );

char TempCon[buflen];
memset(TempCon, '\0', sizeof(TempCon));
strncpy(TempCon, (char *)buf + 8, buflen - 12);
Temp_Con = atof ( TempCon );

char TempExt[buflen];
memset(TempExt, '\0', sizeof(TempExt));
strncpy(TempExt, (char *)buf + 12, buflen - 8);
Temp_Ext = atof ( TempExt );

char TempDep[buflen];
memset(TempDep, '\0', sizeof(TempDep));
strncpy(TempDep, (char *)buf + 16, buflen -4);
Temp_Dep = atof ( TempDep );

char TempRet[buflen];
memset(TempRet, '\0', sizeof(TempRet));
strncpy(TempRet, (char *)buf + 20, buflen);
Temp_Ret = atof ( TempRet );

//char PhMetre[buflen];
// memset(PhMetre, '\0', sizeof(PhMetre));
// strncpy(PhMetre, (char *)buf + 30, buflen );
// Ph_Metre = atof ( PhMetre );

//----------------------------------------------------------------------------------
digitalWrite(ledPin, true);

for (i = 0; i < buflen; i++)
{
MessageBuffer[i] = char(buf[i]);
}
MessageBuffer[buflen] = '\0';

Serial.print("Data received: ");
Serial.println(MessageBuffer);
// myGLCD.print(MessageBuffer,200,175);
// myGLCD.print(rtc.getTimeStr(),10,175);


digitalWrite(ledPin, false);

}
//myGLCD.setColor(0,0, 0);
//myGLCD.fillRect(299,29,317,47);
}

Reception des données sur + de 50 Metres et enregistrement sur SD pour visualiser en temps reel dans graphique sur tft 240*400

Bon courage...
Paphio20
 
Messages: 17
Inscription: Mar 8 Jan 2013 14:39

Re: TEMPERATURES SANS FILS et stockage sur SD

Message non lude EricDuino » Mer 1 Jan 2014 01:19

avec une réponse comme ça c'est sur qu'il faut du courage ;)
Avatar de l’utilisateur
EricDuino
 
Messages: 233
Inscription: Sam 5 Mai 2012 10:10
Localisation: Toulouse

Re: TEMPERATURES SANS FILS et stockage sur SD

Message non lude Paphio20 » Jeu 2 Jan 2014 18:48

Pourquoi il faut du courage .........
Paphio20
 
Messages: 17
Inscription: Mar 8 Jan 2013 14:39


Retourner vers Arduino

Qui est en ligne

Utilisateurs parcourant ce forum: Aucun utilisateur enregistré et 2 invités

cron