Beginner kits for outdoor wireless temperature display

I have a couple of months to fill while bones mend after slipping on ice!

I have no Arduino kit at all, and no experience with these boards or IDE.

Is there a starter kit that has the components to allow me to build something that would show inside on a LCD, the outdoor air temperature (wirelessly).

Thanks

Try Google and search for "Arduino starter kit". There are such ones.

I rather doubt that you would find such a thing. Most of the kits I've seen come with a single Arduino and a bunch of jellybean parts such as resistors, LEDs, capacitors, switches etc.

You're going to need a temperature sensor, a display and two wifi capable Arduinos (more likely Wemos D1 or ESPXX) and some means of powering the outside hardware.

Such a thing is eminently doable, but it might be a bit much for your first project

I know I've been reading here about real kits having proper instructions how to manage the different exampels. Don't buy an Ebay collection of unknown stuff.

I would start by making an indoor thermometer, then extend the project to wireless/outdoor.

Shopping list to save you buying one of those awful starter kits full of junk:

A couple of Arduino Pro Mini. 5V would do but 3.3V might be better.
A couple of breadboards (not tiny ones)
A usb-serial adaptor for programming the Pro Minis
A ds18b20 temp sensor
16x2 lcd. One with an I2C "backpack" would be nice but not mandatory
A basic 433MHz transmitter & receiver pair
Solid core connecting wires in a few colours including red & black
Small wire cutters & strippers & pliers
A few odd components like leds, resistors (10K, 4K7, 330R)
A small 10K trimmer pot for adjusting the lcd contrast (the backpacks have these built in)
Basic low power soldering iron with a fine bit like 1~2mm (you will probably need to solder header pins onto things like the Pro Mini, even when constructing on breadboards)
Solder with a flux core, 0.5 or 1mm
Basic digital multimeter
A battery holder with flying wires or a clip connector for 4 AA batteries (I would recommend using rechargeables for the planet's sake. If using non-rechargeable, use a 3 AA holder)

Did I miss anything?

Thanks everyone.
That's just what I wanted to know.

Although I've worked with PIC's in the past, it looks like I'm going to have to start from the beginning with arduino. I was hoping for a quick-start to get me into this project.

The 'shopping list' was really helpful, and there are bound to be examples in this forum for pairing up radio modules - something I'm unfamiliar with

A thermometer and display project is a very good beginner's project. Enough pitfalls but easy enough to debug and general enough to find lots of examples.

Anything wireless is not a beginner's project. Mostly due to the hard debugging of the wireless connection itself, but also the communication between two boards as such.

Hello,
Welcome to the forum and the Arduino world.
What kind of technical background do you have? It all depends on this.
There are 3 areas of expertise you need: electronics, programming and networking.
Depending on what you know, the options are different.
Can you tell us something more about yourselves?
Best Regards,
Johi.

rnewmark:
there are bound to be examples in this forum for pairing up radio modules - something I'm unfamiliar with

Generally no need for pairing with basic radio modules.

OK, so you got a thingy outside sending you data, how are you going to get at that data?

I have 7 ESP32's doing various things. I can read the data and set my heater or AC to on off or a higher or lower temperature, from my web site.

I use a MQTT Broker that the ESP32's send data to and receive data from. Perhaps you might want to consider expansion into your connectivity scheme. I found using MQTT it is easy add a new ESP32 doing a new thing to my system.

For my weather station, I use a BME680 and a ESP32.

A solar cell is connected to a PWM Charge Controller that charges a 12V 16Ah LifePo4 battery. The battery is connected to an automotive 12V to 5V weatherized switching regulator. The output from the regulator is distributed to several servos, two ESP32's and associated components.

You may find circuits on using a TP4560 to handle the battery charge. This scheme will work but is not a hands off solution. The LiPo's undergo a fast charge discharge cycle and wear out over 4ish months.

The only good solar charging solutions are PWM or MPPT Charge controllers using a 12V lead acid battery of a 12V LifePo4 battery.

Here is some code that reads the BME680 and sends the data to the MQTT Broker for distrubitioon.

/*
   Project, use solar cells to generate power
   2/2/2020

*/
#include <WiFi.h>
#include <PubSubClient.h>
#include "certs.h"
#include "sdkconfig.h"
#include "esp_system.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/timers.h"
#include "freertos/event_groups.h"
//#include "esp_sleep.h"
#include <SPI.h>
#include <Adafruit_Sensor.h>
#include "Adafruit_BME680.h"
////
#define evtDoMQTTwd          ( 1 << 1 )
EventGroupHandle_t eg; // variable for the event group handle
////
WiFiClient wifiClient;
PubSubClient MQTTclient(mqtt_server, mqtt_port, wifiClient);
//////
Adafruit_BME680 bme( GPIO_NUM_5 );
///
/*
   This semaphore is used to stop or prevent a publish from happening during client.loop()
*/
SemaphoreHandle_t sema_MQTT_KeepAlive;
SemaphoreHandle_t sema_mqttOK; // protects the int mqttOK
////
int mqttOK = 0; // stores a count value that is used to cause an esp reset 
////
/*
 * A single subject has been scribed to, the mqtt broker sends out "OK" messages if the client receives an OK message the mqttOK value is set back to zero
 */
void IRAM_ATTR mqttCallback(char* topic, byte * payload, unsigned int length)
{
  xSemaphoreTake( sema_mqttOK, portMAX_DELAY );
  mqttOK = 0;
  xSemaphoreGive( sema_mqttOK );
} // void mqttCallback(char* topic, byte* payload, unsigned int length)
////
// interrupt service routine for WiFi events put into IRAM
void IRAM_ATTR WiFiEvent(WiFiEvent_t event)
{
  switch (event) {
    case SYSTEM_EVENT_STA_CONNECTED:
      break;
    case SYSTEM_EVENT_STA_DISCONNECTED:
      log_i("Disconnected from WiFi access point");
      break;
    case SYSTEM_EVENT_AP_STADISCONNECTED:
      log_i("WiFi client disconnected");
      break;
    default: break;
  }
} // void IRAM_ATTR WiFiEvent(WiFiEvent_t event)
////
////
void setup()
{
  sema_mqttOK = xSemaphoreCreateBinary();
  xSemaphoreGive( sema_mqttOK );
  eg = xEventGroupCreate(); // get an event group handle
  xTaskCreatePinnedToCore( MQTTkeepalive, "MQTTkeepalive", 20000, NULL, 5, NULL, 1 );
  xTaskCreatePinnedToCore( fDoBME, "fDoBME", 20000, NULL, 3, NULL, 1 ); // assigned to core
  xTaskCreatePinnedToCore( fmqttWatchDog, "fmqttWatchDog", 3000, NULL, 3, NULL, 1 ); // assign all to core 1
} //void setup()
////
////
void fmqttWatchDog( void * paramater )
{
  int maxNonMQTTresponse = 20;
  for (;;)
  {
    xEventGroupWaitBits (eg, evtDoMQTTwd, pdTRUE, pdTRUE, portMAX_DELAY );
    xSemaphoreTake( sema_mqttOK, portMAX_DELAY );
    mqttOK++;
    xSemaphoreGive( sema_mqttOK );
    if ( mqttOK >= maxNonMQTTresponse )
    {
      ESP.restart();
    }
  }
  vTaskDelete( NULL );
} //void fmqttWatchDog( void * paramater )
////
void connectToMQTT()
{
  MQTTclient.setKeepAlive( 90 ); // needs be made before connecting
  // create client ID from mac address
  byte mac[5];
  WiFi.macAddress(mac); // get mac address
  String clientID = String(mac[0]) + String(mac[4]) ; // use mac address to create clientID
  while ( !MQTTclient.connected() )
  {
    // boolean connect(const char* id, const char* user, const char* pass, const char* willTopic, uint8_t willQos, boolean willRetain, const char* willMessage);
    MQTTclient.connect( clientID.c_str(), mqtt_username, mqtt_password, NULL , 1, true, NULL );
    vTaskDelay( 250 );
  }
  MQTTclient.setCallback( mqttCallback );
  MQTTclient.subscribe( topicOK );
  log_i("MQTT Connected");
} // void connectToMQTT()
////
void fDoBME ( void *pvParameters )
{
  if (!bme.begin()) {
    log_i("Could not find a valid BME680 sensor, check wiring!");
    while (1);
  }
  // Set up oversampling and filter initialization
  bme.setTemperatureOversampling(BME680_OS_8X);
  bme.setHumidityOversampling(BME680_OS_2X);
  bme.setPressureOversampling(BME680_OS_4X);
  bme.setIIRFilterSize(BME680_FILTER_SIZE_3);
  bme.setGasHeater(320, 150); // 320*C for 150 ms
  float fTemperature = 0.0f;
  float fPressure = 0.0f;
  float fHumidity = 0.0f;
  uint32_t iGasResistance = 0;
  TickType_t DelayTime = 1000 * 30;
  //wait for a mqtt connection
  while ( !MQTTclient.connected() )
  {
    vTaskDelay( 250 );
  }
  for ( ;; )
  {
    fTemperature = bme.readTemperature();
    fTemperature = (fTemperature * 1.8f) + 32.0f; // (Celsius x 1.8) + 32
    fPressure = bme.readPressure();
    fPressure = fPressure / 133.3223684f; //converts to mmHg
    fHumidity = bme.readHumidity();
    iGasResistance = bme.readGas();
    xSemaphoreTake( sema_MQTT_KeepAlive, portMAX_DELAY ); // whiles MQTTlient.loop() is running no other mqtt operations should be in process
    log_i( "Temperature %f C, Pressure %f mmHg, Humidity %f, gasResistance %d", fTemperature, fPressure, fHumidity, iGasResistance );
    MQTTclient.publish( topicOutsideTemp, String(fTemperature).c_str() );
    vTaskDelay( 5 ); // gives the Raspberry Pi 4 time to receive the message and process
    MQTTclient.publish( topicOutsideHumidity, String(fHumidity).c_str() );
    vTaskDelay( 5 ); // no delay and RPi is still processing previous message
    MQTTclient.publish( topicOutsideGasResistance, String(iGasResistance).c_str() );
    vTaskDelay( 5 );
    MQTTclient.publish( topicOutsidePressure, String(fPressure).c_str() );
    vTaskDelay( 5 );
    xSemaphoreGive( sema_MQTT_KeepAlive );
    xEventGroupSetBits( eg, evtDoMQTTwd );
    vTaskDelay( DelayTime );
  } // for loop
  vTaskDelete ( NULL );
} // void fDoBME ( void *pvParameters )
////
/*
    Important to not set vTaskDelay to less then 10. Errors begin to develop with the MQTT and network connection.
    makes the initial wifi/mqtt connection and works to keeps those connections open.
*/
void MQTTkeepalive( void *pvParameters )
{
  sema_MQTT_KeepAlive   = xSemaphoreCreateBinary();
  xSemaphoreGive( sema_MQTT_KeepAlive ); // found keep alive can mess with a publish, stop keep alive during publish
  // setting must be set before a mqtt connection is made
  MQTTclient.setKeepAlive( 90 ); // setting keep alive to 90 seconds makes for a very reliable connection, must be set before the 1st connection is made.
  for (;;)
  {
    //check for a is-connected and if the WiFi 'thinks' its connected, found checking on both is more realible than just a single check
    if ( (wifiClient.connected()) && (WiFi.status() == WL_CONNECTED) )
    {
      xSemaphoreTake( sema_MQTT_KeepAlive, portMAX_DELAY ); // whiles MQTTlient.loop() is running no other mqtt operations should be in process
      MQTTclient.loop();
      xSemaphoreGive( sema_MQTT_KeepAlive );
    }
    else {
      log_i( "MQTT keep alive found MQTT status %s WiFi status %s", String(wifiClient.connected()), String(WiFi.status()) );
      if ( !(wifiClient.connected()) || !(WiFi.status() == WL_CONNECTED) )
      {
        connectToWiFi();
      }
      connectToMQTT();
    }
    vTaskDelay( 250 ); //task runs approx every 250 mS
  }
  vTaskDelete ( NULL );
}
////
void connectToWiFi()
{
  int TryCount = 0;
  //log_i( "connect to wifi" );
  while ( WiFi.status() != WL_CONNECTED )
  {
    TryCount++;
    WiFi.disconnect();
    WiFi.begin( SSID, PASSWORD );
    vTaskDelay( 4000 );
    if ( TryCount == 10 )
    {
      ESP.restart();
    }
  }
  WiFi.onEvent( WiFiEvent );
} // void connectToWiFi()
////
void loop() {}
////

Esp8266
Bme280. Not bmp280
Ds18b20
Small oled i2c
47k ohm resistors
Cheap 10$ temperature controlled soldersoldering iron and solder
Breadboard.

That will get you started.

All beginner level.
Lots of tutorials and we are all familiar with these parts.
So help is readily available

Ebay is way cheaper than amazon

Another aspect to consider. If the environmental sensor is in the same case as the MCU the heat from the MCU will affect the readings.

I came to realize that the sensor must be insulated and isolated from the MCU and the sensor needs to be exposed to the air. Yuppers the electronics will be exposed to the weather.

You’ll want to mount the sensor so it can be replaced and you’ll want to shield the sensor from the elements.

I found a premade Stevenson Shield, on Amazon. What I had to do was rework the sensor case so it would fit into the shield and make openings in the case so the openings are only exposed in the shields attic.

Put a fine netting over the openings so bugs do not make the sensor case a home.

Yup, there is a BME680 in there that is exposed but protected from the elements.


No snow.


Shield removed. Top box contains the BME680 and insolation, at the bottom of the case. Middle case contains ESP32 and circuity, Bottom case holds the battery, charge controller and 5V regulator.

This topic was automatically closed 120 days after the last reply. New replies are no longer allowed.