tsl4531.c

Go to the documentation of this file.

 
#include <errno.h>
#include <stdint.h>
#include <string.h>
 
#include <i2c/smbus.h>
 
#include "../log.h"
#include "sensor.h"
 
#include "tsl4531.h"
 
const int tsl4531_sensors[] = TSL4531_I2C_ADDRESSES;
 
int tsl4531_set_range(int sensor_identifier, int range);
 
int tsl4531_get_range(int sensor_identifier);
 
int tsl4531_get_id(void);
 
int tsl4531_set_parameters(int sensor_identifier);
 
int tsl4531_send_range(int sensor_identifier, int range);
 
int tsl4531_get_index(int sensor_identifier);
 
tsl4531_range_t tsl4531_range[sizeof(tsl4531_sensors)] = {TSL4531_RANGE_AUTO};
 
tsl4531_range_t tsl4531_auto_range[sizeof(tsl4531_sensors)] = {
    TSL4531_RANGE_MEDIUM};
 
uint8_t tsl4531_multiplier[sizeof(tsl4531_sensors)] = {TSL4531_MULT_200};
 
int32_t tsl4531_values[sizeof(tsl4531_sensors)] = {0};
 
int tsl4531_init(int sensor_identifier) {
    int sensor_bus = sensors_get_bus();
 
    if (sensor_bus < 0) {
        rl_log(RL_LOG_ERROR, "TSL4531 I2C bus not initialized properly");
        return sensor_bus;
    }
 
    int result = 0;
 
    uint8_t device_address = (uint8_t)sensor_identifier;
    result = sensors_init_comm(device_address);
    if (result < 0) {
        rl_log(RL_LOG_ERROR,
               "TSL4531 I2C initialization failed; %d message: %s", errno,
               strerror(errno));
        return result;
    }
 
    int sensor_id = tsl4531_get_id();
    if (sensor_id != TSL4531_ID) {
        rl_log(RL_LOG_ERROR, "TSL4531 with wrong sensor ID: %d; %d message: %s",
               sensor_id, errno, strerror(errno));
        return sensor_id;
    }
 
    result = tsl4531_set_parameters(sensor_identifier);
    if (result < 0) {
        rl_log(RL_LOG_ERROR,
               "TSL4531 setting configuration failed; %d message: %s", errno,
               strerror(errno));
        return result;
    }
 
    return 0;
}
 
void tsl4531_deinit(int sensor_identifier) {
    (void)sensor_identifier; // suppress unused parameter warning
}
 
int tsl4531_read(int sensor_identifier) {
    int sensor_index = tsl4531_get_index(sensor_identifier);
    int sensor_bus = sensors_get_bus();
 
    int result;
 
    uint8_t device_address = (uint8_t)sensor_identifier;
    result = sensors_init_comm(device_address);
    if (result < 0) {
        rl_log(RL_LOG_ERROR, "TSL4531 I2C communication failed; %d message: %s",
               errno, strerror(errno));
        return result;
    }
 
    // read sensor data word
    int32_t data = i2c_smbus_read_word_data(
        sensor_bus, TSL4531_COMMAND | TSL4531_REG_DATALOW);
    if (data < 0) {
        rl_log(RL_LOG_ERROR, "TSL4531 reading data word failed; %d message: %s",
               errno, strerror(errno));
        return data;
    }
 
    tsl4531_values[sensor_index] =
        (data & 0xffff) * tsl4531_multiplier[sensor_index];
 
    if (tsl4531_range[sensor_index] == TSL4531_RANGE_AUTO) {
        // Auto-Range
        tsl4531_range_t range_set = tsl4531_auto_range[sensor_index];
        switch (range_set) {
        case TSL4531_RANGE_LOW:
            if (tsl4531_values[sensor_index] >= TSL4531_RANGE_LOW_MAX) {
                tsl4531_auto_range[sensor_index] = TSL4531_RANGE_MEDIUM;
            }
            break;
        case TSL4531_RANGE_MEDIUM:
            if (tsl4531_values[sensor_index] >= TSL4531_RANGE_MEDIUM_MAX) {
                tsl4531_auto_range[sensor_index] = TSL4531_RANGE_HIGH;
            } else if (tsl4531_values[sensor_index] <
                       TSL4531_RANGE_LOW_MAX - TSL4531_RANGE_HYSTERESIS) {
                tsl4531_auto_range[sensor_index] = TSL4531_RANGE_LOW;
            }
            break;
        case TSL4531_RANGE_HIGH:
            if (tsl4531_values[sensor_index] <
                TSL4531_RANGE_MEDIUM_MAX - TSL4531_RANGE_HYSTERESIS) {
                tsl4531_auto_range[sensor_index] = TSL4531_RANGE_MEDIUM;
            }
            break;
        default:
            rl_log(RL_LOG_ERROR, "TSL4531 auto range logic failure");
            return ERROR;
        }
 
        int result = tsl4531_send_range(sensor_identifier,
                                        tsl4531_auto_range[sensor_index]);
        if (result < 0) {
            tsl4531_auto_range[sensor_index] = range_set;
            rl_log(RL_LOG_ERROR, "TSL4531 auto range update failed");
            return result;
        }
    }
 
    return 0;
}
 
int32_t tsl4531_get_value(int sensor_identifier, int channel) {
    if (channel > 0) {
        return 0;
    }
 
    int sensor_index = tsl4531_get_index(sensor_identifier);
 
    return tsl4531_values[sensor_index];
}
 
int tsl4531_set_range(int sensor_identifier, int range) {
    int sensor_index = tsl4531_get_index(sensor_identifier);
 
    int result = tsl4531_send_range(sensor_identifier, range);
    if (result < 0) {
        rl_log(RL_LOG_ERROR, "TSL4531 auto range update failed; %d message: %s",
               errno, strerror(errno));
        return result;
    }
 
    tsl4531_range[sensor_index] = range;
 
    return 0;
}
 
int tsl4531_get_range(int sensor_identifier) {
    int sensor_index = tsl4531_get_index(sensor_identifier);
 
    if (tsl4531_range[sensor_index] == TSL4531_RANGE_AUTO) {
        return tsl4531_auto_range[sensor_index];
    } else {
        return tsl4531_range[sensor_index];
    }
}
 
int tsl4531_get_id(void) {
    int sensor_bus = sensors_get_bus();
 
    int read_result =
        i2c_smbus_read_byte_data(sensor_bus, TSL4531_COMMAND | TSL4531_REG_ID);
 
    if (read_result < 0) {
        rl_log(RL_LOG_ERROR, "TSL4531 I2C error reading ID of sensor");
    }
    return read_result;
}
 
int tsl4531_set_parameters(int sensor_identifier) {
    int sensor_bus = sensors_get_bus();
 
    int result;
 
    result = i2c_smbus_write_byte_data(sensor_bus,
                                       TSL4531_COMMAND | TSL4531_REG_CONTROL,
                                       TSL4531_SAMPLE_CONTINUOUS);
    if (result < 0) {
        rl_log(RL_LOG_ERROR,
               "TSL4531 writing control register failed; %d message: %s", errno,
               strerror(errno));
        return result;
    }
 
    result = tsl4531_set_range(sensor_identifier, TSL4531_RANGE_AUTO);
    if (result < 0) {
        rl_log(RL_LOG_ERROR, "TSL4531 setting range failed; %d message: %s",
               errno, strerror(errno));
        return result;
    }
 
    return 0;
}
 
int tsl4531_send_range(int sensor_identifier, int range) {
    int sensor_index = tsl4531_get_index(sensor_identifier);
    int sensor_bus = sensors_get_bus();
 
    int result = -1;
 
    switch (range) {
    case TSL4531_RANGE_LOW:
        result = i2c_smbus_write_byte_data(
            sensor_bus, TSL4531_COMMAND | TSL4531_REG_CONFIG,
            TSL4531_INT_TIME_400 | TSL4531_LOW_POWER);
        if (result < 0) {
            rl_log(RL_LOG_ERROR,
                   "TSL4531 writing new range configuration failed; %d "
                   "message: %s",
                   errno, strerror(errno));
            return result;
        }
        tsl4531_multiplier[sensor_index] = TSL4531_MULT_400;
        break;
    case TSL4531_RANGE_MEDIUM:
        result = i2c_smbus_write_byte_data(
            sensor_bus, TSL4531_COMMAND | TSL4531_REG_CONFIG,
            TSL4531_INT_TIME_200 | TSL4531_LOW_POWER);
        if (result < 0) {
            rl_log(RL_LOG_ERROR,
                   "TSL4531 writing new range configuration failed; %d "
                   "message: %s",
                   errno, strerror(errno));
            return result;
        }
        tsl4531_multiplier[sensor_index] = TSL4531_MULT_200;
        break;
    case TSL4531_RANGE_HIGH:
        result = i2c_smbus_write_byte_data(
            sensor_bus, TSL4531_COMMAND | TSL4531_REG_CONFIG,
            TSL4531_INT_TIME_100 | TSL4531_LOW_POWER);
        if (result < 0) {
            rl_log(RL_LOG_ERROR,
                   "TSL4531 writing new range configuration failed; %d "
                   "message: %s",
                   errno, strerror(errno));
            return result;
        }
        tsl4531_multiplier[sensor_index] = TSL4531_MULT_100;
        break;
    case TSL4531_RANGE_AUTO:
        result = i2c_smbus_write_byte_data(
            sensor_bus, TSL4531_COMMAND | TSL4531_REG_CONFIG,
            TSL4531_INT_TIME_200 | TSL4531_LOW_POWER);
        if (result < 0) {
            rl_log(RL_LOG_ERROR,
                   "TSL4531 writing new range configuration failed; %d "
                   "message: %s",
                   errno, strerror(errno));
            return result;
        }
        tsl4531_multiplier[sensor_index] = TSL4531_MULT_200;
        tsl4531_auto_range[sensor_index] = TSL4531_RANGE_MEDIUM;
        break;
    default:
        rl_log(RL_LOG_ERROR, "TSL4531 invalid range");
        errno = EINVAL;
        return result;
    }
 
    return 0;
}
 
int tsl4531_get_index(int sensor_identifier) {
    unsigned int index = 0;
    while (index < sizeof(tsl4531_sensors)) {
        if (sensor_identifier == tsl4531_sensors[index]) {
            return (int)index;
        }
        index++;
    }
    return -1;
}