j3d1/esp-open-rtos
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

bmp280 ds1307 hmc5883l update

Browse source
This commit is contained in:
lilian 2017-08-04 14:39:31 -03:00
parent 60cbd9c710
commit 13efa882d2
10 changed files with 169 additions and 160 deletions
Download patch file Download diff file Expand all files Collapse all files

12
examples/bmp280/bmp280_example.c
View file

@ -10,9 +10,9 @@
#include "bmp280/bmp280.h" #include "bmp280/bmp280.h"
// In forced mode user initiate measurement each time. // In forced mode user initiate measurement each time.
// In normal mode measurement is done continuously with specified standby time. // In normal mode measurement is done continuously with specified standby time.
// #define MODE_FORCED // #define MODE_FORCED
const uint8_t i2c_bus = 0;
const uint8_t scl_pin = 0; const uint8_t scl_pin = 0;
const uint8_t sda_pin = 2; const uint8_t sda_pin = 2;
@ -26,7 +26,8 @@ static void bmp280_task_forced(void *pvParameters)
params.mode = BMP280_MODE_FORCED; params.mode = BMP280_MODE_FORCED;
bmp280_t bmp280_dev; bmp280_t bmp280_dev;
bmp280_dev.i2c_addr = BMP280_I2C_ADDRESS_0; bmp280_dev.i2c_dev.bus = i2c_bus;
bmp280_dev.i2c_dev.addr = BMP280_I2C_ADDRESS_0;
while (1) { while (1) {
while (!bmp280_init(&bmp280_dev, &params)) { while (!bmp280_init(&bmp280_dev, &params)) {
@ -67,7 +68,8 @@ static void bmp280_task_normal(void *pvParameters)
bmp280_init_default_params(&params); bmp280_init_default_params(&params);
bmp280_t bmp280_dev; bmp280_t bmp280_dev;
bmp280_dev.i2c_addr = BMP280_I2C_ADDRESS_0; bmp280_dev.i2c_dev.bus = i2c_bus;
bmp280_dev.i2c_dev.addr = BMP280_I2C_ADDRESS_0;
while (1) { while (1) {
while (!bmp280_init(&bmp280_dev, &params)) { while (!bmp280_init(&bmp280_dev, &params)) {
@ -103,7 +105,7 @@ void user_init(void)
printf("SDK version : %s\n", sdk_system_get_sdk_version()); printf("SDK version : %s\n", sdk_system_get_sdk_version());
printf("GIT version : %s\n", GITSHORTREV); printf("GIT version : %s\n", GITSHORTREV);
i2c_init(scl_pin, sda_pin); i2c_init(i2c_bus, scl_pin, sda_pin, I2C_FREQ_400K);
#ifdef MODE_FORCED #ifdef MODE_FORCED
xTaskCreate(bmp280_task_forced, "bmp280_task", 256, NULL, 2, NULL); xTaskCreate(bmp280_task_forced, "bmp280_task", 256, NULL, 2, NULL);

13
examples/ds1307/main.c
View file

@ -11,6 +11,7 @@
#include <ds1307/ds1307.h> #include <ds1307/ds1307.h>
#include <stdio.h> #include <stdio.h>
#define I2C_BUS 0
#define SCL_PIN 5 #define SCL_PIN 5
#define SDA_PIN 4 #define SDA_PIN 4
@ -19,8 +20,12 @@ void user_init(void)
uart_set_baud(0, 115200); uart_set_baud(0, 115200);
printf("SDK version:%s\n", sdk_system_get_sdk_version()); printf("SDK version:%s\n", sdk_system_get_sdk_version());
i2c_init(SCL_PIN, SDA_PIN); i2c_init(I2C_BUS, SCL_PIN, SDA_PIN, I2C_FREQ_400K);
ds1307_start(true); i2c_dev_t dev = {
.addr = DS1307_ADDR,
.bus = I2C_BUS,
};
ds1307_start(&dev, true);
// setup datetime: 2016-10-09 13:50:10 // setup datetime: 2016-10-09 13:50:10
struct tm time = { struct tm time = {
@ -31,11 +36,11 @@ void user_init(void)
.tm_min = 50, .tm_min = 50,
.tm_sec = 10 .tm_sec = 10
}; };
ds1307_set_time(&time); ds1307_set_time(&dev, &time);
while (true) while (true)
{ {
ds1307_get_time(&time); ds1307_get_time(&dev, &time);
printf("%04d-%02d-%02d %02d:%02d:%02d\n", time.tm_year, time.tm_mon + 1, printf("%04d-%02d-%02d %02d:%02d:%02d\n", time.tm_year, time.tm_mon + 1,
time.tm_mday, time.tm_hour, time.tm_min, time.tm_sec); time.tm_mday, time.tm_hour, time.tm_min, time.tm_sec);

19
examples/hmc5883l/main.c
View file

@ -11,6 +11,7 @@
#include <i2c/i2c.h> #include <i2c/i2c.h>
#include <hmc5883l/hmc5883l.h> #include <hmc5883l/hmc5883l.h>
#define I2C_BUS 0
#define SCL_PIN 5 #define SCL_PIN 5
#define SDA_PIN 4 #define SDA_PIN 4
@ -19,20 +20,24 @@ void user_init(void)
uart_set_baud(0, 115200); uart_set_baud(0, 115200);
printf("SDK version:%s\n\n", sdk_system_get_sdk_version()); printf("SDK version:%s\n\n", sdk_system_get_sdk_version());
i2c_init(SCL_PIN, SDA_PIN); i2c_init(I2C_BUS, SCL_PIN, SDA_PIN, I2C_FREQ_100K);
i2c_dev_t dev = {
.addr = HMC5883L_ADDR,
.bus = I2C_BUS,
};
while (!hmc5883l_init()) while (!hmc5883l_init(&dev))
printf("Device not found\n"); printf("Device not found\n");
hmc5883l_set_operating_mode(HMC5883L_MODE_CONTINUOUS); hmc5883l_set_operating_mode(&dev, HMC5883L_MODE_CONTINUOUS);
hmc5883l_set_samples_averaged(HMC5883L_SAMPLES_8); hmc5883l_set_samples_averaged(&dev, HMC5883L_SAMPLES_8);
hmc5883l_set_data_rate(HMC5883L_DATA_RATE_07_50); hmc5883l_set_data_rate(&dev, HMC5883L_DATA_RATE_07_50);
hmc5883l_set_gain(HMC5883L_GAIN_1090); hmc5883l_set_gain(&dev, HMC5883L_GAIN_1090);
while (true) while (true)
{ {
hmc5883l_data_t data; hmc5883l_data_t data;
hmc5883l_get_data(&data); hmc5883l_get_data(&dev, &data);
printf("Magnetic data: X:%.2f mG, Y:%.2f mG, Z:%.2f mG\n", data.x, data.y, data.z); printf("Magnetic data: X:%.2f mG, Y:%.2f mG, Z:%.2f mG\n", data.x, data.y, data.z);
for (uint32_t i = 0; i < 1000; i++) for (uint32_t i = 0; i < 1000; i++)

1
extras/ad770x/ad770x.c
View file

@ -179,4 +179,3 @@ uint16_t ad770x_raw_adc_value(const ad770x_params_t *params, uint8_t channel)
prepare(channel, REG_DATA, true, params->cs_pin, false); prepare(channel, REG_DATA, true, params->cs_pin, false);
return read_word(params->cs_pin); return read_word(params->cs_pin);
} }

74
extras/bmp280/bmp280.c
View file

@ -23,7 +23,6 @@
*/ */
#include <stddef.h> #include <stddef.h>
#include "bmp280.h" #include "bmp280.h"
#include "i2c/i2c.h"
#ifdef BMP280_DEBUG #ifdef BMP280_DEBUG
#include <stdio.h> #include <stdio.h>
@ -66,37 +65,36 @@ void bmp280_init_default_params(bmp280_params_t *params)
params->standby = BMP280_STANDBY_250; params->standby = BMP280_STANDBY_250;
} }
static bool read_register16(uint8_t i2c_addr, uint8_t addr, uint16_t *value) static bool read_register16(i2c_dev_t* dev, uint8_t addr, uint16_t *value)
{ {
uint8_t d[] = {0, 0}; uint8_t d[] = {0, 0};
if (!i2c_slave_read(i2c_addr, &addr, d, sizeof(d))) { if (!i2c_slave_read(dev->bus, dev->addr, &addr, d, sizeof(d))) {
*value = d[0] | (d[1] << 8); *value = d[0] | (d[1] << 8);
return true; return true;
} }
return false; return false;
} }
static inline int read_data(uint8_t i2c_addr, uint8_t addr, uint8_t *value, uint8_t len) static inline int read_data(i2c_dev_t* dev, uint8_t addr, uint8_t *value, uint8_t len)
{ {
return i2c_slave_read(i2c_addr, &addr, value, len); return i2c_slave_read(dev->bus, dev->addr, &addr, value, len);
} }
static bool read_calibration_data(bmp280_t *dev) static bool read_calibration_data(bmp280_t *dev)
{ {
uint8_t i2c_addr = dev->i2c_addr;
if (read_register16(i2c_addr, 0x88, &dev->dig_T1) && if (read_register16(&dev->i2c_dev, 0x88, &dev->dig_T1) &&
read_register16(i2c_addr, 0x8a, (uint16_t *)&dev->dig_T2) && read_register16(&dev->i2c_dev, 0x8a, (uint16_t *)&dev->dig_T2) &&
read_register16(i2c_addr, 0x8c, (uint16_t *)&dev->dig_T3) && read_register16(&dev->i2c_dev, 0x8c, (uint16_t *)&dev->dig_T3) &&
read_register16(i2c_addr, 0x8e, &dev->dig_P1) && read_register16(&dev->i2c_dev, 0x8e, &dev->dig_P1) &&
read_register16(i2c_addr, 0x90, (uint16_t *)&dev->dig_P2) && read_register16(&dev->i2c_dev, 0x90, (uint16_t *)&dev->dig_P2) &&
read_register16(i2c_addr, 0x92, (uint16_t *)&dev->dig_P3) && read_register16(&dev->i2c_dev, 0x92, (uint16_t *)&dev->dig_P3) &&
read_register16(i2c_addr, 0x94, (uint16_t *)&dev->dig_P4) && read_register16(&dev->i2c_dev, 0x94, (uint16_t *)&dev->dig_P4) &&
read_register16(i2c_addr, 0x96, (uint16_t *)&dev->dig_P5) && read_register16(&dev->i2c_dev, 0x96, (uint16_t *)&dev->dig_P5) &&
read_register16(i2c_addr, 0x98, (uint16_t *)&dev->dig_P6) && read_register16(&dev->i2c_dev, 0x98, (uint16_t *)&dev->dig_P6) &&
read_register16(i2c_addr, 0x9a, (uint16_t *)&dev->dig_P7) && read_register16(&dev->i2c_dev, 0x9a, (uint16_t *)&dev->dig_P7) &&
read_register16(i2c_addr, 0x9c, (uint16_t *)&dev->dig_P8) && read_register16(&dev->i2c_dev, 0x9c, (uint16_t *)&dev->dig_P8) &&
read_register16(i2c_addr, 0x9e, (uint16_t *)&dev->dig_P9)) { read_register16(&dev->i2c_dev, 0x9e, (uint16_t *)&dev->dig_P9)) {
debug("Calibration data received:"); debug("Calibration data received:");
debug("dig_T1=%d", dev->dig_T1); debug("dig_T1=%d", dev->dig_T1);
@ -120,15 +118,14 @@ static bool read_calibration_data(bmp280_t *dev)
static bool read_hum_calibration_data(bmp280_t *dev) static bool read_hum_calibration_data(bmp280_t *dev)
{ {
uint8_t i2c_addr = dev->i2c_addr;
uint16_t h4, h5; uint16_t h4, h5;
if (!read_data(i2c_addr, 0xa1, &dev->dig_H1, 1) && if (!read_data(&dev->i2c_dev, 0xa1, &dev->dig_H1, 1) &&
read_register16(i2c_addr, 0xe1, (uint16_t *)&dev->dig_H2) && read_register16(&dev->i2c_dev, 0xe1, (uint16_t *)&dev->dig_H2) &&
!read_data(i2c_addr, 0xe3, &dev->dig_H3, 1) && !read_data(&dev->i2c_dev, 0xe3, &dev->dig_H3, 1) &&
read_register16(i2c_addr, 0xe4, &h4) && read_register16(&dev->i2c_dev, 0xe4, &h4) &&
read_register16(i2c_addr, 0xe5, &h5) && read_register16(&dev->i2c_dev, 0xe5, &h5) &&
!read_data(i2c_addr, 0xe7, (uint8_t *)&dev->dig_H6, 1)) { !read_data(&dev->i2c_dev, 0xe7, (uint8_t *)&dev->dig_H6, 1)) {
dev->dig_H4 = (h4 & 0x00ff) << 4 | (h4 & 0x0f00) >> 8; dev->dig_H4 = (h4 & 0x00ff) << 4 | (h4 & 0x0f00) >> 8;
dev->dig_H5 = h5 >> 4; dev->dig_H5 = h5 >> 4;
debug("Calibration data received:"); debug("Calibration data received:");
@ -144,21 +141,20 @@ static bool read_hum_calibration_data(bmp280_t *dev)
return false; return false;
} }
static int write_register8(uint8_t i2c_addr, uint8_t addr, uint8_t value) static int write_register8(i2c_dev_t* dev, uint8_t addr, uint8_t value)
{ {
return i2c_slave_write(i2c_addr, &addr, &value, 1); return i2c_slave_write(dev->bus, dev->addr, &addr, &value, 1);
} }
bool bmp280_init(bmp280_t *dev, bmp280_params_t *params) bool bmp280_init(bmp280_t *dev, bmp280_params_t *params)
{ {
uint8_t i2c_addr = dev->i2c_addr;
if (i2c_addr != BMP280_I2C_ADDRESS_0 && i2c_addr != BMP280_I2C_ADDRESS_1) { if (dev->i2c_dev.addr != BMP280_I2C_ADDRESS_0 && dev->i2c_dev.addr != BMP280_I2C_ADDRESS_1) {
debug("Invalid I2C address"); debug("Invalid I2C address");
return false; return false;
} }
if (read_data(i2c_addr, BMP280_REG_ID, &dev->id, 1)) { if (read_data(&dev->i2c_dev, BMP280_REG_ID, &dev->id, 1)) {
debug("Sensor not found"); debug("Sensor not found");
return false; return false;
} }
@ -169,7 +165,7 @@ bool bmp280_init(bmp280_t *dev, bmp280_params_t *params)
} }
// Soft reset. // Soft reset.
if (write_register8(i2c_addr, BMP280_REG_RESET, BMP280_RESET_VALUE)) { if (write_register8(&dev->i2c_dev, BMP280_REG_RESET, BMP280_RESET_VALUE)) {
debug("Failed resetting sensor"); debug("Failed resetting sensor");
return false; return false;
} }
@ -177,7 +173,7 @@ bool bmp280_init(bmp280_t *dev, bmp280_params_t *params)
// Wait until finished copying over the NVP data. // Wait until finished copying over the NVP data.
while (1) { while (1) {
uint8_t status; uint8_t status;
if (!read_data(i2c_addr, BMP280_REG_STATUS, &status, 1) && (status & 1) == 0) if (!read_data(&dev->i2c_dev, BMP280_REG_STATUS, &status, 1) && (status & 1) == 0)
break; break;
} }
@ -193,7 +189,7 @@ bool bmp280_init(bmp280_t *dev, bmp280_params_t *params)
uint8_t config = (params->standby << 5) | (params->filter << 2); uint8_t config = (params->standby << 5) | (params->filter << 2);
debug("Writing config reg=%x", config); debug("Writing config reg=%x", config);
if (write_register8(i2c_addr, BMP280_REG_CONFIG, config)) { if (write_register8(&dev->i2c_dev, BMP280_REG_CONFIG, config)) {
debug("Failed configuring sensor"); debug("Failed configuring sensor");
return false; return false;
} }
@ -210,14 +206,14 @@ bool bmp280_init(bmp280_t *dev, bmp280_params_t *params)
// Write crtl hum reg first, only active after write to BMP280_REG_CTRL. // Write crtl hum reg first, only active after write to BMP280_REG_CTRL.
uint8_t ctrl_hum = params->oversampling_humidity; uint8_t ctrl_hum = params->oversampling_humidity;
debug("Writing ctrl hum reg=%x", ctrl_hum); debug("Writing ctrl hum reg=%x", ctrl_hum);
if (write_register8(i2c_addr, BMP280_REG_CTRL_HUM, ctrl_hum)) { if (write_register8(&dev->i2c_dev, BMP280_REG_CTRL_HUM, ctrl_hum)) {
debug("Failed controlling sensor"); debug("Failed controlling sensor");
return false; return false;
} }
} }
debug("Writing ctrl reg=%x", ctrl); debug("Writing ctrl reg=%x", ctrl);
if (write_register8(i2c_addr, BMP280_REG_CTRL, ctrl)) { if (write_register8(&dev->i2c_dev, BMP280_REG_CTRL, ctrl)) {
debug("Failed controlling sensor"); debug("Failed controlling sensor");
return false; return false;
} }
@ -228,12 +224,12 @@ bool bmp280_init(bmp280_t *dev, bmp280_params_t *params)
bool bmp280_force_measurement(bmp280_t *dev) bool bmp280_force_measurement(bmp280_t *dev)
{ {
uint8_t ctrl; uint8_t ctrl;
if (read_data(dev->i2c_addr, BMP280_REG_CTRL, &ctrl, 1)) if (read_data(&dev->i2c_dev, BMP280_REG_CTRL, &ctrl, 1))
return false; return false;
ctrl &= ~0b11; // clear two lower bits ctrl &= ~0b11; // clear two lower bits
ctrl |= BMP280_MODE_FORCED; ctrl |= BMP280_MODE_FORCED;
debug("Writing ctrl reg=%x", ctrl); debug("Writing ctrl reg=%x", ctrl);
if (write_register8(dev->i2c_addr, BMP280_REG_CTRL, ctrl)) { if (write_register8(&dev->i2c_dev, BMP280_REG_CTRL, ctrl)) {
debug("Failed starting forced mode"); debug("Failed starting forced mode");
return false; return false;
} }
@ -243,7 +239,7 @@ bool bmp280_force_measurement(bmp280_t *dev)
bool bmp280_is_measuring(bmp280_t *dev) bool bmp280_is_measuring(bmp280_t *dev)
{ {
uint8_t status; uint8_t status;
if (read_data(dev->i2c_addr, BMP280_REG_STATUS, &status, 1)) if (read_data(&dev->i2c_dev, BMP280_REG_STATUS, &status, 1))
return false; return false;
if (status & (1 << 3)) { if (status & (1 << 3)) {
debug("Status: measuring"); debug("Status: measuring");
@ -345,7 +341,7 @@ bool bmp280_read_fixed(bmp280_t *dev, int32_t *temperature,
// Need to read in one sequence to ensure they match. // Need to read in one sequence to ensure they match.
size_t size = humidity ? 8 : 6; size_t size = humidity ? 8 : 6;
if (read_data(dev->i2c_addr, 0xf7, data, size)) { if (read_data(&dev->i2c_dev, 0xf7, data, size)) {
debug("Failed reading"); debug("Failed reading");
return false; return false;
} }

3
extras/bmp280/bmp280.h
View file

@ -26,6 +26,7 @@
#include <stdint.h> #include <stdint.h>
#include <stdbool.h> #include <stdbool.h>
#include "i2c/i2c.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
@ -127,7 +128,7 @@ typedef struct {
int16_t dig_H5; int16_t dig_H5;
int8_t dig_H6; int8_t dig_H6;
uint8_t i2c_addr; /* I2C address. */ i2c_dev_t i2c_dev; /* I2C dev setting. */
uint8_t id; /* Chip ID */ uint8_t id; /* Chip ID */
} bmp280_t; } bmp280_t;

60
extras/ds1307/ds1307.c
View file

@ -6,10 +6,8 @@
* BSD Licensed as described in the file LICENSE * BSD Licensed as described in the file LICENSE
*/ */
#include "ds1307.h" #include "ds1307.h"
#include <i2c/i2c.h>
#include <stdio.h> #include <stdio.h>
#define ADDR 0x68
#define RAM_SIZE 56 #define RAM_SIZE 56
#define TIME_REG 0 #define TIME_REG 0
@ -40,36 +38,36 @@ static uint8_t dec2bcd(uint8_t val)
return ((val / 10) << 4) + (val % 10); return ((val / 10) << 4) + (val % 10);
} }
static uint8_t read_register(uint8_t reg) static uint8_t read_register(i2c_dev_t* dev, uint8_t reg)
{ {
uint8_t val; uint8_t val;
i2c_slave_read(ADDR, &reg, &val, 1); i2c_slave_read(dev->bus, dev->addr, &reg, &val, 1);
return val; return val;
} }
static void update_register(uint8_t reg, uint8_t mask, uint8_t val) static void update_register(i2c_dev_t* dev, uint8_t reg, uint8_t mask, uint8_t val)
{ {
uint8_t buf = (read_register(reg) & mask) | val; uint8_t buf = (read_register(dev,reg) & mask) | val;
i2c_slave_write(ADDR, &reg, &buf, 1); i2c_slave_write(dev->bus, dev->addr, &reg, &buf, 1);
} }
void ds1307_start(bool start) void ds1307_start(i2c_dev_t* dev, bool start)
{ {
update_register(TIME_REG, CH_MASK, start ? 0 : CH_BIT); update_register(dev, TIME_REG, CH_MASK, start ? 0 : CH_BIT);
} }
bool ds1307_is_running() bool ds1307_is_running(i2c_dev_t* dev)
{ {
return !(read_register(TIME_REG) & CH_BIT); return !(read_register(dev, TIME_REG) & CH_BIT);
} }
void ds1307_get_time(struct tm *time) void ds1307_get_time(i2c_dev_t* dev, struct tm *time)
{ {
uint8_t buf[7]; uint8_t buf[7];
uint8_t reg = TIME_REG ; uint8_t reg = TIME_REG ;
i2c_slave_read(ADDR, &reg , buf, 7); i2c_slave_read(dev->bus, dev->addr, &reg , buf, 7);
time->tm_sec = bcd2dec(buf[0] & SECONDS_MASK); time->tm_sec = bcd2dec(buf[0] & SECONDS_MASK);
time->tm_min = bcd2dec(buf[1]); time->tm_min = bcd2dec(buf[1]);
@ -87,7 +85,7 @@ void ds1307_get_time(struct tm *time)
time->tm_year = bcd2dec(buf[6]) + 2000; time->tm_year = bcd2dec(buf[6]) + 2000;
} }
void ds1307_set_time(const struct tm *time) void ds1307_set_time(i2c_dev_t* dev, const struct tm *time)
{ {
uint8_t buf[8]; uint8_t buf[8];
buf[0] = TIME_REG; buf[0] = TIME_REG;
@ -99,51 +97,51 @@ void ds1307_set_time(const struct tm *time)
buf[6] = dec2bcd(time->tm_mon + 1); buf[6] = dec2bcd(time->tm_mon + 1);
buf[7] = dec2bcd(time->tm_year - 2000); buf[7] = dec2bcd(time->tm_year - 2000);
i2c_slave_write(ADDR, &buf[0], &buf[1] , 7); i2c_slave_write(dev->bus, dev->addr, &buf[0], &buf[1] , 7);
} }
void ds1307_enable_squarewave(bool enable) void ds1307_enable_squarewave(i2c_dev_t* dev, bool enable)
{ {
update_register(CONTROL_REG, SQWE_MASK, enable ? SQWE_BIT : 0); update_register(dev, CONTROL_REG, SQWE_MASK, enable ? SQWE_BIT : 0);
} }
bool ds1307_is_squarewave_enabled() bool ds1307_is_squarewave_enabled(i2c_dev_t* dev)
{ {
return read_register(CONTROL_REG) & SQWE_BIT; return read_register(dev, CONTROL_REG) & SQWE_BIT;
} }
void ds1307_set_squarewave_freq(ds1307_squarewave_freq_t freq) void ds1307_set_squarewave_freq(i2c_dev_t* dev, ds1307_squarewave_freq_t freq)
{ {
update_register(CONTROL_REG, SQWEF_MASK, (uint8_t)freq); update_register(dev, CONTROL_REG, SQWEF_MASK, (uint8_t)freq);
} }
ds1307_squarewave_freq_t ds1307_get_squarewave_freq() ds1307_squarewave_freq_t ds1307_get_squarewave_freq(i2c_dev_t* dev)
{ {
return (ds1307_squarewave_freq_t)(read_register(CONTROL_REG) & SQWEF_MASK); return (ds1307_squarewave_freq_t)(read_register(dev, CONTROL_REG) & SQWEF_MASK);
} }
bool ds1307_get_output() bool ds1307_get_output(i2c_dev_t* dev)
{ {
return read_register(CONTROL_REG) & OUT_BIT; return read_register(dev, CONTROL_REG) & OUT_BIT;
} }
void ds1307_set_output(bool value) void ds1307_set_output(i2c_dev_t* dev, bool value)
{ {
update_register(CONTROL_REG, OUT_MASK, value ? OUT_BIT : 0); update_register(dev, CONTROL_REG, OUT_MASK, value ? OUT_BIT : 0);
} }
int ds1307_read_ram(uint8_t offset, uint8_t *buf, uint8_t len) int ds1307_read_ram(i2c_dev_t* dev, uint8_t offset, uint8_t *buf, uint8_t len)
{ {
if (offset + len > RAM_SIZE) return false; if (offset + len > RAM_SIZE) return false;
uint8_t reg = RAM_REG + offset ; uint8_t reg = RAM_REG + offset ;
return i2c_slave_read(ADDR, &reg, buf, len); return i2c_slave_read(dev->bus, dev->addr, &reg, buf, len);
} }
int ds1307_write_ram(uint8_t offset, uint8_t *buf, uint8_t len) int ds1307_write_ram(i2c_dev_t* dev, uint8_t offset, uint8_t *buf, uint8_t len)
{ {
if (offset + len > RAM_SIZE) return false; if (offset + len > RAM_SIZE) return false;
uint8_t reg = RAM_REG + offset ; uint8_t reg = RAM_REG + offset ;
return i2c_slave_write(ADDR, &reg, buf, len); return i2c_slave_write(dev->bus, dev->addr, &reg, buf, len);
} }

26
extras/ds1307/ds1307.h
View file

@ -11,11 +11,13 @@
#include <stdint.h> #include <stdint.h>
#include <stdbool.h> #include <stdbool.h>
#include <time.h> #include <time.h>
#include <i2c/i2c.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#define DS1307_ADDR 0x68
/** /**
* Squarewave frequency * Squarewave frequency
*/ */
@ -31,62 +33,62 @@ typedef enum _ds1307_squarewave_freq_t
* \brief Start/stop clock * \brief Start/stop clock
* \param start Start clock if true * \param start Start clock if true
*/ */
void ds1307_start(bool start); void ds1307_start(i2c_dev_t* dev, bool start);
/** /**
* \brief Get current clock state * \brief Get current clock state
* \return true if clock running * \return true if clock running
*/ */
bool ds1307_is_running(); bool ds1307_is_running(i2c_dev_t* dev);
/** /**
* \brief Get current time * \brief Get current time
* \param time Pointer to the time struct to fill * \param time Pointer to the time struct to fill
*/ */
void ds1307_get_time(struct tm *time); void ds1307_get_time(i2c_dev_t* dev, struct tm *time);
/** /**
* \brief Set time to RTC * \brief Set time to RTC
* \param time Pointer to the time struct * \param time Pointer to the time struct
*/ */
void ds1307_set_time(const struct tm *time); void ds1307_set_time(i2c_dev_t* dev, const struct tm *time);
/** /**
* \brief Enable or disable square-wave oscillator output * \brief Enable or disable square-wave oscillator output
* \param enable Enable oscillator if true * \param enable Enable oscillator if true
*/ */
void ds1307_enable_squarewave(bool enable); void ds1307_enable_squarewave(i2c_dev_t* dev, bool enable);
/** /**
* \brief Get square-wave oscillator output * \brief Get square-wave oscillator output
* \return true if square-wave oscillator enabled * \return true if square-wave oscillator enabled
*/ */
bool ds1307_is_squarewave_enabled(); bool ds1307_is_squarewave_enabled(i2c_dev_t* dev);
/** /**
* \brief Set square-wave oscillator frequency * \brief Set square-wave oscillator frequency
* \param freq Frequency * \param freq Frequency
*/ */
void ds1307_set_squarewave_freq(ds1307_squarewave_freq_t freq); void ds1307_set_squarewave_freq(i2c_dev_t* dev, ds1307_squarewave_freq_t freq);
/** /**
* \brief Get current square-wave oscillator frequency * \brief Get current square-wave oscillator frequency
* \return Frequency * \return Frequency
*/ */
ds1307_squarewave_freq_t ds1307_get_squarewave_freq(); ds1307_squarewave_freq_t ds1307_get_squarewave_freq(i2c_dev_t* dev);
/** /**
* \brief Get current output level of the SQW/OUT pin * \brief Get current output level of the SQW/OUT pin
* \return true if high * \return true if high
*/ */
bool ds1307_get_output(); bool ds1307_get_output(i2c_dev_t* dev);
/** /**
* \brief Set output level of the SQW/OUT pin * \brief Set output level of the SQW/OUT pin
* Set output level if square-wave output is disabled * Set output level if square-wave output is disabled
* \param value High level if true * \param value High level if true
*/ */
void ds1307_set_output(bool value); void ds1307_set_output(i2c_dev_t* dev, bool value);
/** /**
* \brief Read RAM contents into the buffer * \brief Read RAM contents into the buffer
@ -95,7 +97,7 @@ void ds1307_set_output(bool value);
* \param len Bytes to read, 1..56 * \param len Bytes to read, 1..56
* \return Non-zero if error occured * \return Non-zero if error occured
*/ */
int ds1307_read_ram(uint8_t offset, uint8_t *buf, uint8_t len); int ds1307_read_ram(i2c_dev_t* dev, uint8_t offset, uint8_t *buf, uint8_t len);
/** /**
* \brief Write buffer to RTC RAM * \brief Write buffer to RTC RAM
@ -104,7 +106,7 @@ int ds1307_read_ram(uint8_t offset, uint8_t *buf, uint8_t len);
* \param len Bytes to write, 1..56 * \param len Bytes to write, 1..56
* \return Non-zero if error occured * \return Non-zero if error occured
*/ */
int ds1307_write_ram(uint8_t offset, uint8_t *buf, uint8_t len); int ds1307_write_ram(i2c_dev_t* dev, uint8_t offset, uint8_t *buf, uint8_t len);
#ifdef __cplusplus #ifdef __cplusplus

86
extras/hmc5883l/hmc5883l.c
View file

@ -6,10 +6,8 @@
* BSD Licensed as described in the file LICENSE * BSD Licensed as described in the file LICENSE
*/ */
#include "hmc5883l.h" #include "hmc5883l.h"
#include <i2c/i2c.h>
#include <espressif/esp_common.h> #include <espressif/esp_common.h>
#define ADDR 0x1e
#define REG_CR_A 0x00 #define REG_CR_A 0x00
#define REG_CR_B 0x01 #define REG_CR_B 0x01
@ -54,112 +52,112 @@ static const float gain_values [] = {
static float current_gain; static float current_gain;
static hmc5883l_operating_mode_t current_mode; static hmc5883l_operating_mode_t current_mode;
static inline void write_register(uint8_t reg, uint8_t val) static inline void write_register(i2c_dev_t* dev, uint8_t reg, uint8_t val)
{ {
i2c_slave_write(ADDR, &reg, &val, 1); i2c_slave_write(dev->bus, dev->addr, &reg, &val, 1);
} }
static inline uint8_t read_register(uint8_t reg) static inline uint8_t read_register(i2c_dev_t* dev, uint8_t reg)
{ {
uint8_t res; uint8_t res;
i2c_slave_read(ADDR, &reg, &res, 1); i2c_slave_read(dev->bus, dev->addr, &reg, &res, 1);
return res; return res;
} }
static inline void update_register(uint8_t reg, uint8_t mask, uint8_t val) static inline void update_register(i2c_dev_t* dev, uint8_t reg, uint8_t mask, uint8_t val)
{ {
write_register(reg, (read_register(reg) & mask) | val); write_register(dev, reg, (read_register(dev, reg) & mask) | val);
} }
bool hmc5883l_init() bool hmc5883l_init(i2c_dev_t* dev)
{ {
if (hmc5883l_get_id() != HMC5883L_ID) if (hmc5883l_get_id(dev) != HMC5883L_ID)
return false; return false;
current_gain = gain_values[hmc5883l_get_gain()]; current_gain = gain_values[hmc5883l_get_gain(dev)];
current_mode = hmc5883l_get_operating_mode(); current_mode = hmc5883l_get_operating_mode(dev);
return true; return true;
} }
uint32_t hmc5883l_get_id() uint32_t hmc5883l_get_id(i2c_dev_t* dev)
{ {
uint32_t res = 0; uint32_t res = 0;
uint8_t reg = REG_ID_A; uint8_t reg = REG_ID_A;
i2c_slave_read(ADDR, &reg, (uint8_t *)&res, 3); i2c_slave_read(dev->bus, dev->addr, &reg, (uint8_t *)&res, 3);
return res; return res;
} }
hmc5883l_operating_mode_t hmc5883l_get_operating_mode() hmc5883l_operating_mode_t hmc5883l_get_operating_mode(i2c_dev_t* dev)
{ {
uint8_t res = read_register(REG_MODE) & MASK_MD; uint8_t res = read_register(dev, REG_MODE) & MASK_MD;
return res == 0 ? HMC5883L_MODE_CONTINUOUS : HMC5883L_MODE_SINGLE; return res == 0 ? HMC5883L_MODE_CONTINUOUS : HMC5883L_MODE_SINGLE;
} }
void hmc5883l_set_operating_mode(hmc5883l_operating_mode_t mode) void hmc5883l_set_operating_mode(i2c_dev_t* dev, hmc5883l_operating_mode_t mode)
{ {
write_register(REG_MODE, mode); write_register(dev, REG_MODE, mode);
current_mode = mode; current_mode = mode;
} }
hmc5883l_samples_averaged_t hmc5883l_get_samples_averaged() hmc5883l_samples_averaged_t hmc5883l_get_samples_averaged(i2c_dev_t* dev)
{ {
return (read_register(REG_CR_A) & MASK_MA) >> BIT_MA; return (read_register(dev, REG_CR_A) & MASK_MA) >> BIT_MA;
} }
void hmc5883l_set_samples_averaged(hmc5883l_samples_averaged_t samples) void hmc5883l_set_samples_averaged(i2c_dev_t* dev, hmc5883l_samples_averaged_t samples)
{ {
update_register(REG_CR_A, MASK_MA, samples << BIT_MA); update_register(dev, REG_CR_A, MASK_MA, samples << BIT_MA);
} }
hmc5883l_data_rate_t hmc5883l_get_data_rate() hmc5883l_data_rate_t hmc5883l_get_data_rate(i2c_dev_t* dev)
{ {
return (read_register(REG_CR_A) & MASK_DO) >> BIT_DO; return (read_register(dev, REG_CR_A) & MASK_DO) >> BIT_DO;
} }
void hmc5883l_set_data_rate(hmc5883l_data_rate_t rate) void hmc5883l_set_data_rate(i2c_dev_t* dev, hmc5883l_data_rate_t rate)
{ {
update_register(REG_CR_A, MASK_DO, rate << BIT_DO); update_register(dev, REG_CR_A, MASK_DO, rate << BIT_DO);
} }
hmc5883l_bias_t hmc5883l_get_bias() hmc5883l_bias_t hmc5883l_get_bias(i2c_dev_t* dev)
{ {
return read_register(REG_CR_A) & MASK_MS; return read_register(dev, REG_CR_A) & MASK_MS;
} }
void hmc5883l_set_bias(hmc5883l_bias_t bias) void hmc5883l_set_bias(i2c_dev_t* dev, hmc5883l_bias_t bias)
{ {
update_register(REG_CR_A, MASK_MS, bias); update_register(dev, REG_CR_A, MASK_MS, bias);
} }
hmc5883l_gain_t hmc5883l_get_gain() hmc5883l_gain_t hmc5883l_get_gain(i2c_dev_t* dev)
{ {
return read_register(REG_CR_B) >> BIT_GN; return read_register(dev, REG_CR_B) >> BIT_GN;
} }
void hmc5883l_set_gain(hmc5883l_gain_t gain) void hmc5883l_set_gain(i2c_dev_t* dev, hmc5883l_gain_t gain)
{ {
write_register(REG_CR_B, gain << BIT_GN); write_register(dev, REG_CR_B, gain << BIT_GN);
current_gain = gain_values[gain]; current_gain = gain_values[gain];
} }
bool hmc5883l_data_is_locked() bool hmc5883l_data_is_locked(i2c_dev_t* dev)
{ {
return read_register(REG_STAT) & MASK_DL; return read_register(dev, REG_STAT) & MASK_DL;
} }
bool hmc5883l_data_is_ready() bool hmc5883l_data_is_ready(i2c_dev_t* dev)
{ {
return read_register(REG_STAT) & MASK_DR; return read_register(dev, REG_STAT) & MASK_DR;
} }
bool hmc5883l_get_raw_data(hmc5883l_raw_data_t *data) bool hmc5883l_get_raw_data(i2c_dev_t* dev, hmc5883l_raw_data_t *data)
{ {
if (current_mode == HMC5883L_MODE_SINGLE) if (current_mode == HMC5883L_MODE_SINGLE)
{ {
// overwrite mode register for measurement // overwrite mode register for measurement
hmc5883l_set_operating_mode(current_mode); hmc5883l_set_operating_mode(dev, current_mode);
// wait for data // wait for data
uint32_t start = sdk_system_get_time(); uint32_t start = sdk_system_get_time();
while (!hmc5883l_data_is_ready()) while (!hmc5883l_data_is_ready(dev))
{ {
if (timeout_expired(start, MEASUREMENT_TIMEOUT)) if (timeout_expired(start, MEASUREMENT_TIMEOUT))
return false; return false;
@ -167,7 +165,7 @@ bool hmc5883l_get_raw_data(hmc5883l_raw_data_t *data)
} }
uint8_t buf[6]; uint8_t buf[6];
uint8_t reg = REG_DX_H; uint8_t reg = REG_DX_H;
i2c_slave_read(ADDR, &reg, buf, 6); i2c_slave_read(dev->bus, dev->addr, &reg, buf, 6);
data->x = ((int16_t)buf[REG_DX_H - REG_DX_H] << 8) | buf[REG_DX_L - REG_DX_H]; data->x = ((int16_t)buf[REG_DX_H - REG_DX_H] << 8) | buf[REG_DX_L - REG_DX_H];
data->y = ((int16_t)buf[REG_DY_H - REG_DX_H] << 8) | buf[REG_DY_L - REG_DX_H]; data->y = ((int16_t)buf[REG_DY_H - REG_DX_H] << 8) | buf[REG_DY_L - REG_DX_H];
data->z = ((int16_t)buf[REG_DZ_H - REG_DX_H] << 8) | buf[REG_DZ_L - REG_DX_H]; data->z = ((int16_t)buf[REG_DZ_H - REG_DX_H] << 8) | buf[REG_DZ_L - REG_DX_H];
@ -181,11 +179,11 @@ void hmc5883l_raw_to_mg(const hmc5883l_raw_data_t *raw, hmc5883l_data_t *mg)
mg->z = raw->z * current_gain; mg->z = raw->z * current_gain;
} }
bool hmc5883l_get_data(hmc5883l_data_t *data) bool hmc5883l_get_data(i2c_dev_t* dev, hmc5883l_data_t *data)
{ {
hmc5883l_raw_data_t raw; hmc5883l_raw_data_t raw;
if (!hmc5883l_get_raw_data(&raw)) if (!hmc5883l_get_raw_data(dev, &raw))
return false; return false;
hmc5883l_raw_to_mg(&raw, data); hmc5883l_raw_to_mg(&raw, data);
return true; return true;

35
extras/hmc5883l/hmc5883l.h
View file

@ -10,12 +10,15 @@
#include <stdint.h> #include <stdint.h>
#include <stdbool.h> #include <stdbool.h>
#include <i2c/i2c.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" extern "C"
{ {
#endif #endif
#define HMC5883L_ADDR 0x1e
#define HMC5883L_ID 0x00333448 // "H43" #define HMC5883L_ID 0x00333448 // "H43"
/** /**
@ -101,82 +104,82 @@ typedef struct
* \brief Init device * \brief Init device
* \return false if error occured * \return false if error occured
*/ */
bool hmc5883l_init(); bool hmc5883l_init(i2c_dev_t* dev);
/** /**
* \brief Get device ID * \brief Get device ID
* Always returns 0x00333448 if IC functioning properly. * Always returns 0x00333448 if IC functioning properly.
* \return Device ID * \return Device ID
*/ */
uint32_t hmc5883l_get_id(); uint32_t hmc5883l_get_id(i2c_dev_t* dev);
/** /**
* \brief Get operating mode * \brief Get operating mode
* \return Measurement mode * \return Measurement mode
*/ */
hmc5883l_operating_mode_t hmc5883l_get_operating_mode(); hmc5883l_operating_mode_t hmc5883l_get_operating_mode(i2c_dev_t* dev);
/** /**
* \brief Set operating mode * \brief Set operating mode
* \param mode Measurement mode * \param mode Measurement mode
*/ */
void hmc5883l_set_operating_mode(hmc5883l_operating_mode_t mode); void hmc5883l_set_operating_mode(i2c_dev_t* dev, hmc5883l_operating_mode_t mode);
/** /**
* \brief Get number of samples averaged per measurement output * \brief Get number of samples averaged per measurement output
* \return Number of samples * \return Number of samples
*/ */
hmc5883l_samples_averaged_t hmc5883l_get_samples_averaged(); hmc5883l_samples_averaged_t hmc5883l_get_samples_averaged(i2c_dev_t* dev);
/** /**
* \brief Set number of samples averaged per measurement output * \brief Set number of samples averaged per measurement output
* \param samples Number of samples * \param samples Number of samples
*/ */
void hmc5883l_set_samples_averaged(hmc5883l_samples_averaged_t samples); void hmc5883l_set_samples_averaged(i2c_dev_t* dev, hmc5883l_samples_averaged_t samples);
/** /**
* \brief Get data output rate in continuous measurement mode * \brief Get data output rate in continuous measurement mode
* \return Data output rate * \return Data output rate
*/ */
hmc5883l_data_rate_t hmc5883l_get_data_rate(); hmc5883l_data_rate_t hmc5883l_get_data_rate(i2c_dev_t* dev);
/** /**
* \brief Set data output rate in continuous measurement mode * \brief Set data output rate in continuous measurement mode
* \param rate Data output rate * \param rate Data output rate
*/ */
void hmc5883l_set_data_rate(hmc5883l_data_rate_t rate); void hmc5883l_set_data_rate(i2c_dev_t* dev, hmc5883l_data_rate_t rate);
/** /**
* \brief Get measurement mode (bias of the axes) * \brief Get measurement mode (bias of the axes)
* See datasheet for self test description * See datasheet for self test description
* \return Bias * \return Bias
*/ */
hmc5883l_bias_t hmc5883l_get_bias(); hmc5883l_bias_t hmc5883l_get_bias(i2c_dev_t* dev);
/** /**
* \brief Set measurement mode (bias of the axes) * \brief Set measurement mode (bias of the axes)
* See datasheet for self test description * See datasheet for self test description
* \param bias Bias * \param bias Bias
*/ */
void hmc5883l_set_bias(hmc5883l_bias_t bias); void hmc5883l_set_bias(i2c_dev_t* dev, hmc5883l_bias_t bias);
/** /**
* \brief Get device gain * \brief Get device gain
* \return Current gain * \return Current gain
*/ */
hmc5883l_gain_t hmc5883l_get_gain(); hmc5883l_gain_t hmc5883l_get_gain(i2c_dev_t* dev);
/** /**
* \brief Set device gain * \brief Set device gain
* \param gain Gain * \param gain Gain
*/ */
void hmc5883l_set_gain(hmc5883l_gain_t gain); void hmc5883l_set_gain(i2c_dev_t* dev, hmc5883l_gain_t gain);
/** /**
* \brief Get data state * \brief Get data state
* \return true when data is written to all six data registers * \return true when data is written to all six data registers
*/ */
bool hmc5883l_data_is_ready(); bool hmc5883l_data_is_ready(i2c_dev_t* dev);
/** /**
* \brief Get lock state. * \brief Get lock state.
@ -188,14 +191,14 @@ bool hmc5883l_data_is_ready();
* 4. power is reset. * 4. power is reset.
* \return true when data registers is locked * \return true when data registers is locked
*/ */
bool hmc5883l_data_is_locked(); bool hmc5883l_data_is_locked(i2c_dev_t* dev);
/** /**
* \brief Get raw magnetic data * \brief Get raw magnetic data
* \param data Pointer to the struct to write raw data * \param data Pointer to the struct to write raw data
* \return false if error occured in single measurement mode, always true in continuous mode * \return false if error occured in single measurement mode, always true in continuous mode
*/ */
bool hmc5883l_get_raw_data(hmc5883l_raw_data_t *data); bool hmc5883l_get_raw_data(i2c_dev_t* dev, hmc5883l_raw_data_t *data);
/** /**
* \brief Convert raw magnetic data to milligausses * \brief Convert raw magnetic data to milligausses
@ -209,7 +212,7 @@ void hmc5883l_raw_to_mg(const hmc5883l_raw_data_t *raw, hmc5883l_data_t *mg);
* \param data Pointer to the struct to write data * \param data Pointer to the struct to write data
* \return false if error occured in single measurement mode, always true in continuous mode * \return false if error occured in single measurement mode, always true in continuous mode
*/ */
bool hmc5883l_get_data(hmc5883l_data_t *data); bool hmc5883l_get_data(i2c_dev_t* dev, hmc5883l_data_t *data);
#ifdef __cplusplus #ifdef __cplusplus
} }