Beehive Monitoring and Tracking

Add sensors in a beehive to follow bees life.

Sep 8, 2017

•

28346 views

•

34 respects

environmental sensing

tracking

remote control

monitoring

Components and supplies

DS18B20 Programmable Resolution 1-Wire Digital Thermometer

HX711

Arduino Nano R3

DHT22 Temperature Sensor

Tools and machines

load cell bar

Project description

Code

beehive monitoring

arduino

beehive monitoring

1//*******************************************
2//
3//  Systme eruche  installe au Joug
4//
5// S.GOUTTEBROZE (c) 01.2017
6//*******************************************
7
8
9#include  "HX711.h"
10#include <OneWire.h>
11#include <DHT.h>;
12
13//Constants
14#define  DHTPIN 4     // what pin we're connected to = D2
15#define DHTTYPE DHT22   // DHT  22  (AM2302)
16DHT dht(DHTPIN, DHTTYPE); //// Initialize DHT sensor for normal  16mhz Arduino
17
18// DS18S20 Temperature chip i/o
19OneWire ds(2);  // on pin  4
20
21
22//Variables
23int chk,cpt;
24float hum;  //Stores humidity value
25float  temp; //Stores temperature value
26
27
28 // the setup function runs once when  you press reset or power the board
29unsigned long Weight = 0;
30unsigned long  AverageWeight = 0;
31unsigned long AverageWeightot = 0;
32unsigned long AverageWeightold  = 0;
33int ini(0);
34int Clock = 7; //3 on board
35int Dout = 6; //2 on board
36  
37
38float poidsD(0);
39
40float Tc_100_A,Tc_100_B;
41byte i;
42byte type_s;
43byte  present = 0;
44byte data[12];
45byte addr[8];
46char *msg ;
47
48void lire_scaleD()  {
49  //Serial.println("Lire D...");
50  // wait for the chip to become ready
51  while (digitalRead(Dout) == HIGH);
52
53 AverageWeight = 0;
54  for (char j =  0; j<100; j++)
55  {
56     Weight =0;
57    // pulse the clock pin 24 times  to read the data
58    for (char i = 0; i<24; i++)
59    {
60      digitalWrite(Clock,  HIGH);
61      delayMicroseconds(2);
62      Weight = Weight <<1;
63      if  (digitalRead(Dout)==HIGH) Weight++;
64      digitalWrite(Clock, LOW);
65    }
66    // set the channel and the gain factor (A 128) for the next reading using the  clock pin (one pulse)
67    digitalWrite(Clock, HIGH);
68    Weight = Weight ^  0x800000;
69    digitalWrite(Clock, LOW);
70    AverageWeight += Weight;
71    delayMicroseconds(60);
72  }
73  AverageWeight = AverageWeight/100;
74  //Serial.print("PoidsDnew=");
75  //Serial.println(AverageWeight);
76
77}
78
79
80
81void setup() {
82     
83  Serial.begin(9600);
84
85  //intialize HX711    "Module 4"  SCALE D
86  pinMode(Clock,  OUTPUT); // initialize digital pin 4 as an output.(clock)
87
88  digitalWrite(Clock,  HIGH); 
89  delayMicroseconds(100);   //be sure to go into sleep mode if > 60s
90  digitalWrite(Clock, LOW);     //exit sleep mode*/
91
92  pinMode(Dout, INPUT);  // initialize digital pin 5 as an input.(data Out)
93       
94  dht.begin();
95  
96  Serial.println("ready");
97
98  ini=1;
99  
100  // Initialisation...
101  
102  lire_scaleD();
103  //poidsD=AverageWeight*0.8774529-7360044.76;
104  //Serial.println(poidsD);
105  
106}
107
108
109void loop() {
110
111
112// Pour les tests sans Bluetooth,
113lecture_data();
114envoi_msg();
115
116//  Pause entre 2mesures...
117delay(3000);
118delay(1000);
119// pour 10secondes de  dlai
120delay(20000);
121// on ajoute 20sec
122
123delay(90054);
124// on ajoute  90sec --> lecture toutes les 2min
125delay(3000); // ajustement pour atteindre 2min
126
127delay(500);
128  
129}
130
131
132void lecture_data() {
133  //Serial.println("Loop Readings:...");
134
135//  Temperature #A capteur interne boitier
136  ds.reset();
137  addr[0]=16;
138  addr[1]=71;
139  addr[2]=193;
140  addr[3]=37;
141  addr[4]=1;
142  addr[5]=8;
143  addr[6]=0;
144  addr[7]=200;
145  
146 // the first ROM byte indicates which chip
147  switch  (addr[0]) {
148    case 0x10:
149      //Serial.println("  Chip = DS18S20");  //  or old DS1820
150      type_s = 1;
151      break;
152    case 0x28:
153      //Serial.println("  Chip = DS18B20");
154      type_s = 0;
155      break;
156    case 0x22:
157      //Serial.println("  Chip = DS1822");
158      type_s = 0;
159      break;
160    default:
161      Serial.println("Device is not a DS18x20 family device.");
162      return;
163  } 
164  ds.select(addr);
165  ds.write(0x44, 1);        // start  conversion, with parasite power on at the end
166  
167  delay(1000);     // maybe  750ms is enough, maybe not
168  // we might do a ds.depower() here, but the reset  will take care of it.
169  
170  present = ds.reset();
171  ds.select(addr);    
172  ds.write(0xBE);         // Read Scratchpad
173
174  for ( i = 0; i < 9; i++) {           // we need 9 bytes
175    data[i] = ds.read();
176  }
177
178
179  //  Convert the data to actual temperature
180  // because the result is a 16 bit signed  integer, it should
181  // be stored to an "int16_t" type, which is always 16  bits
182  // even when compiled on a 32 bit processor.
183  int16_t raw = (data[1]  << 8) | data[0];
184  if (type_s) {
185    raw = raw << 3; // 9 bit resolution default
186    if (data[7] == 0x10) {
187      // "count remain" gives full 12 bit resolution
188      raw = (raw & 0xFFF0) + 12 - data[6];
189    }
190  } else {
191    byte cfg  = (data[4] & 0x60);
192    // at lower res, the low bits are undefined, so let's  zero them
193    if (cfg == 0x00) raw = raw & ~7;  // 9 bit resolution, 93.75 ms
194    else if (cfg == 0x20) raw = raw & ~3; // 10 bit res, 187.5 ms
195    else if  (cfg == 0x40) raw = raw & ~1; // 11 bit res, 375 ms
196    //// default is 12 bit  resolution, 750 ms conversion time
197  }
198  Tc_100_A = (float)raw / 16.0;
199
200
201  
202//  Temperature #B  capteur volant
203  ds.reset();
204  addr[0]=16;
205  addr[1]=228;
206  addr[2]=224;
207  addr[3]=37;
208  addr[4]=1;
209  addr[5]=8;
210  addr[6]=0;
211  addr[7]=248;
212 // the first ROM byte indicates which chip
213  switch (addr[0])  {
214    case 0x10:
215      //Serial.println("  Chip = DS18S20");  // or old  DS1820
216      type_s = 1;
217      break;
218    case 0x28:
219      //Serial.println("  Chip = DS18B20");
220      type_s = 0;
221      break;
222    case 0x22:
223      //Serial.println("  Chip = DS1822");
224      type_s = 0;
225      break;
226    default:
227      Serial.println("Device is not a DS18x20 family device.");
228      return;
229  } 
230  ds.select(addr);
231  ds.write(0x44, 1);        // start  conversion, with parasite power on at the end
232  
233  delay(1000);     // maybe  750ms is enough, maybe not
234  // we might do a ds.depower() here, but the reset  will take care of it.
235  
236  present = ds.reset();
237  ds.select(addr);    
238  ds.write(0xBE);         // Read Scratchpad
239
240  for ( i = 0; i < 9; i++) {           // we need 9 bytes
241    data[i] = ds.read();
242  }
243
244
245  //  Convert the data to actual temperature
246  // because the result is a 16 bit signed  integer, it should
247  // be stored to an "int16_t" type, which is always 16  bits
248  // even when compiled on a 32 bit processor.
249  raw = (data[1] << 8)  | data[0];
250  if (type_s) {
251    raw = raw << 3; // 9 bit resolution default
252    if (data[7] == 0x10) {
253      // "count remain" gives full 12 bit resolution
254      raw = (raw & 0xFFF0) + 12 - data[6];
255    }
256  } else {
257    byte cfg  = (data[4] & 0x60);
258    // at lower res, the low bits are undefined, so let's  zero them
259    if (cfg == 0x00) raw = raw & ~7;  // 9 bit resolution, 93.75 ms
260    else if (cfg == 0x20) raw = raw & ~3; // 10 bit res, 187.5 ms
261    else if  (cfg == 0x40) raw = raw & ~1; // 11 bit res, 375 ms
262    //// default is 12 bit  resolution, 750 ms conversion time
263  }
264  Tc_100_B = (float)raw / 16.0;
265
266
267
268
269//  Lecture du quatrime module connect sur Digital PIN
270//Serial.print("PoidsD_old=");
271//Serial.println(AverageWeightold);
272lire_scaleD();
273//Serial.print("PoidsDnew=");
274//Serial.println(AverageWeight);
275
276while  (AverageWeightold-AverageWeight>5) {
277
278  lire_scaleD();
279  if (ini==1) {
280    AverageWeightold=AverageWeight;
281    ini=0;
282  }
283  AverageWeightold=AverageWeight;
284  //Serial.print(".");
285  
286}
287
288  AverageWeightold=AverageWeight;
289  poidsD=AverageWeight*4.6645331632-4605.0-39148787.5+16000.0;   // capteur de 200kg
290
291
292  
293      //Read data and store it to variables hum and temp from DHT22 on pin  #D2
294    hum = dht.readHumidity();
295    temp= dht.readTemperature();
296    
297}
298
299void  envoi_msg() {
300  
301 //Serial.println("envoi ok        ");
302 char str_tempa[10];
303  dtostrf(Tc_100_A, 4, 2, str_tempa);
304 char str_tempb[10];
305 dtostrf(Tc_100_B,  4, 2, str_tempb);
306 char str_poids[20];
307 dtostrf(poidsD, 4, 2, str_poids);
308  char str_tempc[10];
309 dtostrf(temp, 4, 2, str_tempc);
310 char str_hum[10];
311  dtostrf(hum, 4, 2, str_hum);
312
313 char message[100]; 
314
315 sprintf(message,  ";GRJ;%s;%s;%s;%s;%s;0.0", str_tempa,str_tempb,str_tempc,str_hum,str_poids);
316  Serial.println(message);
317}
318
319
320
321
322
323
324
325

//*******************************************
//
//  Systme eruche  installe au Joug
//
// S.GOUTTEBROZE (c) 01.2017
//*******************************************


#include  "HX711.h"
#include <OneWire.h>
#include <DHT.h>;

//Constants
#define  DHTPIN 4     // what pin we're connected to = D2
#define DHTTYPE DHT22   // DHT  22  (AM2302)
DHT dht(DHTPIN, DHTTYPE); //// Initialize DHT sensor for normal  16mhz Arduino

// DS18S20 Temperature chip i/o
OneWire ds(2);  // on pin  4


//Variables
int chk,cpt;
float hum;  //Stores humidity value
float  temp; //Stores temperature value


 // the setup function runs once when  you press reset or power the board
unsigned long Weight = 0;
unsigned long  AverageWeight = 0;
unsigned long AverageWeightot = 0;
unsigned long AverageWeightold  = 0;
int ini(0);
int Clock = 7; //3 on board
int Dout = 6; //2 on board
  

float poidsD(0);

float Tc_100_A,Tc_100_B;
byte i;
byte type_s;
byte  present = 0;
byte data[12];
byte addr[8];
char *msg ;

void lire_scaleD()  {
  //Serial.println("Lire D...");
  // wait for the chip to become ready
  while (digitalRead(Dout) == HIGH);

 AverageWeight = 0;
  for (char j =  0; j<100; j++)
  {
     Weight =0;
    // pulse the clock pin 24 times  to read the data
    for (char i = 0; i<24; i++)
    {
      digitalWrite(Clock,  HIGH);
      delayMicroseconds(2);
      Weight = Weight <<1;
      if  (digitalRead(Dout)==HIGH) Weight++;
      digitalWrite(Clock, LOW);
    }
    // set the channel and the gain factor (A 128) for the next reading using the  clock pin (one pulse)
    digitalWrite(Clock, HIGH);
    Weight = Weight ^  0x800000;
    digitalWrite(Clock, LOW);
    AverageWeight += Weight;
    delayMicroseconds(60);
  }
  AverageWeight = AverageWeight/100;
  //Serial.print("PoidsDnew=");
  //Serial.println(AverageWeight);

}



void setup() {
     
  Serial.begin(9600);

  //intialize HX711    "Module 4"  SCALE D
  pinMode(Clock,  OUTPUT); // initialize digital pin 4 as an output.(clock)

  digitalWrite(Clock,  HIGH); 
  delayMicroseconds(100);   //be sure to go into sleep mode if > 60s
  digitalWrite(Clock, LOW);     //exit sleep mode*/

  pinMode(Dout, INPUT);  // initialize digital pin 5 as an input.(data Out)
       
  dht.begin();
  
  Serial.println("ready");

  ini=1;
  
  // Initialisation...
  
  lire_scaleD();
  //poidsD=AverageWeight*0.8774529-7360044.76;
  //Serial.println(poidsD);
  
}


void loop() {


// Pour les tests sans Bluetooth,
lecture_data();
envoi_msg();

//  Pause entre 2mesures...
delay(3000);
delay(1000);
// pour 10secondes de  dlai
delay(20000);
// on ajoute 20sec

delay(90054);
// on ajoute  90sec --> lecture toutes les 2min
delay(3000); // ajustement pour atteindre 2min

delay(500);
  
}


void lecture_data() {
  //Serial.println("Loop Readings:...");

//  Temperature #A capteur interne boitier
  ds.reset();
  addr[0]=16;
  addr[1]=71;
  addr[2]=193;
  addr[3]=37;
  addr[4]=1;
  addr[5]=8;
  addr[6]=0;
  addr[7]=200;
  
 // the first ROM byte indicates which chip
  switch  (addr[0]) {
    case 0x10:
      //Serial.println("  Chip = DS18S20");  //  or old DS1820
      type_s = 1;
      break;
    case 0x28:
      //Serial.println("  Chip = DS18B20");
      type_s = 0;
      break;
    case 0x22:
      //Serial.println("  Chip = DS1822");
      type_s = 0;
      break;
    default:
      Serial.println("Device is not a DS18x20 family device.");
      return;
  } 
  ds.select(addr);
  ds.write(0x44, 1);        // start  conversion, with parasite power on at the end
  
  delay(1000);     // maybe  750ms is enough, maybe not
  // we might do a ds.depower() here, but the reset  will take care of it.
  
  present = ds.reset();
  ds.select(addr);    
  ds.write(0xBE);         // Read Scratchpad

  for ( i = 0; i < 9; i++) {           // we need 9 bytes
    data[i] = ds.read();
  }


  //  Convert the data to actual temperature
  // because the result is a 16 bit signed  integer, it should
  // be stored to an "int16_t" type, which is always 16  bits
  // even when compiled on a 32 bit processor.
  int16_t raw = (data[1]  << 8) | data[0];
  if (type_s) {
    raw = raw << 3; // 9 bit resolution default
    if (data[7] == 0x10) {
      // "count remain" gives full 12 bit resolution
      raw = (raw & 0xFFF0) + 12 - data[6];
    }
  } else {
    byte cfg  = (data[4] & 0x60);
    // at lower res, the low bits are undefined, so let's  zero them
    if (cfg == 0x00) raw = raw & ~7;  // 9 bit resolution, 93.75 ms
    else if (cfg == 0x20) raw = raw & ~3; // 10 bit res, 187.5 ms
    else if  (cfg == 0x40) raw = raw & ~1; // 11 bit res, 375 ms
    //// default is 12 bit  resolution, 750 ms conversion time
  }
  Tc_100_A = (float)raw / 16.0;


  
//  Temperature #B  capteur volant
  ds.reset();
  addr[0]=16;
  addr[1]=228;
  addr[2]=224;
  addr[3]=37;
  addr[4]=1;
  addr[5]=8;
  addr[6]=0;
  addr[7]=248;
 // the first ROM byte indicates which chip
  switch (addr[0])  {
    case 0x10:
      //Serial.println("  Chip = DS18S20");  // or old  DS1820
      type_s = 1;
      break;
    case 0x28:
      //Serial.println("  Chip = DS18B20");
      type_s = 0;
      break;
    case 0x22:
      //Serial.println("  Chip = DS1822");
      type_s = 0;
      break;
    default:
      Serial.println("Device is not a DS18x20 family device.");
      return;
  } 
  ds.select(addr);
  ds.write(0x44, 1);        // start  conversion, with parasite power on at the end
  
  delay(1000);     // maybe  750ms is enough, maybe not
  // we might do a ds.depower() here, but the reset  will take care of it.
  
  present = ds.reset();
  ds.select(addr);    
  ds.write(0xBE);         // Read Scratchpad

  for ( i = 0; i < 9; i++) {           // we need 9 bytes
    data[i] = ds.read();
  }


  //  Convert the data to actual temperature
  // because the result is a 16 bit signed  integer, it should
  // be stored to an "int16_t" type, which is always 16  bits
  // even when compiled on a 32 bit processor.
  raw = (data[1] << 8)  | data[0];
  if (type_s) {
    raw = raw << 3; // 9 bit resolution default
    if (data[7] == 0x10) {
      // "count remain" gives full 12 bit resolution
      raw = (raw & 0xFFF0) + 12 - data[6];
    }
  } else {
    byte cfg  = (data[4] & 0x60);
    // at lower res, the low bits are undefined, so let's  zero them
    if (cfg == 0x00) raw = raw & ~7;  // 9 bit resolution, 93.75 ms
    else if (cfg == 0x20) raw = raw & ~3; // 10 bit res, 187.5 ms
    else if  (cfg == 0x40) raw = raw & ~1; // 11 bit res, 375 ms
    //// default is 12 bit  resolution, 750 ms conversion time
  }
  Tc_100_B = (float)raw / 16.0;




//  Lecture du quatrime module connect sur Digital PIN
//Serial.print("PoidsD_old=");
//Serial.println(AverageWeightold);
lire_scaleD();
//Serial.print("PoidsDnew=");
//Serial.println(AverageWeight);

while  (AverageWeightold-AverageWeight>5) {

  lire_scaleD();
  if (ini==1) {
    AverageWeightold=AverageWeight;
    ini=0;
  }
  AverageWeightold=AverageWeight;
  //Serial.print(".");
  
}

  AverageWeightold=AverageWeight;
  poidsD=AverageWeight*4.6645331632-4605.0-39148787.5+16000.0;   // capteur de 200kg


  
      //Read data and store it to variables hum and temp from DHT22 on pin  #D2
    hum = dht.readHumidity();
    temp= dht.readTemperature();
    
}

void  envoi_msg() {
  
 //Serial.println("envoi ok        ");
 char str_tempa[10];
  dtostrf(Tc_100_A, 4, 2, str_tempa);
 char str_tempb[10];
 dtostrf(Tc_100_B,  4, 2, str_tempb);
 char str_poids[20];
 dtostrf(poidsD, 4, 2, str_poids);
  char str_tempc[10];
 dtostrf(temp, 4, 2, str_tempc);
 char str_hum[10];
  dtostrf(hum, 4, 2, str_hum);

 char message[100]; 

 sprintf(message,  ";GRJ;%s;%s;%s;%s;%s;0.0", str_tempa,str_tempb,str_tempc,str_hum,str_poids);
  Serial.println(message);
}

Downloadable files

schematic

Comments

Only logged in users can leave comments

sgoutteb

0 Followers

•

0 Projects

Intro