Remote Weather Station

A remote weather station that uses two arduinos, one as a transmitter and one as a data-logging receiver.

Jan 30, 2020

•

2487 views

•

0 respects

environmental sensing

communication

monitoring

Components and supplies

SparkFun XBee Explorer USB

Coin cell battery

DfRobot XBee Shield

SD card

9 volt power supply

Stack Through Headers

Half Breadboard

8' White Exterior Extension Cord

USB A to mini USB B

OLED

ABS electrical box

M/F Jumper Wire

Arduino UNO

Alphanumeric LCD, 16 x 2

BME 280 Sensor

ABS Plastic Waterproof Electronic Box

SD card reader/writer

Jumper Wire

Adafruit Logging Sheild

Xbee RF TXRX MODULE 802.15.4 Wire Ant

Potentiometer

Tools and machines

Saw

Soldering iron (generic)

Drill

Hole Saw

Apps and platforms

XCTU

Arduino IDE

Project description

Code

TempPresHumLCD_Station_Reciever_No_Logger.ino

arduino

If you do not want to log the data coming into the receiver use this sketch.

1/* This sketch is from https://www.programmingelectronics.com/wireless-weather-monitoring-hc-12-long-range-transceivers-student-project/
2  * It is slightly altered, the original sketch was designed for use with  
3 *  solar panels for a remote weather station.
4 *  
5 * The transmitter sketch  uses the Adafruit BME 280 sensor.  
6 */
7 
8/*
9 * I am using a 2x16 LCD  for this reciever because the data loger shield and RTC uses 
10 * the SPI and  I2C pins that OLEDs typically use.
11 */
12
13//#include "RTClib.h"
14//RTC_DS1307  rtc;
15// OLED Libraries
16#include <Wire.h>
17#include <SPI.h>
18
19//Include  LCD library and initialize:
20#include<LiquidCrystal.h>
21LiquidCrystal lcd(2,  3, 4, 5, 6, 7);
22
23//Take a number of readings from potentiometers and average  to smooth out the input value.
24//Higher # of readings increase smoothing but  slow down process.
25const int numReadings = 10;
26
27int readings[numReadings];   //the readings from analog pot 
28int readIndex = 0;           //the index of  the current reading
29int total = 0;               //the running total for readings
30int  average = 0;             //the average for pot
31
32int inputPot = A0;  //Potentometer  on Analog pin 0.
33int Pval = 0;     //Variable to store Kristin's Pain Value.
34     
35int tval = 0;     //Variable to store Temperature Value.
36int hval =  0;     //
37float pval = 0;   //Variable to store Pressure Value.
38
39
40void  setup() {
41  Serial.begin(9600);
42  Wire.begin(); // begins RTC serial data
43
44  //Set up the LCD's number of columns and rows
45  lcd.begin(16,2);
46  lcd.clear();
47
48   // intitialize all the readings for Potentometer to 0:
49  for (int thisReading  = 0; thisReading < numReadings; thisReading++)
50  {
51    readings[thisReading]  =0;
52  }
53 
54}
55
56
57void loop() 
58{ 
59  //subtract the last potentometer  reading;
60  total = total - readings[readIndex];
61  //read from the potentometer;
62  readings[readIndex] = analogRead(inputPot);
63  //add the reading to the total;
64  total = total + readings[readIndex];
65  //advance to the next position in the  array;
66  readIndex = readIndex + 1;
67  //if we're at the end of the array...
68  if (readIndex >= numReadings)
69  {
70    //... wrap around to the beginning:
71    readIndex = 0;
72  }
73  //calculate the average:
74  average = total / numReadings;
75  //Take the average and reduce to a lower number to work closer to temperture values.
76  int Pval = map(average, 0, 1023, 0, 9);
77  Pval = constrain(Pval, 0, 9);
78  
79
80  
81 // DateTime now = rtc.now(); // get time and date from RTC
82
83  if (Serial.available() > 1) // checks to see if HC-12 is receiving data.
84  {  
85    for (int x = 0; x < 1; x ++) // run once. Keep in mind transmitter actually  sends twice.
86    {
87      int t = Serial.parseInt(); //read temp
88      int  tval = t;
89      int h = Serial.parseInt(); //read humidity
90      int hval  = h;
91      float p = Serial.parseFloat(); // read barometeric value
92      float  pval = p;
93      
94    Serial.print(tval);
95    Serial.print(',');
96    Serial.print(hval);
97    Serial.print(',');
98    Serial.print(pval);
99    Serial.print(',');
100    Serial.println(Pval);
101
102    //Send the Pressure and Pain value to LCD.
103    lcd.setCursor(0,0);
104    lcd.print("Hg: ");
105    lcd.print(pval);
106    lcd.print("  F: ");
107    lcd.print(tval);
108    lcd.setCursor(0,1);
109    lcd.print("Pain: ");
110    lcd.print(Pval);
111    lcd.print("    H: ");
112    lcd.print(hval);
113    
114    }
115  Serial.flush();
116  delay(50);
117  
118}
119}
120

/* This sketch is from https://www.programmingelectronics.com/wireless-weather-monitoring-hc-12-long-range-transceivers-student-project/
  * It is slightly altered, the original sketch was designed for use with  
 *  solar panels for a remote weather station.
 *  
 * The transmitter sketch  uses the Adafruit BME 280 sensor.  
 */
 
/*
 * I am using a 2x16 LCD  for this reciever because the data loger shield and RTC uses 
 * the SPI and  I2C pins that OLEDs typically use.
 */

//#include "RTClib.h"
//RTC_DS1307  rtc;
// OLED Libraries
#include <Wire.h>
#include <SPI.h>

//Include  LCD library and initialize:
#include<LiquidCrystal.h>
LiquidCrystal lcd(2,  3, 4, 5, 6, 7);

//Take a number of readings from potentiometers and average  to smooth out the input value.
//Higher # of readings increase smoothing but  slow down process.
const int numReadings = 10;

int readings[numReadings];   //the readings from analog pot 
int readIndex = 0;           //the index of  the current reading
int total = 0;               //the running total for readings
int  average = 0;             //the average for pot

int inputPot = A0;  //Potentometer  on Analog pin 0.
int Pval = 0;     //Variable to store Kristin's Pain Value.
     
int tval = 0;     //Variable to store Temperature Value.
int hval =  0;     //
float pval = 0;   //Variable to store Pressure Value.


void  setup() {
  Serial.begin(9600);
  Wire.begin(); // begins RTC serial data

  //Set up the LCD's number of columns and rows
  lcd.begin(16,2);
  lcd.clear();

   // intitialize all the readings for Potentometer to 0:
  for (int thisReading  = 0; thisReading < numReadings; thisReading++)
  {
    readings[thisReading]  =0;
  }
 
}


void loop() 
{ 
  //subtract the last potentometer  reading;
  total = total - readings[readIndex];
  //read from the potentometer;
  readings[readIndex] = analogRead(inputPot);
  //add the reading to the total;
  total = total + readings[readIndex];
  //advance to the next position in the  array;
  readIndex = readIndex + 1;
  //if we're at the end of the array...
  if (readIndex >= numReadings)
  {
    //... wrap around to the beginning:
    readIndex = 0;
  }
  //calculate the average:
  average = total / numReadings;
  //Take the average and reduce to a lower number to work closer to temperture values.
  int Pval = map(average, 0, 1023, 0, 9);
  Pval = constrain(Pval, 0, 9);
  

  
 // DateTime now = rtc.now(); // get time and date from RTC

  if (Serial.available() > 1) // checks to see if HC-12 is receiving data.
  {  
    for (int x = 0; x < 1; x ++) // run once. Keep in mind transmitter actually  sends twice.
    {
      int t = Serial.parseInt(); //read temp
      int  tval = t;
      int h = Serial.parseInt(); //read humidity
      int hval  = h;
      float p = Serial.parseFloat(); // read barometeric value
      float  pval = p;
      
    Serial.print(tval);
    Serial.print(',');
    Serial.print(hval);
    Serial.print(',');
    Serial.print(pval);
    Serial.print(',');
    Serial.println(Pval);

    //Send the Pressure and Pain value to LCD.
    lcd.setCursor(0,0);
    lcd.print("Hg: ");
    lcd.print(pval);
    lcd.print("  F: ");
    lcd.print(tval);
    lcd.setCursor(0,1);
    lcd.print("Pain: ");
    lcd.print(Pval);
    lcd.print("    H: ");
    lcd.print(hval);
    
    }
  Serial.flush();
  delay(50);
  
}
}

TempPresHumLCD_Station_Reciever_Final.ino

arduino

This is the sketch for the data logging remote weather station receiver.

1/* This sketch is an adaptation from 
2 * https://www.programmingelectronics.com/wireless-weather-monitoring-hc-12   *-long-range-transceivers-student-project/
3 * It is slightly altered; the  original sketch was designed for use with  
4 * solar panels for a remote weather  station.
5 * 
6 * The original intent for this project was for a wireless weather  station
7 * not reliant on internet applications. After starting the project,  I        * decided to add
8 * a pain variable to compare nerve pain to changes  in pressure. That         * required adding a 
9 * potentiometer to record changing  pain levels and data logging to compare   * pressure
10 * changes with pain over  time.
11 *  
12 * The transmitter sketch uses the Adafruit BME 280 sensor.  
13  * 
14 * I am using a 2x16 LCD for this receiver because the data logger shield  and  * RTC uses 
15 * the SPI and I2C pins that OLEDs typically use.
16 */
17  
18// Real Time Clock library and initialize:
19#include "RTClib.h" //For Real  Time Clock
20#include <Wire.h>  //For RTC I2C communication
21RTC_DS1307 RTC;  // Defining the RTC
22
23//Data Logging library and initialize:
24#include  <SD.h>   //For talking to SD Card
25#include <SPI.h>   //For SD Card communication
26
27//Set  by default for the SD card library:
28//MOSI = pin 11
29//MISO = pin 12
30//SCLK  = pin 13
31//We always need to set the CS Pin:
32const int CS_PIN = 10; //Chip  Select pin
33
34//We set this high to provide power:
35const int POW_PIN = 8;
36
37//Variable  for conditional counting for data recording intervals
38int c = 0; //variable counting.
39
40//Initialize  strings:
41String year, month, day, hour, minute, second, time, date;
42
43//Include  LCD library and initialize:
44#include<LiquidCrystal.h>
45LiquidCrystal lcd(2,  3, 4, 5, 6, 7);
46
47//potentiometer for recording pain initializers:
48const  int inputPot = A0;  //Pain recording potentiometer on Analog pin 0.
49int Pval  = 0;     //Variable to store Kristin's Pain value.
50
51//Take a number of readings  from potentiometers and average to smooth out the input value.
52//Higher # of  readings increase smoothing but slow down process.
53const int numReadings = 10;
54
55int  readings[numReadings];   //the readings from analog pot 
56int readIndex = 0;           //the  index of the current reading
57int total = 0;               //the running total  for readings
58int average = 0;             //the average for pot
59
60//Incoming  sensor data initializers:     
61int tval = 0;     //Variable to store Temperature  value.
62int hval = 0;     //Variable to store Humidity value.
63float pval =  0;   //Variable to store Pressure value.
64
65
66void setup() {
67  Serial.begin(9600);
68  Serial.println(F("Initializing Card"));
69  //CS pin, and pwr/gnd pins are  outputs
70  pinMode(CS_PIN,   OUTPUT);
71  
72  //Initiate the I2C bus and the  RTC library
73  //Card will draw power from pin 8, so set it high
74  pinMode(POW_PIN,  OUTPUT);
75  digitalWrite(POW_PIN, HIGH);
76  
77  Wire.begin();
78  RTC.begin();
79
80   //If RTC is not running, set it to the computer's compile time
81  if (! RTC.isrunning())
82  {
83    Serial.println(F("RTC is NOT running!"));
84    RTC.adjust(DateTime(__DATE__,  __TIME__));
85  }
86 
87  //Initialize SD card
88  if (!SD.begin(CS_PIN))
89  {
90    Serial.println(F("Card Failure"));
91    return;
92  }
93  Serial.println(F("Card  Ready"));
94
95  //Write column headers
96  File dataFile = SD.open("log.csv",  FILE_WRITE);
97  if (dataFile)
98  {
99    dataFile.println(F("\
100New Log Started!"));
101    dataFile.println(F("Date,Time,Pressure,Pain"));
102    dataFile.close(); //Data  isn't actually written until we close the connection!
103  
104    //Print same  thing to the screen for debugging
105    Serial.println(F("\
106New Log Started!"));
107    Serial.println(F("Date,Time,Pressure,Pain"));
108  }
109  else
110  {
111    Serial.println(F("Couldn't open log file"));
112  }
113
114  //Set up the  LCD's number of columns and rows
115  lcd.begin(16,2);
116  lcd.clear();
117
118   // intitialize all the readings for potentiometer to 0:
119  for (int thisReading  = 0; thisReading < numReadings; thisReading++)
120  {
121    readings[thisReading]  =0;
122  }
123  delay(100);
124}
125
126
127void loop() 
128{ 
129  //Get the current  date and time info and store in strings
130  DateTime datetime = RTC.now();
131  year  = String(datetime.year(),  DEC);
132  month = String(datetime.month(), DEC);
133  day  = String(datetime.day(),  DEC);
134  hour  = String(datetime.hour(),  DEC);
135  minute = String(datetime.minute(), DEC);
136  second = String(datetime.second(),  DEC);
137 
138  //Concatenate the strings into date and time
139  date = year +  "/" + month + "/" + day;
140  time = hour + ":" + minute + ":" + second;
141  
142  //This section of loop is for collecting and updating 
143  //Pain potentiometer  data.
144  
145  //subtract the last potentiometer reading;
146  total = total -  readings[readIndex];
147  //read from the potentiometer;
148  readings[readIndex]  = analogRead(inputPot);
149  //add the reading to the total;
150  total = total  + readings[readIndex];
151  //advance to the next position in the array;
152  readIndex  = readIndex + 1;
153  //if we're at the end of the array...
154  if (readIndex >=  numReadings)
155  {
156    //... wrap around to the beginning:
157    readIndex  = 0;
158  }
159  //calculate the average:
160  average = total / numReadings;
161  //Take the average and reduce to a lower number to work closer to temperature  values.
162  int Pval = map(average, 0, 1023, 0, 9);
163  Pval = constrain(Pval,  0, 9);
164  
165  //Gather sensor data from xbee radio transmission.
166  if (Serial.available()  > 1) // checks to see if XBEE is receiving data.
167  { 
168    for (int x = 0;  x < 1; x ++) // run once. Keep in mind transmitter actually sends twice.
169    {
170      int t = Serial.parseInt(); //read temp
171      int tval = t;
172      int  h = Serial.parseInt(); //read humidity
173      int hval = h;
174      float p =  Serial.parseFloat(); // read barometric value
175      float pval = p;
176
177      //Send  the Pressure and Pain value to LCD.
178      lcd.setCursor(0,0);
179      lcd.print("Hg:  ");
180      lcd.print(pval);
181      lcd.print("  F: ");
182      lcd.print(tval);
183      lcd.setCursor(0,1);
184      lcd.print("Pain: ");
185      lcd.print(Pval);
186      lcd.print("    H: ");
187      lcd.print(hval);
188    
189   
190   if(c  >= 12000) 
191/*
192Can change this # in () to increase or decrease the time interval  between data recording.  The time is the above # multiplied by the delay time at  the end of the main loop so, the # * 50 mls. Because of the xbee radio transmissions,  it is important to not have long delays so this counting loop avoids that problem.  12000 loops is logging about every 22 minutes. So the math is not quite working  out, perhaps there is additional time accumulating in the other processes.
193*/
194  //Open a file and write to it.
195  {
196    File dataFile = SD.open("log.csv",  FILE_WRITE);
197    if (dataFile)
198      {
199      dataFile.print(date);
200      dataFile.print(F(","));
201      dataFile.print(time);
202      dataFile.print(F(","));
203      dataFile.print(pval);
204      dataFile.print(F(","));
205      dataFile.println(Pval);
206      dataFile.close(); //Data isn't actually written until we close the connection!
207   
208      //Print same thing to the screen for debugging    
209      Serial.print(date);
210      Serial.print(F(","));
211      Serial.print(time);
212      Serial.print(F(","));
213      Serial.print(pval);
214      Serial.print(F(","));
215      Serial.println(Pval);
216      }
217      c = (0); // reset counter
218     }
219     else
220     {
221      c++; 
222     }
223     Serial.flush();
224     delay(50); 
225    }
226  }  
227}
228

/* This sketch is an adaptation from 
 * https://www.programmingelectronics.com/wireless-weather-monitoring-hc-12   *-long-range-transceivers-student-project/
 * It is slightly altered; the  original sketch was designed for use with  
 * solar panels for a remote weather  station.
 * 
 * The original intent for this project was for a wireless weather  station
 * not reliant on internet applications. After starting the project,  I        * decided to add
 * a pain variable to compare nerve pain to changes  in pressure. That         * required adding a 
 * potentiometer to record changing  pain levels and data logging to compare   * pressure
 * changes with pain over  time.
 *  
 * The transmitter sketch uses the Adafruit BME 280 sensor.  
  * 
 * I am using a 2x16 LCD for this receiver because the data logger shield  and  * RTC uses 
 * the SPI and I2C pins that OLEDs typically use.
 */
  
// Real Time Clock library and initialize:
#include "RTClib.h" //For Real  Time Clock
#include <Wire.h>  //For RTC I2C communication
RTC_DS1307 RTC;  // Defining the RTC

//Data Logging library and initialize:
#include  <SD.h>   //For talking to SD Card
#include <SPI.h>   //For SD Card communication

//Set  by default for the SD card library:
//MOSI = pin 11
//MISO = pin 12
//SCLK  = pin 13
//We always need to set the CS Pin:
const int CS_PIN = 10; //Chip  Select pin

//We set this high to provide power:
const int POW_PIN = 8;

//Variable  for conditional counting for data recording intervals
int c = 0; //variable counting.

//Initialize  strings:
String year, month, day, hour, minute, second, time, date;

//Include  LCD library and initialize:
#include<LiquidCrystal.h>
LiquidCrystal lcd(2,  3, 4, 5, 6, 7);

//potentiometer for recording pain initializers:
const  int inputPot = A0;  //Pain recording potentiometer on Analog pin 0.
int Pval  = 0;     //Variable to store Kristin's Pain value.

//Take a number of readings  from potentiometers and average to smooth out the input value.
//Higher # of  readings increase smoothing but slow down process.
const int numReadings = 10;

int  readings[numReadings];   //the readings from analog pot 
int readIndex = 0;           //the  index of the current reading
int total = 0;               //the running total  for readings
int average = 0;             //the average for pot

//Incoming  sensor data initializers:     
int tval = 0;     //Variable to store Temperature  value.
int hval = 0;     //Variable to store Humidity value.
float pval =  0;   //Variable to store Pressure value.


void setup() {
  Serial.begin(9600);
  Serial.println(F("Initializing Card"));
  //CS pin, and pwr/gnd pins are  outputs
  pinMode(CS_PIN,   OUTPUT);
  
  //Initiate the I2C bus and the  RTC library
  //Card will draw power from pin 8, so set it high
  pinMode(POW_PIN,  OUTPUT);
  digitalWrite(POW_PIN, HIGH);
  
  Wire.begin();
  RTC.begin();

   //If RTC is not running, set it to the computer's compile time
  if (! RTC.isrunning())
  {
    Serial.println(F("RTC is NOT running!"));
    RTC.adjust(DateTime(__DATE__,  __TIME__));
  }
 
  //Initialize SD card
  if (!SD.begin(CS_PIN))
  {
    Serial.println(F("Card Failure"));
    return;
  }
  Serial.println(F("Card  Ready"));

  //Write column headers
  File dataFile = SD.open("log.csv",  FILE_WRITE);
  if (dataFile)
  {
    dataFile.println(F("\
New Log Started!"));
    dataFile.println(F("Date,Time,Pressure,Pain"));
    dataFile.close(); //Data  isn't actually written until we close the connection!
  
    //Print same  thing to the screen for debugging
    Serial.println(F("\
New Log Started!"));
    Serial.println(F("Date,Time,Pressure,Pain"));
  }
  else
  {
    Serial.println(F("Couldn't open log file"));
  }

  //Set up the  LCD's number of columns and rows
  lcd.begin(16,2);
  lcd.clear();

   // intitialize all the readings for potentiometer to 0:
  for (int thisReading  = 0; thisReading < numReadings; thisReading++)
  {
    readings[thisReading]  =0;
  }
  delay(100);
}


void loop() 
{ 
  //Get the current  date and time info and store in strings
  DateTime datetime = RTC.now();
  year  = String(datetime.year(),  DEC);
  month = String(datetime.month(), DEC);
  day  = String(datetime.day(),  DEC);
  hour  = String(datetime.hour(),  DEC);
  minute = String(datetime.minute(), DEC);
  second = String(datetime.second(),  DEC);
 
  //Concatenate the strings into date and time
  date = year +  "/" + month + "/" + day;
  time = hour + ":" + minute + ":" + second;
  
  //This section of loop is for collecting and updating 
  //Pain potentiometer  data.
  
  //subtract the last potentiometer reading;
  total = total -  readings[readIndex];
  //read from the potentiometer;
  readings[readIndex]  = analogRead(inputPot);
  //add the reading to the total;
  total = total  + readings[readIndex];
  //advance to the next position in the array;
  readIndex  = readIndex + 1;
  //if we're at the end of the array...
  if (readIndex >=  numReadings)
  {
    //... wrap around to the beginning:
    readIndex  = 0;
  }
  //calculate the average:
  average = total / numReadings;
  //Take the average and reduce to a lower number to work closer to temperature  values.
  int Pval = map(average, 0, 1023, 0, 9);
  Pval = constrain(Pval,  0, 9);
  
  //Gather sensor data from xbee radio transmission.
  if (Serial.available()  > 1) // checks to see if XBEE is receiving data.
  { 
    for (int x = 0;  x < 1; x ++) // run once. Keep in mind transmitter actually sends twice.
    {
      int t = Serial.parseInt(); //read temp
      int tval = t;
      int  h = Serial.parseInt(); //read humidity
      int hval = h;
      float p =  Serial.parseFloat(); // read barometric value
      float pval = p;

      //Send  the Pressure and Pain value to LCD.
      lcd.setCursor(0,0);
      lcd.print("Hg:  ");
      lcd.print(pval);
      lcd.print("  F: ");
      lcd.print(tval);
      lcd.setCursor(0,1);
      lcd.print("Pain: ");
      lcd.print(Pval);
      lcd.print("    H: ");
      lcd.print(hval);
    
   
   if(c  >= 12000) 
/*
Can change this # in () to increase or decrease the time interval  between data recording.  The time is the above # multiplied by the delay time at  the end of the main loop so, the # * 50 mls. Because of the xbee radio transmissions,  it is important to not have long delays so this counting loop avoids that problem.  12000 loops is logging about every 22 minutes. So the math is not quite working  out, perhaps there is additional time accumulating in the other processes.
*/
  //Open a file and write to it.
  {
    File dataFile = SD.open("log.csv",  FILE_WRITE);
    if (dataFile)
      {
      dataFile.print(date);
      dataFile.print(F(","));
      dataFile.print(time);
      dataFile.print(F(","));
      dataFile.print(pval);
      dataFile.print(F(","));
      dataFile.println(Pval);
      dataFile.close(); //Data isn't actually written until we close the connection!
   
      //Print same thing to the screen for debugging    
      Serial.print(date);
      Serial.print(F(","));
      Serial.print(time);
      Serial.print(F(","));
      Serial.print(pval);
      Serial.print(F(","));
      Serial.println(Pval);
      }
      c = (0); // reset counter
     }
     else
     {
      c++; 
     }
     Serial.flush();
     delay(50); 
    }
  }  
}

XBee Radio Testing from Jeremy Blum's arduino_read_pot.ino from, "Exploring Arduino.com/content/ch6"

arduino

Use this sketch to test XBee Radios

1/*
2Exploring Arduino - Code Listing 6-6: Arduino Code to send Data  to the Computer
3http://www.exploringarduino.com/content/ch6
4
5Copyright  2013 Jeremy Blum ( http://www.jeremyblum.com )
6This program is free software:  you can redistribute it and/or modify
7it under the terms of the GNU General Public  License v3 as published by
8the Free Software Foundation.
9*/
10
11//Sending  POT value to the computer
12
13const int POT=0; //Pot on Analog Pin 0
14
15int  val; //For holding mapped pot value
16
17void setup()
18{
19  Serial.begin(9600);  //Start Serial
20}
21
22void loop()
23{
24  val = map(analogRead(POT), 0, 1023,  0, 255); //Read and map POT
25  Serial.println(val);                         //Send  value
26  delay(50);                                   //Delay so we don't flood  the computer
27}
28
29

/*
Exploring Arduino - Code Listing 6-6: Arduino Code to send Data  to the Computer
http://www.exploringarduino.com/content/ch6

Copyright  2013 Jeremy Blum ( http://www.jeremyblum.com )
This program is free software:  you can redistribute it and/or modify
it under the terms of the GNU General Public  License v3 as published by
the Free Software Foundation.
*/

//Sending  POT value to the computer

const int POT=0; //Pot on Analog Pin 0

int  val; //For holding mapped pot value

void setup()
{
  Serial.begin(9600);  //Start Serial
}

void loop()
{
  val = map(analogRead(POT), 0, 1023,  0, 255); //Read and map POT
  Serial.println(val);                         //Send  value
  delay(50);                                   //Delay so we don't flood  the computer
}

TempPresHumOLED_Station_Transmitter_Final.ino

arduino

This is an update to the original sketch for the remote weather station transmitter. After completing a comparison of multiple temperature and humidity records with other local sensor records, the calibration for temperature and humidity have been adjusted.

1/* 
2 * This sketch is from https://www.programmingelectronics.com/wireless-weather-monitoring-hc-12-long-range-transceivers-student-project/
3  * It is slightly altered; the original sketch was designed for use with  
4 *  solar panels for a remote weather station.
5 * 
6 * This code is to use with  Adafruit BMP280 and OLED screen   (Imperial)
7 * It measures both temperature  and pressure and it displays them on the OLED display with the altitude
8 * It's  a modified version of the Adafruit example code
9 * Refer to www.surtrtech.com  or SurtrTech Youtube channel
10 */
11 
12/*
13 * Note from John on 11/13/2019.  Iam using a DIYmall Yellow & Blue 128x64 OLED.
14 * This requires in the "void  setup" changing 0x3D to 0x3c in the following statement 
15 * if(!display.begin(SSD1306_SWITCHCAPVCC,  0x3c)) { // Address 0x3D for 128x64 // Had to change for DIYmall OLED 
16 * This  change makes this sketch work for this type of OLED screen. Surtrtech.com included
17  * this change.
18 * 
19 * Additionally, I am using the Adafruit BME280 sensor  because I wanted a humidity sensor. So BME replaces
20 * BMP throughout the sketch  as well as the library.
21 */
22
23// OLED Libraries
24#include <Wire.h>
25#include  <SPI.h>
26#include <Adafruit_GFX.h>
27#include <Adafruit_SSD1306.h>
28
29//  OLED declarations
30#define SCREEN_WIDTH 128 // OLED display width, in pixels
31#define  SCREEN_HEIGHT 64 // OLED display height, in pixels
32
33// Declaration for an  SSD1306 display connected to I2C (SDA, SCL pins)
34#define OLED_RESET     4 //  Reset pin # (or -1 if sharing Arduino reset pin)
35Adafruit_SSD1306 display(SCREEN_WIDTH,  SCREEN_HEIGHT, &Wire, OLED_RESET);     
36
37#define NUMFLAKES     10 // Number  of snowflakes in the animation example
38
39#define LOGO_HEIGHT   16
40#define  LOGO_WIDTH    16
41static const unsigned char PROGMEM logo_bmp[] =
42{ B00000000,  B11000000,
43  B00000001, B11000000,
44  B00000001, B11000000,
45  B00000011,  B11100000,
46  B11110011, B11100000,
47  B11111110, B11111000,
48  B01111110,  B11111111,
49  B00110011, B10011111,
50  B00011111, B11111100,
51  B00001101,  B01110000,
52  B00011011, B10100000,
53  B00111111, B11100000,
54  B00111111,  B11110000,
55  B01111100, B11110000,
56  B01110000, B01110000,
57  B00000000,  B00110000 };
58//varialbe to storing "for data # of loops"
59  int y = 0;
60
61//valiables  to store serial data for transmition through xbees.
62  int t = 0;
63  int p =  0;
64  float P = 0;
65// BME280 Libraries
66
67#include <Adafruit_Sensor.h>
68#include  <Adafruit_BME280.h>
69
70// BME Declarations - pins
71#define BME_SCK 13
72#define  BME_MISO 12
73#define BME_MOSI 11
74#define BME_CS 10
75
76#define SEALEVELPRESSURE_HPA  (1013.25)
77
78//Adafruit_BME280 bme; // I2C
79//Adafruit_BME280 bme(BME_CS);  // hardware SPI
80Adafruit_BME280 bme(BME_CS, BME_MOSI, BME_MISO, BME_SCK); //  software SPI
81
82unsigned long delayTime;
83
84void setup() {
85    Serial.begin(9600);
86  bme.begin();                                //Start the bme                  
87  display.begin(SSD1306_SWITCHCAPVCC, 0x3C); //Start the OLED display
88  display.clearDisplay();
89  display.display();
90  display.setTextColor(WHITE);
91  display.setTextSize(1);  
92  display.print("SurtrTech");     //Show the name, you can remove it or replace  it
93  display.setCursor(32,12);
94  display.setTextSize(2);          
95  display.println("BME280");  
96  display.display();
97  delay(2000);
98}
99
100
101void loop() { 
102
103  for(y = 0; y < 1; y ++)
104  {
105     display.clearDisplay();
106    float T  = bme.readTemperature() * 9 / 5 + 32-2;    //Read temperature in C and conversion  to F; 
107                                                     //the -2 is for calibrating  the sensor
108                                                     // inacuracy  that may be caused by heat generated in
109                                                     //  the electrical box enclosure.   If your sensor does not
110                                                     //  have this problem, the -2  can
111                                                     //be  removed from the conversion calculation.
112    float P = bme.readPressure()/3386.39;        //Read Pressure in Pa and conversion to inches of mercury
113    float H  = bme.readHumidity()* 1.644310631;   //Read humidity; the * 1.644310631 is for calibration.  
114                                                 //If you do not have this problem  it can be removed.
115
116    //convert to int for serial communication
117    int  t = T; 
118    int h = H;                                              
119
120    display.setCursor(0,0);                       //Oled display, just playing with  text size and cursor to get the display you want
121    display.setTextColor(WHITE);
122    display.setTextSize(2); 
123    display.print("Temp");
124    
125    display.setCursor(0,25);  //originally 0,18
126    display.print(T,1);
127    display.setCursor(50,17);
128    display.setTextSize(1);
129    display.print("F");
130
131    display.setTextSize(1);
132    display.setCursor(65,0); //originally 65,0
133    display.print("Pres-inHg");
134    display.setTextSize(2);
135    display.setCursor(65,17); //originally 65,10
136    display.print(P,2);
137    display.setTextSize(1);
138
139    display.setCursor(65,50);  //originally 65,25
140    display.print("Hum");
141    display.setTextSize(2);
142    display.setCursor(90,50); //originally 90,25
143    display.print(H,0);
144    display.setTextSize(1);
145    display.setCursor(120,50); //originally 110,25
146    display.print("%");
147    
148    display.display();
149
150    //Send data  through xbee radio
151     Serial.print(t);
152     Serial.print(',');
153     Serial.print(h);
154     Serial.print(',');
155     Serial.println(P);
156  }
157  int t = 0; // Clear  buffer data 
158  int h = 0;
159  int p = 0;
160  float P = 0;                                           
161  delay(50);
162  
163   
164}
165

/* 
 * This sketch is from https://www.programmingelectronics.com/wireless-weather-monitoring-hc-12-long-range-transceivers-student-project/
  * It is slightly altered; the original sketch was designed for use with  
 *  solar panels for a remote weather station.
 * 
 * This code is to use with  Adafruit BMP280 and OLED screen   (Imperial)
 * It measures both temperature  and pressure and it displays them on the OLED display with the altitude
 * It's  a modified version of the Adafruit example code
 * Refer to www.surtrtech.com  or SurtrTech Youtube channel
 */
 
/*
 * Note from John on 11/13/2019.  Iam using a DIYmall Yellow & Blue 128x64 OLED.
 * This requires in the "void  setup" changing 0x3D to 0x3c in the following statement 
 * if(!display.begin(SSD1306_SWITCHCAPVCC,  0x3c)) { // Address 0x3D for 128x64 // Had to change for DIYmall OLED 
 * This  change makes this sketch work for this type of OLED screen. Surtrtech.com included
  * this change.
 * 
 * Additionally, I am using the Adafruit BME280 sensor  because I wanted a humidity sensor. So BME replaces
 * BMP throughout the sketch  as well as the library.
 */

// OLED Libraries
#include <Wire.h>
#include  <SPI.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

//  OLED declarations
#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define  SCREEN_HEIGHT 64 // OLED display height, in pixels

// Declaration for an  SSD1306 display connected to I2C (SDA, SCL pins)
#define OLED_RESET     4 //  Reset pin # (or -1 if sharing Arduino reset pin)
Adafruit_SSD1306 display(SCREEN_WIDTH,  SCREEN_HEIGHT, &Wire, OLED_RESET);     

#define NUMFLAKES     10 // Number  of snowflakes in the animation example

#define LOGO_HEIGHT   16
#define  LOGO_WIDTH    16
static const unsigned char PROGMEM logo_bmp[] =
{ B00000000,  B11000000,
  B00000001, B11000000,
  B00000001, B11000000,
  B00000011,  B11100000,
  B11110011, B11100000,
  B11111110, B11111000,
  B01111110,  B11111111,
  B00110011, B10011111,
  B00011111, B11111100,
  B00001101,  B01110000,
  B00011011, B10100000,
  B00111111, B11100000,
  B00111111,  B11110000,
  B01111100, B11110000,
  B01110000, B01110000,
  B00000000,  B00110000 };
//varialbe to storing "for data # of loops"
  int y = 0;

//valiables  to store serial data for transmition through xbees.
  int t = 0;
  int p =  0;
  float P = 0;
// BME280 Libraries

#include <Adafruit_Sensor.h>
#include  <Adafruit_BME280.h>

// BME Declarations - pins
#define BME_SCK 13
#define  BME_MISO 12
#define BME_MOSI 11
#define BME_CS 10

#define SEALEVELPRESSURE_HPA  (1013.25)

//Adafruit_BME280 bme; // I2C
//Adafruit_BME280 bme(BME_CS);  // hardware SPI
Adafruit_BME280 bme(BME_CS, BME_MOSI, BME_MISO, BME_SCK); //  software SPI

unsigned long delayTime;

void setup() {
    Serial.begin(9600);
  bme.begin();                                //Start the bme                  
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C); //Start the OLED display
  display.clearDisplay();
  display.display();
  display.setTextColor(WHITE);
  display.setTextSize(1);  
  display.print("SurtrTech");     //Show the name, you can remove it or replace  it
  display.setCursor(32,12);
  display.setTextSize(2);          
  display.println("BME280");  
  display.display();
  delay(2000);
}


void loop() { 

  for(y = 0; y < 1; y ++)
  {
     display.clearDisplay();
    float T  = bme.readTemperature() * 9 / 5 + 32-2;    //Read temperature in C and conversion  to F; 
                                                     //the -2 is for calibrating  the sensor
                                                     // inacuracy  that may be caused by heat generated in
                                                     //  the electrical box enclosure.   If your sensor does not
                                                     //  have this problem, the -2  can
                                                     //be  removed from the conversion calculation.
    float P = bme.readPressure()/3386.39;        //Read Pressure in Pa and conversion to inches of mercury
    float H  = bme.readHumidity()* 1.644310631;   //Read humidity; the * 1.644310631 is for calibration.  
                                                 //If you do not have this problem  it can be removed.

    //convert to int for serial communication
    int  t = T; 
    int h = H;                                              

    display.setCursor(0,0);                       //Oled display, just playing with  text size and cursor to get the display you want
    display.setTextColor(WHITE);
    display.setTextSize(2); 
    display.print("Temp");
    
    display.setCursor(0,25);  //originally 0,18
    display.print(T,1);
    display.setCursor(50,17);
    display.setTextSize(1);
    display.print("F");

    display.setTextSize(1);
    display.setCursor(65,0); //originally 65,0
    display.print("Pres-inHg");
    display.setTextSize(2);
    display.setCursor(65,17); //originally 65,10
    display.print(P,2);
    display.setTextSize(1);

    display.setCursor(65,50);  //originally 65,25
    display.print("Hum");
    display.setTextSize(2);
    display.setCursor(90,50); //originally 90,25
    display.print(H,0);
    display.setTextSize(1);
    display.setCursor(120,50); //originally 110,25
    display.print("%");
    
    display.display();

    //Send data  through xbee radio
     Serial.print(t);
     Serial.print(',');
     Serial.print(h);
     Serial.print(',');
     Serial.println(P);
  }
  int t = 0; // Clear  buffer data 
  int h = 0;
  int p = 0;
  float P = 0;                                           
  delay(50);
  
   
}

TempPresHumLCD_Station_Reciever_No_Logger.ino

arduino

If you do not want to log the data coming into the receiver use this sketch.

1/* This sketch is from https://www.programmingelectronics.com/wireless-weather-monitoring-hc-12-long-range-transceivers-student-project/
2
3  * It is slightly altered, the original sketch was designed for use with  
4 *
5  solar panels for a remote weather station.
6 *  
7 * The transmitter sketch
8  uses the Adafruit BME 280 sensor.  
9 */
10 
11/*
12 * I am using a 2x16 LCD
13  for this reciever because the data loger shield and RTC uses 
14 * the SPI and
15  I2C pins that OLEDs typically use.
16 */
17
18//#include "RTClib.h"
19//RTC_DS1307
20  rtc;
21// OLED Libraries
22#include <Wire.h>
23#include <SPI.h>
24
25//Include
26  LCD library and initialize:
27#include<LiquidCrystal.h>
28LiquidCrystal lcd(2,
29  3, 4, 5, 6, 7);
30
31//Take a number of readings from potentiometers and average
32  to smooth out the input value.
33//Higher # of readings increase smoothing but
34  slow down process.
35const int numReadings = 10;
36
37int readings[numReadings];
38   //the readings from analog pot 
39int readIndex = 0;           //the index of
40  the current reading
41int total = 0;               //the running total for readings
42int
43  average = 0;             //the average for pot
44
45int inputPot = A0;  //Potentometer
46  on Analog pin 0.
47int Pval = 0;     //Variable to store Kristin's Pain Value.
48
49     
50int tval = 0;     //Variable to store Temperature Value.
51int hval =
52  0;     //
53float pval = 0;   //Variable to store Pressure Value.
54
55
56void
57  setup() {
58  Serial.begin(9600);
59  Wire.begin(); // begins RTC serial data
60
61
62  //Set up the LCD's number of columns and rows
63  lcd.begin(16,2);
64  lcd.clear();
65
66
67   // intitialize all the readings for Potentometer to 0:
68  for (int thisReading
69  = 0; thisReading < numReadings; thisReading++)
70  {
71    readings[thisReading]
72  =0;
73  }
74 
75}
76
77
78void loop() 
79{ 
80  //subtract the last potentometer
81  reading;
82  total = total - readings[readIndex];
83  //read from the potentometer;
84
85  readings[readIndex] = analogRead(inputPot);
86  //add the reading to the total;
87
88  total = total + readings[readIndex];
89  //advance to the next position in the
90  array;
91  readIndex = readIndex + 1;
92  //if we're at the end of the array...
93
94  if (readIndex >= numReadings)
95  {
96    //... wrap around to the beginning:
97
98    readIndex = 0;
99  }
100  //calculate the average:
101  average = total / numReadings;
102
103  //Take the average and reduce to a lower number to work closer to temperture values.
104
105  int Pval = map(average, 0, 1023, 0, 9);
106  Pval = constrain(Pval, 0, 9);
107
108  
109
110  
111 // DateTime now = rtc.now(); // get time and date from RTC
112
113
114  if (Serial.available() > 1) // checks to see if HC-12 is receiving data.
115  {
116  
117    for (int x = 0; x < 1; x ++) // run once. Keep in mind transmitter actually
118  sends twice.
119    {
120      int t = Serial.parseInt(); //read temp
121      int
122  tval = t;
123      int h = Serial.parseInt(); //read humidity
124      int hval
125  = h;
126      float p = Serial.parseFloat(); // read barometeric value
127      float
128  pval = p;
129      
130    Serial.print(tval);
131    Serial.print(',');
132    Serial.print(hval);
133
134    Serial.print(',');
135    Serial.print(pval);
136    Serial.print(',');
137
138    Serial.println(Pval);
139
140    //Send the Pressure and Pain value to LCD.
141
142    lcd.setCursor(0,0);
143    lcd.print("Hg: ");
144    lcd.print(pval);
145
146    lcd.print("  F: ");
147    lcd.print(tval);
148    lcd.setCursor(0,1);
149
150    lcd.print("Pain: ");
151    lcd.print(Pval);
152    lcd.print("    H: ");
153
154    lcd.print(hval);
155    
156    }
157  Serial.flush();
158  delay(50);
159  
160}
161}
162

/* This sketch is from https://www.programmingelectronics.com/wireless-weather-monitoring-hc-12-long-range-transceivers-student-project/

  * It is slightly altered, the original sketch was designed for use with  
 *
  solar panels for a remote weather station.
 *  
 * The transmitter sketch
  uses the Adafruit BME 280 sensor.  
 */
 
/*
 * I am using a 2x16 LCD
  for this reciever because the data loger shield and RTC uses 
 * the SPI and
  I2C pins that OLEDs typically use.
 */

//#include "RTClib.h"
//RTC_DS1307
  rtc;
// OLED Libraries
#include <Wire.h>
#include <SPI.h>

//Include
  LCD library and initialize:
#include<LiquidCrystal.h>
LiquidCrystal lcd(2,
  3, 4, 5, 6, 7);

//Take a number of readings from potentiometers and average
  to smooth out the input value.
//Higher # of readings increase smoothing but
  slow down process.
const int numReadings = 10;

int readings[numReadings];
   //the readings from analog pot 
int readIndex = 0;           //the index of
  the current reading
int total = 0;               //the running total for readings
int
  average = 0;             //the average for pot

int inputPot = A0;  //Potentometer
  on Analog pin 0.
int Pval = 0;     //Variable to store Kristin's Pain Value.

     
int tval = 0;     //Variable to store Temperature Value.
int hval =
  0;     //
float pval = 0;   //Variable to store Pressure Value.


void
  setup() {
  Serial.begin(9600);
  Wire.begin(); // begins RTC serial data


  //Set up the LCD's number of columns and rows
  lcd.begin(16,2);
  lcd.clear();


   // intitialize all the readings for Potentometer to 0:
  for (int thisReading
  = 0; thisReading < numReadings; thisReading++)
  {
    readings[thisReading]
  =0;
  }
 
}


void loop() 
{ 
  //subtract the last potentometer
  reading;
  total = total - readings[readIndex];
  //read from the potentometer;

  readings[readIndex] = analogRead(inputPot);
  //add the reading to the total;

  total = total + readings[readIndex];
  //advance to the next position in the
  array;
  readIndex = readIndex + 1;
  //if we're at the end of the array...

  if (readIndex >= numReadings)
  {
    //... wrap around to the beginning:

    readIndex = 0;
  }
  //calculate the average:
  average = total / numReadings;

  //Take the average and reduce to a lower number to work closer to temperture values.

  int Pval = map(average, 0, 1023, 0, 9);
  Pval = constrain(Pval, 0, 9);

  

  
 // DateTime now = rtc.now(); // get time and date from RTC


  if (Serial.available() > 1) // checks to see if HC-12 is receiving data.
  {
  
    for (int x = 0; x < 1; x ++) // run once. Keep in mind transmitter actually
  sends twice.
    {
      int t = Serial.parseInt(); //read temp
      int
  tval = t;
      int h = Serial.parseInt(); //read humidity
      int hval
  = h;
      float p = Serial.parseFloat(); // read barometeric value
      float
  pval = p;
      
    Serial.print(tval);
    Serial.print(',');
    Serial.print(hval);

    Serial.print(',');
    Serial.print(pval);
    Serial.print(',');

    Serial.println(Pval);

    //Send the Pressure and Pain value to LCD.

    lcd.setCursor(0,0);
    lcd.print("Hg: ");
    lcd.print(pval);

    lcd.print("  F: ");
    lcd.print(tval);
    lcd.setCursor(0,1);

    lcd.print("Pain: ");
    lcd.print(Pval);
    lcd.print("    H: ");

    lcd.print(hval);
    
    }
  Serial.flush();
  delay(50);
  
}
}

TempPresHumOLED_Station_Transmitter_Final.ino

arduino

1/* 
2 * This sketch is from https://www.programmingelectronics.com/wireless-weather-monitoring-hc-12-long-range-transceivers-student-project/
3
4  * It is slightly altered; the original sketch was designed for use with  
5 *
6  solar panels for a remote weather station.
7 * 
8 * This code is to use with
9  Adafruit BMP280 and OLED screen   (Imperial)
10 * It measures both temperature
11  and pressure and it displays them on the OLED display with the altitude
12 * It's
13  a modified version of the Adafruit example code
14 * Refer to www.surtrtech.com
15  or SurtrTech Youtube channel
16 */
17 
18/*
19 * Note from John on 11/13/2019.
20  Iam using a DIYmall Yellow & Blue 128x64 OLED.
21 * This requires in the "void
22  setup" changing 0x3D to 0x3c in the following statement 
23 * if(!display.begin(SSD1306_SWITCHCAPVCC,
24  0x3c)) { // Address 0x3D for 128x64 // Had to change for DIYmall OLED 
25 * This
26  change makes this sketch work for this type of OLED screen. Surtrtech.com included
27
28  * this change.
29 * 
30 * Additionally, I am using the Adafruit BME280 sensor
31  because I wanted a humidity sensor. So BME replaces
32 * BMP throughout the sketch
33  as well as the library.
34 */
35
36// OLED Libraries
37#include <Wire.h>
38#include
39  <SPI.h>
40#include <Adafruit_GFX.h>
41#include <Adafruit_SSD1306.h>
42
43//
44  OLED declarations
45#define SCREEN_WIDTH 128 // OLED display width, in pixels
46#define
47  SCREEN_HEIGHT 64 // OLED display height, in pixels
48
49// Declaration for an
50  SSD1306 display connected to I2C (SDA, SCL pins)
51#define OLED_RESET     4 //
52  Reset pin # (or -1 if sharing Arduino reset pin)
53Adafruit_SSD1306 display(SCREEN_WIDTH,
54  SCREEN_HEIGHT, &Wire, OLED_RESET);     
55
56#define NUMFLAKES     10 // Number
57  of snowflakes in the animation example
58
59#define LOGO_HEIGHT   16
60#define
61  LOGO_WIDTH    16
62static const unsigned char PROGMEM logo_bmp[] =
63{ B00000000,
64  B11000000,
65  B00000001, B11000000,
66  B00000001, B11000000,
67  B00000011,
68  B11100000,
69  B11110011, B11100000,
70  B11111110, B11111000,
71  B01111110,
72  B11111111,
73  B00110011, B10011111,
74  B00011111, B11111100,
75  B00001101,
76  B01110000,
77  B00011011, B10100000,
78  B00111111, B11100000,
79  B00111111,
80  B11110000,
81  B01111100, B11110000,
82  B01110000, B01110000,
83  B00000000,
84  B00110000 };
85//varialbe to storing "for data # of loops"
86  int y = 0;
87
88//valiables
89  to store serial data for transmition through xbees.
90  int t = 0;
91  int p =
92  0;
93  float P = 0;
94// BME280 Libraries
95
96#include <Adafruit_Sensor.h>
97#include
98  <Adafruit_BME280.h>
99
100// BME Declarations - pins
101#define BME_SCK 13
102#define
103  BME_MISO 12
104#define BME_MOSI 11
105#define BME_CS 10
106
107#define SEALEVELPRESSURE_HPA
108  (1013.25)
109
110//Adafruit_BME280 bme; // I2C
111//Adafruit_BME280 bme(BME_CS);
112  // hardware SPI
113Adafruit_BME280 bme(BME_CS, BME_MOSI, BME_MISO, BME_SCK); //
114  software SPI
115
116unsigned long delayTime;
117
118void setup() {
119    Serial.begin(9600);
120
121  bme.begin();                                //Start the bme                  
122
123  display.begin(SSD1306_SWITCHCAPVCC, 0x3C); //Start the OLED display
124  display.clearDisplay();
125
126  display.display();
127  display.setTextColor(WHITE);
128  display.setTextSize(1);
129  
130  display.print("SurtrTech");     //Show the name, you can remove it or replace
131  it
132  display.setCursor(32,12);
133  display.setTextSize(2);          
134  display.println("BME280");
135  
136  display.display();
137  delay(2000);
138}
139
140
141void loop() { 
142
143
144  for(y = 0; y < 1; y ++)
145  {
146     display.clearDisplay();
147    float T
148  = bme.readTemperature() * 9 / 5 + 32-2;    //Read temperature in C and conversion
149  to F; 
150                                                     //the -2 is for calibrating
151  the sensor
152                                                     // inacuracy
153  that may be caused by heat generated in
154                                                     //
155  the electrical box enclosure.   If your sensor does not
156                                                     //
157  have this problem, the -2  can
158                                                     //be
159  removed from the conversion calculation.
160    float P = bme.readPressure()/3386.39;
161        //Read Pressure in Pa and conversion to inches of mercury
162    float H
163  = bme.readHumidity()* 1.644310631;   //Read humidity; the * 1.644310631 is for calibration.
164  
165                                                 //If you do not have this problem
166  it can be removed.
167
168    //convert to int for serial communication
169    int
170  t = T; 
171    int h = H;                                              
172
173
174    display.setCursor(0,0);                       //Oled display, just playing with
175  text size and cursor to get the display you want
176    display.setTextColor(WHITE);
177
178    display.setTextSize(2); 
179    display.print("Temp");
180    
181    display.setCursor(0,25);
182  //originally 0,18
183    display.print(T,1);
184    display.setCursor(50,17);
185
186    display.setTextSize(1);
187    display.print("F");
188
189    display.setTextSize(1);
190
191    display.setCursor(65,0); //originally 65,0
192    display.print("Pres-inHg");
193
194    display.setTextSize(2);
195    display.setCursor(65,17); //originally 65,10
196
197    display.print(P,2);
198    display.setTextSize(1);
199
200    display.setCursor(65,50);
201  //originally 65,25
202    display.print("Hum");
203    display.setTextSize(2);
204
205    display.setCursor(90,50); //originally 90,25
206    display.print(H,0);
207
208    display.setTextSize(1);
209    display.setCursor(120,50); //originally 110,25
210
211    display.print("%");
212    
213    display.display();
214
215    //Send data
216  through xbee radio
217     Serial.print(t);
218     Serial.print(',');
219     Serial.print(h);
220
221     Serial.print(',');
222     Serial.println(P);
223  }
224  int t = 0; // Clear
225  buffer data 
226  int h = 0;
227  int p = 0;
228  float P = 0;                                           
229
230  delay(50);
231  
232   
233}
234

/* 
 * This sketch is from https://www.programmingelectronics.com/wireless-weather-monitoring-hc-12-long-range-transceivers-student-project/

  * It is slightly altered; the original sketch was designed for use with  
 *
  solar panels for a remote weather station.
 * 
 * This code is to use with
  Adafruit BMP280 and OLED screen   (Imperial)
 * It measures both temperature
  and pressure and it displays them on the OLED display with the altitude
 * It's
  a modified version of the Adafruit example code
 * Refer to www.surtrtech.com
  or SurtrTech Youtube channel
 */
 
/*
 * Note from John on 11/13/2019.
  Iam using a DIYmall Yellow & Blue 128x64 OLED.
 * This requires in the "void
  setup" changing 0x3D to 0x3c in the following statement 
 * if(!display.begin(SSD1306_SWITCHCAPVCC,
  0x3c)) { // Address 0x3D for 128x64 // Had to change for DIYmall OLED 
 * This
  change makes this sketch work for this type of OLED screen. Surtrtech.com included

  * this change.
 * 
 * Additionally, I am using the Adafruit BME280 sensor
  because I wanted a humidity sensor. So BME replaces
 * BMP throughout the sketch
  as well as the library.
 */

// OLED Libraries
#include <Wire.h>
#include
  <SPI.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

//
  OLED declarations
#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define
  SCREEN_HEIGHT 64 // OLED display height, in pixels

// Declaration for an
  SSD1306 display connected to I2C (SDA, SCL pins)
#define OLED_RESET     4 //
  Reset pin # (or -1 if sharing Arduino reset pin)
Adafruit_SSD1306 display(SCREEN_WIDTH,
  SCREEN_HEIGHT, &Wire, OLED_RESET);     

#define NUMFLAKES     10 // Number
  of snowflakes in the animation example

#define LOGO_HEIGHT   16
#define
  LOGO_WIDTH    16
static const unsigned char PROGMEM logo_bmp[] =
{ B00000000,
  B11000000,
  B00000001, B11000000,
  B00000001, B11000000,
  B00000011,
  B11100000,
  B11110011, B11100000,
  B11111110, B11111000,
  B01111110,
  B11111111,
  B00110011, B10011111,
  B00011111, B11111100,
  B00001101,
  B01110000,
  B00011011, B10100000,
  B00111111, B11100000,
  B00111111,
  B11110000,
  B01111100, B11110000,
  B01110000, B01110000,
  B00000000,
  B00110000 };
//varialbe to storing "for data # of loops"
  int y = 0;

//valiables
  to store serial data for transmition through xbees.
  int t = 0;
  int p =
  0;
  float P = 0;
// BME280 Libraries

#include <Adafruit_Sensor.h>
#include
  <Adafruit_BME280.h>

// BME Declarations - pins
#define BME_SCK 13
#define
  BME_MISO 12
#define BME_MOSI 11
#define BME_CS 10

#define SEALEVELPRESSURE_HPA
  (1013.25)

//Adafruit_BME280 bme; // I2C
//Adafruit_BME280 bme(BME_CS);
  // hardware SPI
Adafruit_BME280 bme(BME_CS, BME_MOSI, BME_MISO, BME_SCK); //
  software SPI

unsigned long delayTime;

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

  bme.begin();                                //Start the bme                  

  display.begin(SSD1306_SWITCHCAPVCC, 0x3C); //Start the OLED display
  display.clearDisplay();

  display.display();
  display.setTextColor(WHITE);
  display.setTextSize(1);
  
  display.print("SurtrTech");     //Show the name, you can remove it or replace
  it
  display.setCursor(32,12);
  display.setTextSize(2);          
  display.println("BME280");
  
  display.display();
  delay(2000);
}


void loop() { 


  for(y = 0; y < 1; y ++)
  {
     display.clearDisplay();
    float T
  = bme.readTemperature() * 9 / 5 + 32-2;    //Read temperature in C and conversion
  to F; 
                                                     //the -2 is for calibrating
  the sensor
                                                     // inacuracy
  that may be caused by heat generated in
                                                     //
  the electrical box enclosure.   If your sensor does not
                                                     //
  have this problem, the -2  can
                                                     //be
  removed from the conversion calculation.
    float P = bme.readPressure()/3386.39;
        //Read Pressure in Pa and conversion to inches of mercury
    float H
  = bme.readHumidity()* 1.644310631;   //Read humidity; the * 1.644310631 is for calibration.
  
                                                 //If you do not have this problem
  it can be removed.

    //convert to int for serial communication
    int
  t = T; 
    int h = H;                                              


    display.setCursor(0,0);                       //Oled display, just playing with
  text size and cursor to get the display you want
    display.setTextColor(WHITE);

    display.setTextSize(2); 
    display.print("Temp");
    
    display.setCursor(0,25);
  //originally 0,18
    display.print(T,1);
    display.setCursor(50,17);

    display.setTextSize(1);
    display.print("F");

    display.setTextSize(1);

    display.setCursor(65,0); //originally 65,0
    display.print("Pres-inHg");

    display.setTextSize(2);
    display.setCursor(65,17); //originally 65,10

    display.print(P,2);
    display.setTextSize(1);

    display.setCursor(65,50);
  //originally 65,25
    display.print("Hum");
    display.setTextSize(2);

    display.setCursor(90,50); //originally 90,25
    display.print(H,0);

    display.setTextSize(1);
    display.setCursor(120,50); //originally 110,25

    display.print("%");
    
    display.display();

    //Send data
  through xbee radio
     Serial.print(t);
     Serial.print(',');
     Serial.print(h);

     Serial.print(',');
     Serial.println(P);
  }
  int t = 0; // Clear
  buffer data 
  int h = 0;
  int p = 0;
  float P = 0;                                           

  delay(50);
  
   
}

TempPresHumLCD_Station_Reciever_Final.ino

arduino

This is the sketch for the data logging remote weather station receiver.

1/* This sketch is an adaptation from 
2 * https://www.programmingelectronics.com/wireless-weather-monitoring-hc-12
3   *-long-range-transceivers-student-project/
4 * It is slightly altered; the
5  original sketch was designed for use with  
6 * solar panels for a remote weather
7  station.
8 * 
9 * The original intent for this project was for a wireless weather
10  station
11 * not reliant on internet applications. After starting the project,
12  I        * decided to add
13 * a pain variable to compare nerve pain to changes
14  in pressure. That         * required adding a 
15 * potentiometer to record changing
16  pain levels and data logging to compare   * pressure
17 * changes with pain over
18  time.
19 *  
20 * The transmitter sketch uses the Adafruit BME 280 sensor.  
21
22  * 
23 * I am using a 2x16 LCD for this receiver because the data logger shield
24  and  * RTC uses 
25 * the SPI and I2C pins that OLEDs typically use.
26 */
27
28  
29// Real Time Clock library and initialize:
30#include "RTClib.h" //For Real
31  Time Clock
32#include <Wire.h>  //For RTC I2C communication
33RTC_DS1307 RTC;
34  // Defining the RTC
35
36//Data Logging library and initialize:
37#include
38  <SD.h>   //For talking to SD Card
39#include <SPI.h>   //For SD Card communication
40
41//Set
42  by default for the SD card library:
43//MOSI = pin 11
44//MISO = pin 12
45//SCLK
46  = pin 13
47//We always need to set the CS Pin:
48const int CS_PIN = 10; //Chip
49  Select pin
50
51//We set this high to provide power:
52const int POW_PIN = 8;
53
54//Variable
55  for conditional counting for data recording intervals
56int c = 0; //variable counting.
57
58//Initialize
59  strings:
60String year, month, day, hour, minute, second, time, date;
61
62//Include
63  LCD library and initialize:
64#include<LiquidCrystal.h>
65LiquidCrystal lcd(2,
66  3, 4, 5, 6, 7);
67
68//potentiometer for recording pain initializers:
69const
70  int inputPot = A0;  //Pain recording potentiometer on Analog pin 0.
71int Pval
72  = 0;     //Variable to store Kristin's Pain value.
73
74//Take a number of readings
75  from potentiometers and average to smooth out the input value.
76//Higher # of
77  readings increase smoothing but slow down process.
78const int numReadings = 10;
79
80int
81  readings[numReadings];   //the readings from analog pot 
82int readIndex = 0;           //the
83  index of the current reading
84int total = 0;               //the running total
85  for readings
86int average = 0;             //the average for pot
87
88//Incoming
89  sensor data initializers:     
90int tval = 0;     //Variable to store Temperature
91  value.
92int hval = 0;     //Variable to store Humidity value.
93float pval =
94  0;   //Variable to store Pressure value.
95
96
97void setup() {
98  Serial.begin(9600);
99
100  Serial.println(F("Initializing Card"));
101  //CS pin, and pwr/gnd pins are
102  outputs
103  pinMode(CS_PIN,   OUTPUT);
104  
105  //Initiate the I2C bus and the
106  RTC library
107  //Card will draw power from pin 8, so set it high
108  pinMode(POW_PIN,
109  OUTPUT);
110  digitalWrite(POW_PIN, HIGH);
111  
112  Wire.begin();
113  RTC.begin();
114
115
116   //If RTC is not running, set it to the computer's compile time
117  if (! RTC.isrunning())
118
119  {
120    Serial.println(F("RTC is NOT running!"));
121    RTC.adjust(DateTime(__DATE__,
122  __TIME__));
123  }
124 
125  //Initialize SD card
126  if (!SD.begin(CS_PIN))
127
128  {
129    Serial.println(F("Card Failure"));
130    return;
131  }
132  Serial.println(F("Card
133  Ready"));
134
135  //Write column headers
136  File dataFile = SD.open("log.csv",
137  FILE_WRITE);
138  if (dataFile)
139  {
140    dataFile.println(F("\
141New Log Started!"));
142
143    dataFile.println(F("Date,Time,Pressure,Pain"));
144    dataFile.close(); //Data
145  isn't actually written until we close the connection!
146  
147    //Print same
148  thing to the screen for debugging
149    Serial.println(F("\
150New Log Started!"));
151
152    Serial.println(F("Date,Time,Pressure,Pain"));
153  }
154  else
155  {
156
157    Serial.println(F("Couldn't open log file"));
158  }
159
160  //Set up the
161  LCD's number of columns and rows
162  lcd.begin(16,2);
163  lcd.clear();
164
165
166   // intitialize all the readings for potentiometer to 0:
167  for (int thisReading
168  = 0; thisReading < numReadings; thisReading++)
169  {
170    readings[thisReading]
171  =0;
172  }
173  delay(100);
174}
175
176
177void loop() 
178{ 
179  //Get the current
180  date and time info and store in strings
181  DateTime datetime = RTC.now();
182
183  year  = String(datetime.year(),  DEC);
184  month = String(datetime.month(), DEC);
185
186  day  = String(datetime.day(),  DEC);
187  hour  = String(datetime.hour(),  DEC);
188
189  minute = String(datetime.minute(), DEC);
190  second = String(datetime.second(),
191  DEC);
192 
193  //Concatenate the strings into date and time
194  date = year +
195  "/" + month + "/" + day;
196  time = hour + ":" + minute + ":" + second;
197
198  
199  //This section of loop is for collecting and updating 
200  //Pain potentiometer
201  data.
202  
203  //subtract the last potentiometer reading;
204  total = total -
205  readings[readIndex];
206  //read from the potentiometer;
207  readings[readIndex]
208  = analogRead(inputPot);
209  //add the reading to the total;
210  total = total
211  + readings[readIndex];
212  //advance to the next position in the array;
213  readIndex
214  = readIndex + 1;
215  //if we're at the end of the array...
216  if (readIndex >=
217  numReadings)
218  {
219    //... wrap around to the beginning:
220    readIndex
221  = 0;
222  }
223  //calculate the average:
224  average = total / numReadings;
225
226  //Take the average and reduce to a lower number to work closer to temperature
227  values.
228  int Pval = map(average, 0, 1023, 0, 9);
229  Pval = constrain(Pval,
230  0, 9);
231  
232  //Gather sensor data from xbee radio transmission.
233  if (Serial.available()
234  > 1) // checks to see if XBEE is receiving data.
235  { 
236    for (int x = 0;
237  x < 1; x ++) // run once. Keep in mind transmitter actually sends twice.
238    {
239
240      int t = Serial.parseInt(); //read temp
241      int tval = t;
242      int
243  h = Serial.parseInt(); //read humidity
244      int hval = h;
245      float p =
246  Serial.parseFloat(); // read barometric value
247      float pval = p;
248
249      //Send
250  the Pressure and Pain value to LCD.
251      lcd.setCursor(0,0);
252      lcd.print("Hg:
253  ");
254      lcd.print(pval);
255      lcd.print("  F: ");
256      lcd.print(tval);
257
258      lcd.setCursor(0,1);
259      lcd.print("Pain: ");
260      lcd.print(Pval);
261
262      lcd.print("    H: ");
263      lcd.print(hval);
264    
265   
266   if(c
267  >= 12000) 
268/*
269Can change this # in () to increase or decrease the time interval
270  between data recording.  The time is the above # multiplied by the delay time at
271  the end of the main loop so, the # * 50 mls. Because of the xbee radio transmissions,
272  it is important to not have long delays so this counting loop avoids that problem.
273  12000 loops is logging about every 22 minutes. So the math is not quite working
274  out, perhaps there is additional time accumulating in the other processes.
275*/
276
277  //Open a file and write to it.
278  {
279    File dataFile = SD.open("log.csv",
280  FILE_WRITE);
281    if (dataFile)
282      {
283      dataFile.print(date);
284
285      dataFile.print(F(","));
286      dataFile.print(time);
287      dataFile.print(F(","));
288
289      dataFile.print(pval);
290      dataFile.print(F(","));
291      dataFile.println(Pval);
292
293      dataFile.close(); //Data isn't actually written until we close the connection!
294
295   
296      //Print same thing to the screen for debugging    
297      Serial.print(date);
298
299      Serial.print(F(","));
300      Serial.print(time);
301      Serial.print(F(","));
302
303      Serial.print(pval);
304      Serial.print(F(","));
305      Serial.println(Pval);
306
307      }
308      c = (0); // reset counter
309     }
310     else
311     {
312
313      c++; 
314     }
315     Serial.flush();
316     delay(50); 
317    }
318  }
319  
320}
321

/* This sketch is an adaptation from 
 * https://www.programmingelectronics.com/wireless-weather-monitoring-hc-12
   *-long-range-transceivers-student-project/
 * It is slightly altered; the
  original sketch was designed for use with  
 * solar panels for a remote weather
  station.
 * 
 * The original intent for this project was for a wireless weather
  station
 * not reliant on internet applications. After starting the project,
  I        * decided to add
 * a pain variable to compare nerve pain to changes
  in pressure. That         * required adding a 
 * potentiometer to record changing
  pain levels and data logging to compare   * pressure
 * changes with pain over
  time.
 *  
 * The transmitter sketch uses the Adafruit BME 280 sensor.  

  * 
 * I am using a 2x16 LCD for this receiver because the data logger shield
  and  * RTC uses 
 * the SPI and I2C pins that OLEDs typically use.
 */

  
// Real Time Clock library and initialize:
#include "RTClib.h" //For Real
  Time Clock
#include <Wire.h>  //For RTC I2C communication
RTC_DS1307 RTC;
  // Defining the RTC

//Data Logging library and initialize:
#include
  <SD.h>   //For talking to SD Card
#include <SPI.h>   //For SD Card communication

//Set
  by default for the SD card library:
//MOSI = pin 11
//MISO = pin 12
//SCLK
  = pin 13
//We always need to set the CS Pin:
const int CS_PIN = 10; //Chip
  Select pin

//We set this high to provide power:
const int POW_PIN = 8;

//Variable
  for conditional counting for data recording intervals
int c = 0; //variable counting.

//Initialize
  strings:
String year, month, day, hour, minute, second, time, date;

//Include
  LCD library and initialize:
#include<LiquidCrystal.h>
LiquidCrystal lcd(2,
  3, 4, 5, 6, 7);

//potentiometer for recording pain initializers:
const
  int inputPot = A0;  //Pain recording potentiometer on Analog pin 0.
int Pval
  = 0;     //Variable to store Kristin's Pain value.

//Take a number of readings
  from potentiometers and average to smooth out the input value.
//Higher # of
  readings increase smoothing but slow down process.
const int numReadings = 10;

int
  readings[numReadings];   //the readings from analog pot 
int readIndex = 0;           //the
  index of the current reading
int total = 0;               //the running total
  for readings
int average = 0;             //the average for pot

//Incoming
  sensor data initializers:     
int tval = 0;     //Variable to store Temperature
  value.
int hval = 0;     //Variable to store Humidity value.
float pval =
  0;   //Variable to store Pressure value.


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

  Serial.println(F("Initializing Card"));
  //CS pin, and pwr/gnd pins are
  outputs
  pinMode(CS_PIN,   OUTPUT);
  
  //Initiate the I2C bus and the
  RTC library
  //Card will draw power from pin 8, so set it high
  pinMode(POW_PIN,
  OUTPUT);
  digitalWrite(POW_PIN, HIGH);
  
  Wire.begin();
  RTC.begin();


   //If RTC is not running, set it to the computer's compile time
  if (! RTC.isrunning())

  {
    Serial.println(F("RTC is NOT running!"));
    RTC.adjust(DateTime(__DATE__,
  __TIME__));
  }
 
  //Initialize SD card
  if (!SD.begin(CS_PIN))

  {
    Serial.println(F("Card Failure"));
    return;
  }
  Serial.println(F("Card
  Ready"));

  //Write column headers
  File dataFile = SD.open("log.csv",
  FILE_WRITE);
  if (dataFile)
  {
    dataFile.println(F("\
New Log Started!"));

    dataFile.println(F("Date,Time,Pressure,Pain"));
    dataFile.close(); //Data
  isn't actually written until we close the connection!
  
    //Print same
  thing to the screen for debugging
    Serial.println(F("\
New Log Started!"));

    Serial.println(F("Date,Time,Pressure,Pain"));
  }
  else
  {

    Serial.println(F("Couldn't open log file"));
  }

  //Set up the
  LCD's number of columns and rows
  lcd.begin(16,2);
  lcd.clear();


   // intitialize all the readings for potentiometer to 0:
  for (int thisReading
  = 0; thisReading < numReadings; thisReading++)
  {
    readings[thisReading]
  =0;
  }
  delay(100);
}


void loop() 
{ 
  //Get the current
  date and time info and store in strings
  DateTime datetime = RTC.now();

  year  = String(datetime.year(),  DEC);
  month = String(datetime.month(), DEC);

  day  = String(datetime.day(),  DEC);
  hour  = String(datetime.hour(),  DEC);

  minute = String(datetime.minute(), DEC);
  second = String(datetime.second(),
  DEC);
 
  //Concatenate the strings into date and time
  date = year +
  "/" + month + "/" + day;
  time = hour + ":" + minute + ":" + second;

  
  //This section of loop is for collecting and updating 
  //Pain potentiometer
  data.
  
  //subtract the last potentiometer reading;
  total = total -
  readings[readIndex];
  //read from the potentiometer;
  readings[readIndex]
  = analogRead(inputPot);
  //add the reading to the total;
  total = total
  + readings[readIndex];
  //advance to the next position in the array;
  readIndex
  = readIndex + 1;
  //if we're at the end of the array...
  if (readIndex >=
  numReadings)
  {
    //... wrap around to the beginning:
    readIndex
  = 0;
  }
  //calculate the average:
  average = total / numReadings;

  //Take the average and reduce to a lower number to work closer to temperature
  values.
  int Pval = map(average, 0, 1023, 0, 9);
  Pval = constrain(Pval,
  0, 9);
  
  //Gather sensor data from xbee radio transmission.
  if (Serial.available()
  > 1) // checks to see if XBEE is receiving data.
  { 
    for (int x = 0;
  x < 1; x ++) // run once. Keep in mind transmitter actually sends twice.
    {

      int t = Serial.parseInt(); //read temp
      int tval = t;
      int
  h = Serial.parseInt(); //read humidity
      int hval = h;
      float p =
  Serial.parseFloat(); // read barometric value
      float pval = p;

      //Send
  the Pressure and Pain value to LCD.
      lcd.setCursor(0,0);
      lcd.print("Hg:
  ");
      lcd.print(pval);
      lcd.print("  F: ");
      lcd.print(tval);

      lcd.setCursor(0,1);
      lcd.print("Pain: ");
      lcd.print(Pval);

      lcd.print("    H: ");
      lcd.print(hval);
    
   
   if(c
  >= 12000) 
/*
Can change this # in () to increase or decrease the time interval
  between data recording.  The time is the above # multiplied by the delay time at
  the end of the main loop so, the # * 50 mls. Because of the xbee radio transmissions,
  it is important to not have long delays so this counting loop avoids that problem.
  12000 loops is logging about every 22 minutes. So the math is not quite working
  out, perhaps there is additional time accumulating in the other processes.
*/

  //Open a file and write to it.
  {
    File dataFile = SD.open("log.csv",
  FILE_WRITE);
    if (dataFile)
      {
      dataFile.print(date);

      dataFile.print(F(","));
      dataFile.print(time);
      dataFile.print(F(","));

      dataFile.print(pval);
      dataFile.print(F(","));
      dataFile.println(Pval);

      dataFile.close(); //Data isn't actually written until we close the connection!

   
      //Print same thing to the screen for debugging    
      Serial.print(date);

      Serial.print(F(","));
      Serial.print(time);
      Serial.print(F(","));

      Serial.print(pval);
      Serial.print(F(","));
      Serial.println(Pval);

      }
      c = (0); // reset counter
     }
     else
     {

      c++; 
     }
     Serial.flush();
     delay(50); 
    }
  }
  
}

XBee Radio Testing from Jeremy Blum's arduino_read_pot.ino from, "Exploring Arduino.com/content/ch6"

arduino

Use this sketch to test XBee Radios

1/*
2Exploring Arduino - Code Listing 6-6: Arduino Code to send Data
3  to the Computer
4http://www.exploringarduino.com/content/ch6
5
6Copyright
7  2013 Jeremy Blum ( http://www.jeremyblum.com )
8This program is free software:
9  you can redistribute it and/or modify
10it under the terms of the GNU General Public
11  License v3 as published by
12the Free Software Foundation.
13*/
14
15//Sending
16  POT value to the computer
17
18const int POT=0; //Pot on Analog Pin 0
19
20int
21  val; //For holding mapped pot value
22
23void setup()
24{
25  Serial.begin(9600);
26  //Start Serial
27}
28
29void loop()
30{
31  val = map(analogRead(POT), 0, 1023,
32  0, 255); //Read and map POT
33  Serial.println(val);                         //Send
34  value
35  delay(50);                                   //Delay so we don't flood
36  the computer
37}
38
39

/*
Exploring Arduino - Code Listing 6-6: Arduino Code to send Data
  to the Computer
http://www.exploringarduino.com/content/ch6

Copyright
  2013 Jeremy Blum ( http://www.jeremyblum.com )
This program is free software:
  you can redistribute it and/or modify
it under the terms of the GNU General Public
  License v3 as published by
the Free Software Foundation.
*/

//Sending
  POT value to the computer

const int POT=0; //Pot on Analog Pin 0

int
  val; //For holding mapped pot value

void setup()
{
  Serial.begin(9600);
  //Start Serial
}

void loop()
{
  val = map(analogRead(POT), 0, 1023,
  0, 255); //Read and map POT
  Serial.println(val);                         //Send
  value
  delay(50);                                   //Delay so we don't flood
  the computer
}

Downloadable files

Transmitter Installation 4

Mounting the birdhouse cabinet over electric housing.

Transmitter Installation 4

Transmitter Installation 3

detail

Transmitter Installation 3

Adafruit BME280 Tutorial

Helpful tutorial for the BME sensor

Adafruit BME280 Tutorial

Receiver Circuit Diagram

This is the circuit diagram for the receiver. Be sure to consult the photos for how to wire the power to the XBee Shield and breadboard.

Receiver Circuit Diagram

Receiver

This image illustrates how to wire the Receiver.

Receiver

Transmitter Installation 1

Mounting the transmitter

Transmitter Installation 1

Transmitter Installation 8

Weather station on shed.

Transmitter Installation 8

Transmitter Installation 2

detail

Transmitter Installation 2

Power supply for Xbee shield

NOTE: Now the Stacking Header Pin kits have headers for the ICSP pins. So if you have the new kits you can skip this example for supplying power to the peripherals. If you skip these steps you will have to solder male header pins on the Xbee Shield to supply power for the 3 & 5 Volt components. The data logger on the receiver blocks the power supply for the Xbee. These three images show how to wire around that and transmit power to the ICSP socket on the Xbee shield.

Power supply for Xbee shield

Transmitter Installation 7

Viewing window for OLED. The camera used fast shutter speed so the OLED data looks broken, the OLED actually works fine.

Transmitter Installation 7

Transmitter Installation 5

Completed birdhouse

Transmitter Installation 5

Transmitter Circuit Diagram

This is the circuit diagram for the transmitter.

Transmitter Circuit Diagram

Sample of recorded data and graph

This is an example of data from the SD card of the Data Logger. I am using a Windows computer, so the data is opened in Excel and graphed within that application.

Sample of recorded data and graph

receiver_box_build_(2)_lk64rZMpLZ.JPG

Transmitter Installation 6

Open front for access to electrical box for reprogramming.

Transmitter Installation 6

Transmitter Wiring Example

This image illustrates how to wire the transmitter. Additionally, male header pins must be soldered to the Xbee shield in order to supply both the 5 volt and 3 volts necessary for the OLED and BME280 sensor.

Transmitter Wiring Example

Adafruit Logging Shield Tutorial

This tutorial walks through the set up of the logging shield and setting the real time clock.

Adafruit Logging Shield Tutorial

receiver_box_build_(1)_nf92bPIM1D.JPG

Sample of recorded data and graph

This is an example of data from the SD card of the Data Logger. I am using a Windows computer, so the data is opened in Excel and graphed within that application.

Sample of recorded data and graph

receiver_box_build_(2)_lk64rZMpLZ.JPG

Transmitter Circuit Diagram

This is the circuit diagram for the transmitter.

Transmitter Circuit Diagram

Transmitter Installation 2

detail

Transmitter Installation 2

Transmitter Installation 8

Weather station on shed.

Transmitter Installation 8

Transmitter Installation 7

Viewing window for OLED. The camera used fast shutter speed so the OLED data looks broken, the OLED actually works fine.

Transmitter Installation 7

Adafruit BME280 Tutorial

Helpful tutorial for the BME sensor

Adafruit BME280 Tutorial

Receiver

This image illustrates how to wire the Receiver.

Receiver

Receiver Circuit Diagram

This is the circuit diagram for the receiver. Be sure to consult the photos for how to wire the power to the XBee Shield and breadboard.

Receiver Circuit Diagram

Transmitter Installation 4

Mounting the birdhouse cabinet over electric housing.

Transmitter Installation 4

Power supply for Xbee shield

Transmitter Installation 3

detail

Transmitter Installation 3

Transmitter Installation 6

Open front for access to electrical box for reprogramming.

Transmitter Installation 6

Notes for configuring Xbee radios

The configuration approach highlighted by Blum requires changes to be made with the XTCU application. The attached PDF file walks through the steps to do this .

Notes for configuring Xbee radios

Transmitter Wiring Example

Adafruit Logging Shield Tutorial

This tutorial walks through the set up of the logging shield and setting the real time clock.

Adafruit Logging Shield Tutorial

receiver_box_build_(1)_nf92bPIM1D.JPG

Transmitter Installation 5

Completed birdhouse

Transmitter Installation 5

Transmitter Installation 1

Mounting the transmitter

Transmitter Installation 1

Comments

Only logged in users can leave comments

Anderson-Bricker

0 Followers

•

0 Projects

Intro

Trademarks & CopyrightsWhistleblowingDigital Services ActTerms of ServicePrivacy PolicySecurityCookie Settings

Report content