alexey.zholtikov/upm
1
0
Fork 0
mirror of https://github.com/eclipse/upm.git synced 2025-07-05 11:21:12 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

bh17xx: minor documentation and formatting updates, added rohm to vendor groups

Browse Source 
Signed-off-by: Mihai Tudor Panu <mihai.tudor.panu@intel.com>
This commit is contained in:
Mihai Tudor Panu
2018-08-09 16:11:51 -07:00
parent 4935a16530
commit 89e2ec870a
18 changed files with 1843 additions and 1839 deletions
Download Patch File Download Diff File Expand all files Collapse all files

686
src/bh1749/bh1749.c
View File

@ -34,7 +34,7 @@
/**
* @brief Reads the value of a register
*
*
* @param dev The sensor context
* @param reg Register address
* @param data Pointer of uint8_t to save register value
@ -42,19 +42,19 @@
*/
static upm_result_t bh1749_read_register(bh1749_context dev, uint8_t reg, uint8_t *data)
{
uint8_t value = mraa_i2c_read_byte_data(dev->i2c, reg);
if(value < 0) {
printf("%s: mraa_i2c_read_byte_data() failed\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
uint8_t value = mraa_i2c_read_byte_data(dev->i2c, reg);
if(value < 0) {
printf("%s: mraa_i2c_read_byte_data() failed\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
*data = value;
return UPM_SUCCESS;
*data = value;
return UPM_SUCCESS;
}
/**
* @brief Reads the values of a set of registers
*
*
* @param dev The sensor context
* @param reg Register address
* @param data Pointer of uint8_t to save registers values
@ -62,22 +62,22 @@ static upm_result_t bh1749_read_register(bh1749_context dev, uint8_t reg, uint8_
*/
static upm_result_t bh1749_read_registers(bh1749_context dev, uint8_t reg, uint8_t *data, uint8_t len)
{
uint8_t value;
uint8_t value;
for(int i = 0; i < len; i++) {
if(bh1749_read_register(dev, reg + i, &value) != UPM_SUCCESS) {
return UPM_ERROR_OPERATION_FAILED;
}
for(int i = 0; i < len; i++) {
if(bh1749_read_register(dev, reg + i, &value) != UPM_SUCCESS) {
return UPM_ERROR_OPERATION_FAILED;
}
*(data + i) = value;
}
*(data + i) = value;
}
return UPM_SUCCESS;
}
/**
* @brief Writes a value to a register
*
*
* @param dev The sensor context
* @param value Value to write
* @param reg Register address
@ -85,17 +85,17 @@ static upm_result_t bh1749_read_registers(bh1749_context dev, uint8_t reg, uint8
*/
static upm_result_t bh1749_write_register(bh1749_context dev, uint8_t value, uint8_t reg)
{
if (mraa_i2c_write_byte_data(dev->i2c, value, reg) != MRAA_SUCCESS) {
printf("%s: mraa_i2c_write_byte_data() failed\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
if (mraa_i2c_write_byte_data(dev->i2c, value, reg) != MRAA_SUCCESS) {
printf("%s: mraa_i2c_write_byte_data() failed\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
return UPM_SUCCESS;
return UPM_SUCCESS;
}
/**
* @brief Sets a bit on in a register with a bit mask
*
*
* @param dev The sensor context
* @param reg Register address
* @param bit_mask Mask to use
@ -103,14 +103,14 @@ static upm_result_t bh1749_write_register(bh1749_context dev, uint8_t value, uin
*/
static upm_result_t bh1749_set_bit_on(bh1749_context dev, uint8_t reg, uint8_t bit_mask)
{
uint8_t reg_value;
int status;
uint8_t reg_value;
int status;
status = bh1749_read_register(dev, reg, &reg_value);
if(status < 0) {
printf("%s: Failed to read register 0x%2X\n", __FUNCTION__, reg);
return UPM_ERROR_OPERATION_FAILED;
}
status = bh1749_read_register(dev, reg, &reg_value);
if(status < 0) {
printf("%s: Failed to read register 0x%2X\n", __FUNCTION__, reg);
return UPM_ERROR_OPERATION_FAILED;
}
reg_value |= bit_mask;
return bh1749_write_register(dev, reg_value, reg);
@ -118,7 +118,7 @@ static upm_result_t bh1749_set_bit_on(bh1749_context dev, uint8_t reg, uint8_t b
/**
* @brief Sets a bit off in a register with a bit mask
*
*
* @param dev The sensor context
* @param reg Register address
* @param bit_mask Mask to use
@ -126,14 +126,14 @@ static upm_result_t bh1749_set_bit_on(bh1749_context dev, uint8_t reg, uint8_t b
*/
static upm_result_t bh1749_set_bit_off(bh1749_context dev, uint8_t reg, uint8_t bit_mask)
{
uint8_t reg_value;
int status;
uint8_t reg_value;
int status;
status = bh1749_read_register(dev, reg, &reg_value);
if(status < 0) {
printf("%s: Failed to read register 0x%2X\n", __FUNCTION__, reg);
return UPM_ERROR_OPERATION_FAILED;
}
status = bh1749_read_register(dev, reg, &reg_value);
if(status < 0) {
printf("%s: Failed to read register 0x%2X\n", __FUNCTION__, reg);
return UPM_ERROR_OPERATION_FAILED;
}
reg_value &= ~bit_mask;
return bh1749_write_register(dev, reg_value, reg);
@ -141,7 +141,7 @@ static upm_result_t bh1749_set_bit_off(bh1749_context dev, uint8_t reg, uint8_t
/**
* @brief Sets the value of a register as a given pattern with a bit mask
*
*
* @param dev The sensor context
* @param reg Register address
* @param value Value to write
@ -150,45 +150,45 @@ static upm_result_t bh1749_set_bit_off(bh1749_context dev, uint8_t reg, uint8_t
*/
static upm_result_t bh1749_set_bits_with_mask(bh1749_context dev, uint8_t reg, uint8_t value, uint8_t bit_mask)
{
uint8_t reg_value;
int status;
uint8_t reg_value;
int status;
status = bh1749_read_register(dev, reg, &reg_value);
if(status < 0) {
printf("%s: Failed to read register 0x%2X\n", __FUNCTION__, reg);
return UPM_ERROR_OPERATION_FAILED;
}
status = bh1749_read_register(dev, reg, &reg_value);
if(status < 0) {
printf("%s: Failed to read register 0x%2X\n", __FUNCTION__, reg);
return UPM_ERROR_OPERATION_FAILED;
}
reg_value &= ~bit_mask;
reg_value |= value;
return bh1749_write_register(dev, reg_value, reg);
reg_value |= value;
return bh1749_write_register(dev, reg_value, reg);
}
upm_result_t bh1749_check_who_am_i(bh1749_context dev)
{
uint8_t partId;
if(bh1749_read_register(dev, BH1749_SYSTEM_CONTROL, &partId) != UPM_SUCCESS)
return UPM_ERROR_OPERATION_FAILED;
uint8_t partId;
if(bh1749_read_register(dev, BH1749_SYSTEM_CONTROL, &partId) != UPM_SUCCESS)
return UPM_ERROR_OPERATION_FAILED;
partId &= BH1749_SYSTEM_CONTROL_PART_MASK;
if(partId != BH1749_SYSTEM_CONTROL_PART_ID) {
printf("%s: wrong manufacturer ID\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
partId &= BH1749_SYSTEM_CONTROL_PART_MASK;
if(partId != BH1749_SYSTEM_CONTROL_PART_ID) {
printf("%s: wrong manufacturer ID\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
return UPM_SUCCESS;
return UPM_SUCCESS;
}
bh1749_context bh1749_init(int bus, int addr)
{
bh1749_context dev = (bh1749_context)malloc(sizeof(struct _bh1749_context));
if (!dev)
bh1749_context dev = (bh1749_context)malloc(sizeof(struct _bh1749_context));
if (!dev)
return NULL;
dev->i2c = NULL;
dev->i2c = NULL;
dev->interrupt = NULL;
if (mraa_init() != MRAA_SUCCESS) {
if (mraa_init() != MRAA_SUCCESS) {
printf("%s: mraa_init() failed.\n", __FUNCTION__);
bh1749_close(dev);
return NULL;
@ -206,452 +206,452 @@ bh1749_context bh1749_init(int bus, int addr)
return NULL;
}
if(bh1749_check_who_am_i(dev) != UPM_SUCCESS)
return NULL;
if(bh1749_check_who_am_i(dev) != UPM_SUCCESS)
return NULL;
dev->enabled = false;
dev->isrEnabled = false;
if(bh1749_sensor_init(dev, DEFAULT_OP_MODE, DEFAULT_MEAS_TIME,
DEFAULT_RGB_GAIN, DEFAULT_IR_GAIN, DEFAULT_INT_SOURCE) != UPM_SUCCESS)
return NULL;
bh1749_set_threshold_high(dev, DEFUALT_THRESHOLD_HIGH);
dev->enabled = false;
dev->isrEnabled = false;
if(bh1749_sensor_init(dev, DEFAULT_OP_MODE, DEFAULT_MEAS_TIME,
DEFAULT_RGB_GAIN, DEFAULT_IR_GAIN, DEFAULT_INT_SOURCE) != UPM_SUCCESS)
return NULL;
bh1749_set_threshold_high(dev, DEFUALT_THRESHOLD_HIGH);
return dev;
return dev;
}
void bh1749_close(bh1749_context dev)
{
if(dev->isrEnabled)
bh1749_remove_isr(dev);
if(dev->isrEnabled)
bh1749_remove_isr(dev);
if (dev->i2c)
mraa_i2c_stop(dev->i2c);
free(dev);
free(dev);
}
upm_result_t bh1749_enable(bh1749_context dev)
{
int status;
int status;
status = bh1749_set_bit_on(dev, BH1749_MODE_CONTROL2,
BH1749_MODE_CONTROL2_RGB_MEASUREMENT_MASK);
if(status != UPM_SUCCESS) {
printf("%s: Failed to bh1749_enable RGB measurement\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
dev->enabled = true;
status = bh1749_set_bit_on(dev, BH1749_MODE_CONTROL2,
BH1749_MODE_CONTROL2_RGB_MEASUREMENT_MASK);
if(status != UPM_SUCCESS) {
printf("%s: Failed to bh1749_enable RGB measurement\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
dev->enabled = true;
return UPM_SUCCESS;
return UPM_SUCCESS;
}
upm_result_t bh1749_disable(bh1749_context dev)
{
int status;
int status;
status = bh1749_set_bit_off(dev, BH1749_MODE_CONTROL2,
BH1749_MODE_CONTROL2_RGB_MEASUREMENT_MASK);
if(status != UPM_SUCCESS) {
printf("%s: Failed to bh1749_disable RGB measurement\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
dev->enabled = false;
status = bh1749_set_bit_off(dev, BH1749_MODE_CONTROL2,
BH1749_MODE_CONTROL2_RGB_MEASUREMENT_MASK);
if(status != UPM_SUCCESS) {
printf("%s: Failed to bh1749_disable RGB measurement\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
dev->enabled = false;
return UPM_SUCCESS;
return UPM_SUCCESS;
}
upm_result_t bh1749_sensor_init(bh1749_context dev, OPERATING_MODES opMode,
MEAS_TIMES measTime,
RGB_GAINS rgbGain,
IR_GAINS irGain,
INT_SOURCES intSource)
MEAS_TIMES measTime,
RGB_GAINS rgbGain,
IR_GAINS irGain,
INT_SOURCES intSource)
{
if(bh1749_set_operating_mode(dev, opMode) != UPM_SUCCESS)
return UPM_ERROR_OPERATION_FAILED;
if(bh1749_set_measurement_time(dev, measTime) != UPM_SUCCESS)
return UPM_ERROR_OPERATION_FAILED;
if(bh1749_set_rgb_gain(dev, rgbGain) != UPM_SUCCESS)
return UPM_ERROR_OPERATION_FAILED;
if(bh1749_set_ir_gain(dev, irGain) != UPM_SUCCESS)
return UPM_ERROR_OPERATION_FAILED;
return bh1749_set_int_source(dev, intSource);
if(bh1749_set_operating_mode(dev, opMode) != UPM_SUCCESS)
return UPM_ERROR_OPERATION_FAILED;
if(bh1749_set_measurement_time(dev, measTime) != UPM_SUCCESS)
return UPM_ERROR_OPERATION_FAILED;
if(bh1749_set_rgb_gain(dev, rgbGain) != UPM_SUCCESS)
return UPM_ERROR_OPERATION_FAILED;
if(bh1749_set_ir_gain(dev, irGain) != UPM_SUCCESS)
return UPM_ERROR_OPERATION_FAILED;
return bh1749_set_int_source(dev, intSource);
}
upm_result_t bh1749_set_operating_mode(bh1749_context dev, OPERATING_MODES opMode)
{
if(bh1749_write_register(dev, opMode, BH1749_PERSISTENCE) != UPM_SUCCESS) {
printf("%s: Setting operating mode failed\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
dev->operating_mode = opMode;
if(bh1749_write_register(dev, opMode, BH1749_PERSISTENCE) != UPM_SUCCESS) {
printf("%s: Setting operating mode failed\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
dev->operating_mode = opMode;
return UPM_SUCCESS;
return UPM_SUCCESS;
}
upm_result_t bh1749_get_operating_mode(bh1749_context dev, uint8_t *opMode)
{
uint8_t value;
uint8_t value;
if(bh1749_read_register(dev, BH1749_PERSISTENCE, &value) != UPM_SUCCESS) {
printf("%s: Failed to read operating mode\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
if(bh1749_read_register(dev, BH1749_PERSISTENCE, &value) != UPM_SUCCESS) {
printf("%s: Failed to read operating mode\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
value &= BH1749_PERSISTENCE_MODE_MASK;
if(value != INT_JUDGE_0 && value != INT_JUDGE_1 &&
value != INT_JUDGE_4 && value != INT_JUDGE_4) {
printf("%s: Returned invalid mode\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
value &= BH1749_PERSISTENCE_MODE_MASK;
if(value != INT_JUDGE_0 && value != INT_JUDGE_1 &&
value != INT_JUDGE_4 && value != INT_JUDGE_4) {
printf("%s: Returned invalid mode\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
*opMode = value;
*opMode = value;
return UPM_SUCCESS;
return UPM_SUCCESS;
}
upm_result_t bh1749_set_measurement_time(bh1749_context dev, MEAS_TIMES measTime)
{
if(bh1749_set_bits_with_mask(dev, BH1749_MODE_CONTROL1, measTime,
BH1749_MODE_CONTROL1_ODR_MASK) != UPM_SUCCESS) {
printf("%s: Failed setting measurement time\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
dev->meas_time = measTime;
if(bh1749_set_bits_with_mask(dev, BH1749_MODE_CONTROL1, measTime,
BH1749_MODE_CONTROL1_ODR_MASK) != UPM_SUCCESS) {
printf("%s: Failed setting measurement time\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
dev->meas_time = measTime;
return UPM_SUCCESS;
return UPM_SUCCESS;
}
upm_result_t bh1749_get_measurement_time(bh1749_context dev, uint8_t *meas_time)
{
uint8_t time_reg;
uint8_t time_reg;
if(bh1749_read_register(dev, BH1749_MODE_CONTROL1, &time_reg) != UPM_SUCCESS) {
printf("%s: Failed to read measurement time\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
if(bh1749_read_register(dev, BH1749_MODE_CONTROL1, &time_reg) != UPM_SUCCESS) {
printf("%s: Failed to read measurement time\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
time_reg &= BH1749_MODE_CONTROL1_ODR_MASK;
if(time_reg == MEAS_35MS)
*meas_time = 35;
else if(time_reg == MEAS_120MS)
*meas_time = 120;
else if(time_reg == MEAS_240MS)
*meas_time = 240;
else {
printf("%s: Returned invalid time\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
time_reg &= BH1749_MODE_CONTROL1_ODR_MASK;
if(time_reg == MEAS_35MS)
*meas_time = 35;
else if(time_reg == MEAS_120MS)
*meas_time = 120;
else if(time_reg == MEAS_240MS)
*meas_time = 240;
else {
printf("%s: Returned invalid time\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
return UPM_SUCCESS;
return UPM_SUCCESS;
}
upm_result_t bh1749_set_rgb_gain(bh1749_context dev, RGB_GAINS rgbGain)
{
if(bh1749_set_bits_with_mask(dev, BH1749_MODE_CONTROL1, rgbGain,
BH1749_MODE_CONTROL1_RGB_GAIN_MASK) != UPM_SUCCESS) {
printf("%s: Failed setting RGB gain\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
dev->rgb_gain = rgbGain;
if(bh1749_set_bits_with_mask(dev, BH1749_MODE_CONTROL1, rgbGain,
BH1749_MODE_CONTROL1_RGB_GAIN_MASK) != UPM_SUCCESS) {
printf("%s: Failed setting RGB gain\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
dev->rgb_gain = rgbGain;
return UPM_SUCCESS;
return UPM_SUCCESS;
}
upm_result_t bh1749_get_rgb_gain(bh1749_context dev, uint8_t *gain)
{
uint8_t rgb_gain;
uint8_t rgb_gain;
if(bh1749_read_register(dev, BH1749_MODE_CONTROL1, &rgb_gain) != UPM_SUCCESS) {
printf("%s: Failed to read rgb gain\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
if(bh1749_read_register(dev, BH1749_MODE_CONTROL1, &rgb_gain) != UPM_SUCCESS) {
printf("%s: Failed to read rgb gain\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
rgb_gain &= BH1749_MODE_CONTROL1_RGB_GAIN_MASK;
if(rgb_gain == RGB_GAIN_1X)
*gain = 1;
else if(rgb_gain == RGB_GAIN_32X)
*gain = 32;
else {
printf("%s: Returned invalid gain\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
rgb_gain &= BH1749_MODE_CONTROL1_RGB_GAIN_MASK;
if(rgb_gain == RGB_GAIN_1X)
*gain = 1;
else if(rgb_gain == RGB_GAIN_32X)
*gain = 32;
else {
printf("%s: Returned invalid gain\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
return UPM_SUCCESS;
return UPM_SUCCESS;
}
upm_result_t bh1749_set_ir_gain(bh1749_context dev, IR_GAINS irGain)
{
if(bh1749_set_bits_with_mask(dev, BH1749_MODE_CONTROL1, irGain,
BH1749_MODE_CONTROL1_IR_GAIN_MASK) != UPM_SUCCESS) {
printf("%s: Failed setting IR gain\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
dev->ir_gain = irGain;
if(bh1749_set_bits_with_mask(dev, BH1749_MODE_CONTROL1, irGain,
BH1749_MODE_CONTROL1_IR_GAIN_MASK) != UPM_SUCCESS) {
printf("%s: Failed setting IR gain\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
dev->ir_gain = irGain;
return UPM_SUCCESS;
return UPM_SUCCESS;
}
upm_result_t bh1749_get_ir_gain(bh1749_context dev, uint8_t *gain)
{
uint8_t ir_gain;
uint8_t ir_gain;
if(bh1749_read_register(dev, BH1749_MODE_CONTROL1, &ir_gain) != UPM_SUCCESS) {
printf("%s: Failed to read rgb gain\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
if(bh1749_read_register(dev, BH1749_MODE_CONTROL1, &ir_gain) != UPM_SUCCESS) {
printf("%s: Failed to read rgb gain\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
ir_gain &= BH1749_MODE_CONTROL1_IR_GAIN_MASK;
if(ir_gain == IR_GAIN_1X)
*gain = 1;
else if(ir_gain == IR_GAIN_32X)
*gain = 32;
else {
printf("%s: Returned invalid gain\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
ir_gain &= BH1749_MODE_CONTROL1_IR_GAIN_MASK;
if(ir_gain == IR_GAIN_1X)
*gain = 1;
else if(ir_gain == IR_GAIN_32X)
*gain = 32;
else {
printf("%s: Returned invalid gain\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
return UPM_SUCCESS;
return UPM_SUCCESS;
}
upm_result_t bh1749_set_int_source(bh1749_context dev, INT_SOURCES intSource)
{
if(bh1749_set_bits_with_mask(dev, BH1749_INTERRUPT, intSource,
BH1749_INTERRUPT_SOURCE_MASK) != UPM_SUCCESS) {
printf("%s: Failed setting interrupt source gain\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
dev->int_src = intSource;
if(bh1749_set_bits_with_mask(dev, BH1749_INTERRUPT, intSource,
BH1749_INTERRUPT_SOURCE_MASK) != UPM_SUCCESS) {
printf("%s: Failed setting interrupt source gain\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
dev->int_src = intSource;
return UPM_SUCCESS;
return UPM_SUCCESS;
}
char bh1749_get_interrupt_source_char(bh1749_context dev)
{
char intSourceChar = ' ';
uint8_t intSource;
if(bh1749_read_register(dev, BH1749_INTERRUPT, &intSource) != UPM_SUCCESS) {
printf("%s: Failed to read interrupt source\n", __FUNCTION__);
return intSourceChar;
}
intSource &= BH1749_INTERRUPT_SOURCE_MASK;
if(intSource == RED)
intSourceChar = 'r';
else if(intSource == GREEN)
intSourceChar = 'g';
else if(intSource == BLUE)
intSourceChar = 'b';
else {
printf("%s: Returned invalid interrupt source\n", __FUNCTION__);
return intSourceChar;
}
char intSourceChar = ' ';
uint8_t intSource;
return intSourceChar;
if(bh1749_read_register(dev, BH1749_INTERRUPT, &intSource) != UPM_SUCCESS) {
printf("%s: Failed to read interrupt source\n", __FUNCTION__);
return intSourceChar;
}
intSource &= BH1749_INTERRUPT_SOURCE_MASK;
if(intSource == RED)
intSourceChar = 'r';
else if(intSource == GREEN)
intSourceChar = 'g';
else if(intSource == BLUE)
intSourceChar = 'b';
else {
printf("%s: Returned invalid interrupt source\n", __FUNCTION__);
return intSourceChar;
}
return intSourceChar;
}
upm_result_t bh1749_enable_interrupt(bh1749_context dev)
{
if(bh1749_set_bit_on(dev, BH1749_INTERRUPT, BH1749_INTERRUPT_EN_MASK) != UPM_SUCCESS)
return UPM_ERROR_OPERATION_FAILED;
return bh1749_reset_interrupt(dev);
if(bh1749_set_bit_on(dev, BH1749_INTERRUPT, BH1749_INTERRUPT_EN_MASK) != UPM_SUCCESS)
return UPM_ERROR_OPERATION_FAILED;
return bh1749_reset_interrupt(dev);
}
upm_result_t bh1749_disable_interrupt(bh1749_context dev)
{
return bh1749_set_bit_off(dev, BH1749_INTERRUPT, BH1749_INTERRUPT_EN_MASK);
return bh1749_set_bit_off(dev, BH1749_INTERRUPT, BH1749_INTERRUPT_EN_MASK);
}
upm_result_t bh1749_reset_interrupt(bh1749_context dev)
{
return bh1749_set_bit_on(dev, BH1749_SYSTEM_CONTROL, BH1749_SYSTEM_CONTROL_INT_RESET);
return bh1749_set_bit_on(dev, BH1749_SYSTEM_CONTROL, BH1749_SYSTEM_CONTROL_INT_RESET);
}
bool bh1749_is_interrupted(bh1749_context dev)
{
uint8_t intStatus;
uint8_t intStatus;
if(bh1749_read_register(dev, BH1749_INTERRUPT, &intStatus) != UPM_SUCCESS) {
printf("%s: Failed to read interrupt status\n", __FUNCTION__);
return false;
}
if(bh1749_read_register(dev, BH1749_INTERRUPT, &intStatus) != UPM_SUCCESS) {
printf("%s: Failed to read interrupt status\n", __FUNCTION__);
return false;
}
intStatus &= BH1749_INTERRUPT_STATUS_MASK;
if(intStatus != BH1749_INTERRUPT_STATUS_ACTIVE)
return false;
intStatus &= BH1749_INTERRUPT_STATUS_MASK;
if(intStatus != BH1749_INTERRUPT_STATUS_ACTIVE)
return false;
return true;
return true;
}
bool bh1749_is_interrupt_enabled(bh1749_context dev)
{
uint8_t intStatus;
uint8_t intStatus;
if(bh1749_read_register(dev, BH1749_INTERRUPT, &intStatus) != UPM_SUCCESS) {
printf("%s: Failed to read interrupt enabled\n", __FUNCTION__);
return false;
}
if(bh1749_read_register(dev, BH1749_INTERRUPT, &intStatus) != UPM_SUCCESS) {
printf("%s: Failed to read interrupt enabled\n", __FUNCTION__);
return false;
}
intStatus &= BH1749_INTERRUPT_EN_MASK;
if(intStatus != BH1749_INTERRUPT_EN_ENABLE)
return false;
intStatus &= BH1749_INTERRUPT_EN_MASK;
if(intStatus != BH1749_INTERRUPT_EN_ENABLE)
return false;
return true;
return true;
}
upm_result_t bh1749_soft_reset(bh1749_context dev)
{
return bh1749_set_bit_on(dev, BH1749_SYSTEM_CONTROL, BH1749_SYSTEM_CONTROL_SW_RESET_MASK);
return bh1749_set_bit_on(dev, BH1749_SYSTEM_CONTROL, BH1749_SYSTEM_CONTROL_SW_RESET_MASK);
}
upm_result_t bh1749_set_threshold_high(bh1749_context dev, uint16_t threshold)
{
if(bh1749_write_register(dev, threshold, BH1749_TH_LSBS) != UPM_SUCCESS ||
bh1749_write_register(dev, threshold >> 8, BH1749_TH_MSBS) != UPM_SUCCESS) {
printf("%s: Failed to write high threshold\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
dev->int_thh = threshold;
if(bh1749_write_register(dev, threshold, BH1749_TH_LSBS) != UPM_SUCCESS ||
bh1749_write_register(dev, threshold >> 8, BH1749_TH_MSBS) != UPM_SUCCESS) {
printf("%s: Failed to write high threshold\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
dev->int_thh = threshold;
return UPM_SUCCESS;
return UPM_SUCCESS;
}
upm_result_t bh1749_get_threshold_high(bh1749_context dev, uint16_t *threshold)
{
uint8_t data[2];
uint8_t data[2];
if(bh1749_read_register(dev, BH1749_TH_MSBS, &data[0]) ||
bh1749_read_register(dev, BH1749_TH_LSBS, &data[1]) != UPM_SUCCESS)
return UPM_ERROR_OPERATION_FAILED;
if(bh1749_read_register(dev, BH1749_TH_MSBS, &data[0]) ||
bh1749_read_register(dev, BH1749_TH_LSBS, &data[1]) != UPM_SUCCESS)
return UPM_ERROR_OPERATION_FAILED;
*threshold = data[0] << 8 | data[1];
return UPM_SUCCESS;
*threshold = data[0] << 8 | data[1];
return UPM_SUCCESS;
}
upm_result_t bh1749_set_threshold_low(bh1749_context dev, uint16_t threshold)
{
if(bh1749_write_register(dev, threshold, BH1749_TL_LSBS) != UPM_SUCCESS ||
bh1749_write_register(dev, threshold >> 8, BH1749_TL_MSBS) != UPM_SUCCESS) {
printf("%s: Failed to write low threshold\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
dev->int_thl = threshold;
if(bh1749_write_register(dev, threshold, BH1749_TL_LSBS) != UPM_SUCCESS ||
bh1749_write_register(dev, threshold >> 8, BH1749_TL_MSBS) != UPM_SUCCESS) {
printf("%s: Failed to write low threshold\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
dev->int_thl = threshold;
return UPM_SUCCESS;
return UPM_SUCCESS;
}
upm_result_t bh1749_get_threshold_low(bh1749_context dev, uint16_t *threshold)
{
uint8_t data[2];
uint8_t data[2];
if(bh1749_read_register(dev, BH1749_TL_MSBS, &data[0]) ||
bh1749_read_register(dev, BH1749_TL_LSBS, &data[1]) != UPM_SUCCESS)
return UPM_ERROR_OPERATION_FAILED;
if(bh1749_read_register(dev, BH1749_TL_MSBS, &data[0]) ||
bh1749_read_register(dev, BH1749_TL_LSBS, &data[1]) != UPM_SUCCESS)
return UPM_ERROR_OPERATION_FAILED;
*threshold = data[0] << 8 | data[1];
return UPM_SUCCESS;
*threshold = data[0] << 8 | data[1];
return UPM_SUCCESS;
}
upm_result_t bh1749_get_red(bh1749_context dev, uint16_t *red)
{
uint8_t data[2];
uint8_t data[2];
if(bh1749_read_register(dev, BH1749_RED_DATA_MSBS, &data[0]) != UPM_SUCCESS ||
bh1749_read_register(dev, BH1749_RED_DATA_LSBS, &data[1]) != UPM_SUCCESS)
return -UPM_ERROR_OPERATION_FAILED;
if(bh1749_read_register(dev, BH1749_RED_DATA_MSBS, &data[0]) != UPM_SUCCESS ||
bh1749_read_register(dev, BH1749_RED_DATA_LSBS, &data[1]) != UPM_SUCCESS)
return -UPM_ERROR_OPERATION_FAILED;
*red = data[0] << 8 | data[1];
*red = data[0] << 8 | data[1];
return UPM_SUCCESS;
return UPM_SUCCESS;
}
upm_result_t bh1749_get_green(bh1749_context dev, uint16_t *green)
{
uint8_t data[2];
uint8_t data[2];
if(bh1749_read_register(dev, BH1749_GREEN_DATA_MSBS, &data[0]) != UPM_SUCCESS ||
bh1749_read_register(dev, BH1749_GREEN_DATA_LSBS, &data[1]) != UPM_SUCCESS)
return -UPM_ERROR_OPERATION_FAILED;
if(bh1749_read_register(dev, BH1749_GREEN_DATA_MSBS, &data[0]) != UPM_SUCCESS ||
bh1749_read_register(dev, BH1749_GREEN_DATA_LSBS, &data[1]) != UPM_SUCCESS)
return -UPM_ERROR_OPERATION_FAILED;
*green = data[0] << 8 | data[1];
*green = data[0] << 8 | data[1];
return UPM_SUCCESS;
return UPM_SUCCESS;
}
upm_result_t bh1749_get_blue(bh1749_context dev, uint16_t *blue)
{
uint8_t data[2];
uint8_t data[2];
if(bh1749_read_register(dev, BH1749_BLUE_DATA_MSBS, &data[0]) != UPM_SUCCESS ||
bh1749_read_register(dev, BH1749_BLUE_DATA_LSBS, &data[1]) != UPM_SUCCESS)
return -UPM_ERROR_OPERATION_FAILED;
if(bh1749_read_register(dev, BH1749_BLUE_DATA_MSBS, &data[0]) != UPM_SUCCESS ||
bh1749_read_register(dev, BH1749_BLUE_DATA_LSBS, &data[1]) != UPM_SUCCESS)
return -UPM_ERROR_OPERATION_FAILED;
*blue = data[0] << 8 | data[1];
*blue = data[0] << 8 | data[1];
return UPM_SUCCESS;
return UPM_SUCCESS;
}
upm_result_t bh1749_get_ir(bh1749_context dev, uint16_t *ir)
{
uint8_t data[2];
uint8_t data[2];
if(bh1749_read_register(dev, BH1749_IR_DATA_MSBS, &data[0]) != UPM_SUCCESS ||
bh1749_read_register(dev, BH1749_IR_DATA_LSBS, &data[1]) != UPM_SUCCESS)
return -UPM_ERROR_OPERATION_FAILED;
if(bh1749_read_register(dev, BH1749_IR_DATA_MSBS, &data[0]) != UPM_SUCCESS ||
bh1749_read_register(dev, BH1749_IR_DATA_LSBS, &data[1]) != UPM_SUCCESS)
return -UPM_ERROR_OPERATION_FAILED;
*ir = data[0] << 8 | data[1];
*ir = data[0] << 8 | data[1];
return UPM_SUCCESS;
return UPM_SUCCESS;
}
upm_result_t bh1749_get_green2(bh1749_context dev, uint16_t *green2)
{
uint8_t data[2];
uint8_t data[2];
if(bh1749_read_register(dev, BH1749_GREEN2_DATA_MSBS, &data[0]) != UPM_SUCCESS ||
bh1749_read_register(dev, BH1749_GREEN2_DATA_LSBS, &data[1]) != UPM_SUCCESS)
return -UPM_ERROR_OPERATION_FAILED;
if(bh1749_read_register(dev, BH1749_GREEN2_DATA_MSBS, &data[0]) != UPM_SUCCESS ||
bh1749_read_register(dev, BH1749_GREEN2_DATA_LSBS, &data[1]) != UPM_SUCCESS)
return -UPM_ERROR_OPERATION_FAILED;
*green2 = data[0] << 8 | data[1];
*green2 = data[0] << 8 | data[1];
return UPM_SUCCESS;
return UPM_SUCCESS;
}
upm_result_t bh1749_get_measurements(bh1749_context dev, uint16_t *result)
{
uint16_t value;
int step = 0;
uint16_t value;
int step = 0;
if(bh1749_get_red(dev, &value) != UPM_SUCCESS)
return UPM_ERROR_OPERATION_FAILED;
*(result + step++) = value;
if(bh1749_get_green(dev, &value) != UPM_SUCCESS)
return UPM_ERROR_OPERATION_FAILED;
*(result + step++) = value;
if(bh1749_get_blue(dev, &value) != UPM_SUCCESS)
return UPM_ERROR_OPERATION_FAILED;
*(result + step++) = value;
if(bh1749_get_ir(dev, &value) != UPM_SUCCESS)
return UPM_ERROR_OPERATION_FAILED;
*(result + step++) = value;
if(bh1749_get_green2(dev, &value) != UPM_SUCCESS)
return UPM_ERROR_OPERATION_FAILED;
*(result + step++) = value;
if(bh1749_get_red(dev, &value) != UPM_SUCCESS)
return UPM_ERROR_OPERATION_FAILED;
*(result + step++) = value;
if(bh1749_get_green(dev, &value) != UPM_SUCCESS)
return UPM_ERROR_OPERATION_FAILED;
*(result + step++) = value;
if(bh1749_get_blue(dev, &value) != UPM_SUCCESS)
return UPM_ERROR_OPERATION_FAILED;
*(result + step++) = value;
if(bh1749_get_ir(dev, &value) != UPM_SUCCESS)
return UPM_ERROR_OPERATION_FAILED;
*(result + step++) = value;
if(bh1749_get_green2(dev, &value) != UPM_SUCCESS)
return UPM_ERROR_OPERATION_FAILED;
*(result + step++) = value;
return UPM_SUCCESS;
return UPM_SUCCESS;
}
upm_result_t bh1749_install_isr(bh1749_context dev, mraa_gpio_edge_t edge, int pin,
void (*isr)(void *), void *isr_args)
void (*isr)(void *), void *isr_args)
{
if(dev->isrEnabled)
bh1749_remove_isr(dev);
if(dev->isrEnabled)
bh1749_remove_isr(dev);
mraa_gpio_context isr_gpio = NULL;
mraa_gpio_context isr_gpio = NULL;
if (!(isr_gpio = mraa_gpio_init(pin))) {
if (!(isr_gpio = mraa_gpio_init(pin))) {
printf("%s: mraa_gpio_init() failed.\n", __FUNCTION__);
return UPM_ERROR_OPERATION_FAILED;
}
@ -664,39 +664,39 @@ upm_result_t bh1749_install_isr(bh1749_context dev, mraa_gpio_edge_t edge, int p
return UPM_ERROR_OPERATION_FAILED;
}
dev->interrupt = isr_gpio;
dev->isrEnabled = true;
dev->interrupt = isr_gpio;
dev->isrEnabled = true;
return UPM_SUCCESS;
return UPM_SUCCESS;
}
void bh1749_remove_isr(bh1749_context dev)
{
mraa_gpio_isr_exit(dev->interrupt);
mraa_gpio_isr_exit(dev->interrupt);
mraa_gpio_close(dev->interrupt);
dev->interrupt = NULL;
dev->isrEnabled = false;
dev->interrupt = NULL;
dev->isrEnabled = false;
}
upm_result_t bh1749_registers_dump(bh1749_context dev, char *dump)
{
uint8_t reg_values[10];
int count = 0;
int len = 3;
uint8_t reg_values[10];
int count = 0;
int len = 3;
if(bh1749_read_registers(dev, BH1749_SYSTEM_CONTROL, reg_values, len) != UPM_SUCCESS)
return UPM_ERROR_OPERATION_FAILED;
count += sprintf(dump, "0x40 ");
for(int i = 0; i < len; i++)
count += sprintf(dump + count, "%02X ", reg_values[i]);
sprintf(dump + count - 1, "\n");
if(bh1749_read_registers(dev, BH1749_SYSTEM_CONTROL, reg_values, len) != UPM_SUCCESS)
return UPM_ERROR_OPERATION_FAILED;
count += sprintf(dump, "0x40 ");
for(int i = 0; i < len; i++)
count += sprintf(dump + count, "%02X ", reg_values[i]);
sprintf(dump + count - 1, "\n");
len = 6;
if(bh1749_read_registers(dev, BH1749_INTERRUPT, reg_values, len) != UPM_SUCCESS)
return UPM_ERROR_OPERATION_FAILED;
count += sprintf(dump + count, "0x60 ");
for(int i = 0; i < len; i++)
count += sprintf(dump + count, "%02X ", reg_values[i]);
len = 6;
if(bh1749_read_registers(dev, BH1749_INTERRUPT, reg_values, len) != UPM_SUCCESS)
return UPM_ERROR_OPERATION_FAILED;
count += sprintf(dump + count, "0x60 ");
for(int i = 0; i < len; i++)
count += sprintf(dump + count, "%02X ", reg_values[i]);
return UPM_SUCCESS;
return UPM_SUCCESS;
}

264
src/bh1749/bh1749.cxx
View File

@ -31,274 +31,274 @@ using namespace upm;
void BH1749::CheckWhoAmI()
{
if(bh1749_check_who_am_i(m_bh1749) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_check_who_am_i() failed");
if(bh1749_check_who_am_i(m_bh1749) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_check_who_am_i() failed");
}
BH1749::BH1749(int bus, int addr) : m_bh1749(bh1749_init(bus, addr))
{
if(!m_bh1749)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_init() failed");
if(!m_bh1749)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_init() failed");
}
BH1749::~BH1749()
{
bh1749_close(m_bh1749);
bh1749_close(m_bh1749);
}
void BH1749::Enable()
{
if(bh1749_enable(m_bh1749) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_enable() failed");
if(bh1749_enable(m_bh1749) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_enable() failed");
}
void BH1749::Disable()
{
if(bh1749_disable(m_bh1749) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_disable() failed");
if(bh1749_disable(m_bh1749) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_disable() failed");
}
void BH1749::SensorInit(OPERATING_MODES opMode,
MEAS_TIMES measTime,
RGB_GAINS rgbGain,
IR_GAINS irGain,
INT_SOURCES intSource)
MEAS_TIMES measTime,
RGB_GAINS rgbGain,
IR_GAINS irGain,
INT_SOURCES intSource)
{
if(bh1749_sensor_init(m_bh1749, opMode, measTime, rgbGain, irGain, intSource) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_sensor_init() failed");
if(bh1749_sensor_init(m_bh1749, opMode, measTime, rgbGain, irGain, intSource) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_sensor_init() failed");
}
void BH1749::SetOperatingMode(OPERATING_MODES opMode)
{
if(bh1749_set_operating_mode(m_bh1749, opMode) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_set_operating_mode() failed");
if(bh1749_set_operating_mode(m_bh1749, opMode) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_set_operating_mode() failed");
}
int BH1749::GetOperatingMode()
{
uint8_t opMode;
if(bh1749_get_operating_mode(m_bh1749, &opMode) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_get_operating_mode() failed");
return opMode;
uint8_t opMode;
if(bh1749_get_operating_mode(m_bh1749, &opMode) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_get_operating_mode() failed");
return opMode;
}
void BH1749::SetMeasurementTime(MEAS_TIMES measTime)
{
if(bh1749_set_measurement_time(m_bh1749, measTime) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_set_measurement_time() failed");
if(bh1749_set_measurement_time(m_bh1749, measTime) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_set_measurement_time() failed");
}
int BH1749::GetMeasurementTime()
{
uint8_t measTime;
if(bh1749_get_measurement_time(m_bh1749, &measTime) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_get_measurement_time() failed");
return measTime;
uint8_t measTime;
if(bh1749_get_measurement_time(m_bh1749, &measTime) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_get_measurement_time() failed");
return measTime;
}
void BH1749::SetRgbGain(RGB_GAINS rgbGain)
{
if(bh1749_set_rgb_gain(m_bh1749, rgbGain) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_set_rgb_gain() failed");
if(bh1749_set_rgb_gain(m_bh1749, rgbGain) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_set_rgb_gain() failed");
}
int BH1749::GetRgbGain()
{
uint8_t rgbGain;
if(bh1749_get_rgb_gain(m_bh1749, &rgbGain) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_get_rgb_gain() failed");
return rgbGain;
uint8_t rgbGain;
if(bh1749_get_rgb_gain(m_bh1749, &rgbGain) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_get_rgb_gain() failed");
return rgbGain;
}
void BH1749::SetIrGain(IR_GAINS irGain)
{
if(bh1749_set_ir_gain(m_bh1749, irGain) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_set_ir_gain() failed");
if(bh1749_set_ir_gain(m_bh1749, irGain) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_set_ir_gain() failed");
}
int BH1749::GetIrGain()
{
uint8_t irGain;
if(bh1749_get_ir_gain(m_bh1749, &irGain) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_get_ir_gain() failed");
return irGain;
uint8_t irGain;
if(bh1749_get_ir_gain(m_bh1749, &irGain) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_get_ir_gain() failed");
return irGain;
}
void BH1749::SetIntSource(INT_SOURCES intSource)
{
if(bh1749_set_int_source(m_bh1749, intSource) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_set_int_source() failed");
if(bh1749_set_int_source(m_bh1749, intSource) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_set_int_source() failed");
}
char BH1749::GetInterruptSourceChar()
{
char intSource = bh1749_get_interrupt_source_char(m_bh1749);
if( intSource == ' ')
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_get_interrupt_source_char() failed");
return intSource;
char intSource = bh1749_get_interrupt_source_char(m_bh1749);
if( intSource == ' ')
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_get_interrupt_source_char() failed");
return intSource;
}
void BH1749::EnableInterrupt()
{
if(bh1749_enable_interrupt(m_bh1749) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_enable_interrupt() failed");
if(bh1749_enable_interrupt(m_bh1749) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_enable_interrupt() failed");
}
void BH1749::DisableInterrupt()
{
if(bh1749_disable_interrupt(m_bh1749) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_disable_interrupt() failed");
if(bh1749_disable_interrupt(m_bh1749) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_disable_interrupt() failed");
}
void BH1749::ResetInterrupt()
{
if(bh1749_reset_interrupt(m_bh1749) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_reset_interrupt() failed");
if(bh1749_reset_interrupt(m_bh1749) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_reset_interrupt() failed");
}
bool BH1749::IsInterrupted()
{
return bh1749_is_interrupted(m_bh1749);
return bh1749_is_interrupted(m_bh1749);
}
bool BH1749::IsInterruptEnabled()
{
return bh1749_is_interrupt_enabled(m_bh1749);
return bh1749_is_interrupt_enabled(m_bh1749);
}
void BH1749::SoftReset()
{
if(bh1749_soft_reset(m_bh1749) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_soft_reset() failed");
if(bh1749_soft_reset(m_bh1749) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_soft_reset() failed");
}
void BH1749::SetThresholdHigh(uint16_t threshold)
{
if(bh1749_set_threshold_high(m_bh1749, threshold) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_set_threshold_high() failed");
if(bh1749_set_threshold_high(m_bh1749, threshold) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_set_threshold_high() failed");
}
int BH1749::GetThresholdHigh()
{
uint16_t threhold;
if(bh1749_get_threshold_high(m_bh1749, &threhold) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_get_threshold_high() failed");
return threhold;
uint16_t threhold;
if(bh1749_get_threshold_high(m_bh1749, &threhold) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_get_threshold_high() failed");
return threhold;
}
void BH1749::SetThresholdLow(uint16_t threshold)
{
if(bh1749_set_threshold_low(m_bh1749, threshold) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_set_threshold_low() failed");
if(bh1749_set_threshold_low(m_bh1749, threshold) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_set_threshold_low() failed");
}
int BH1749::GetThresholdLow()
{
uint16_t threhold;
if(bh1749_get_threshold_low(m_bh1749, &threhold) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_get_threshold_low() failed");
return threhold;
uint16_t threhold;
if(bh1749_get_threshold_low(m_bh1749, &threhold) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_get_threshold_low() failed");
return threhold;
}
uint16_t BH1749::GetRed()
{
uint16_t red;
if(bh1749_get_red(m_bh1749, &red) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_get_red() failed");
return red;
uint16_t red;
if(bh1749_get_red(m_bh1749, &red) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_get_red() failed");
return red;
}
uint16_t BH1749::GetGreen()
{
uint16_t green;
if(bh1749_get_green(m_bh1749, &green) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_get_green() failed");
return green;
uint16_t green;
if(bh1749_get_green(m_bh1749, &green) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_get_green() failed");
return green;
}
uint16_t BH1749::GetBlue()
{
uint16_t blue;
if(bh1749_get_blue(m_bh1749, &blue) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_get_blue() failed");
return blue;
uint16_t blue;
if(bh1749_get_blue(m_bh1749, &blue) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_get_blue() failed");
return blue;
}
uint16_t BH1749::GetIr()
{
uint16_t ir;
if(bh1749_get_ir(m_bh1749, &ir) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_get_ir() failed");
return ir;
uint16_t ir;
if(bh1749_get_ir(m_bh1749, &ir) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_get_ir() failed");
return ir;
}
uint16_t BH1749::GetGeen2()
{
uint16_t green2;
if(bh1749_get_green2(m_bh1749, &green2) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_get_green2() failed");
return green2;
uint16_t green2;
if(bh1749_get_green2(m_bh1749, &green2) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_get_green2() failed");
return green2;
}
std::vector<uint16_t> BH1749::GetMeasurements()
{
uint16_t res[5];
if(bh1749_get_measurements(m_bh1749, res) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_get_measurements() failed");
uint16_t res[5];
if(bh1749_get_measurements(m_bh1749, res) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_get_measurements() failed");
std::vector<uint16_t> result(res, res + sizeof res / sizeof res[0]);
return result;
std::vector<uint16_t> result(res, res + sizeof res / sizeof res[0]);
return result;
}
void BH1749::InstallISR(mraa_gpio_edge_t edge, int pin, void (*isr)(void *), void *isr_args)
{
if(bh1749_install_isr(m_bh1749, edge, pin, isr, isr_args) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_install_isr() failed");
if(bh1749_install_isr(m_bh1749, edge, pin, isr, isr_args) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_install_isr() failed");
}
void BH1749::RemoveISR()
{
bh1749_remove_isr(m_bh1749);
bh1749_remove_isr(m_bh1749);
}
std::string BH1749::RegistersDump()
{
char dump[255];
std::string dumpStr;
char dump[255];
std::string dumpStr;
if(bh1749_registers_dump(m_bh1749, dump) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_registers_dump() failed");
dumpStr = dump;
return dumpStr;
if(bh1749_registers_dump(m_bh1749, dump) != UPM_SUCCESS)
throw std::runtime_error(std::string(__FUNCTION__) +
"bh1749_registers_dump() failed");
dumpStr = dump;
return dumpStr;
}

150
src/bh1749/bh1749.h
View File

@ -36,63 +36,55 @@ extern "C"
#include "bh1749_registers.h"
/**
* @brief C API for the bh1749 color sensor driver
* @defgroup bh1749 libupm-bh1749
* @ingroup ROHM i2c color
*/
/**
* @file bh1749.h
* @library bh1749
* @sensor bh1749
* @comname ROHM Color Sensor
* @type color
* @man ROHM
* @con i2c
*
* @brief C API for the bh1749 driver
*
* @include bh1749.c
*/
/**
* @brief Operation modes enum for interrupt modes (persistance)
*/
typedef enum {
INT_JUDGE_0 = BH1749_PERSISTENCE_MODE_STATUS_ACTIVE_AFTER_MEASUREMENT,
INT_JUDGE_1 = BH1749_PERSISTENCE_MODE_STATUS_UPDATE_AFTER_MEASUREMENT,
INT_JUDGE_4 = BH1749_PERSISTENCE_MODE_STATUS_UPDATE_AFTER_4_SAME,
INT_JUDGE_8 = BH1749_PERSISTENCE_MODE_STATUS_UPDATE_AFTER_8_SAME,
INT_JUDGE_0 = BH1749_PERSISTENCE_MODE_STATUS_ACTIVE_AFTER_MEASUREMENT,
INT_JUDGE_1 = BH1749_PERSISTENCE_MODE_STATUS_UPDATE_AFTER_MEASUREMENT,
INT_JUDGE_4 = BH1749_PERSISTENCE_MODE_STATUS_UPDATE_AFTER_4_SAME,
INT_JUDGE_8 = BH1749_PERSISTENCE_MODE_STATUS_UPDATE_AFTER_8_SAME,
} OPERATING_MODES;
/**
* @brief Measuremnt time choices
*/
typedef enum {
MEAS_35MS = BH1749_MODE_CONTROL1_ODR_28P6,
MEAS_120MS = BH1749_MODE_CONTROL1_ODR_8P333,
MEAS_240MS = BH1749_MODE_CONTROL1_ODR_4P167
MEAS_35MS = BH1749_MODE_CONTROL1_ODR_28P6,
MEAS_120MS = BH1749_MODE_CONTROL1_ODR_8P333,
MEAS_240MS = BH1749_MODE_CONTROL1_ODR_4P167
} MEAS_TIMES;
/**
* @brief RGB gain choices
*/
typedef enum {
RGB_GAIN_1X = BH1749_MODE_CONTROL1_RGB_GAIN_1X,
RGB_GAIN_32X = BH1749_MODE_CONTROL1_RGB_GAIN_32X
RGB_GAIN_1X = BH1749_MODE_CONTROL1_RGB_GAIN_1X,
RGB_GAIN_32X = BH1749_MODE_CONTROL1_RGB_GAIN_32X
} RGB_GAINS;
/**
* @brief IR gain choices
*/
typedef enum {
IR_GAIN_1X = BH1749_MODE_CONTROL1_IR_GAIN_1X,
IR_GAIN_32X = BH1749_MODE_CONTROL1_IR_GAIN_32X
IR_GAIN_1X = BH1749_MODE_CONTROL1_IR_GAIN_1X,
IR_GAIN_32X = BH1749_MODE_CONTROL1_IR_GAIN_32X
} IR_GAINS;
/**
* @brief Interrupt source choices
*/
typedef enum {
RED = BH1749_INTERRUPT_SOURCE_SELECT_RED,
GREEN = BH1749_INTERRUPT_SOURCE_SELECT_GREEN,
BLUE = BH1749_INTERRUPT_SOURCE_SELECT_BLUE
RED = BH1749_INTERRUPT_SOURCE_SELECT_RED,
GREEN = BH1749_INTERRUPT_SOURCE_SELECT_GREEN,
BLUE = BH1749_INTERRUPT_SOURCE_SELECT_BLUE
} INT_SOURCES;
/**
@ -100,32 +92,32 @@ typedef enum {
*/
typedef struct _bh1749_context
{
mraa_i2c_context i2c;
mraa_gpio_context interrupt;
bool enabled;
bool isrEnabled;
uint16_t int_thh;
uint16_t int_thl;
INT_SOURCES int_src;
IR_GAINS ir_gain;
RGB_GAINS rgb_gain;
MEAS_TIMES meas_time;
OPERATING_MODES operating_mode;
mraa_i2c_context i2c;
mraa_gpio_context interrupt;
bool enabled;
bool isrEnabled;
uint16_t int_thh;
uint16_t int_thl;
INT_SOURCES int_src;
IR_GAINS ir_gain;
RGB_GAINS rgb_gain;
MEAS_TIMES meas_time;
OPERATING_MODES operating_mode;
} *bh1749_context;
/**
* @brief Check "who am I" register value to identify the sensor
*
*
* @param dev Sensor context
* @return UPM result
*/
upm_result_t bh1749_check_who_am_i(bh1749_context dev);
/**
* @brief Init the sensor with specific bus and address. This function calls
* @brief Init the sensor with specific bus and address. This function calls
* the sensor_init() function to set default values for operating mode, gains,
* measurement time, interrupt source and then sets threshold high to 511.
*
*
* @param bus I2C bus number
* @param addr I2C sensor address
* @return context of initialized sensor
@ -134,14 +126,14 @@ bh1749_context bh1749_init(int bus, int addr);
/**
* @brief Close and free sensor context
*
*
* @param dev Sensor context
*/
void bh1749_close(bh1749_context dev);
/**
* @brief Enables RGB color measurement on the sensor
*
*
* @param dev Sensor context
* @return UPM result
*/
@ -149,7 +141,7 @@ upm_result_t bh1749_enable(bh1749_context dev);
/**
* @brief Disables RGB color measurement on the sensor
*
*
* @param dev Sensor context
* @return UPM result
*/
@ -157,7 +149,7 @@ upm_result_t bh1749_disable(bh1749_context dev);
/**
* @brief Initializes (writes) configuration values to sensor
*
*
* @param dev Sensor context
* @param opMode Operating mode choice, a value of OPERATING_MODES enum
* @param measTime Measurement time choice, a value of MEAS_TIMES enum
@ -167,14 +159,14 @@ upm_result_t bh1749_disable(bh1749_context dev);
* @return UPM result
*/
upm_result_t bh1749_sensor_init(bh1749_context dev, OPERATING_MODES opMode,
MEAS_TIMES measTime,
RGB_GAINS rgbGain,
IR_GAINS irGain,
INT_SOURCES intSource);
MEAS_TIMES measTime,
RGB_GAINS rgbGain,
IR_GAINS irGain,
INT_SOURCES intSource);
/**
* @brief Sets operating mode (interrupt persistance)
*
*
* @param dev Sensor context
* @param opMode Operating mode choice, a value of OPERATING_MODES enum
* @return UPM result
@ -183,7 +175,7 @@ upm_result_t bh1749_set_operating_mode(bh1749_context dev, OPERATING_MODES opMod
/**
* @brief Gets operating mode (interrupt persistance) value
*
*
* @param dev Sensor context
* @param opMode pointer (uint8_t) to save value
* @return UPM result
@ -192,7 +184,7 @@ upm_result_t bh1749_get_operating_mode(bh1749_context dev, uint8_t *opMode);
/**
* @brief Sets measurement time (ODR)
*
*
* @param dev Sensor context
* @param measTime measurement time choice, a value of MEAS_TIMES enum
* @return UPM result
@ -201,7 +193,7 @@ upm_result_t bh1749_set_measurement_time(bh1749_context dev, MEAS_TIMES measTime
/**
* @brief Sets measurement time (ODR)
*
*
* @param dev Sensor context
* @param meas_time pointer (uint8_t) to save value
* @return UPM result
@ -210,7 +202,7 @@ upm_result_t bh1749_get_measurement_time(bh1749_context dev, uint8_t *meas_time)
/**
* @brief Sets RGB gain values
*
*
* @param dev Sensor context
* @param rgbGain RGB gain choice, a value of RGB_GAINS enum
* @return UPM result
@ -219,7 +211,7 @@ upm_result_t bh1749_set_rgb_gain(bh1749_context dev, RGB_GAINS rgbGain);
/**
* @brief Gets RGB gain value
*
*
* @param dev Sensor context
* @param gain pointer (uint8_t) to save value
* @return UPM result
@ -228,7 +220,7 @@ upm_result_t bh1749_get_rgb_gain(bh1749_context dev, uint8_t *gain);
/**
* @brief Sets IR gain values
*
*
* @param dev Sensor context
* @param irGain IR gain choice, a value of IR_GAINS enum
* @return UPM result
@ -237,7 +229,7 @@ upm_result_t bh1749_set_ir_gain(bh1749_context dev, IR_GAINS irGain);
/**
* @brief Gets IR gain value
*
*
* @param dev Sensor context
* @param gain pointer (uint8_t) to save value
* @return UPM result
@ -246,7 +238,7 @@ upm_result_t bh1749_get_ir_gain(bh1749_context dev, uint8_t *gain);
/**
* @brief Sets interrupt source value
*
*
* @param dev Sensor context
* @param intSource interrupt source choice, a value of INT_SOURCES enum
* @return UPM result
@ -255,7 +247,7 @@ upm_result_t bh1749_set_int_source(bh1749_context dev, INT_SOURCES intSource);
/**
* @brief Gets interrupt source value
*
*
* @param dev Sensor context
* @return character of interrupt source
*/
@ -263,7 +255,7 @@ char bh1749_get_interrupt_source_char(bh1749_context dev);
/**
* @brief Enables interrupt mode and resets the interrupt status (clear)
*
*
* @param dev Sensor context
* @return UPM result
*/
@ -271,7 +263,7 @@ upm_result_t bh1749_enable_interrupt(bh1749_context dev);
/**
* @brief Disables interrupt mode
*
*
* @param dev Sensor context
* @return UPM result
*/
@ -279,7 +271,7 @@ upm_result_t bh1749_disable_interrupt(bh1749_context dev);
/**
* @brief Resets interrupt status (clear) to allow new interrupts
*
*
* @param dev Sensor context
* @return UPM result
*/
@ -287,7 +279,7 @@ upm_result_t bh1749_reset_interrupt(bh1749_context dev);
/**
* @brief Checks the status of the interrupt
*
*
* @param dev Sensor context
* @return true if there is interrupt, otherwise false
*/
@ -295,7 +287,7 @@ bool bh1749_is_interrupted(bh1749_context dev);
/**
* @brief Checks whether interrupt mode is enabled
*
*
* @param dev Sensor context
* @return true if interrupt is enabled, otherwise false
*/
@ -305,7 +297,7 @@ bool bh1749_is_interrupt_enabled(bh1749_context dev);
* @brief Initiates a software reset to the sensor. All register values will
* be written to their defaults, thus sensor_init() must be called after this,
* and thresholds also needs to be set.
*
*
* @param dev Sensor context
* @return UPM result
*/
@ -313,7 +305,7 @@ upm_result_t bh1749_soft_reset(bh1749_context dev);
/**
* @brief Sets interrupt threshold high value
*
*
* @param dev Sensor context
* @param threshold Value to be written, range 0-65536
* @return UPM result
@ -322,7 +314,7 @@ upm_result_t bh1749_set_threshold_high(bh1749_context dev, uint16_t threshold);
/**
* @brief Gets interrupt threshold high value
*
*
* @param dev Sensor context
* @param threshold Pointer (uint16_t) to write value
* @return UPM result
@ -331,7 +323,7 @@ upm_result_t bh1749_get_threshold_high(bh1749_context dev, uint16_t *threshold);
/**
* @brief Sets interrupt threshold low value
*
*
* @param dev Sensor context
* @param threshold Value to be written, range 0-65536
* @return UPM result
@ -340,7 +332,7 @@ upm_result_t bh1749_set_threshold_low(bh1749_context dev, uint16_t threshold);
/**
* @brief Gets interrupt threshold low value
*
*
* @param dev Sensor context
* @param threshold Pointer (uint16_t) to write value
* @return UPM result
@ -349,7 +341,7 @@ upm_result_t bh1749_get_threshold_low(bh1749_context dev, uint16_t *threshold);
/**
* @brief Gets value of Red color channel
*
*
* @param dev Sensor context
* @param red Pointer (uint16_t) to write value
* @return UPM result
@ -358,7 +350,7 @@ upm_result_t bh1749_get_red(bh1749_context dev, uint16_t *red);
/**
* @brief Gets value of Green color channel
*
*
* @param dev Sensor context
* @param green Pointer (uint16_t) to write value
* @return UPM result
@ -367,7 +359,7 @@ upm_result_t bh1749_get_green(bh1749_context dev, uint16_t *green);
/**
* @brief Gets value of Blue color channel
*
*
* @param dev Sensor context
* @param blue Pointer (uint16_t) to write value
* @return UPM result
@ -376,7 +368,7 @@ upm_result_t bh1749_get_blue(bh1749_context dev, uint16_t *blue);
/**
* @brief Gets value of IR color channel
*
*
* @param dev Sensor context
* @param ir Pointer (uint16_t) to write value
* @return UPM result
@ -385,7 +377,7 @@ upm_result_t bh1749_get_ir(bh1749_context dev, uint16_t *ir);
/**
* @brief Gets value of Green2 color channel
*
*
* @param dev Sensor context
* @param green Pointer (uint16_t) to write value
* @return UPM result
@ -394,18 +386,18 @@ upm_result_t bh1749_get_green2(bh1749_context dev, uint16_t *green2);
/**
* @brief Gets all channels measurements values
*
*
* @param dev Sensor context
* @param result Pointer of uint16_t to write all values ordered as:
* @param result Pointer of uint16_t to write all values ordered as:
* Red, Green, Blue, IR, Green2
*
*
* @return UPM result
*/
upm_result_t bh1749_get_measurements(bh1749_context dev, uint16_t *result);
/**
* @brief Installs the ISR to a given GPIO pin
*
*
* @param dev Sensor context
* @param edge Edge type to raise ISR with, of type mraa_gpio_edge_t
* @param pin GPIO pin number
@ -414,18 +406,18 @@ upm_result_t bh1749_get_measurements(bh1749_context dev, uint16_t *result);
* @return UPM result
*/
upm_result_t bh1749_install_isr(bh1749_context dev, mraa_gpio_edge_t edge, int pin,
void (*isr)(void *), void *isr_args);
void (*isr)(void *), void *isr_args);
/**
* @brief Removes the ISR if it is installed
*
*
* @param dev Sensor context
*/
void bh1749_remove_isr(bh1749_context dev);
/**
* @brief Gets a dump of configuration registers as a string
*
*
* @param dev Sensor context
* @param dump Pointer of char to save dump string
* @return UPM result

529
src/bh1749/bh1749.hpp
View File

@ -28,315 +28,318 @@
#include "bh1749.h"
/**
* @brief C++ API wrapper for the bh1749 color sensor driver
* @brief BH1749 Color Sensor
* @defgroup bh1749 libupm-bh1749
* @ingroup ROHM i2c color
* @ingroup rohm i2c color
*/
/**
* @library bh1749
* @sensor bh1749
* @comname Color Sensor
* @type color sensor
* @man ROHM
* @man rohm
* @con i2c
*
* @brief C++ API wrapper for the bh1749 driver
*
* @snippet bh1749.cxx Interesting
*/
namespace upm {
class BH1749 {
public:
/**
* @brief Initialize a sensor instance with bus and address.
*
* This calls SensorInit() to set default values for operating mode,
* gains, measurement time, interrupt source and then sets threshold
* high to 511.
*
* @param bus I2C bus number
* @param addr I2C sensor address
* @throws std::runtime_error on initialization failure
*/
BH1749(int bus = 0, int addr = 0x39);
class BH1749 {
public:
/**
* @brief Initialize a sensor instance with bus and address.
*
* This calls SensorInit() to set default values for operating mode,
* gains, measurement time, interrupt source and then sets threshold
* high to 511.
*
* @param bus I2C bus number
* @param addr I2C sensor address
* @throws std::runtime_error on initialization failure
*/
BH1749(int bus = 0, int addr = 0x39);
/**
* @brief Close and free sensor
*/
virtual ~BH1749();
/**
* @brief Close and free sensor
*/
virtual ~BH1749();
/**
* @brief Enables RGB color measurement on the sensor
*
* @throws std::runtime_error if bh1749_enable() fails
*/
void Enable();
/**
* @brief Enables RGB color measurement on the sensor
*
* @throws std::runtime_error if bh1749_enable() fails
*/
void Enable();
/**
* @brief Disables RGB color measurement on the sensor
*
* @throws std::runtime_error if bh1749_disable() fails
*/
void Disable();
/**
* @brief Disables RGB color measurement on the sensor
*
* @throws std::runtime_error if bh1749_disable() fails
*/
void Disable();
/**
* @brief Check "who am I" register value to identify the sensor
*
* @throws std::runtime_error if this value is incorrect
*/
void CheckWhoAmI();
/**
* @brief Check "who am I" register value to identify the sensor
*
* @throws std::runtime_error if this value is incorrect
*/
void CheckWhoAmI();
/**
* @brief Initializes (writes) configuration values to sensor
*
* @param opMode Operating mode choice, a value of OPERATING_MODES enum
* @param measTime Measurement time choice, a value of MEAS_TIMES enum
* @param rgbGain RGB gain choice, a value of RGB_GAINS enum
* @param irGain IR gain choice, a value of IR_GAINS enum
* @param intSource interrupt source choice, a value of INT_SOURCES enum
*
* @throws std::runtime_error if one of values setting fails
*/
void SensorInit(OPERATING_MODES opMode,
MEAS_TIMES measTime,
RGB_GAINS rgbGain,
IR_GAINS irGain,
INT_SOURCES intSource);
/**
* @brief Initializes (writes) configuration values to sensor
*
* @param opMode Operating mode choice, a value of OPERATING_MODES enum
* @param measTime Measurement time choice, a value of MEAS_TIMES enum
* @param rgbGain RGB gain choice, a value of RGB_GAINS enum
* @param irGain IR gain choice, a value of IR_GAINS enum
* @param intSource interrupt source choice, a value of INT_SOURCES enum
*
* @throws std::runtime_error if one of values setting fails
*/
void SensorInit(OPERATING_MODES opMode,
MEAS_TIMES measTime,
RGB_GAINS rgbGain,
IR_GAINS irGain,
INT_SOURCES intSource);
/**
* @brief Sets operating mode (interrupt persistance)
*
* @param opMode Operating mode choice, a value of OPERATING_MODES enum
* @throws std::runtime_error if writing value fails
*/
void SetOperatingMode(OPERATING_MODES opMode);
/**
* @brief Sets operating mode (interrupt persistance)
*
* @param opMode Operating mode choice, a value of OPERATING_MODES enum
* @throws std::runtime_error if writing value fails
*/
void SetOperatingMode(OPERATING_MODES opMode);
/**
* @brief Gets operating mode (interrupt persistance) value
*
* @param opMode pointer (uint8_t) to save value
* @return operating mode value
* @throws std::runtime_error if reading the value fails
*/
int GetOperatingMode();
/**
* @brief Gets operating mode (interrupt persistance) value
*
* @param opMode pointer (uint8_t) to save value
* @return operating mode value
* @throws std::runtime_error if reading the value fails
*/
int GetOperatingMode();
/**
* @brief Sets measurement time (ODR)
*
* @param measTime measurement time choice, a value of MEAS_TIMES enum
* @throws std::runtime_error if writing value fails
*/
void SetMeasurementTime(MEAS_TIMES measTime);
/**
* @brief Sets measurement time (ODR)
*
* @param measTime measurement time choice, a value of MEAS_TIMES enum
* @throws std::runtime_error if writing value fails
*/
void SetMeasurementTime(MEAS_TIMES measTime);
/**
* @brief Gets measurement time (ODR) value
*
* @return measurement time value
* @throws std::runtime_error if reading the value fails
*/
int GetMeasurementTime();
/**
* @brief Gets measurement time (ODR) value
*
* @return measurement time value
* @throws std::runtime_error if reading the value fails
*/
int GetMeasurementTime();
/**
* @brief Sets RGB gain value
*
* @param rgbGain RGB gain choice, a value of RGB_GAINS enum
* @throws std::runtime_error if writing value fails
*/
void SetRgbGain(RGB_GAINS rgbGain);
/**
* @brief Sets RGB gain value
*
* @param rgbGain RGB gain choice, a value of RGB_GAINS enum
* @throws std::runtime_error if writing value fails
*/
void SetRgbGain(RGB_GAINS rgbGain);
/**
* @brief Gets RGB gain value
*
* @return RGB gain value value
* @throws std::runtime_error if reading the value fails
*/
int GetRgbGain();
/**
* @brief Gets RGB gain value
*
* @return RGB gain value value
* @throws std::runtime_error if reading the value fails
*/
int GetRgbGain();
/**
* @brief Sets IR gain value
*
* @param irGain IR gain choice, a value of IR_GAINS enum
* @throws std::runtime_error if writing value fails
*/
void SetIrGain(IR_GAINS irGain);
/**
* @brief Sets IR gain value
*
* @param irGain IR gain choice, a value of IR_GAINS enum
* @throws std::runtime_error if writing value fails
*/
void SetIrGain(IR_GAINS irGain);
/**
* @brief Gets IR gain value
*
* @return IR gain value value
* @throws std::runtime_error if reading the value fails
*/
int GetIrGain();
/**
* @brief Gets IR gain value
*
* @return IR gain value value
* @throws std::runtime_error if reading the value fails
*/
int GetIrGain();
/**
* @brief Sets interrupt source value
*
* @param intSource interrupt source choice, a value of INT_SOURCES enum
* @throws std::runtime_error if writing value fails
*/
void SetIntSource(INT_SOURCES intSource);
/**
* @brief Sets interrupt source value
*
* @param intSource interrupt source choice, a value of INT_SOURCES enum
* @throws std::runtime_error if writing value fails
*/
void SetIntSource(INT_SOURCES intSource);
/**
* @brief Gets interrupt source value
*
* @return interrupt source value
* @throws std::runtime_error if reading the value fails
*/
char GetInterruptSourceChar();
/**
* @brief Gets interrupt source value
*
* @return interrupt source value
* @throws std::runtime_error if reading the value fails
*/
char GetInterruptSourceChar();
/**
* @brief Enables interrupt mode
*
* @throws std::runtime_error if writing enable bit fails
*/
void EnableInterrupt();
/**
* @brief Enables interrupt mode
*
* @throws std::runtime_error if writing enable bit fails
*/
void EnableInterrupt();
/**
* @brief Disables interrupt mode
*
* @throws std::runtime_error if writing disable bit fails
*/
void DisableInterrupt();
/**
* @brief Disables interrupt mode
*
* @throws std::runtime_error if writing disable bit fails
*/
void DisableInterrupt();
/**
* @brief Resets interrupt status (clear) to allow new interrupt reads
*
* @throws std::runtime_error if writing reset bit fails
*/
void ResetInterrupt();
/**
* @brief Resets interrupt status (clear) to allow new interrupt reads
*
* @throws std::runtime_error if writing reset bit fails
*/
void ResetInterrupt();
/**
* @brief Gets interrupt status, whether interrupt is raised or not
*
* @return true if interrupt is raised, otherwise false
*/
bool IsInterrupted();
/**
* @brief Gets interrupt status, whether interrupt is raised or not
*
* @return true if interrupt is raised, otherwise false
*/
bool IsInterrupted();
/**
* @brief Gets interrupt mode status
*
* @return true if interrupt is enabled, otherwise false
*/
bool IsInterruptEnabled();
/**
* @brief Gets interrupt mode status
*
* @return true if interrupt is enabled, otherwise false
*/
bool IsInterruptEnabled();
/**
* @brief Initiates a software reset to the sensor. All register values
* will be written to their defaults, thus sensor_init() must be called
* after this, and thresholds also needs to be set.
*
* @throws std::runtime_error if writing reset bit fails
*/
void SoftReset();
/**
* @brief Initiates a software reset to the sensor. All register values
* will be written to their defaults, thus sensor_init() must be called
* after this, and thresholds also needs to be set.
*
* @throws std::runtime_error if writing reset bit fails
*/
void SoftReset();
/**
* @brief Sets threshold high value
*
* @param threshold interrupt threshold high value, range 0-65536
* @throws std::runtime_error if writing value fails
*/
void SetThresholdHigh(uint16_t threshold);
/**
* @brief Sets threshold high value
*
* @param threshold interrupt threshold high value, range 0-65536
* @throws std::runtime_error if writing value fails
*/
void SetThresholdHigh(uint16_t threshold);
/**
* @brief Gets threshold high value
*
* @return threshold high value
* @throws std::runtime_error if reading the value fails
*/
int GetThresholdHigh();
/**
* @brief Gets threshold high value
*
* @return threshold high value
* @throws std::runtime_error if reading the value fails
*/
int GetThresholdHigh();
/**
* @brief Sets threshold low value
*
* @param threshold interrupt threshold low value, range 0-65536
* @throws std::runtime_error if writing value fails
*/
void SetThresholdLow(uint16_t threshold);
/**
* @brief Sets threshold low value
*
* @param threshold interrupt threshold low value, range 0-65536
* @throws std::runtime_error if writing value fails
*/
void SetThresholdLow(uint16_t threshold);
/**
* @brief Gets threshold low value
*
* @return threshold low value
* @throws std::runtime_error if reading the value fails
*/
int GetThresholdLow();
/**
* @brief Gets threshold low value
*
* @return threshold low value
* @throws std::runtime_error if reading the value fails
*/
int GetThresholdLow();
/**
* @brief Gets value of Red color channel
*
* @return red channel value
* @throws std::runtime_error if reading the value fails
*/
uint16_t GetRed();
/**
* @brief Gets value of Red color channel
*
* @return red channel value
* @throws std::runtime_error if reading the value fails
*/
uint16_t GetRed();
/**
* @brief Gets value of Green color channel
*
* @return green channel value
* @throws std::runtime_error if reading the value fails
*/
uint16_t GetGreen();
/**
* @brief Gets value of Green color channel
*
* @return green channel value
* @throws std::runtime_error if reading the value fails
*/
uint16_t GetGreen();
/**
* @brief Gets value of Blue color channel
*
* @return blue channel value
* @throws std::runtime_error if reading the value fails
*/
uint16_t GetBlue();
/**
* @brief Gets value of Blue color channel
*
* @return blue channel value
* @throws std::runtime_error if reading the value fails
*/
uint16_t GetBlue();
/**
* @brief Gets value of IR color channel
*
* @return ir channel value
* @throws std::runtime_error if reading the value fails
*/
uint16_t GetIr();
/**
* @brief Gets value of IR color channel
*
* @return ir channel value
* @throws std::runtime_error if reading the value fails
*/
uint16_t GetIr();
/**
* @brief Gets value of Green2 color channel
*
* @return green2 channel value
* @throws std::runtime_error if reading the value fails
*/
uint16_t GetGeen2();
/**
* @brief Gets value of Green2 color channel
*
* @return green2 channel value
* @throws std::runtime_error if reading the value fails
*/
uint16_t GetGeen2();
/**
* @brief Gets all channels measurements values
*
* @return vector with all channels values ordered as:
* Red, Green, Blue, IR, Green2
* @throws std::runtime_error if reading one of the values fails
*/
std::vector<uint16_t> GetMeasurements();
/**
* @brief Gets all channels measurements values
*
* @return vector with all channels values ordered as:
* Red, Green, Blue, IR, Green2
* @throws std::runtime_error if reading one of the values fails
*/
std::vector<uint16_t> GetMeasurements();
/**
* @brief Installs the ISR to a given GPIO pin
*
* @param edge Edge type to raise ISR with, of type mraa_gpio_edge_t
* @param pin GPIO pin number
* @param isr Pointer to ISR function
* @param isr_args Arguments to pass the ISR function
* @throws std::runtime_error if installing ISR fails
*/
void InstallISR(mraa_gpio_edge_t edge, int pin, void (*isr)(void *), void *isr_args);
/**
* @brief Removes the ISR if it is installed
*/
void RemoveISR();
/**
* @brief Installs the ISR to a given GPIO pin
*
* @param edge Edge type to raise ISR with, of type mraa_gpio_edge_t
* @param pin GPIO pin number
* @param isr Pointer to ISR function
* @param isr_args Arguments to pass the ISR function
* @throws std::runtime_error if installing ISR fails
*/
void InstallISR(mraa_gpio_edge_t edge, int pin, void (*isr)(void *), void *isr_args);
/**
* @brief Gets a dump of configuration registers as a string
*
* @return string of dumped registers
* @throws std::runtime_error if reading one of the registers fails
*/
std::string RegistersDump();
/**
* @brief Removes the ISR if it is installed
*/
void RemoveISR();
private:
bh1749_context m_bh1749;
/**
* @brief Gets a dump of configuration registers as a string
*
* @return string of dumped registers
* @throws std::runtime_error if reading one of the registers fails
*/
std::string RegistersDump();
/* Disable implicit copy and assignment operators */
BH1749(const BH1749 &) = delete;
BH1749 &operator=(const BH1749 &) = delete;
};
private:
bh1749_context m_bh1749;
/* Disable implicit copy and assignment operators */
BH1749(const BH1749 &) = delete;
BH1749 &operator=(const BH1749 &) = delete;
};
}

6
src/bh1749/bh1749.json
View File

@ -32,9 +32,9 @@
"min": -40,
"max": 85
}, "Illumination Detection": {
"unit" : "klx",
"value": 80
}
"unit" : "klx",
"value": 80
}
},
"Urls": {
"Product Pages": [

2
src/bh1749/bh1749_registers.h
View File

@ -139,7 +139,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#define BH1749_MODE_CONTROL1_IR_GAIN_MASK 0x60
#define BH1749_MODE_CONTROL1_RGB_GAIN_MASK 0x18
#define BH1749_MODE_CONTROL1_ODR_MASK 0x07
// Measurement data update flag. Sets to 0 if MODE_CONTROL1/2 reg,
// Measurement data update flag. Sets to 0 if MODE_CONTROL1/2 reg,
// MODE_CONTROL2, INTERRUPT, T(H/L)_(LSB/MSB) is written or
// MODE_CONTROL2 read. In specification named as VALID.
#define BH1749_MODE_CONTROL2_VALID_MASK 0x80