Weather_Monitoring.ino

WisBlock
1

I am developing the weather monitoring via RAK4631 by PlatformIO:
examples/RAK4630/solutions/Weather_Monitoring/Weather_Monitoring.ino

But there are errors:
identifier “Wire” is undefinedC/C++(20) [Ln 176,Col 3]
identifier “BARO” is undefinedC/C++(20) [Ln 195, Col 8]
identifier “BARO” is undefinedC/C++(20) [Ln 350, Col 16]

How can I fix these problems?

2

The examples are originally written for ArduinoIDE and the required libraries have to be installed with the ArduinoIDE library manager.

In PlatformIO you have to add them in platformio.ini.

Do you have the Arduino_LPW22HW in your platformio.ini?
With this platformio.ini it compiles for me:

[env:wiscore_rak4631]
platform = nordicnrf52
board = wiscore_rak4631
framework = arduino
lib_deps =
	beegee-tokyo/sx126x-arduino
	sparkfun/SparkFun SHTC3 Humidity and Temperature Sensor Library
	ClosedCube/ClosedCube OPT3001
	arduino-libraries/Arduino_LPS22HB

But it needs one change in the code for PIO, you need to add declarations for two functions in the top of the file:

// Forward declarations
void configureSensor();
void data_get();

image
image1067×673 34.2 KB

3

Do I need to replace Arduino_LPS22HB with Arduino_LPW22HW in my platformio.ini?

Because the error identifier “Wire” is undefinedC/C++(20) [Ln 176,Col 3] did not solve yet after I added declarations for two functions.

How can I fix “Wire” error?

4

Can you share your platformio.ini file.

The example is compiling without problems in my installation.

5

Sure.
[env:wiscore_rak4631]

platform = nordicnrf52

board = wiscore_rak4631

framework = arduino

lib_deps =

beegee-tokyo/sx126x-arduino

sparkfun/SparkFun SHTC3 Humidity and Temperature Sensor Library

ClosedCube/ClosedCube OPT3001

arduino-libraries/Arduino_LPS22HB

debug_speed = 10000

upload_protocol = jlink

monitor_speed = 115200

debug_tool = jlink

debug_init_break = tbreak setup

6

Beside of the last lines I have the same.
No problem to compile. Wire.h is included from the sketch.

Does it compile in ArduinoIDE? Maybe a problem in the BSP installation or the patch in PlatformIO.

Other than that I don’t know. It compiles on my setup without any error.

Try to remove the last lines in your platfromio.ini

debug_speed = 10000
upload_protocol = jlink
monitor_speed = 115200
debug_tool = jlink
debug_init_break = tbreak setup
7

Maybe because of this error:
*** [.pio\build\wiscore_rak4631\lib9ef\Adafruit_TinyUSB_Arduino\arduino\Adafruit_USBH_Host.cpp.o] Error 1

*** [.pio\build\wiscore_rak4631\lib9ef\Adafruit_TinyUSB_Arduino\arduino\Adafruit_TinyUSB_API.cpp.o] Error 1
*** [.pio\build\wiscore_rak4631\lib9ef\Adafruit_TinyUSB_Arduino\arduino\Adafruit_USBD_Device.cpp.o] Error 1

8

And I forgot to let you know that I could not run RAK_PATCH at all.

Capture

9

Can you have a look my codes, just make sure that the codes are correct?

/**

  • @file Weather_Monitoring.ino
  • @author rakwireless.com
  • @brief This sketch demonstrate reading a data from a weather station
  • and send the data to lora gateway.
  • @version 0.1
  • @date 2020-07-28
  • @copyright Copyright (c) 2020
  • @note RAK4631 GPIO mapping to nRF52840 GPIO ports
    RAK4631 ↔ nRF52840
    WB_IO1 ↔ P0.17 (GPIO 17)
    WB_IO2 ↔ P1.02 (GPIO 34)
    WB_IO3 ↔ P0.21 (GPIO 21)
    WB_IO4 ↔ P0.04 (GPIO 4)
    WB_IO5 ↔ P0.09 (GPIO 9)
    WB_IO6 ↔ P0.10 (GPIO 10)
    WB_SW1 ↔ P0.01 (GPIO 1)
    WB_A0 ↔ P0.04/AIN2 (AnalogIn A2)
    WB_A1 ↔ P0.31/AIN7 (AnalogIn A7)
    */

#include <Commissioning.h>
#include <Adafruit_TinyUSB.h>
#include <Arduino.h>
#include <LoRaWan-RAK4630.h> //Click here to get the library: http://librarymanager/All#SX126x
#include <SPI.h>
#include <Wire.h>
#include <Arduino_LPS22HB.h> // Click here to get the library: http://librarymanager/All#Arduino_LPS22HB
#include “SparkFun_SHTC3.h” // Click here to get the library: http://librarymanager/All#SparkFun_SHTC3
#include <ClosedCube_OPT3001.h> // Click here to get the library: http://librarymanager/All#OPT3001

#define OPT3001_ADDRESS 0x44

ClosedCube_OPT3001 opt3001;
SHTC3 mySHTC3; // Declare an instance of the SHTC3 class

// Forward declarations
void configureSensor();
void data_get();

// RAK4630 supply two LED
#ifndef LED_BUILTIN
#define LED_BUILTIN 35
#endif

#ifndef LED_BUILTIN2
#define LED_BUILTIN2 36
#endif

bool doOTAA = true; // OTAA is used by default.
#define SCHED_MAX_EVENT_DATA_SIZE APP_TIMER_SCHED_EVENT_DATA_SIZE /< Maximum size of scheduler events. */
#define SCHED_QUEUE_SIZE 60 /< Maximum number of events in the scheduler queue. /
#define LORAWAN_DATERATE DR_0 /LoRaMac datarates definition, from DR_0 to DR_5/
#define LORAWAN_TX_POWER TX_POWER_5 /LoRaMac tx power definition, from TX_POWER_0 to TX_POWER_15/
#define JOINREQ_NBTRIALS 3 /**< Number of trials for the join request. /
DeviceClass_t g_CurrentClass = CLASS_A; / class definition/
LoRaMacRegion_t g_CurrentRegion = LORAMAC_REGION_EU868; /* Region:EU868*/
lmh_confirm gCurrentConfirm = LMH_UNCONFIRMED_MSG; /* confirm/unconfirm packet definition*/
uint8_t gAppPort = LORAWAN_APP_PORT; /* data port*/

/**@brief Structure containing LoRaWan parameters, needed for lmh_init()
*/
static lmh_param_t g_lora_param_init = {LORAWAN_ADR_ON, LORAWAN_DATERATE, LORAWAN_PUBLIC_NETWORK, JOINREQ_NBTRIALS, LORAWAN_TX_POWER, LORAWAN_DUTYCYCLE_OFF};

// Foward declaration
static void lorawan_has_joined_handler(void);
static void lorawan_join_failed_handler(void);
static void lorawan_rx_handler(lmh_app_data_t *app_data);
static void lorawan_confirm_class_handler(DeviceClass_t Class);
static void send_lora_frame(void);

/**@brief Structure containing LoRaWan callback functions, needed for lmh_init()
*/
static lmh_callback_t g_lora_callbacks = {BoardGetBatteryLevel, BoardGetUniqueId, BoardGetRandomSeed,
lorawan_rx_handler, lorawan_has_joined_handler, lorawan_confirm_class_handler, lorawan_join_failed_handler
};

//OTAA keys !!! KEYS ARE MSB !!!
uint8_t nodeDeviceEUI[8] = {0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x33, 0x33};
uint8_t nodeAppEUI[8] = {0xB8, 0x27, 0xEB, 0xFF, 0xFE, 0x39, 0x00, 0x00};
uint8_t nodeAppKey[16] = {0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88};

// ABP keys
uint32_t nodeDevAddr = 0x260116F8;
uint8_t nodeNwsKey[16] = {0x7E, 0xAC, 0xE2, 0x55, 0xB8, 0xA5, 0xE2, 0x69, 0x91, 0x51, 0x96, 0x06, 0x47, 0x56, 0x9D, 0x23};
uint8_t nodeAppsKey[16] = {0xFB, 0xAC, 0xB6, 0x47, 0xF3, 0x58, 0x45, 0xC7, 0x50, 0x7D, 0xBF, 0x16, 0x8B, 0xA8, 0xC1, 0x7C};

// Private defination
#define LORAWAN_APP_DATA_BUFF_SIZE 64 /< buffer size of the data to be transmitted. */
#define LORAWAN_APP_INTERVAL 20000 /< Defines for user timer, the application data transmission interval. 20s, value in [ms]. */
static uint8_t m_lora_app_data_buffer[LORAWAN_APP_DATA_BUFF_SIZE]; //< Lora user application data buffer.
static lmh_app_data_t m_lora_app_data = {m_lora_app_data_buffer, 0, 0, 0, 0}; //< Lora user application data structure.

TimerEvent_t appTimer;
static uint32_t timers_init(void);
static uint32_t count = 0;
static uint32_t count_fail = 0;

void setup()
{
pinMode(LED_BUILTIN, OUTPUT);
digitalWrite(LED_BUILTIN, LOW);

// Initialize Serial for debug output
time_t timeout = millis();
Serial.begin(115200);
while (!Serial)
{
if ((millis() - timeout) < 5000)
{
delay(100);
}
else
{
break;
}
}

// Initialize LoRa chip.
lora_rak4630_init();

Serial.println(“=====================================”);
Serial.println(“Welcome to RAK4630 LoRaWan!!!”);
if (doOTAA)
{
Serial.println(“Type: OTAA”);
}
else
{
Serial.println(“Type: ABP”);
}

switch (g_CurrentRegion)
{
case LORAMAC_REGION_AS923:
Serial.println(“Region: AS923”);
break;
case LORAMAC_REGION_AU915:
Serial.println(“Region: AU915”);
break;
case LORAMAC_REGION_CN470:
Serial.println(“Region: CN470”);
break;
case LORAMAC_REGION_CN779:
Serial.println(“Region: CN779”);
break;
case LORAMAC_REGION_EU433:
Serial.println(“Region: EU433”);
break;
case LORAMAC_REGION_IN865:
Serial.println(“Region: IN865”);
break;
case LORAMAC_REGION_EU868:
Serial.println(“Region: EU868”);
break;
case LORAMAC_REGION_KR920:
Serial.println(“Region: KR920”);
break;
case LORAMAC_REGION_US915:
Serial.println(“Region: US915”);
break;
case LORAMAC_REGION_RU864:
Serial.println(“Region: RU864”);
break;
case LORAMAC_REGION_AS923_2:
Serial.println(“Region: AS923-2”);
break;
case LORAMAC_REGION_AS923_3:
Serial.println(“Region: AS923-3”);
break;
case LORAMAC_REGION_AS923_4:
Serial.println(“Region: AS923-4”);
break;
}
Serial.println(“=====================================”);

Wire.begin();
/* shtc3 init */
Serial.println(“shtc3 init”);
Serial.print("Beginning sensor. Result = "); // Most SHTC3 functions return a variable of the type “SHTC3_Status_TypeDef” to indicate the status of their execution
mySHTC3.begin(); // To start the sensor you must call “begin()”, the default settings use Wire (default Arduino I2C port)
Wire.setClock(400000); // The sensor is listed to work up to 1 MHz I2C speed, but the I2C clock speed is global for all sensors on that bus so using 400kHz or 100kHz is recommended
Serial.println();

if (mySHTC3.passIDcrc) // Whenever data is received the associated checksum is calculated and verified so you can be sure the data is true
{ // The checksum pass indicators are: passIDcrc, passRHcrc, and passTcrc for the ID, RH, and T readings respectively
Serial.print("ID Passed Checksum. ");
Serial.print(“Device ID: 0b”);
Serial.println(mySHTC3.ID, BIN); // The 16-bit device ID can be accessed as a member variable of the object
}
else
{
Serial.println("ID Checksum Failed. ");
}
/* LPS22HB init /
if (!BARO.begin())
{
Serial.println(“Failed to initialize pressure sensor!”);
while (1)
;
}
/ opt3001 init */
opt3001.begin(OPT3001_ADDRESS);
Serial.print(“OPT3001 Manufacturer ID”);
Serial.println(opt3001.readManufacturerID());
Serial.print(“OPT3001 Device ID”);
Serial.println(opt3001.readDeviceID());

configureSensor();

// Initialize Scheduler and timer
uint32_t err_code;
err_code = timers_init();
if (err_code != 0)
{
Serial.printf(“timers_init failed - %d\n”, err_code);
return;
}

// Setup the EUIs and Keys
if (doOTAA)
{
lmh_setDevEui(nodeDeviceEUI);
lmh_setAppEui(nodeAppEUI);
lmh_setAppKey(nodeAppKey);
}
else
{
lmh_setNwkSKey(nodeNwsKey);
lmh_setAppSKey(nodeAppsKey);
lmh_setDevAddr(nodeDevAddr);
}

// Initialize LoRaWan
err_code = lmh_init(&g_lora_callbacks, g_lora_param_init, doOTAA, g_CurrentClass, g_CurrentRegion);
if (err_code != 0)
{
Serial.printf(“lmh_init failed - %d\n”, err_code);
return;
}

// Start Join procedure
lmh_join();
}

void loop()
{
// Put your application tasks here, like reading of sensors,
// Controlling actuators and/or other functions.
}

/@brief LoRa function for handling HasJoined event.
*/
void lorawan_has_joined_handler(void)
{
if(doOTAA == true)
{
Serial.println(“OTAA Mode, Network Joined!”);
}
else
{
Serial.println(“ABP Mode”);
}
lmh_error_status ret = lmh_class_request(g_CurrentClass);
if (ret == LMH_SUCCESS)
{
delay(1000);
TimerSetValue(&appTimer, LORAWAN_APP_INTERVAL);
TimerStart(&appTimer);
}
}
/@brief LoRa function for handling OTAA join failed
*/
static void lorawan_join_failed_handler(void)
{
Serial.println(“OTAA join failed!”);
Serial.println(“Check your EUI’s and Keys’s!”);
Serial.println(“Check if a Gateway is in range!”);
}
/**@brief Function for handling LoRaWan received data from Gateway
*

  • @param[in] app_data Pointer to rx data
    */
    void lorawan_rx_handler(lmh_app_data_t *app_data)
    {
    Serial.printf(“LoRa Packet received on port %d, size:%d, rssi:%d, snr:%d, data:%s\n”,
    app_data->port, app_data->buffsize, app_data->rssi, app_data->snr, app_data->buffer);
    }

void lorawan_confirm_class_handler(DeviceClass_t Class)
{
Serial.printf(“switch to class %c done\n”, “ABC”[Class]);
// Informs the server that switch has occurred ASAP
m_lora_app_data.buffsize = 0;
m_lora_app_data.port = gAppPort;
lmh_send(&m_lora_app_data, gCurrentConfirm);
}

void send_lora_frame(void)
{
if (lmh_join_status_get() != LMH_SET)
{
//Not joined, try again later
return;
}
data_get();

lmh_error_status error = lmh_send(&m_lora_app_data, gCurrentConfirm);
if (error == LMH_SUCCESS)
{
count++;
Serial.printf(“lmh_send ok count %d\n”, count);
}
else
{
count_fail++;
Serial.printf(“lmh_send fail count %d\n”, count_fail);
}
}

/**@brief Function for handling user timerout event.
*/
void tx_lora_periodic_handler(void)
{
TimerSetValue(&appTimer, LORAWAN_APP_INTERVAL);
TimerStart(&appTimer);
Serial.println(“Sending frame now…”);
send_lora_frame();
}

/**@brief Function for the Timer initialization.
*

  • @details Initializes the timer module. This creates and starts application timers.
    */
    uint32_t timers_init(void)
    {
    TimerInit(&appTimer, tx_lora_periodic_handler);
    return 0;
    }
    String data = “”;
    void data_get()
    {
    Serial.print("result: ");
    uint32_t i = 0;
    memset(m_lora_app_data.buffer, 0, LORAWAN_APP_DATA_BUFF_SIZE);
    m_lora_app_data.port = gAppPort;
    mySHTC3.update();

float temp = mySHTC3.toDegC();
float hum = mySHTC3.toPercent();
float pres = BARO.readPressure();

OPT3001 result = opt3001.readResult();

data = “Tem:” + String(temp) + "C " + “Hum:” + String(hum) + "% " + “Pres:” + String(pres) + "KPa " + “Lig:” + String(result.lux) + “lux”;
Serial.println(data);

uint16_t t = temp * 100;
uint16_t h = hum * 100;
uint32_t pre = pres * 100;
uint16_t l = result.lux * 100;
//result: T=28.25C, RH=50.00%, P=958.57hPa, light=100.46 lux
m_lora_app_data.buffer[i++] = 0x02;
m_lora_app_data.buffer[i++] = (uint8_t)(t >> 8);
m_lora_app_data.buffer[i++] = (uint8_t)t;
m_lora_app_data.buffer[i++] = (uint8_t)(h >> 8);
m_lora_app_data.buffer[i++] = (uint8_t)h;
m_lora_app_data.buffer[i++] = (uint8_t)((pre & 0xFF000000) >> 24);
m_lora_app_data.buffer[i++] = (uint8_t)((pre & 0x00FF0000) >> 16);
m_lora_app_data.buffer[i++] = (uint8_t)((pre & 0x0000FF00) >> 8);
m_lora_app_data.buffer[i++] = (uint8_t)(pre & 0x000000FF);
m_lora_app_data.buffer[i++] = (uint8_t)(l >> 8);
m_lora_app_data.buffer[i++] = (uint8_t)l;
m_lora_app_data.buffsize = i;
}
void configureSensor()
{
OPT3001_Config newConfig;

newConfig.RangeNumber = B1100;
newConfig.ConvertionTime = B0;
newConfig.Latch = B1;
newConfig.ModeOfConversionOperation = B11;

OPT3001_ErrorCode errorConfig = opt3001.writeConfig(newConfig);
if (errorConfig != NO_ERROR)
{
} //printError(“OPT3001 configuration”, errorConfig);
else
{
OPT3001_Config sensorConfig = opt3001.readConfig();
Serial.println(“OPT3001 Current Config:”);
Serial.println(“------------------------------”);

Serial.print("Conversion ready (R):");
Serial.println(sensorConfig.ConversionReady, HEX);

Serial.print("Conversion time (R/W):");
Serial.println(sensorConfig.ConvertionTime, HEX);

Serial.print("Fault count field (R/W):");
Serial.println(sensorConfig.FaultCount, HEX);

Serial.print("Flag high field (R-only):");
Serial.println(sensorConfig.FlagHigh, HEX);

Serial.print("Flag low field (R-only):");
Serial.println(sensorConfig.FlagLow, HEX);

Serial.print("Latch field (R/W):");
Serial.println(sensorConfig.Latch, HEX);

Serial.print("Mask exponent field (R/W):");
Serial.println(sensorConfig.MaskExponent, HEX);

Serial.print("Mode of conversion operation (R/W):");
Serial.println(sensorConfig.ModeOfConversionOperation, HEX);

Serial.print("Polarity field (R/W):");
Serial.println(sensorConfig.Polarity, HEX);

Serial.print("Overflow flag (R-only):");
Serial.println(sensorConfig.OverflowFlag, HEX);

Serial.print("Range number (R/W):");
Serial.println(sensorConfig.RangeNumber, HEX);

Serial.println("------------------------------");

}
}

10

After all, I also have these problems below

Capture

Do you have any ideas to deal with those problems?

11

You need to get the BSP patch working first. Unless that is done, you cannot compile without errors.

If rak_patch.py does not run on your computer (answered you in the other thread) you can manully patch the PIO package

From RAK_PATCH/packages folder copy the folder framework-arduinoadafruitnrf52 to .platformio/packages, allow overwrites

From RAK_PATCH/platforms folder copy the folder nordicnrf52 to .platformio/platforms, allow overwrites

About `Commisioning.h’, you do not need this include.

12

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