upm_result_t light_get_lux(const light_context dev, float *value)
{
*value = mraa_aio_read(dev->aio);
if (*value < 0)
return UPM_ERROR_OPERATION_FAILED;
/* Get max adc value range 1023, 2047, 4095, etc... */
float max_adc = (1 << mraa_aio_get_bit(dev->aio)) - 1;
/* Convert the value to lux */
*value = 10000.0/pow(((max_adc - *value) * 10.0 / *value)*15.0,4.0/3.0);
/* Apply scale */
*value *= dev->m_scale;
/* Apply the offset in lux */
*value += dev->m_offset;
return UPM_SUCCESS;
}
ad8232_context ad8232_init(int lo_plus, int lo_minus, int output,
float a_ref) {
ad8232_context dev =
(ad8232_context) malloc(sizeof(struct _ad8232_context));
if(dev == NULL){
printf("Unable to assign memory to the Heart Rate Monitor structure");
return NULL;
}
dev->aio = mraa_aio_init(output);
dev->gpio_lo_plus = mraa_gpio_init(lo_plus);
dev->gpio_lo_minus = mraa_gpio_init(lo_minus);
if (dev->aio == NULL || dev->gpio_lo_minus == NULL ||
dev->gpio_lo_plus == NULL){
printf("The pins did not initialize correctly");
return NULL;
}
if (mraa_gpio_dir(dev->gpio_lo_minus, MRAA_GPIO_IN) != MRAA_SUCCESS ||
mraa_gpio_dir(dev->gpio_lo_plus, MRAA_GPIO_IN) != MRAA_SUCCESS){
printf("Couldn't set the direction for the GPIO pins");
return NULL;
}
dev->a_res = (1 << mraa_aio_get_bit(dev->aio));
return dev;
}
gp2y0a_context gp2y0a_init(uint8_t pin, float a_ref){
gp2y0a_context dev = (gp2y0a_context) malloc(sizeof(struct _gp2y0a_context));
dev->pin = pin;
dev->aio = mraa_aio_init(dev->pin);
if(dev->aio == NULL){
free(dev);
return NULL;
}
dev->a_res = (1 << mraa_aio_get_bit(dev->aio));
return dev;
}
rotary_context rotary_init(int pin, float aRef)
{
rotary_context dev = (rotary_context)malloc(sizeof(struct _rotary_context));
if(dev == NULL) return NULL;
dev->aio = mraa_aio_init(pin);
if(dev->aio == NULL){
free(dev);
return NULL;
}
dev->m_aRef = aRef;
// get adc bit range
dev->m_aRes = (1 << mraa_aio_get_bit(dev->aio));
return dev;
}
/**
* Gets the bit value mraa is shifting the analog read to.
*
* @return bit value mraa is set return from the read function
*/
int
getBit()
{
return mraa_aio_get_bit(m_aio);
}
mma7361_context mma7361_init(int x_pin, int y_pin, int z_pin,
int selftest_pin, int sleep_pin,
int freefall_pin, int range_pin,
float a_ref)
{
// sanity check - at least one axis needs to be enabled, or what's
// the point?
if (x_pin < 0 && y_pin < 0 && z_pin < 0)
{
printf("%s: At least one axis must be enabled.\n", __FUNCTION__);
return NULL;
}
mma7361_context dev =
(mma7361_context)malloc(sizeof(struct _mma7361_context));
if (!dev)
return NULL;
// zero out context
memset((void *)dev, 0, sizeof(struct _mma7361_context));
dev->aio_x = NULL;
dev->aio_y = NULL;
dev->aio_z = NULL;
dev->gpio_selftest = NULL;
dev->gpio_sleep = NULL;
dev->gpio_freefall = NULL;
dev->gpio_range = NULL;
dev->a_res = 0;
dev->a_ref = a_ref;
dev->g_range = 1.5;
dev->offset_x = dev->offset_y = dev->offset_z = 0.0;
dev->scale_x = dev->scale_y = dev->scale_z = 1.0;
dev->accel_x = 0.0;
dev->accel_y = 0.0;
dev->accel_z = 0.0;
dev->volts_x = 0.0;
dev->volts_y = 0.0;
dev->volts_z = 0.0;
dev->normalized_x = 0;
dev->normalized_y = 0;
dev->normalized_z = 0;
// initialize the MRAA contexts (only what we need)
// analogs
if (x_pin >= 0)
{
if (!(dev->aio_x = mraa_aio_init(x_pin)))
{
printf("%s: mraa_aio_init(x) failed.\n", __FUNCTION__);
mma7361_close(dev);
return NULL;
}
// set our analog resolution
dev->a_res = (float)(1 << mraa_aio_get_bit(dev->aio_x)) - 1;
}
if (y_pin >= 0)
{
if (!(dev->aio_y = mraa_aio_init(y_pin)))
{
printf("%s: mraa_aio_init(y) failed.\n", __FUNCTION__);
mma7361_close(dev);
return NULL;
}
// set our analog resolution if not already set
if (!dev->a_res)
dev->a_res = (float)(1 << mraa_aio_get_bit(dev->aio_y)) - 1;
}
if (z_pin >= 0)
{
if (!(dev->aio_z = mraa_aio_init(z_pin)))
{
printf("%s: mraa_aio_init(z) failed.\n", __FUNCTION__);
mma7361_close(dev);
return NULL;
}
// set our analog resolution if not already set
if (!dev->a_res)
dev->a_res = (float)(1 << mraa_aio_get_bit(dev->aio_z)) - 1;
}
// now the gpios
if (selftest_pin >= 0)
{
if (!(dev->gpio_selftest = mraa_gpio_init(selftest_pin)))
{
printf("%s: mraa_gpio_init(selftest) failed.\n", __FUNCTION__);
mma7361_close(dev);
return NULL;
}
mraa_gpio_dir(dev->gpio_selftest, MRAA_GPIO_OUT);
mma7361_selftest(dev, false);
}
if (sleep_pin >= 0)
{
if (!(dev->gpio_sleep = mraa_gpio_init(sleep_pin)))
{
printf("%s: mraa_gpio_init(sleep) failed.\n", __FUNCTION__);
mma7361_close(dev);
return NULL;
}
mraa_gpio_dir(dev->gpio_sleep, MRAA_GPIO_OUT);
mma7361_sleep(dev, false);
}
if (freefall_pin >= 0)
{
if (!(dev->gpio_freefall = mraa_gpio_init(freefall_pin)))
{
printf("%s: mraa_gpio_init(freefall) failed.\n", __FUNCTION__);
mma7361_close(dev);
return NULL;
}
mraa_gpio_dir(dev->gpio_freefall, MRAA_GPIO_IN);
}
if (range_pin >= 0)
{
if (!(dev->gpio_range = mraa_gpio_init(range_pin)))
{
printf("%s: mraa_gpio_init(range) failed.\n", __FUNCTION__);
mma7361_close(dev);
return NULL;
}
mraa_gpio_dir(dev->gpio_range, MRAA_GPIO_OUT);
mma7361_set_range(dev, false);
}
return dev;
}
