CanSat/EmbeddedESP
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update

Browse Source
This commit is contained in:
Bruno Rybársky
2025-04-26 17:09:55 +02:00
parent 5853bf849f
commit cb339e6b66
18 changed files with 270 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.vscode/settings.json vendored
View File

@@ -1,6 +1,6 @@
{
"C_Cpp.intelliSenseEngine": "default",
"idf.espIdfPath": "/home/bruno/esp/master/esp-idf",
"idf.espIdfPath": "/home/bruno/esp/v5.4.1/esp-idf",
"idf.pythonInstallPath": "/usr/bin/python",
"idf.openOcdConfigs": [
"board/esp32s3-builtin.cfg"

2
dependencies.lock
View File

@@ -2,7 +2,7 @@ dependencies:
idf:
source:
type: idf
version: 5.5.0
version: 5.4.1
k0i05/esp_bme680:
component_hash: 2df0cb14d4425565a8745d4a96bfaa8ff7e90bbec3e208a073821406dded23c8
dependencies:

101
main/components/sensors.c
View File

@@ -8,14 +8,94 @@
static uint8_t s_led_state = 0;
uint8_t foundDevices[128];
uint8_t prevDevices[128];
static void configure_led(void)
{
gpio_reset_pin(BLINK_GPIO);
gpio_set_direction(BLINK_GPIO, GPIO_MODE_OUTPUT);
}
// void update_devices() {
// memcpy(prevDevices, foundDevices, sizeof(prevDevices));
// memset(foundDevices, 0, sizeof(foundDevices));
// for (uint8_t i = 0; i < 128; i++)
// {
// fflush(stdout);
// esp_err_t ret = i2c_master_probe(i2c0_bus_hdl, i, 20);
// if (ret == ESP_OK)
// {
// foundDevices[i] = 1;
// printf("Found device at 0x%02X\n", i);
// }
// }
// }
// void init_connected() {
// for (uint8_t i = 0; i < 128; i++) {
// if (foundDevices[i] != prevDevices[i]) {
// if (foundDevices[i]) {
// switch (i)
// {
// case MCP23018_ADDRESS:
// /* code */
// if (mcp23018_init() == ESP_OK) {
// foundDevices[i] = 2;
// }
// break;
// case INA260_ADDRESS:
// if (ina260_init() == ESP_OK) {
// foundDevices[i] = 2;
// }
// /* code */
// break;
// case CCS811_ADDRESS:
// if (ccs811_init() == ESP_OK) {
// foundDevices[i] = 2;
// }
// /* code */
// break;
// case MPU9250_ADDRESS:
// if (mpu9250_init() == ESP_OK) {
// foundDevices[i] = 2;
// }
// /* code */
// break;
// case BME680_ADDRESS:
// if (bme680b_init() == ESP_OK) {
// foundDevices[i] = 2;
// }
// /* code */
// break;
// default:
// break;
// }
// }
// }
// }
// }
void i2c_sensors_task(void *pvParameters)
{
memset(foundDevices, 0, sizeof(foundDevices));
memset(prevDevices, 0, sizeof(prevDevices));
bme680b_init();
mpu9250_init();
ccs811_init();
ina260_init();
// update_devices();
// init_connected();
// initialize the xLastWakeTime variable with the current time.
const int64_t interval_us = 100000; // 100 ms
int64_t start_time, end_time, elapsed;
@@ -23,11 +103,6 @@ void i2c_sensors_task(void *pvParameters)
//
// initialize i2c device configuration
bme680b_init();
mpu9250_init();
ina260_init();
ccs811_init();
mcp3550_spi_init();
configure_led();
@@ -97,16 +172,20 @@ void i2c_sensors_task(void *pvParameters)
ina260_readParams(&volts, &current, &power);
ina260_printParams(volts, current, power);
float VREFVoltage = volts * 1.25 / 1000; // Mame vobec nieco na VREFE? Na scheme su len medzi sebou prepojene
float VREFVoltage = 2.5;
mics_adc_data_t ADCData = mcp3550_read_all(5.0); // vref = 5.0V
log_mics_adc_values(&ADCData);
mics_adc_data_t ADCData;
memset(&ADCData, 0, sizeof(ADCData));
//mics_adc_data_t ADCData = mcp3550_read_all(VREFVoltage);
ADCData = mcp3550_read_all(VREFVoltage);
//log_mics_adc_values(&ADCData);
log_mics_adc_values(&ADCData);
int32_t nh3val = mcp3550_read(MCP_CS_ADC_NH3);
gpio_set_level(BLINK_GPIO, s_led_state);
ESP_LOGI(TAG_BME, "MICS NH3: %ld -> %fV", nh3val, mcp3550_to_voltage(nh3val, VREFVoltage));
//gpio_set_level(BLINK_GPIO, s_led_state);
mcp23018_set_pin(MCP23018_DEV_HANDLE, MCP_CS_ADC_UVC, s_led_state);
/* Toggle the LED state */
s_led_state = !s_led_state;
end_time = esp_timer_get_time();

2
main/components/sensors.h
View File

@@ -19,6 +19,8 @@
#include "esp_log.h"
extern uint8_t foundDevices[128];
extern uint8_t prevDevices[128];
void i2c_sensors_task(void *pvParameters);

5
main/hw/bme680b.c
View File

@@ -38,14 +38,15 @@ void bme680_print_registers(bme680_handle_t handle)
ESP_LOGI(TAG_BME, "Control Gas 1 (0x%02x): %s", ctrl_gas1_reg.reg, uint8_to_binary(ctrl_gas1_reg.reg));
}
void bme680b_init() {
esp_err_t bme680b_init() {
// init device
bme680_init(i2c0_bus_hdl, &BME680_DEV_CFG, &BME680_DEV_HANDLE);
esp_err_t ret = bme680_init(i2c0_bus_hdl, &BME680_DEV_CFG, &BME680_DEV_HANDLE);
if (BME680_DEV_HANDLE == NULL)
{
ESP_LOGE(TAG_BME, "bme680 handle init failed");
} else {
bme680_print_registers(BME680_DEV_HANDLE);
}
return ret;
}

2
main/hw/bme680b.h
View File

@@ -8,6 +8,6 @@ extern bme680_config_t BME680_DEV_CFG;
extern bme680_handle_t BME680_DEV_HANDLE;
void bme680_print_registers(bme680_handle_t handle);
void bme680b_init();
esp_err_t bme680b_init();
#endif

8
main/hw/buscfg.h
View File

@@ -8,6 +8,12 @@
#define ESP_RXD0 GPIO_NUM_44
#define ESP_TXD0 GPIO_NUM_43
#define MCP23018_ADDRESS 0x20
#define INA260_ADDRESS 0x40
#define CCS811_ADDRESS 0x5A
#define MPU9250_ADDRESS 0x68
#define BME680_ADDRESS 0x76
#define ESP_CONNECTOR_P1 MCP3550_MISO_GPIO
#define ESP_CONNECTOR_P2 MCP3550_MOSI_GPIO
#define ESP_CONNECTOR_P3 MCP3550_SCK_GPIO
@@ -42,8 +48,6 @@
#define HSPI_MISO_GPIO GPIO_NUM_13
#define HSPI_MOSI_GPIO GPIO_NUM_11
//#define HSPI_MISO_GPIO GPIO_NUM_11
//#define HSPI_MOSI_GPIO GPIO_NUM_13
#define HSPI_SCK_GPIO GPIO_NUM_12
#define HSPI_LORA_CS GPIO_NUM_48

45
main/hw/ccs811.c
View File

@@ -4,13 +4,13 @@
i2c_device_config_t CCS811_DEV_CFG = {
.dev_addr_length = I2C_ADDR_BIT_LEN_7,
.device_address = 0x5A,
.device_address = CCS811_ADDRESS,
.scl_speed_hz = 100000,
};
i2c_master_dev_handle_t CCS811_DEV_HANDLE;
void ccs811_getStatus()
esp_err_t ccs811_getStatus()
{
uint8_t errorID;
uint8_t status;
@@ -18,29 +18,42 @@ void ccs811_getStatus()
uint16_t version;
uint16_t bootVersion;
i2c_read_register_8(CCS811_DEV_HANDLE, CCS811_REG_STATUS, &status);
i2c_read_register_16(CCS811_DEV_HANDLE, CCS811_REG_FW_APP_VERSION, &version);
i2c_read_register_16(CCS811_DEV_HANDLE, CCS811_REG_FW_BOOT_VERSION, &bootVersion);
i2c_read_register_8(CCS811_DEV_HANDLE, CCS811_REG_HW_VERSION, &hardwareVersion);
i2c_read_register_8(CCS811_DEV_HANDLE, CCS811_REG_ERROR_ID, &errorID);
esp_err_t ret = i2c_read_register_8(CCS811_DEV_HANDLE, CCS811_REG_STATUS, &status);
if (ret != ESP_OK) {return ret;}
ret = i2c_read_register_16(CCS811_DEV_HANDLE, CCS811_REG_FW_APP_VERSION, &version);
if (ret != ESP_OK) {return ret;}
ret = i2c_read_register_16(CCS811_DEV_HANDLE, CCS811_REG_FW_BOOT_VERSION, &bootVersion);
if (ret != ESP_OK) {return ret;}
ret = i2c_read_register_8(CCS811_DEV_HANDLE, CCS811_REG_HW_VERSION, &hardwareVersion);
if (ret != ESP_OK) {return ret;}
ret = i2c_read_register_8(CCS811_DEV_HANDLE, CCS811_REG_ERROR_ID, &errorID);
ESP_LOGW(TAG_CCS, "CCS811 status: %d, version: %d, boot version: %d, hardware version: %d, error ID: %d", status, version, bootVersion, hardwareVersion, errorID);
return ret;
}
void ccs811_init()
esp_err_t ccs811_init()
{
ESP_ERROR_CHECK(i2c_master_bus_add_device(i2c0_bus_hdl, &CCS811_DEV_CFG, &CCS811_DEV_HANDLE));
mcp23018_set_pin(MCP23018_DEV_HANDLE, MCP_CCS811_WAKE, 0);
mcp23018_set_pin(MCP23018_DEV_HANDLE, MCP_CCS811_POWER, 1);
esp_err_t ret =i2c_master_bus_add_device(i2c0_bus_hdl, &CCS811_DEV_CFG, &CCS811_DEV_HANDLE);
if (ret != ESP_OK) {return ret;}
ret = mcp23018_set_pin(MCP23018_DEV_HANDLE, MCP_CCS811_WAKE, 0);
if (ret != ESP_OK) {return ret;}
ret = mcp23018_set_pin(MCP23018_DEV_HANDLE, MCP_CCS811_POWER, 1);
if (ret != ESP_OK) {return ret;}
vTaskDelay(10 / portTICK_PERIOD_MS);
uint8_t reset_seq[4] = {0x11, 0xE5, 0x72, 0x8A};
i2c_write_register(CCS811_DEV_HANDLE, CCS811_REG_SW_RESET, reset_seq, sizeof(reset_seq)); // Reset
ret = i2c_write_register(CCS811_DEV_HANDLE, CCS811_REG_SW_RESET, reset_seq, sizeof(reset_seq)); // Reset
if (ret != ESP_OK) {return ret;}
vTaskDelay(10 / portTICK_PERIOD_MS);
ccs811_getStatus();
i2c_write_register(CCS811_DEV_HANDLE, CCS811_REG_APP_START, NULL, 0); // start
ret = ccs811_getStatus();
if (ret != ESP_OK) {return ret;}
ret = i2c_write_register(CCS811_DEV_HANDLE, CCS811_REG_APP_START, NULL, 0); // start
if (ret != ESP_OK) {return ret;}
vTaskDelay(10 / portTICK_PERIOD_MS);
i2c_write_register_8(CCS811_DEV_HANDLE, CCS811_REG_MEAS_MODE, 0x40); // MODE 1 interrupts vypnuté
ccs811_getStatus();
ret = i2c_write_register_8(CCS811_DEV_HANDLE, CCS811_REG_MEAS_MODE, 0x40); // MODE 1 interrupts vypnuté
if (ret != ESP_OK) {return ret;}
ret = ccs811_getStatus();
return ret;
}
esp_err_t ccs811_get_data(uint16_t *eCO2, uint16_t *tvoc, uint8_t *current, uint16_t *rawData)
{

2
main/hw/ccs811.h
View File

@@ -37,7 +37,7 @@ extern i2c_device_config_t CCS811_DEV_CFG;
extern i2c_master_dev_handle_t CCS811_DEV_HANDLE;
void ccs811_init();
esp_err_t ccs811_init();
esp_err_t ccs811_get_data(uint16_t *eCO2, uint16_t *tvoc, uint8_t *current, uint16_t *rawData);
esp_err_t ccs811_set_env_data(float temperature, float humidity);
#endif

9
main/hw/ina260.c
View File

@@ -2,7 +2,7 @@
i2c_device_config_t INA260_DEV_CFG = {
.dev_addr_length = I2C_ADDR_BIT_LEN_7,
.device_address = 0x40,
.device_address = INA260_ADDRESS,
.scl_speed_hz = 100000,
};
@@ -13,10 +13,11 @@ void ina260_reset() {
i2c_write_register_16(INA260_DEV_HANDLE, 0x00, 0x0FFF); // set ina max averaging and max time
}
void ina260_init()
esp_err_t ina260_init()
{
ESP_ERROR_CHECK(i2c_master_bus_add_device(i2c0_bus_hdl, &INA260_DEV_CFG, &INA260_DEV_HANDLE));
i2c_write_register_16(INA260_DEV_HANDLE, INA260_CONFIG_REGISTER,
esp_err_t ret = i2c_master_bus_add_device(i2c0_bus_hdl, &INA260_DEV_CFG, &INA260_DEV_HANDLE);
if (ret != ESP_OK) {return ret;}
return i2c_write_register_16(INA260_DEV_HANDLE, INA260_CONFIG_REGISTER,
CONFIG_AVG_1024 | CONFIG_VBUSCT_8_244MS | CONFIG_ISHCT_8_244MS | CONFIG_MODE_CURRENT_VOLTAGE_CONTINOUS); // set ina max averaging and max time
}

2
main/hw/ina260.h
View File

@@ -65,7 +65,7 @@ extern i2c_master_dev_handle_t INA260_DEV_HANDLE;
#define CONFIG_MODE_VOLTAGE_CONTINOUS 0x06
#define CONFIG_MODE_CURRENT_VOLTAGE_CONTINOUS 0x07
void ina260_init();
esp_err_t ina260_init();
void ina260_readParams(uint16_t *volt, uint16_t *cur, uint16_t *pow);
void ina260_printParams(uint16_t volt, uint16_t cur, uint16_t pow);

26
main/hw/mcp23018.c
View File

@@ -1,11 +1,12 @@
#include "mcp23018.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "../components/sensors.h"
// Local buffer for tracking GPIO state
i2c_device_config_t MCP23018_DEV_CFG = {
.dev_addr_length = I2C_ADDR_BIT_LEN_7,
.device_address = 0x20,
.device_address = MCP23018_ADDRESS,
.scl_speed_hz = 100000,
};
@@ -13,8 +14,12 @@ i2c_master_dev_handle_t MCP23018_DEV_HANDLE;
uint8_t gpioa_state = 0x00; // All LOW initially
uint8_t gpiob_state = 0x00; // All LOW initially
void mcp23018_set_pin(i2c_master_dev_handle_t dev_handle, uint8_t pin, uint8_t value)
esp_err_t mcp23018_set_pin(i2c_master_dev_handle_t dev_handle, uint8_t pin, uint8_t value)
{
// while(foundDevices[MCP23018_ADDRESS] != 2) {
// vTaskDelay(1);
// }
esp_err_t ret = ESP_FAIL;
if (pin < 8)
{
// GPIOA (Pins 0-7)
@@ -24,7 +29,7 @@ void mcp23018_set_pin(i2c_master_dev_handle_t dev_handle, uint8_t pin, uint8_t v
gpioa_state &= ~(1 << pin); // Clear bit
// Write updated buffer to MCP23018
i2c_write_register_8(dev_handle, MCP23018_GPIOA, gpioa_state);
ret = i2c_write_register_8(dev_handle, MCP23018_GPIOA, gpioa_state);
}
else if (pin < 16)
{
@@ -36,19 +41,28 @@ void mcp23018_set_pin(i2c_master_dev_handle_t dev_handle, uint8_t pin, uint8_t v
gpiob_state &= ~(1 << pinB); // Clear bit
// Write updated buffer to MCP23018
i2c_write_register_8(dev_handle, MCP23018_GPIOB, gpiob_state);
ret = i2c_write_register_8(dev_handle, MCP23018_GPIOB, gpiob_state);
}
vTaskDelay(1 / portTICK_PERIOD_MS);
return ret;
}
void mcp23018_init()
esp_err_t mcp23018_init()
{
ESP_ERROR_CHECK(i2c_master_bus_add_device(i2c0_bus_hdl, &MCP23018_DEV_CFG, &MCP23018_DEV_HANDLE));
esp_err_t ret = i2c_master_bus_add_device(i2c0_bus_hdl, &MCP23018_DEV_CFG, &MCP23018_DEV_HANDLE);
if (ret != ESP_OK) {return ret;}
i2c_write_register_8(MCP23018_DEV_HANDLE, MCP23018_IODIRA, gpioa_state);
if (ret != ESP_OK) {return ret;}
i2c_write_register_8(MCP23018_DEV_HANDLE, MCP23018_IODIRB, gpiob_state);
if (ret != ESP_OK) {return ret;}
mcp23018_set_pin(MCP23018_DEV_HANDLE, MCP_CS_ADC_CO, 1);
if (ret != ESP_OK) {return ret;}
mcp23018_set_pin(MCP23018_DEV_HANDLE, MCP_CS_ADC_NH3, 1);
if (ret != ESP_OK) {return ret;}
mcp23018_set_pin(MCP23018_DEV_HANDLE, MCP_CS_ADC_NO2, 1);
if (ret != ESP_OK) {return ret;}
mcp23018_set_pin(MCP23018_DEV_HANDLE, MCP_CS_ADC_UVC, 1);
if (ret != ESP_OK) {return ret;}
mcp23018_set_pin(MCP23018_DEV_HANDLE, MCP_LORA_RST, 1);
return ret;
}

5
main/hw/mcp23018.h
View File

@@ -7,6 +7,7 @@
#define MCP23018_GPIOA 0x12 // GPIO Output A
#define MCP23018_GPIOB 0x13 // GPIO Output B
#define MCP_LORA_RST 4
#define MCP_MICS_POWER 5
#define MCP_CCS811_WAKE 6
@@ -25,7 +26,7 @@ extern i2c_master_dev_handle_t MCP23018_DEV_HANDLE;
extern uint8_t gpioa_state;
extern uint8_t gpiob_state;
void mcp23018_set_pin(i2c_master_dev_handle_t dev_handle, uint8_t pin, uint8_t value);
void mcp23018_init();
esp_err_t mcp23018_set_pin(i2c_master_dev_handle_t dev_handle, uint8_t pin, uint8_t value);
esp_err_t mcp23018_init();
#endif

111
main/hw/mcp3550.c
View File

@@ -34,40 +34,90 @@ void mcp3550_spi_init()
}
// int32_t mcp3550_read(uint8_t cs_pin)
// {
// uint8_t rx_buf[4] = {0}; // 25 bits fits in 4 bytes
// int64_t start = esp_timer_get_time(); // in microseconds
// while (true) {
// mcp23018_set_pin(MCP23018_DEV_HANDLE, cs_pin, 0); // CS LOW
// vTaskDelay(pdMS_TO_TICKS(30)); // Wait before retrying
// mcp23018_set_pin(MCP23018_DEV_HANDLE, cs_pin, 1); // CS HIGH
// vTaskDelay(pdMS_TO_TICKS(200)); // Wait before retrying
// mcp23018_set_pin(MCP23018_DEV_HANDLE, cs_pin, 0); // CS LOW
// esp_rom_delay_us(1000); // Wait before retrying
// spi_transaction_t trans = {
// .length = 25,
// .rx_buffer = rx_buf,
// };
// esp_err_t err = spi_device_transmit(mcp3550_handle, &trans);
// mcp23018_set_pin(MCP23018_DEV_HANDLE, cs_pin, 1); // CS HIGH
// if (err != ESP_OK) {
// ESP_LOGE(TAG_MICS, "SPI transmit failed on CS pin %u", cs_pin);
// return INT32_MIN;
// }
// bool dr = (rx_buf[0] & 0x80) != 0;
// if (!dr) break;
// if ((esp_timer_get_time() - start) > (MCP3550_TIMEOUT_MS * 1000)) {
// ESP_LOGW(TAG_MICS, "Timeout waiting for DR=0 on CS pin %u", cs_pin);
// return INT32_MIN;
// }
// vTaskDelay(pdMS_TO_TICKS(10)); // Wait before retrying
// }
// // Combine 22-bit result (drop DR + status bits)
// uint32_t raw = ((rx_buf[0] & 0x3F) << 16) | (rx_buf[1] << 8) | rx_buf[2];
// // Sign-extend 22-bit value
// int32_t value = raw;
// if (value & (1 << 21)) value |= 0xFFC00000;
// return value;
// }
int32_t mcp3550_read(uint8_t cs_pin)
{
uint8_t rx_buf[4] = {0}; // 25 bits fits in 4 bytes
uint8_t rx_buf[4] = {0};
uint32_t timeout_us = MCP3550_TIMEOUT_MS * 1000;
int64_t start = esp_timer_get_time();
int64_t start = esp_timer_get_time(); // in microseconds
while (true) {
mcp23018_set_pin(MCP23018_DEV_HANDLE, cs_pin, 0); // CS LOW
// Start conversion
mcp23018_set_pin(MCP23018_DEV_HANDLE, cs_pin, 0); // CS LOW
spi_transaction_t trans = {
.length = 25,
.rx_buffer = rx_buf,
};
esp_err_t err = spi_device_transmit(mcp3550_handle, &trans);
mcp23018_set_pin(MCP23018_DEV_HANDLE, cs_pin, 1); // CS HIGH
if (err != ESP_OK) {
ESP_LOGE(TAG_MICS, "SPI transmit failed on CS pin %u", cs_pin);
// Wait until MISO/SDO goes LOW = DR ready
while (gpio_get_level(MCP3550_MISO_GPIO)) {
if ((esp_timer_get_time() - start) > timeout_us) {
ESP_LOGW(TAG_MICS, "Timeout waiting for MISO=0 on CS %u", cs_pin);
mcp23018_set_pin(MCP23018_DEV_HANDLE, cs_pin, 1); // CS HIGH
return INT32_MIN;
}
bool dr = (rx_buf[0] & 0x80) != 0;
if (!dr) break;
if ((esp_timer_get_time() - start) > (MCP3550_TIMEOUT_MS * 1000)) {
ESP_LOGW(TAG_MICS, "Timeout waiting for DR=0 on CS pin %u", cs_pin);
return INT32_MIN;
}
vTaskDelay(pdMS_TO_TICKS(10)); // Wait before retrying
esp_rom_delay_us(10); // micro delay
}
// Combine 22-bit result (drop DR + status bits)
// Data is ready, do full SPI read
spi_transaction_t trans = {
.length = 25, // 25 bits
.rx_buffer = rx_buf,
};
esp_err_t err = spi_device_transmit(mcp3550_handle, &trans);
mcp23018_set_pin(MCP23018_DEV_HANDLE, cs_pin, 1); // CS HIGH to start next conversion
if (err != ESP_OK) {
ESP_LOGE(TAG_MICS, "SPI transmit failed");
return INT32_MIN;
}
// Extract 22-bit result
uint32_t raw = ((rx_buf[0] & 0x3F) << 16) | (rx_buf[1] << 8) | rx_buf[2];
// Sign-extend 22-bit value
@@ -78,6 +128,7 @@ int32_t mcp3550_read(uint8_t cs_pin)
}
float mcp3550_to_voltage(int32_t value, float vref)
{
return ((float)value / (1 << 21)) * vref;
@@ -107,10 +158,10 @@ void log_mics_adc_values(mics_adc_data_t *data)
{
ESP_LOGI(TAG_MICS,
"ADC Readings:\n"
" NH3 -> Raw: %8d, Voltage: %7.6f V\n"
" CO -> Raw: %8d, Voltage: %7.6f V\n"
" NO2 -> Raw: %8d, Voltage: %7.6f V\n"
" UVC -> Raw: %8d, Voltage: %7.6f V",
" NH3 -> Raw: %ld, Voltage: %f V\n"
" CO -> Raw: %ld, Voltage: %f V\n"
" NO2 -> Raw: %ld, Voltage: %f V\n"
" UVC -> Raw: %ld, Voltage: %f V",
data->raw_nh3, data->volts_nh3,
data->raw_co, data->volts_co,
data->raw_no2, data->volts_no2,

13
main/hw/mpu9250.c
View File

@@ -3,7 +3,7 @@
i2c_device_config_t MPU9250_DEV_CFG = {
.dev_addr_length = I2C_ADDR_BIT_LEN_7,
.device_address = 0x68,
.device_address = MPU9250_ADDRESS,
.scl_speed_hz = 100000,
};
@@ -57,9 +57,12 @@ void mpu9250_convert_data(int16_t *accel, int16_t *gyro, int16_t temp, int16_t *
*temp_out = (temp / 333.87) + 21.0; // Temperature in °C
}
void mpu9250_init()
esp_err_t mpu9250_init()
{
ESP_ERROR_CHECK(i2c_master_bus_add_device(i2c0_bus_hdl, &MPU9250_DEV_CFG, &MPU9250_DEV_HANDLE));
i2c_write_register_16(MPU9250_DEV_HANDLE, 0x6B, 0x0001); // zapni uz tu hovadinu
i2c_write_register_16(MPU9250_DEV_HANDLE, 0x0A, 0x0012); // zapni uz tu hovadinu
esp_err_t ret = i2c_master_bus_add_device(i2c0_bus_hdl, &MPU9250_DEV_CFG, &MPU9250_DEV_HANDLE);
if (ret != ESP_OK) {return ret;}
ret = i2c_write_register_16(MPU9250_DEV_HANDLE, 0x6B, 0x0001); // zapni uz tu hovadinu
if (ret != ESP_OK) {return ret;}
ret = i2c_write_register_16(MPU9250_DEV_HANDLE, 0x0A, 0x0012); // zapni uz tu hovadinu
return ret;
}

2
main/hw/mpu9250.h
View File

@@ -10,6 +10,6 @@ extern i2c_master_dev_handle_t MPU9250_DEV_HANDLE;
esp_err_t mpu9250_read_sensor_data(i2c_master_dev_handle_t dev_handle, int16_t *accel, int16_t *gyro, int16_t *temp, int16_t *magnet);
void mpu9250_convert_data(int16_t *accel, int16_t *gyro, int16_t temp, int16_t *magnet, float *accel_out, float *gyro_out, float *temp_out, float *magnet_out);
void mpu9250_init();
esp_err_t mpu9250_init();
#endif

42
main/hw/sx1262.c
View File

@@ -4,12 +4,15 @@
#include <math.h>
#include <stdlib.h>
#include "../components/sensors.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include <driver/spi_master.h>
#include <driver/gpio.h>
#include "esp_log.h"
#include "buscfg.h"
#include "sx1262.h"
@@ -17,13 +20,6 @@
#define HOST_ID SPI3_HOST
#define CONFIG_MISO_GPIO GPIO_NUM_11
#define CONFIG_MOSI_GPIO GPIO_NUM_10
#define CONFIG_SCLK_GPIO GPIO_NUM_9
#define CONFIG_NSS_GPIO GPIO_NUM_8
#define CONFIG_RST_GPIO GPIO_NUM_12
#define CONFIG_BUSY_GPIO GPIO_NUM_13
static spi_device_handle_t SpiHandle;
// Global Stuff
@@ -32,7 +28,6 @@ static bool txActive;
static int txLost = 0;
static bool debugPrint;
static int SX126x_SPI_SELECT;
static int SX126x_RESET;
static int SX126x_BUSY;
// Arduino compatible macros
@@ -55,16 +50,14 @@ __attribute__ ((weak, alias ("LoRaErrorDefault"))) void LoRaError(int error);
void LoRaInit(void)
{
ESP_LOGI(TAG, "CONFIG_MISO_GPIO=%d", CONFIG_MISO_GPIO);
ESP_LOGI(TAG, "CONFIG_MOSI_GPIO=%d", CONFIG_MOSI_GPIO);
ESP_LOGI(TAG, "CONFIG_SCLK_GPIO=%d", CONFIG_SCLK_GPIO);
ESP_LOGI(TAG, "CONFIG_NSS_GPIO=%d", CONFIG_NSS_GPIO);
ESP_LOGI(TAG, "CONFIG_RST_GPIO=%d", CONFIG_RST_GPIO);
ESP_LOGI(TAG, "CONFIG_BUSY_GPIO=%d", CONFIG_BUSY_GPIO);
ESP_LOGI(TAG, "HSPI_MISO_GPIO=%d", HSPI_MISO_GPIO);
ESP_LOGI(TAG, "HSPI_MOSI_GPIO=%d", HSPI_MOSI_GPIO);
ESP_LOGI(TAG, "HSPI_SCK_GPIO=%d", HSPI_SCK_GPIO);
ESP_LOGI(TAG, "HSPI_LORA_CS=%d", HSPI_LORA_CS);
ESP_LOGI(TAG, "LORA_BUSY=%d", LORA_BUSY);
SX126x_SPI_SELECT = CONFIG_NSS_GPIO;
SX126x_RESET = CONFIG_RST_GPIO;
SX126x_BUSY = CONFIG_BUSY_GPIO;
SX126x_SPI_SELECT = HSPI_LORA_CS;
SX126x_BUSY = LORA_BUSY;
txActive = false;
debugPrint = false;
@@ -72,17 +65,14 @@ void LoRaInit(void)
gpio_reset_pin(SX126x_SPI_SELECT);
gpio_set_direction(SX126x_SPI_SELECT, GPIO_MODE_OUTPUT);
gpio_set_level(SX126x_SPI_SELECT, 1);
gpio_reset_pin(SX126x_RESET);
gpio_set_direction(SX126x_RESET, GPIO_MODE_OUTPUT);
gpio_reset_pin(SX126x_BUSY);
gpio_set_direction(SX126x_BUSY, GPIO_MODE_INPUT);
spi_bus_config_t spi_bus_config = {
.sclk_io_num = CONFIG_SCLK_GPIO,
.mosi_io_num = CONFIG_MOSI_GPIO,
.miso_io_num = CONFIG_MISO_GPIO,
.sclk_io_num = HSPI_SCK_GPIO,
.mosi_io_num = HSPI_MOSI_GPIO,
.miso_io_num = HSPI_MISO_GPIO,
.quadwp_io_num = -1,
.quadhd_io_num = -1
};
@@ -91,7 +81,7 @@ void LoRaInit(void)
spi_device_interface_config_t devcfg = {
.clock_speed_hz = 9000000,
.mode = 0,
.spics_io_num = CONFIG_NSS_GPIO,
.spics_io_num = HSPI_LORA_CS,
.queue_size = 7,
.flags = 0,
.pre_cb = NULL
@@ -399,9 +389,9 @@ void SetTxPower(int8_t txPowerInDbm)
void Reset(void)
{
delay(10);
gpio_set_level(SX126x_RESET,0);
mcp23018_set_pin(MCP23018_DEV_HANDLE, MCP_LORA_RST, 0);
delay(20);
gpio_set_level(SX126x_RESET,1);
mcp23018_set_pin(MCP23018_DEV_HANDLE, MCP_LORA_RST, 1);
delay(10);
// ensure BUSY is low (state meachine ready)
WaitForIdle(BUSY_WAIT, "Reset", true);

2
main/main.c
View File

@@ -61,11 +61,11 @@ void app_main(void)
/* scan i2c devices on i2c master bus 0 and print results */
ESP_ERROR_CHECK(i2c_master_bus_detect_devices(i2c0_bus_hdl));
mcp23018_init();
void servoControllerInit();
/* create task pinned to the app core */
xTaskCreate(
i2c_sensors_task,