282 lines
10 KiB
C++
282 lines
10 KiB
C++
// для работы с ESP-32
|
||
// target Arduino UNO
|
||
#include <GyverBME280.h> // Подключение библиотеки
|
||
GyverBME280 bme; // Создание обьекта bme
|
||
|
||
//#include <AsyncStream.h>
|
||
//AsyncStream<16> serial(&Serial, '~');
|
||
|
||
const int ESP_RESET_PIN = 5; // OLD - 2
|
||
const int ESP_READY_PIN = 3;
|
||
const int ESP_CFG_PIN = 4; // OLD - 5
|
||
const int LED_4BLINK = 6;
|
||
#define ACCSEL_READ_PERIOD 100 // частота опроса акселя в миллисекундах
|
||
#define ESP_WAIT_LIMIT 500 // максимальное время ожидания пробуждения ESP32
|
||
#define ESP_READY_DURATION 25 // длительность сигнала "готов" ESP32
|
||
uint32_t sec;
|
||
uint32_t steps = 0;
|
||
bool blinkmode = false;
|
||
void wakeUp()
|
||
{
|
||
// Just a handler for the pin interrupt.
|
||
}
|
||
int int_loops_cnt = 0;
|
||
#define LOOPS_CNT_AFTER_INT2 15
|
||
|
||
void setup() {
|
||
delay(100); // а то похоже из-за кондёров по 10мкФ на стабилизаторе аксель не успевает запуститьсы до проверки контроллером при первом включении.
|
||
Serial.begin(115200);
|
||
//Serial.begin(57600);
|
||
//Serial.begin(19200);
|
||
//Serial.begin(9600);
|
||
//Serial.begin(2400);
|
||
//Serial.println("LSM6DS3 Basic Reading Code!");
|
||
Wire.begin();
|
||
pinMode(ESP_READY_PIN, INPUT);
|
||
pinMode(ESP_RESET_PIN, OUTPUT);
|
||
//pinMode(ESP_INFO_PIN, OUTPUT);
|
||
pinMode(ESP_CFG_PIN, OUTPUT);
|
||
analogReference(INTERNAL); // встроенный источник опорного на 1.1V (для ATmega168 или ATmega328P) и 2.56V (на ATmega8)
|
||
digitalWrite(ESP_RESET_PIN, LOW);
|
||
|
||
// IMU 1 - LSM6DS3
|
||
IMU1.settings.accelSampleRate = 10; //Hz. Can be: 0,1,10,25,50,100,200,400,1600,5000 Hz
|
||
IMU1.settings.accelRange = 2; //Max G force readable. Can be: 2, 4, 8, 16
|
||
IMU1.settings.xAccelEnabled = 1;
|
||
IMU1.settings.yAccelEnabled = 1;
|
||
IMU1.settings.zAccelEnabled = 1;
|
||
IMU1.settings.adcEnabled = 0;
|
||
IMU1.settings.tempEnabled = 0;
|
||
//Call .begin() to configure the IMU
|
||
//digitalWrite(ESP_CFG_PIN, HIGH);
|
||
|
||
|
||
if (IMU1.begin() != IMU_SUCCESS) {
|
||
//Serial.println("Not Connected. Please check connections and read the hookup guide.");
|
||
blinkmode=true;
|
||
pinMode(LED_4BLINK, OUTPUT);
|
||
//digitalWrite(ESP_RESET_PIN, LOW);
|
||
//delay(50);
|
||
//digitalWrite(ESP_RESET_PIN, HIGH);
|
||
digitalWrite(ESP_CFG_PIN, HIGH);
|
||
delay(50);
|
||
}else{
|
||
configIntterupts();
|
||
}
|
||
delay(ACCSEL_READ_PERIOD);
|
||
sec = millis();
|
||
}
|
||
|
||
|
||
#define LOOPS_LIMIT 10
|
||
int16_t accel_buf[LOOPS_LIMIT * 3];
|
||
int loopnum = 0;
|
||
|
||
void getAccelData() {
|
||
//Serial.println(loopnum);
|
||
if (loopnum >= LOOPS_LIMIT) {return;}
|
||
accel_buf[loopnum * 3] = IMU1.readRawAccelX();
|
||
accel_buf[loopnum * 3 + 1] = IMU1.readRawAccelY();
|
||
accel_buf[loopnum * 3 + 2] = IMU1.readRawAccelZ();
|
||
loopnum++;
|
||
return;
|
||
}
|
||
|
||
uint32_t tm_esp_fin = 0, esp_wait_time = 0;
|
||
void loop() {
|
||
if(blinkmode){
|
||
digitalWrite(LED_4BLINK, HIGH);
|
||
delay(500);
|
||
digitalWrite(LED_4BLINK, LOW);
|
||
delay(500);
|
||
return;
|
||
}
|
||
if(int_loops_cnt >= LOOPS_CNT_AFTER_INT2){
|
||
// Allow wake up pin to trigger interrupt on high.
|
||
attachInterrupt(0, wakeUp, HIGH);
|
||
// Enter power down state with ADC and BOD module disabled.
|
||
// Wake up when wake up pin is high.
|
||
LowPower.powerDown(SLEEP_FOREVER, ADC_OFF, BOD_OFF);
|
||
// Disable external pin interrupt on wake up pin.
|
||
detachInterrupt(0);
|
||
int_loops_cnt = 0;
|
||
//digitalWrite(LED_4BLINK, HIGH);
|
||
sec = millis();
|
||
digitalWrite(ESP_RESET_PIN, HIGH); // это не ресет. Для ESP-32 даём на заданую ногу сигнал пробуждения
|
||
delay(10);
|
||
digitalWrite(ESP_RESET_PIN, LOW);
|
||
}
|
||
getAccelData();
|
||
if (loopnum >= LOOPS_LIMIT) {
|
||
digitalWrite(LED_4BLINK, HIGH);
|
||
// output data
|
||
// blink LOW for restert ESP-01
|
||
|
||
digitalWrite(ESP_CFG_PIN, LOW);
|
||
//delay(50);
|
||
if(esp_wait_time == 0) {esp_wait_time = millis();}
|
||
uint32_t tmp_time = millis();
|
||
// wait ESP led ON
|
||
bool esp_ready = false;
|
||
while ((digitalRead(ESP_READY_PIN) == LOW) && ((millis()-esp_wait_time) < ESP_WAIT_LIMIT)) {delay(1);}
|
||
//while (digitalRead(ESP_READY_PIN) == LOW) {delay(1);}
|
||
if (digitalRead(ESP_READY_PIN) == HIGH){
|
||
uint32_t led_on_time = millis();
|
||
//while ((digitalRead(ESP_READY_PIN) == HIGH) && ((millis()-led_on_time) < ESP_READY_DURATION)) {delay(1);}
|
||
//if ((millis()-led_on_time) >= ESP_READY_DURATION)
|
||
{esp_ready = true;}
|
||
}
|
||
if (esp_ready){
|
||
loopnum = 0;
|
||
// NON STOP VERSION //int_loops_cnt++;
|
||
// delay(95);
|
||
digitalWrite(ESP_RESET_PIN, LOW);
|
||
digitalWrite(LED_4BLINK, HIGH);
|
||
//digitalWrite(ESP_INFO_PIN, HIGH);
|
||
// send data to ESP
|
||
//uint32_t sec_start = millis();
|
||
steps++;
|
||
if(int_loops_cnt >= LOOPS_CNT_AFTER_INT2){
|
||
Serial.print("L/"); // send last loop flag
|
||
}
|
||
Serial.print("Start step ");
|
||
Serial.print(int_loops_cnt);
|
||
Serial.print("/");
|
||
Serial.print(steps);
|
||
Serial.print(" / ");
|
||
Serial.print(String(tm_esp_fin) + "/" + String(millis()));
|
||
Serial.print(" / ESP wait time "+String(esp_wait_time)+"/");
|
||
Serial.print(millis()-esp_wait_time);
|
||
Serial.print(" / bat.volt. ");
|
||
Serial.println(voltmeter(), 2);
|
||
//Serial.println();
|
||
//Serial.println("=============================================");
|
||
for (int i = 0; i < LOOPS_LIMIT; i++) {
|
||
String ds = String(i) + ",";
|
||
// print IMU 1 data / plotter format
|
||
ds += String(accel_buf[i * 3]);
|
||
ds += ",";
|
||
ds += String(accel_buf[i * 3 + 1]);
|
||
ds += ",";
|
||
ds += String(accel_buf[i * 3 + 2]);
|
||
if (i < (LOOPS_LIMIT - 1)) ds += ";";
|
||
Serial.print(ds);
|
||
//Serial.println(ds);
|
||
//if ((millis() - tmp_time) > ACCSEL_READ_PERIOD) {
|
||
// tmp_time = millis();
|
||
// //getAccelData();
|
||
//}
|
||
}
|
||
Serial.println("~");
|
||
digitalWrite(LED_4BLINK, LOW);
|
||
tm_esp_fin = millis();
|
||
esp_wait_time = 0;
|
||
}else{
|
||
for(int nblink=0; nblink < 3; nblink++){
|
||
digitalWrite(ESP_RESET_PIN, HIGH); // это не ресет. Для ESP-32 даём на заданую ногу сигнал пробуждения
|
||
digitalWrite(LED_4BLINK, HIGH);
|
||
delay(50);
|
||
digitalWrite(ESP_RESET_PIN, LOW);
|
||
digitalWrite(LED_4BLINK, LOW);
|
||
delay(50);
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
uint32_t sec_delta = (millis() - sec) % ACCSEL_READ_PERIOD;
|
||
delay(ACCSEL_READ_PERIOD - sec_delta);
|
||
//digitalWrite(LED_4BLINK, LOW);
|
||
}
|
||
|
||
#define VOLTMETER_PIN A3
|
||
#define VOLTMETER_BASE 1.1 // встроенный источник опорного 1.1V (для ATmega168 или ATmega328P) и 2.56V (на ATmega8)
|
||
#define VOLTMETER_CALIBR 1
|
||
float input_volt = 0.0;
|
||
float temp = 0.0;
|
||
float r1 = 100000.0; //сопротивление резистора r1
|
||
float r2 = 10000.0; // сопротивление резистора r2
|
||
float voltmeter() {
|
||
int analogvalue = analogRead(VOLTMETER_PIN);
|
||
temp = (analogvalue * VOLTMETER_BASE) / 1024.0; // формула для конвертирования значения напряжения
|
||
input_volt = temp / (r2 / (r1 + r2)) * VOLTMETER_CALIBR;
|
||
if (input_volt < 0.1) input_volt = 0.0;
|
||
return (input_volt);
|
||
}
|
||
|
||
void configIntterupts()
|
||
{
|
||
uint8_t dataToWrite = 0;
|
||
|
||
//LIS3DH_CLICK_CFG
|
||
dataToWrite = 0;
|
||
//Set these to enable individual axes of generation source (or direction)
|
||
// -- set = 1 to enable
|
||
dataToWrite |= 0x10;//Z click
|
||
dataToWrite |= 0x04;//Y click
|
||
dataToWrite |= 0x01;//X click
|
||
IMU1.writeRegister(LIS3DH_CLICK_CFG, dataToWrite);
|
||
|
||
//LIS3DH_CLICK_SRC
|
||
dataToWrite = 0;
|
||
//Set these to enable click behaviors (also read to check status)
|
||
// -- set = 1 to enable
|
||
dataToWrite |= 0x10;//Enable single clicks
|
||
//dataToWrite |= 0x08;//sine (0 is positive, 1 is negative)
|
||
dataToWrite |= 0x04;//Z click detect enabled
|
||
dataToWrite |= 0x02;//Y click detect enabled
|
||
dataToWrite |= 0x01;//X click detect enabled
|
||
IMU1.writeRegister(LIS3DH_CLICK_SRC, dataToWrite);
|
||
|
||
//LIS3DH_CLICK_THS
|
||
dataToWrite = 0;
|
||
//This sets the threshold where the click detection process is activated.
|
||
//Provide 7 bit value, 0x7F always equals max range by accelRange setting
|
||
//dataToWrite |= 0x0A; // ~1/16 range
|
||
dataToWrite |= 0x05; // ~1/16 range
|
||
IMU1.writeRegister(LIS3DH_CLICK_THS, dataToWrite);
|
||
|
||
//LIS3DH_TIME_LIMIT
|
||
dataToWrite = 0;
|
||
//Time acceleration has to fall below threshold for a valid click.
|
||
//LSB equals 1/(sample rate)
|
||
dataToWrite |= 0x08; // 8 * 1/50 s = 160ms
|
||
IMU1.writeRegister(LIS3DH_TIME_LIMIT, dataToWrite);
|
||
|
||
//LIS3DH_TIME_LATENCY
|
||
dataToWrite = 0;
|
||
//hold-off time before allowing detection after click event
|
||
//LSB equals 1/(sample rate)
|
||
dataToWrite |= 0x08; // 4 * 1/50 s = 160ms
|
||
IMU1.writeRegister(LIS3DH_TIME_LATENCY, dataToWrite);
|
||
|
||
//LIS3DH_TIME_WINDOW
|
||
dataToWrite = 0;
|
||
//hold-off time before allowing detection after click event
|
||
//LSB equals 1/(sample rate)
|
||
dataToWrite |= 0x10; // 16 * 1/50 s = 320ms
|
||
IMU1.writeRegister(LIS3DH_TIME_WINDOW, dataToWrite);
|
||
|
||
//LIS3DH_CTRL_REG5
|
||
//Int1 latch interrupt and 4D on int1 (preserve fifo en)
|
||
IMU1.readRegister(&dataToWrite, LIS3DH_CTRL_REG5);
|
||
dataToWrite &= 0xF3; //Clear bits of interest
|
||
dataToWrite |= 0x08; //Latch interrupt (Cleared by reading int1_src)
|
||
//dataToWrite |= 0x04; //Pipe 4D detection from 6D recognition to int1?
|
||
IMU1.writeRegister(LIS3DH_CTRL_REG5, dataToWrite);
|
||
|
||
//LIS3DH_CTRL_REG3
|
||
//Choose source for pin 1
|
||
dataToWrite = 0;
|
||
// dataToWrite |= 0x40; //AOI1 event (Generator 1 interrupt on pin 1)
|
||
dataToWrite |= 0x20; //AOI2 event ()
|
||
IMU1.writeRegister(LIS3DH_CTRL_REG3, dataToWrite);
|
||
|
||
//LIS3DH_CTRL_REG6
|
||
//Choose source for pin 2 and both pin output inversion state
|
||
dataToWrite = 0;
|
||
dataToWrite |= 0x80; //Click int on pin 2
|
||
IMU1.writeRegister(LIS3DH_CTRL_REG6, dataToWrite);
|
||
|
||
}
|