vlad/Rocket2021
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Refactor code

Browse Source
This commit is contained in:
Vlad Utkin
2021-05-13 16:03:07 +03:00
parent 9f3ffaba30
commit b4adcc4dee
10 changed files with 347 additions and 243 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
.vscode/extensions.json vendored
View File

@@ -1,7 +1,7 @@
{ {
// See http://go.microsoft.com/fwlink/?LinkId=827846 // See http://go.microsoft.com/fwlink/?LinkId=827846
// for the documentation about the extensions.json format // for the documentation about the extensions.json format
"recommendations": [ "recommendations": [
"platformio.platformio-ide" "platformio.platformio-ide"
] ]
} }

23
src/bmp180.h
View File

@@ -2,15 +2,18 @@
Adafruit_BMP085 bmp180; Adafruit_BMP085 bmp180;
void setup_180() { void setup_180()
if (!bmp180.begin()) { {
Serial.println("Could not find a valid BMP085 sensor, check wiring!"); if (!bmp180.begin())
} {
Serial.println("Could not find a valid BMP085 sensor, check wiring!");
}
} }
void loop_180(JsonObject &root) { void loop_180(JsonObject &root)
JsonObject bmp388 = root.createNestedObject("bmp388"); {
/* JsonObject bmp388 = root.createNestedObject("bmp388");
/*
Serial.print("Temperature = "); Serial.print("Temperature = ");
Serial.print(bmp180.readTemperature()); Serial.print(bmp180.readTemperature());
Serial.println(" *C"); Serial.println(" *C");
@@ -39,7 +42,7 @@ void loop_180(JsonObject &root) {
Serial.println(); Serial.println();
*/ */
bmp388["temperature"] = bmp180.readTemperature(); bmp388["temperature"] = bmp180.readTemperature();
bmp388["pressure"] = bmp180.readPressure(); bmp388["pressure"] = bmp180.readPressure();
bmp388["altitude"] = bmp180.readAltitude(); bmp388["altitude"] = bmp180.readAltitude();
} }

97
src/bno055.h
View File

@@ -8,22 +8,32 @@ void displaySensorDetails(void)
sensor_t sensor; sensor_t sensor;
bno.getSensor(&sensor); bno.getSensor(&sensor);
Serial.println("------------------------------------"); Serial.println("------------------------------------");
Serial.print ("Sensor: "); Serial.println(sensor.name); Serial.print("Sensor: ");
Serial.print ("Driver Ver: "); Serial.println(sensor.version); Serial.println(sensor.name);
Serial.print ("Unique ID: "); Serial.println(sensor.sensor_id); Serial.print("Driver Ver: ");
Serial.print ("Max Value: "); Serial.print(sensor.max_value); Serial.println(" xxx"); Serial.println(sensor.version);
Serial.print ("Min Value: "); Serial.print(sensor.min_value); Serial.println(" xxx"); Serial.print("Unique ID: ");
Serial.print ("Resolution: "); Serial.print(sensor.resolution); Serial.println(" xxx"); Serial.println(sensor.sensor_id);
Serial.print("Max Value: ");
Serial.print(sensor.max_value);
Serial.println(" xxx");
Serial.print("Min Value: ");
Serial.print(sensor.min_value);
Serial.println(" xxx");
Serial.print("Resolution: ");
Serial.print(sensor.resolution);
Serial.println(" xxx");
Serial.println("------------------------------------"); Serial.println("------------------------------------");
Serial.println(""); Serial.println("");
} }
void setup_bno(void) void setup_bno(void)
{ {
Serial.println("Orientation Sensor Test"); Serial.println(""); Serial.println("Orientation Sensor Test");
Serial.println("");
/* Initialise the sensor */ /* Initialise the sensor */
if(!bno.begin()) if (!bno.begin())
{ {
/* There was a problem detecting the BNO055 ... check your connections */ /* There was a problem detecting the BNO055 ... check your connections */
Serial.print("Ooops, no BNO055 detected ... Check your wiring or I2C ADDR!"); Serial.print("Ooops, no BNO055 detected ... Check your wiring or I2C ADDR!");
@@ -32,84 +42,91 @@ void setup_bno(void)
/* Use external crystal for better accuracy */ /* Use external crystal for better accuracy */
bno.setExtCrystalUse(true); bno.setExtCrystalUse(true);
/* Display some basic information on this sensor */ /* Display some basic information on this sensor */
displaySensorDetails(); displaySensorDetails();
} }
void printEvent(sensors_event_t* event, JsonObject obj) { void printEvent(sensors_event_t *event, JsonObject obj)
double x = -1000000, y = -1000000 , z = -1000000; //dumb values, easy to spot problem {
if (event->type == SENSOR_TYPE_ACCELEROMETER) { double x = -1000000, y = -1000000, z = -1000000; //dumb values, easy to spot problem
#ifdef debug if (event->type == SENSOR_TYPE_ACCELEROMETER)
{
#ifdef debug
Serial.print("Accl:"); Serial.print("Accl:");
#endif #endif
x = event->acceleration.x; x = event->acceleration.x;
y = event->acceleration.y; y = event->acceleration.y;
z = event->acceleration.z; z = event->acceleration.z;
} }
else if (event->type == SENSOR_TYPE_ORIENTATION) { else if (event->type == SENSOR_TYPE_ORIENTATION)
#ifdef debug {
#ifdef debug
Serial.print("Orient:"); Serial.print("Orient:");
#endif #endif
x = event->orientation.x; x = event->orientation.x;
y = event->orientation.y; y = event->orientation.y;
z = event->orientation.z; z = event->orientation.z;
} }
else if (event->type == SENSOR_TYPE_MAGNETIC_FIELD) { else if (event->type == SENSOR_TYPE_MAGNETIC_FIELD)
#ifdef debug {
#ifdef debug
Serial.print("Mag:"); Serial.print("Mag:");
#endif #endif
x = event->magnetic.x; x = event->magnetic.x;
y = event->magnetic.y; y = event->magnetic.y;
z = event->magnetic.z; z = event->magnetic.z;
} }
else if (event->type == SENSOR_TYPE_GYROSCOPE) { else if (event->type == SENSOR_TYPE_GYROSCOPE)
#ifdef debug {
#ifdef debug
Serial.print("Gyro:"); Serial.print("Gyro:");
#endif #endif
x = event->gyro.x; x = event->gyro.x;
y = event->gyro.y; y = event->gyro.y;
z = event->gyro.z; z = event->gyro.z;
} }
else if (event->type == SENSOR_TYPE_ROTATION_VECTOR) { else if (event->type == SENSOR_TYPE_ROTATION_VECTOR)
#ifdef debug {
#ifdef debug
Serial.print("Rot:"); Serial.print("Rot:");
#endif #endif
x = event->gyro.x; x = event->gyro.x;
y = event->gyro.y; y = event->gyro.y;
z = event->gyro.z; z = event->gyro.z;
} }
else if (event->type == SENSOR_TYPE_LINEAR_ACCELERATION) { else if (event->type == SENSOR_TYPE_LINEAR_ACCELERATION)
#ifdef debug {
#ifdef debug
Serial.print("Linear:"); Serial.print("Linear:");
#endif #endif
x = event->acceleration.x; x = event->acceleration.x;
y = event->acceleration.y; y = event->acceleration.y;
z = event->acceleration.z; z = event->acceleration.z;
} }
else { else
#ifdef debug {
#ifdef debug
Serial.print("Unk:"); Serial.print("Unk:");
#endif #endif
} }
obj["x"] = x; obj["x"] = x;
obj["y"] = y; obj["y"] = y;
obj["z"] = z; obj["z"] = z;
#ifdef debug #ifdef debug
Serial.print("\tx= "); Serial.print("\tx= ");
Serial.print(x); Serial.print(x);
Serial.print(" |\ty= "); Serial.print(" |\ty= ");
Serial.print(y); Serial.print(y);
Serial.print(" |\tz= "); Serial.print(" |\tz= ");
Serial.println(z); Serial.println(z);
#endif #endif
} }
void loop_bno(JsonObject &root) void loop_bno(JsonObject &root)
{ {
JsonObject bno055 = root.createNestedObject("bno055"); JsonObject bno055 = root.createNestedObject("bno055");
sensors_event_t orientationData , angVelocityData , linearAccelData, magnetometerData, accelerometerData, gravityData; sensors_event_t orientationData, angVelocityData, linearAccelData, magnetometerData, accelerometerData, gravityData;
bno.getEvent(&orientationData, Adafruit_BNO055::VECTOR_EULER); bno.getEvent(&orientationData, Adafruit_BNO055::VECTOR_EULER);
bno.getEvent(&angVelocityData, Adafruit_BNO055::VECTOR_GYROSCOPE); bno.getEvent(&angVelocityData, Adafruit_BNO055::VECTOR_GYROSCOPE);
bno.getEvent(&linearAccelData, Adafruit_BNO055::VECTOR_LINEARACCEL); bno.getEvent(&linearAccelData, Adafruit_BNO055::VECTOR_LINEARACCEL);
@@ -130,11 +147,11 @@ void loop_bno(JsonObject &root)
printEvent(&gravityData, gravity_data); printEvent(&gravityData, gravity_data);
int8_t boardTemp = bno.getTemp(); int8_t boardTemp = bno.getTemp();
#ifdef bebug #ifdef bebug
Serial.println(); Serial.println();
Serial.print(F("temperature: ")); Serial.print(F("temperature: "));
Serial.println(boardTemp); Serial.println(boardTemp);
#endif #endif
bno055["temperature"] = boardTemp; bno055["temperature"] = boardTemp;
uint8_t system, gyro, accel, mag = 0; uint8_t system, gyro, accel, mag = 0;
@@ -144,7 +161,7 @@ void loop_bno(JsonObject &root)
calibration["gyro"] = gyro; calibration["gyro"] = gyro;
calibration["accel"] = accel; calibration["accel"] = accel;
calibration["mag"] = mag; calibration["mag"] = mag;
#ifdef debug #ifdef debug
Serial.println(); Serial.println();
Serial.print("Calibration: Sys="); Serial.print("Calibration: Sys=");
Serial.print(system); Serial.print(system);
@@ -156,5 +173,5 @@ void loop_bno(JsonObject &root)
Serial.println(mag); Serial.println(mag);
Serial.println("--"); Serial.println("--");
#endif #endif
} }

8
src/constants.h Normal file
View File

@@ -0,0 +1,8 @@
#define SEALEVELPRESSURE_HPA (1013.25)
#define NETWORK_NAME "Rocket"
#define NEWORK_PASSWORD ""
#define UDP_ADDRESS "192.168.1.255"
#define ALTITUDE_THRESHOLD 50.0
#define PRESSURE_THRESHOLD 3.0
#define START_ACCELERATION_THRESHOLD 5.0
#define TIME_TO_DEPLOY 8 * 1000

6
src/gps.h
View File

@@ -7,8 +7,7 @@
#endif #endif
static NMEAGPS gps;
static NMEAGPS gps;
gps_fix fix; gps_fix fix;
void setup_gps() void setup_gps()
@@ -18,7 +17,8 @@ void setup_gps()
void loop_gps(JsonObject &root) void loop_gps(JsonObject &root)
{ {
if (gps.available( gpsPort)) { if (gps.available(gpsPort))
{
fix = gps.read(); fix = gps.read();
} }
JsonObject gps = root.createNestedObject("gps"); JsonObject gps = root.createNestedObject("gps");

82
src/lora.h
View File

@@ -1,36 +1,37 @@
#include <SPI.h> #include <SPI.h>
#include <SX127XLT.h> #include <SX127XLT.h>
#define NSS 5 //select on LoRa device #define NSS 5 //select on LoRa device
#define SCK 18 //SCK on SPI3 #define SCK 18 //SCK on SPI3
#define MISO 19 //MISO on SPI3 #define MISO 19 //MISO on SPI3
#define MOSI 23 //MOSI on SPI3 #define MOSI 23 //MOSI on SPI3
#define NRESET 35 //reset on LoRa device #define NRESET 35 //reset on LoRa device
#define DIO0 33 //DIO0 on LoRa device, used for RX and TX done #define DIO0 33 //DIO0 on LoRa device, used for RX and TX done
#define DIO1 32 //DIO1 on LoRa device, normally not used so set to -1 #define DIO1 32 //DIO1 on LoRa device, normally not used so set to -1
#define DIO2 -1 //DIO2 on LoRa device, normally not used so set to -1 #define DIO2 -1 //DIO2 on LoRa device, normally not used so set to -1
#define LORA_DEVICE DEVICE_SX1278 //this is the device we are using #define LORA_DEVICE DEVICE_SX1278 //this is the device we are using
//******* Setup LoRa Test Parameters Here ! *************** //******* Setup LoRa Test Parameters Here ! ***************
//LoRa Modem Parameters //LoRa Modem Parameters
const uint32_t Frequency = 429700000; //frequency of transmissions const uint32_t Frequency = 429700000; //frequency of transmissions
const uint32_t Offset = 0; //offset frequency for calibration purposes const uint32_t Offset = 0; //offset frequency for calibration purposes
const uint8_t Bandwidth = LORA_BW_062; //LoRa bandwidth const uint8_t Bandwidth = LORA_BW_062; //LoRa bandwidth
const uint8_t SpreadingFactor = LORA_SF12; //LoRa spreading factor const uint8_t SpreadingFactor = LORA_SF12; //LoRa spreading factor
const uint8_t CodeRate = LORA_CR_4_8; //LoRa coding rate const uint8_t CodeRate = LORA_CR_4_8; //LoRa coding rate
const uint8_t Optimisation = LDRO_AUTO; //low data rate optimisation setting const uint8_t Optimisation = LDRO_AUTO; //low data rate optimisation setting
const int8_t TXpower = 20; //LoRa transmit power in dBm const int8_t TXpower = 20; //LoRa transmit power in dBm
SX127XLT LT; SX127XLT LT;
void setup_lora() { void setup_lora()
SPI.begin(SCK, MISO, MOSI, NSS); {
if (LT.begin(NSS, NRESET, DIO0, DIO1, DIO2, LORA_DEVICE)) SPI.begin(SCK, MISO, MOSI, NSS);
if (LT.begin(NSS, NRESET, DIO0, DIO1, DIO2, LORA_DEVICE))
{ {
Serial.println(F("LoRa Device found")); Serial.println(F("LoRa Device found"));
} }
@@ -42,17 +43,17 @@ if (LT.begin(NSS, NRESET, DIO0, DIO1, DIO2, LORA_DEVICE))
LT.setupLoRa(Frequency, Offset, SpreadingFactor, Bandwidth, CodeRate, Optimisation); LT.setupLoRa(Frequency, Offset, SpreadingFactor, Bandwidth, CodeRate, Optimisation);
Serial.println(); Serial.println();
LT.printModemSettings(); //reads and prints the configured LoRa settings, useful check LT.printModemSettings(); //reads and prints the configured LoRa settings, useful check
Serial.println(); Serial.println();
LT.printOperatingSettings(); //reads and prints the configured operating settings, useful check LT.printOperatingSettings(); //reads and prints the configured operating settings, useful check
Serial.println(); Serial.println();
LT.startWriteSXBuffer(0); //initialise buffer write at address 0 LT.startWriteSXBuffer(0); //initialise buffer write at address 0
LT.writeFloat(0.0); //add latitude LT.writeFloat(0.0); //add latitude
LT.writeFloat(0.0); //add longitude LT.writeFloat(0.0); //add longitude
LT.writeFloat(0.0); //add altitude LT.writeFloat(0.0); //add altitude
LT.writeUint8(0); //add number of satellites LT.writeUint8(0); //add number of satellites
LT.writeUint8(0); //add tracker status LT.writeUint8(0); //add tracker status
uint8_t len = LT.endWriteSXBuffer(); //close buffer write uint8_t len = LT.endWriteSXBuffer(); //close buffer write
LT.transmitSXBuffer(0, len, 10000, TXpower, WAIT_TX); LT.transmitSXBuffer(0, len, 10000, TXpower, WAIT_TX);
} }
@@ -61,14 +62,14 @@ void sendLocation(int32_t Lat, int32_t Lon)
{ {
uint8_t len; uint8_t len;
LT.startWriteSXBuffer(0); //initialise buffer write at address 0 LT.startWriteSXBuffer(0); //initialise buffer write at address 0
LT.writeInt32(Lat); //add latitude LT.writeInt32(Lat); //add latitude
LT.writeInt32(Lon); //add longitude LT.writeInt32(Lon); //add longitude
LT.writeInt16(fix.alt.whole); //add altitude LT.writeInt16(fix.alt.whole); //add altitude
LT.writeInt8(fix.alt.frac); LT.writeInt8(fix.alt.frac);
LT.writeUint8(fix.satellites); //add number of satellites LT.writeUint8(fix.satellites); //add number of satellites
LT.writeUint8(fix.status); //add tracker status LT.writeUint8(fix.status); //add tracker status
len = LT.endWriteSXBuffer(); //close buffer write len = LT.endWriteSXBuffer(); //close buffer write
/* /*
Serial.print("Sending data: "); Serial.print("Sending data: ");
Serial.print(fix.alt.whole); Serial.print(fix.alt.whole);
@@ -78,16 +79,19 @@ void sendLocation(int32_t Lat, int32_t Lon)
LT.transmitSXBuffer(0, len, 10000, TXpower, NO_WAIT); LT.transmitSXBuffer(0, len, 10000, TXpower, NO_WAIT);
} }
void loop_lora_pre()
void loop_lora_pre() { {
if (gps.available( gpsPort) && digitalRead(DIO0)) { if (gps.available(gpsPort) && digitalRead(DIO0))
{
fix = gps.read(); fix = gps.read();
sendLocation(fix.latitudeL(), fix.longitudeL()); sendLocation(fix.latitudeL(), fix.longitudeL());
} }
} }
void loop_lora() { void loop_lora()
if (digitalRead(DIO0)) { {
if (digitalRead(DIO0))
{
sendLocation(fix.latitudeL(), fix.longitudeL()); sendLocation(fix.latitudeL(), fix.longitudeL());
} }
} }

62
src/main.cpp
View File

@@ -1,4 +1,4 @@
#define SEALEVELPRESSURE_HPA (1013.25) #include <constants.h>
#include <Wire.h> #include <Wire.h>
#include <Adafruit_Sensor.h> #include <Adafruit_Sensor.h>
#include <ArduinoJson.h> #include <ArduinoJson.h>
@@ -15,14 +15,16 @@
bool deployed = 0; bool deployed = 0;
void deploy() { void deploy()
digitalWrite(PWM, HIGH); {
delay(1000); digitalWrite(PWM, HIGH);
digitalWrite(PWM, LOW); delay(1000);
delay(1000); digitalWrite(PWM, LOW);
delay(1000);
} }
void TaskDeploycode( void * pvParameters ){ void TaskDeploycode(void *pvParameters)
{
deploy(); deploy();
deployed = 1; deployed = 1;
} }
@@ -36,7 +38,8 @@ bool save = false;
float previous_height; float previous_height;
bool altitude = false; bool altitude = false;
void setup(){ void setup()
{
Serial.begin(115200); Serial.begin(115200);
Wire.setClock(800000); Wire.setClock(800000);
setup_sdcard(); setup_sdcard();
@@ -50,20 +53,23 @@ void setup(){
Serial.println("Configuring access point..."); Serial.println("Configuring access point...");
connectToWiFi(networkName, networkPswd); connectToWiFi(networkName, networkPswd);
ESP_ERROR_CHECK(esp_wifi_set_protocol (WIFI_IF_STA, WIFI_PROTOCOL_11B)); ESP_ERROR_CHECK(esp_wifi_set_protocol(WIFI_IF_STA, WIFI_PROTOCOL_11B));
wifi_country_t country_info = {"JP", 1, 14, WIFI_COUNTRY_POLICY_MANUAL}; wifi_country_t country_info = {"JP", 1, 14, WIFI_COUNTRY_POLICY_MANUAL};
ESP_ERROR_CHECK(esp_wifi_set_country(&country_info)); ESP_ERROR_CHECK(esp_wifi_set_country(&country_info));
ESP_ERROR_CHECK(esp_wifi_set_max_tx_power(80)); ESP_ERROR_CHECK(esp_wifi_set_max_tx_power(80));
ESP_ERROR_CHECK(esp_wifi_set_ps(WIFI_PS_NONE)); ESP_ERROR_CHECK(esp_wifi_set_ps(WIFI_PS_NONE));
pinMode(PWM, OUTPUT); pinMode(PWM, OUTPUT);
uint8_t buffer[50] = "test.txt"; uint8_t buffer[50] = "test.txt";
while(1) { while (1)
if (connected) { {
bmp.performReading(); if (connected)
original_height = bmp.readAltitude(SEALEVELPRESSURE_HPA); {
bmp.performReading();
original_height = bmp.readAltitude(SEALEVELPRESSURE_HPA);
udp.parsePacket(); udp.parsePacket();
if(udp.read(buffer, 50) > 0){ if (udp.read(buffer, 50) > 0)
{
Serial.print("Server to client: "); Serial.print("Server to client: ");
Serial.println((char *)buffer); Serial.println((char *)buffer);
start = millis(); start = millis();
@@ -78,10 +84,11 @@ void setup(){
Serial.println(original_height); Serial.println(original_height);
} }
void loop(){ void loop()
{
DynamicJsonDocument doc(1024); DynamicJsonDocument doc(1024);
JsonObject obj = doc.to<JsonObject>(); JsonObject obj = doc.to<JsonObject>();
obj["seconds"] = millis()/1000; obj["seconds"] = millis() / 1000;
obj["deployed"] = deployed; obj["deployed"] = deployed;
obj["save"] = save; obj["save"] = save;
obj["flight"] = flight; obj["flight"] = flight;
@@ -95,32 +102,37 @@ void loop(){
file.print('\n'); file.print('\n');
file.flush(); file.flush();
//only send data when connected //only send data when connected
if(connected){ if (connected)
{
//Send a packet //Send a packet
udp.beginPacket(udpAddress,udpPort); udp.beginPacket(udpAddress, udpPort);
serializeJson(doc, udp); serializeJson(doc, udp);
udp.println(); udp.println();
udp.endPacket(); udp.endPacket();
} }
if (!save & !deployed & ((obj["bmp388"]["altitude"].as<float>() - original_height) > 50.0)) { if (!save & !deployed & ((obj["bmp388"]["altitude"].as<float>() - original_height) > ALTITUDE_THRESHOLD))
{
Serial.println("Deploy is save"); Serial.println("Deploy is save");
save = true; save = true;
} }
if (save & !deployed & (((obj["bmp388"]["altitude"].as<float>() - previous_height) * 5) < 3.0)) { if (save & !deployed & (((obj["bmp388"]["altitude"].as<float>() - previous_height) * 5) < PRESSURE_THRESHOLD))
{
Serial.println("Start deploy altitude"); Serial.println("Start deploy altitude");
altitude = true; altitude = true;
deployed = true; deployed = true;
digitalWrite(PWM, HIGH); digitalWrite(PWM, HIGH);
} }
if (!flight & (max(max(abs(obj["bno055"]["linear_accel_data"]["x"].as<float>()), if (!flight & (max(max(abs(obj["bno055"]["linear_accel_data"]["x"].as<float>()),
abs(obj["bno055"]["linear_accel_data"]["y"].as<float>())), abs(obj["bno055"]["linear_accel_data"]["y"].as<float>())),
max(abs(obj["bno055"]["linear_accel_data"]["y"].as<float>()), max(abs(obj["bno055"]["linear_accel_data"]["y"].as<float>()),
abs(obj["bno055"]["linear_accel_data"]["z"].as<float>()))) > 5.0)) { abs(obj["bno055"]["linear_accel_data"]["z"].as<float>()))) > START_ACCELERATION_THRESHOLD))
{
Serial.println("Timer trigger"); Serial.println("Timer trigger");
start = millis(); start = millis();
flight = true; flight = true;
} }
if(flight & ((millis()-start) > 8*1000) & !deployed) { // Вот таймер if (flight & ((millis() - start) > TIME_TO_DEPLOY) & !deployed)
{ // Вот таймер
Serial.println("Start deploy timeout"); Serial.println("Start deploy timeout");
deployed = 1; deployed = 1;
digitalWrite(PWM, HIGH); digitalWrite(PWM, HIGH);

218
src/sdcard.h
View File

@@ -1,166 +1,207 @@
#include "FS.h" #include "FS.h"
#include "SD_MMC.h" #include "SD_MMC.h"
void listDir(fs::FS &fs, const char * dirname, uint8_t levels){ void listDir(fs::FS &fs, const char *dirname, uint8_t levels)
#ifdef debug {
#ifdef debug
Serial.printf("Listing directory: %s\n", dirname); Serial.printf("Listing directory: %s\n", dirname);
#endif #endif
File root = fs.open(dirname); File root = fs.open(dirname);
if(!root){ if (!root)
#ifdef debug {
#ifdef debug
Serial.println("Failed to open directory"); Serial.println("Failed to open directory");
#endif #endif
return; return;
} }
if(!root.isDirectory()){ if (!root.isDirectory())
#ifdef debug {
#ifdef debug
Serial.println("Not a directory"); Serial.println("Not a directory");
#endif #endif
return; return;
} }
File file = root.openNextFile(); File file = root.openNextFile();
while(file){ while (file)
if(file.isDirectory()){ {
#ifdef debug if (file.isDirectory())
{
#ifdef debug
Serial.print(" DIR : "); Serial.print(" DIR : ");
#endif #endif
Serial.println(file.name()); Serial.println(file.name());
if(levels){ if (levels)
listDir(fs, file.name(), levels -1); {
listDir(fs, file.name(), levels - 1);
} }
} else { }
#ifdef debug else
{
#ifdef debug
Serial.print(" FILE: "); Serial.print(" FILE: ");
#endif #endif
Serial.print(file.name()); Serial.print(file.name());
#ifdef debug #ifdef debug
Serial.print(" SIZE: "); Serial.print(" SIZE: ");
#endif #endif
Serial.println(file.size()); Serial.println(file.size());
} }
file = root.openNextFile(); file = root.openNextFile();
} }
} }
void createDir(fs::FS &fs, const char * path){ void createDir(fs::FS &fs, const char *path)
#ifdef debug {
#ifdef debug
Serial.printf("Creating Dir: %s\n", path); Serial.printf("Creating Dir: %s\n", path);
#endif #endif
if(fs.mkdir(path)){ if (fs.mkdir(path))
#ifdef debug {
#ifdef debug
Serial.println("Dir created"); Serial.println("Dir created");
#endif #endif
} else { }
#ifdef debug else
{
#ifdef debug
Serial.println("mkdir failed"); Serial.println("mkdir failed");
#endif #endif
} }
} }
void removeDir(fs::FS &fs, const char * path){ void removeDir(fs::FS &fs, const char *path)
#ifdef debug {
#ifdef debug
Serial.printf("Removing Dir: %s\n", path); Serial.printf("Removing Dir: %s\n", path);
#endif #endif
if(fs.rmdir(path)){ if (fs.rmdir(path))
#ifdef debug {
#ifdef debug
Serial.println("Dir removed"); Serial.println("Dir removed");
#endif #endif
} else { }
#ifdef debug else
{
#ifdef debug
Serial.println("rmdir failed"); Serial.println("rmdir failed");
#endif #endif
} }
} }
void readFile(fs::FS &fs, const char * path){ void readFile(fs::FS &fs, const char *path)
#ifdef debug {
#ifdef debug
Serial.printf("Reading file: %s\n", path); Serial.printf("Reading file: %s\n", path);
#endif #endif
File file = fs.open(path); File file = fs.open(path);
if(!file){ if (!file)
#ifdef debug {
#ifdef debug
Serial.println("Failed to open file for reading"); Serial.println("Failed to open file for reading");
#endif #endif
return; return;
} }
#ifdef debug #ifdef debug
Serial.print("Read from file: "); Serial.print("Read from file: ");
#endif #endif
while(file.available()){ while (file.available())
{
Serial.write(file.read()); Serial.write(file.read());
} }
} }
void writeFile(fs::FS &fs, const char * path, const char * message){ void writeFile(fs::FS &fs, const char *path, const char *message)
#ifdef debug {
#ifdef debug
Serial.printf("Writing file: %s\n", path); Serial.printf("Writing file: %s\n", path);
#endif #endif
File file = fs.open(path, FILE_WRITE); File file = fs.open(path, FILE_WRITE);
if(!file){ if (!file)
#ifdef debug {
#ifdef debug
Serial.println("Failed to open file for writing"); Serial.println("Failed to open file for writing");
#endif #endif
return; return;
} }
if(file.print(message)){ if (file.print(message))
#ifdef debug {
#ifdef debug
Serial.println("File written"); Serial.println("File written");
#endif #endif
} else { }
#ifdef debug else
{
#ifdef debug
Serial.println("Write failed"); Serial.println("Write failed");
#endif #endif
} }
} }
void appendFile(fs::FS &fs, const char * path, const char * message){ void appendFile(fs::FS &fs, const char *path, const char *message)
{
Serial.printf("Appending to file: %s\n", path); Serial.printf("Appending to file: %s\n", path);
File file = fs.open(path, FILE_APPEND); File file = fs.open(path, FILE_APPEND);
if(!file){ if (!file)
{
Serial.println("Failed to open file for appending"); Serial.println("Failed to open file for appending");
return; return;
} }
if(file.print(message)){ if (file.print(message))
{
Serial.println("Message appended"); Serial.println("Message appended");
} else { }
else
{
Serial.println("Append failed"); Serial.println("Append failed");
} }
} }
void renameFile(fs::FS &fs, const char * path1, const char * path2){ void renameFile(fs::FS &fs, const char *path1, const char *path2)
{
Serial.printf("Renaming file %s to %s\n", path1, path2); Serial.printf("Renaming file %s to %s\n", path1, path2);
if (fs.rename(path1, path2)) { if (fs.rename(path1, path2))
{
Serial.println("File renamed"); Serial.println("File renamed");
} else { }
else
{
Serial.println("Rename failed"); Serial.println("Rename failed");
} }
} }
void deleteFile(fs::FS &fs, const char * path){ void deleteFile(fs::FS &fs, const char *path)
{
Serial.printf("Deleting file: %s\n", path); Serial.printf("Deleting file: %s\n", path);
if(fs.remove(path)){ if (fs.remove(path))
{
Serial.println("File deleted"); Serial.println("File deleted");
} else { }
else
{
Serial.println("Delete failed"); Serial.println("Delete failed");
} }
} }
void testFileIO(fs::FS &fs, const char * path){ void testFileIO(fs::FS &fs, const char *path)
{
File file = fs.open(path); File file = fs.open(path);
static uint8_t buf[512]; static uint8_t buf[512];
size_t len = 0; size_t len = 0;
uint32_t start = millis(); uint32_t start = millis();
uint32_t end = start; uint32_t end = start;
if(file){ if (file)
{
len = file.size(); len = file.size();
size_t flen = len; size_t flen = len;
start = millis(); start = millis();
while(len){ while (len)
{
size_t toRead = len; size_t toRead = len;
if(toRead > 512){ if (toRead > 512)
{
toRead = 512; toRead = 512;
} }
file.read(buf, toRead); file.read(buf, toRead);
@@ -169,20 +210,23 @@ void testFileIO(fs::FS &fs, const char * path){
end = millis() - start; end = millis() - start;
Serial.printf("%u bytes read for %u ms\n", flen, end); Serial.printf("%u bytes read for %u ms\n", flen, end);
file.close(); file.close();
} else { }
else
{
Serial.println("Failed to open file for reading"); Serial.println("Failed to open file for reading");
} }
file = fs.open(path, FILE_WRITE); file = fs.open(path, FILE_WRITE);
if(!file){ if (!file)
{
Serial.println("Failed to open file for writing"); Serial.println("Failed to open file for writing");
return; return;
} }
size_t i; size_t i;
start = millis(); start = millis();
for(i=0; i<2048; i++){ for (i = 0; i < 2048; i++)
{
file.write(buf, 512); file.write(buf, 512);
} }
end = millis() - start; end = millis() - start;
@@ -190,26 +234,36 @@ void testFileIO(fs::FS &fs, const char * path){
file.close(); file.close();
} }
void setup_sdcard() { void setup_sdcard()
if(!SD_MMC.begin("/sdcard", true, false)){ {
if (!SD_MMC.begin("/sdcard", true, false))
{
Serial.println("Card Mount Failed"); Serial.println("Card Mount Failed");
return; return;
} }
uint8_t cardType = SD_MMC.cardType(); uint8_t cardType = SD_MMC.cardType();
if(cardType == CARD_NONE){ if (cardType == CARD_NONE)
{
Serial.println("No SD_MMC card attached"); Serial.println("No SD_MMC card attached");
return; return;
} }
Serial.print("SD_MMC Card Type: "); Serial.print("SD_MMC Card Type: ");
if(cardType == CARD_MMC){ if (cardType == CARD_MMC)
{
Serial.println("MMC"); Serial.println("MMC");
} else if(cardType == CARD_SD){ }
else if (cardType == CARD_SD)
{
Serial.println("SDSC"); Serial.println("SDSC");
} else if(cardType == CARD_SDHC){ }
else if (cardType == CARD_SDHC)
{
Serial.println("SDHC"); Serial.println("SDHC");
} else { }
else
{
Serial.println("UNKNOWN"); Serial.println("UNKNOWN");
} }
@@ -228,7 +282,7 @@ void setup_sdcard() {
renameFile(SD_MMC, "/hello.txt", "/foo.txt"); renameFile(SD_MMC, "/hello.txt", "/foo.txt");
readFile(SD_MMC, "/foo.txt"); readFile(SD_MMC, "/foo.txt");
*/ */
/* /*
xTaskCreate( xTaskCreate(
Task1code, Task1code,
"Task1", "Task1",

32
src/sht31.h
View File

@@ -2,26 +2,29 @@
Adafruit_SHT31 sht31 = Adafruit_SHT31(); Adafruit_SHT31 sht31 = Adafruit_SHT31();
void setup_sht() { void setup_sht()
if (! sht31.begin(0x44)) { // Set to 0x45 for alternate i2c addr {
Serial.println("Couldn't find SHT31"); if (!sht31.begin(0x44))
} { // Set to 0x45 for alternate i2c addr
sht31.heater(1); Serial.println("Couldn't find SHT31");
Serial.print("Heater Enabled State: "); }
if (sht31.isHeaterEnabled()) sht31.heater(1);
Serial.println("ENABLED"); Serial.print("Heater Enabled State: ");
else if (sht31.isHeaterEnabled())
Serial.println("DISABLED"); Serial.println("ENABLED");
else
Serial.println("DISABLED");
} }
void loop_sht(JsonObject &root) { void loop_sht(JsonObject &root)
JsonObject sht = root.createNestedObject("sht31"); {
JsonObject sht = root.createNestedObject("sht31");
float t = sht31.readTemperature(); float t = sht31.readTemperature();
float h = sht31.readHumidity(); float h = sht31.readHumidity();
sht["temperature"] = t; sht["temperature"] = t;
sht["humidity"] = h; sht["humidity"] = h;
/* /*
if (! isnan(t)) { // check if 'is not a number' if (! isnan(t)) { // check if 'is not a number'
Serial.print("Temp *C = "); Serial.print(t); Serial.print("\t\t"); Serial.print("Temp *C = "); Serial.print(t); Serial.print("\t\t");
} else { } else {
@@ -36,7 +39,6 @@ void loop_sht(JsonObject &root) {
// Toggle heater enabled state every 30 seconds // Toggle heater enabled state every 30 seconds
// An ~3.0 degC temperature increase can be noted when heater is enabled // An ~3.0 degC temperature increase can be noted when heater is enabled
/*
if (++loopCnt == 30) { if (++loopCnt == 30) {
enableHeater = !enableHeater; enableHeater = !enableHeater;
sht31.heater(enableHeater); sht31.heater(enableHeater);

48
src/wifi_setup.h
View File

@@ -2,10 +2,10 @@
#include <WiFiUdp.h> #include <WiFiUdp.h>
#include "esp_wifi.h" #include "esp_wifi.h"
const char * networkName = "Overlord"; const char *networkName = NETWORK_NAME;
const char * networkPswd = "justmonika"; const char *networkPswd = NEWORK_PASSWORD;
const char * udpAddress = "192.168.2.255"; const char *udpAddress = UDP_ADDRESS;
const int udpPort = 3333; const int udpPort = 3333;
boolean connected = false; boolean connected = false;
@@ -13,33 +13,37 @@ boolean connected = false;
WiFiUDP udp; WiFiUDP udp;
//wifi event handler //wifi event handler
void WiFiEvent(WiFiEvent_t event){ void WiFiEvent(WiFiEvent_t event)
switch(event) { {
case SYSTEM_EVENT_STA_GOT_IP: switch (event)
//When connected set {
Serial.print("WiFi connected! IP address: "); case SYSTEM_EVENT_STA_GOT_IP:
Serial.println(WiFi.localIP()); //When connected set
//initializes the UDP state Serial.print("WiFi connected! IP address: ");
//This initializes the transfer buffer Serial.println(WiFi.localIP());
udp.begin(WiFi.localIP(),udpPort); //initializes the UDP state
connected = true; //This initializes the transfer buffer
break; udp.begin(WiFi.localIP(), udpPort);
case SYSTEM_EVENT_STA_DISCONNECTED: connected = true;
Serial.println("WiFi lost connection"); break;
connected = false; case SYSTEM_EVENT_STA_DISCONNECTED:
break; Serial.println("WiFi lost connection");
default: break; connected = false;
} break;
default:
break;
}
} }
void connectToWiFi(const char * ssid, const char * pwd){ void connectToWiFi(const char *ssid, const char *pwd)
{
Serial.println("Connecting to WiFi network: " + String(ssid)); Serial.println("Connecting to WiFi network: " + String(ssid));
// delete old config // delete old config
WiFi.disconnect(true); WiFi.disconnect(true);
//register event handler //register event handler
WiFi.onEvent(WiFiEvent); WiFi.onEvent(WiFiEvent);
//Initiate connection //Initiate connection
WiFi.begin(ssid, pwd); WiFi.begin(ssid, pwd);