Merge pull request #15 from Seeed-Studio/Si1151

Si1151

Si115X.cpp

@@ -0,0 +1,232 @@
+#include <Arduino.h>
+#include "Si115X.h"
+
+// Si115X::Si115X() {
+// 	//empty constructor
+// }
+
+/**
+ * Configures a channel at a given index
+ */
+
+void Si115X::config_channel(uint8_t index, uint8_t *conf){
+    int len = sizeof(conf);
+  
+    if(len != 4 || index > 5)
+      return;
+
+    int inc = index * len;
+    
+    // ADCCONFIGx: 
+    // - bits[7] - Reserved
+    // - bits[6:5] - A/D conversion rate
+    // - bits[4:0] - ADC MUX select (see below)
+    //      00000 - Small IR   00001 - Medium IR   00010 - Large IR
+    //      01011 - Visible    01101 - Large Visible
+    param_set(Si115X::ADCCONFIG_0 + inc, conf[0]);
+
+    // ADCSENSx:
+    // - bits[7] - ADC high signal range enable
+    // - bits[6:4] - an internal accumulation of samples
+    // - bits[3:0] - Measurement time for 512 decimation rate
+    param_set(Si115X::ADCSENS_0 + inc, conf[1]);
+
+    // ADCPOSTx:
+    // - bits[7] - Reserved
+    // - bits[6] - HOSTOUTx size(0 = 16 bits, 1 = 24 bits)
+    // - bits[5:3] - Number of bits to shift right of the output
+    // - bits[2] - Threshold polarity
+    // - bits[1:0] - Threshold enable
+    param_set(Si115X::ADCPOST_0 + inc, conf[2]);
+
+    // MEASCONFIGx:
+    // - bits[7:6] - MEASCOUNTx select
+    // - bits[5:4] - Reserved
+    // - bits[3] - LEDx_A or LEDx_B BANK select
+    // - bits[2:0] - LEDx enable
+    param_set(Si115X::MEASCONFIG_0 + inc, conf[3]);   
+}
+
+/**
+ * Writes data over i2c
+ */
+void Si115X::write_data(uint8_t addr, uint8_t *data, size_t len){
+    Wire.beginTransmission(addr);
+    Wire.write(data, len);
+    Wire.endTransmission();
+}
+
+/**
+ * Reads data from a register over i2c
+ */
+int Si115X::read_register(uint8_t addr, uint8_t reg, int bytesOfData){
+    int val = -1;
+  
+    Si115X::write_data(addr, &reg, sizeof(reg));
+    Wire.requestFrom(addr, bytesOfData);
+  
+    if(Wire.available())
+      val = Wire.read();
+	
+    return val;
+}
+
+/**
+ * param set as shown in the datasheet
+ */
+void Si115X::param_set(uint8_t loc, uint8_t val){
+    uint8_t packet[2];
+    int r;
+    int cmmnd_ctr;
+
+    do {
+        cmmnd_ctr = Si115X::read_register(Si115X::DEVICE_ADDRESS, Si115X::RESPONSE_0, 1);
+      
+        packet[0] = Si115X::HOSTIN_0;
+        packet[1] = val;
+        Si115X::write_data(Si115X::DEVICE_ADDRESS, packet, sizeof(packet));
+      
+        packet[0] = Si115X::COMMAND;
+        packet[1] = loc | (0B10 << 6);
+        Si115X::write_data(Si115X::DEVICE_ADDRESS, packet, sizeof(packet));
+      
+        r = Si115X::read_register(Si115X::DEVICE_ADDRESS, Si115X::RESPONSE_0, 1);	    
+    } while(r > cmmnd_ctr); 
+}
+
+/**
+ * param query as shown in the datasheet
+ */
+int Si115X::param_query(uint8_t loc){
+    int result = -1;
+    uint8_t packet[2];
+    int r;
+    int cmmnd_ctr;
+
+    do {
+        cmmnd_ctr = Si115X::read_register(Si115X::DEVICE_ADDRESS, Si115X::RESPONSE_0, 1);
+	    
+        packet[0] = Si115X::COMMAND;
+        packet[1] = loc | (0B01 << 6);
+	    
+        Si115X::write_data(Si115X::DEVICE_ADDRESS, packet, sizeof(packet));
+	    
+        r = Si115X::read_register(Si115X::DEVICE_ADDRESS, Si115X::RESPONSE_0, 1);
+    } while(r > cmmnd_ctr);
+	
+    result = Si115X::read_register(Si115X::DEVICE_ADDRESS, Si115X::RESPONSE_1, 1);
+	
+    return result;
+}
+
+/**
+ * Sends command to the command register
+ */
+void Si115X::send_command(uint8_t code){
+    uint8_t packet[2];
+    int r;
+    int cmmnd_ctr;
+    do {
+        cmmnd_ctr = Si115X::read_register(Si115X::DEVICE_ADDRESS, Si115X::RESPONSE_0, 1);
+	    
+        packet[0] = Si115X::COMMAND;
+        packet[1] = code;
+	    
+        Si115X::write_data(Si115X::DEVICE_ADDRESS, packet, sizeof(packet));
+	    
+        r = Si115X::read_register(Si115X::DEVICE_ADDRESS, Si115X::RESPONSE_0, 1); 
+    } while(r > cmmnd_ctr);
+}
+
+/**
+ * Returns int given a byte array
+ */
+int Si115X::get_int_from_bytes(uint8_t *data, size_t len){
+    int result = 0;
+    int shift = 8 * len;
+	
+    for(size_t i = 0; i < len; i++){
+        shift -= 8;
+        result |= ((data[i] << shift) & (0xFF << shift));
+    }
+	
+    return result;
+}
+
+
+
+
+bool Si115X::Begin(bool mode){
+    is_autonomous = mode;
+    Wire.begin();
+    // Wire.setClock(400000);
+    // send_command(RESET_SW);
+    if (ReadByte(0x00) != 0x51) {
+        return false;
+    }
+
+    // Enable 2 channels for proximity measurement
+    param_set(CHAN_LIST, 0B000011);
+    // Enable Interrupt
+    write_register(DEVICE_ADDRESS, IRQ_ENABLE, 0B000011);
+    // Initialize LED current
+    param_set(LED1_A, 0x3F);
+    param_set(LED1_B, 0x3F);
+
+    // Configure ADC and enable LED drive
+    if (is_autonomous) {
+        param_set(MEASRATE_H, 0);
+        param_set(MEASRATE_L, 1);  // 1 for a base period of 800 us
+        param_set(MEASCOUNT_0, 1); 
+        param_set(MEASCOUNT_1, 1);
+        param_set(THRESHOLD0_L, 0);
+        param_set(THRESHOLD0_H, 0);
+        uint8_t conf[4]; // ADCCONFIGx, ADCSENSx, ADCPOSTx, MEASCONFIGx
+        conf[0] = 0B01100000; // 1x Small IR
+        conf[1] = 0B00000010; // 48.8us Nominal Measurement time for 512 decimation rate
+        conf[2] = 0B00000001; // 16-bits output, Interrupt when the measurement is larger than THRESHOLD0
+        conf[3] = 0B01000001; // enable LED1A, the time between measurements is 800*MEASRATE*MEASCOUNT0 us
+        config_channel(0, conf);
+        conf[0] = 0B01101101; // 1x Visible
+        conf[1] = 0B00000010; // 48.8us Nominal Measurement time for 512 decimation rate
+        conf[2] = 0B00000001; // 16-bits output, Interrupt when the measurement is larger than THRESHOLD0
+        conf[3] = 0B10001001; // enable LED1B, the time between measurements is 800*MEASRATE*MEASCOUNT1 us
+        config_channel(1, conf);
+        send_command(START);
+    }
+    else {
+        param_set(ADCCONFIG_0, 0B01100000);
+        param_set(MEASCONFIG_0, 0x00);
+        param_set(ADCPOST_0, 0x00);
+        param_set(ADCCONFIG_1, 0B01101101);
+        param_set(MEASCONFIG_1, 0x00);
+        param_set(ADCPOST_1, 0x00);
+    }
+
+    return true;
+
+}
+
+uint16_t Si115X::ReadIR(void) {
+    if (!is_autonomous) send_command(FORCE);
+    uint8_t data[2];
+    data[0] = read_register(DEVICE_ADDRESS, HOSTOUT_0);
+    data[1] = read_register(DEVICE_ADDRESS, HOSTOUT_1);
+    return (data[0] << 8) + data[1];
+}
+
+uint16_t Si115X::ReadVisible(void) {
+    if (!is_autonomous) send_command(FORCE);
+    uint8_t data[2];
+    data[0] = read_register(DEVICE_ADDRESS, HOSTOUT_2);
+    data[1] = read_register(DEVICE_ADDRESS, HOSTOUT_3);
+    return (data[0] << 8) + data[1];
+}
+
+uint8_t Si115X::ReadByte(uint8_t Reg) {
+    Wire.beginTransmission(DEVICE_ADDRESS);
+    Wire.write(Reg);
+    Wire.endTransmission();
+    Wire.requestFrom(DEVICE_ADDRESS, 1);
+    return Wire.read();
+}

Si115X.h

@@ -0,0 +1,152 @@
+#ifndef SI115X_H
+#define SI115X_H
+
+#include <Arduino.h>
+#include <Wire.h>
+
+class Si115X
+{
+	public:
+		typedef enum {
+			DEVICE_ADDRESS = 0x53			
+		} UnitAddress;
+
+		typedef enum {
+			RESET_CMD_CTR = 0x00,
+			RESET_SW = 0x01,
+			FORCE = 0x11,
+			PAUSE = 0x12,
+			START = 0x13
+		} CommandCodes;
+		
+		typedef enum {	
+			PART_ID = 0x00,
+			REV_ID = 0x01,
+			MFR_ID = 0x02,
+			INFO_0 = 0x03,
+			INFO_1 = 0x04,
+			HOSTIN_3 = 0x07,
+			HOSTIN_2 = 0x08,
+	
+			HOSTIN_0 = 0x0A,
+			COMMAND = 0x0B,
+			IRQ_ENABLE = 0x0F,
+			RESPONSE_0 = 0x11,
+			RESPONSE_1 = 0x10,
+			
+			IRQ_STATUS = 0x12,
+			HOSTOUT_0 = 0x13,
+			HOSTOUT_1 = 0x14,
+			HOSTOUT_2 = 0x15,
+			HOSTOUT_3 = 0x16,
+			HOSTOUT_4 = 0x17,
+			HOSTOUT_5 = 0x18,
+			HOSTOUT_6 = 0x19,
+			HOSTOUT_7 = 0x1A,
+			HOSTOUT_8 = 0x1B,
+			HOSTOUT_9 = 0x1C,
+			HOSTOUT_10 = 0x1D,
+			HOSTOUT_11 = 0x1E,
+			HOSTOUT_12 = 0x1F,
+			HOSTOUT_13 = 0x20,
+			HOSTOUT_14 = 0x21,
+			HOSTOUT_15 = 0x22,
+			HOSTOUT_16 = 0x23,
+			HOSTOUT_17 = 0x24,
+			HOSTOUT_18 = 0x25,
+			HOSTOUT_19 = 0x26,
+			HOSTOUT_20 = 0x27,
+			HOSTOUT_21 = 0x28,
+			HOSTOUT_22 = 0x29,
+			HOSTOUT_23 = 0x2A,
+			HOSTOUT_24 = 0x2B,
+			HOSTOUT_25 = 0x2C	
+		} RegisterAddress;
+
+		typedef enum {		
+			I2C_ADDR = 0x00,
+			CHAN_LIST = 0x01,
+
+			ADCCONFIG_0 = 0x02,
+			ADCSENS_0 = 0x03,
+			ADCPOST_0 = 0x04,
+			MEASCONFIG_0 = 0x05,
+			
+			ADCCONFIG_1 = 0x06,
+			ADCPOST_1 = 0x08,
+			ADCSENS_1 = 0x07,
+			MEASCONFIG_1 = 0x09,
+
+			ADCCONFIG_2 = 0x0A,
+			ADCSENS_2 = 0x0B,
+			ADCPOST_2 = 0x0C,
+			MEASCONFIG_2 = 0x0D,
+
+			ADCCONFIG_3 = 0x0E,
+			ADCSENS_3 = 0x0F,
+			ADCPOST_3 = 0x10,
+			MEASCONFIG_3 = 0x11,
+
+			ADCCONFIG_4 = 0x12,
+			ADCSENS_4 = 0x13,
+			ADCPOST_4 = 0x14,
+			MEASCONFIG_4 = 0x15,
+
+			ADCCONFIG_5 = 0x16,
+			ADCSENS_5 = 0x17,
+			ADCPOST_5 = 0x18,
+			MEASCONFIG_5 = 0x19,
+			
+			MEASRATE_H = 0x1A,
+			MEASRATE_L = 0x1B,
+			MEASCOUNT_0 = 0x1C,
+			MEASCOUNT_1 = 0x1D,
+			MEASCOUNT_2 = 0x1E,
+			
+			LED1_A = 0x1F,
+			LED1_B = 0x20,
+			LED2_A = 0x21,
+			LED2_B = 0x22,
+			LED3_A = 0x23,
+			LED3_B = 0x24,
+
+			THRESHOLD0_H = 0x25,
+			THRESHOLD0_L = 0x26,
+			THRESHOLD1_H = 0x27,
+			THRESHOLD1_L = 0x28,
+			THRESHOLD2_H = 0x29,
+			THRESHOLD2_L = 0x2A,
+
+			BURST = 0x2B			
+		} ParameterAddress;
+		
+		// Si115X();
+		void config_channel(uint8_t index, uint8_t *conf);
+		void write_data(uint8_t addr, uint8_t *data, size_t len);
+		int read_register(uint8_t addr, uint8_t reg, int bytesOfData);
+		uint8_t read_register(uint8_t addr, uint8_t reg) {
+			return read_register(addr, reg, 1);
+		}
+		void write_register(uint8_t addr, uint8_t reg, uint8_t val) {
+			uint8_t data[2] = {reg, val};
+			write_data(addr, data, 2);
+		}
+
+		void param_set(uint8_t loc, uint8_t val);
+		int param_query(uint8_t loc);
+		void send_command(uint8_t code);
+		int get_int_from_bytes(uint8_t *data, size_t len);
+
+		bool Begin(bool mode);
+		bool Begin(void) {
+			return Begin(false);
+		}
+		uint16_t ReadIR(void);
+		uint16_t ReadVisible(void);
+		uint8_t ReadByte(uint8_t Reg);
+
+	private:
+		bool is_autonomous;
+};
+
+#endif

examples/Si1151/Si1151.ino

@@ -0,0 +1,35 @@
+#include "Si115X.h"
+
+Si115X si1151;
+
+/**
+ * Setup for configuration
+ */
+void setup()
+{
+    Wire.begin();
+    Serial.begin(115200);
+    if (!si1151.Begin()) {
+        Serial.println("Si1151 is not ready!");
+        while (1) {
+            delay(1000);
+            Serial.print(".");
+        };
+    }
+    else {
+        Serial.println("Si1151 is ready!");
+    }
+}
+
+/**
+ * Loops and reads data from registers
+ */
+void loop()
+{
+    Serial.print("IR: ");
+    Serial.println(si1151.ReadIR());
+    Serial.print("Visible: ");
+    Serial.println(si1151.ReadVisible());
+
+    delay(500);
+}