Executing Gummiworms The trials and tribulations of a grumpy curmudgeonly old git

#include "Adafruit_TSL2561.h"
#include "wiringPi.h"
#include "wiringPiI2C.h"

/* Global Variables */
typedef int bool;
#define true 1
#define false 0

int _fd;
int _addr;
int _gain;
int _integrationtime;
bool _autogain;

#define VER "0.4a"

#define LED_PIN 21
#define ON 1
#define OFF 0
#define setupLed pinMode
#define led digitalWrite

#define ENABLE_PIN 18
#define COIL_A_1_PIN 4
#define COIL_A_2_PIN 17
#define COIL_B_1_PIN 23
#define COIL_B_2_PIN 24

#define gpioDirection pinMode
#define powerCoil digitalWrite

/* Stepper Motor Handling */

void setupStepperMotor(void) {
gpioDirection(ENABLE_PIN, OUTPUT);
gpioDirection(COIL_A_1_PIN, OUTPUT);
gpioDirection(COIL_A_2_PIN, OUTPUT);
gpioDirection(COIL_B_1_PIN, OUTPUT);
gpioDirection(COIL_B_2_PIN, OUTPUT);
}

void doStep(int s1, int s2, int s3, int s4) {
powerCoil(COIL_A_1_PIN, s1);
powerCoil(COIL_A_2_PIN, s2);
powerCoil(COIL_B_1_PIN, s3);
powerCoil(COIL_B_2_PIN, s4);
}

void stepForward(int delay_ms, int steps) {
int i;
for(i=0; i<=steps; i++) {
doStep(ON, OFF, ON, OFF);
delay(delay_ms);
doStep(OFF, ON, ON, OFF);
delay(delay_ms);
doStep(OFF, ON, OFF, ON);
delay(delay_ms);
doStep(ON, OFF, OFF, ON);
delay(delay_ms);
}
}

void stepBackward(int delay_ms, int steps) {
int i;
for(i=0; i<=steps; i++) {
doStep(ON, OFF, OFF, ON);
delay(delay_ms);
doStep(OFF, ON, OFF, ON);
delay(delay_ms);
doStep(OFF, ON, ON, OFF);
delay(delay_ms);
doStep(ON, OFF, ON, OFF);
delay(delay_ms);
}
}

/* TSL2561 Functions (Copied from Adafruit_TSL2561.cpp at https://github.com/adafruit/Adafruit_TSL2561) */
/* enable TSL2561 by setting the control bit to 0x03 */
int enable() {
return wiringPiI2CWriteReg8(_fd, TSL2561_COMMAND_BIT | TSL2561_REGISTER_CONTROL,\
TSL2561_CONTROL_POWERON);
}

/* turn off the TSL2561 to save power */
int disable() {
return wiringPiI2CWriteReg8(_fd, TSL2561_COMMAND_BIT | TSL2561_REGISTER_CONTROL, \
TSL2561_CONTROL_POWEROFF);
}

void getData (uint16_t *broadband, uint16_t *ir)
{
enable();

/* Wait x ms for ADC to complete */
switch (_integrationtime)
{
case TSL2561_INTEGRATIONTIME_13MS:
delay(14);
break;
case TSL2561_INTEGRATIONTIME_101MS:
delay(102);
break;
default:
delay(403);
break;
}

/* Reads a two byte value from channel 0 (visible + infrared) */
*broadband = wiringPiI2CReadReg16(_fd, TSL2561_COMMAND_BIT | TSL2561_WORD_BIT | TSL2561_REGISTER_CHAN0_LOW);

/* Reads a two byte value from channel 1 (infrared) */
*ir = wiringPiI2CReadReg16(_fd, TSL2561_COMMAND_BIT | TSL2561_WORD_BIT | TSL2561_REGISTER_CHAN1_LOW);

/* Turn the device off to save power */
disable();
}

void setIntegrationTime(int time)
{
enable();

/* Update the timing register */
wiringPiI2CWriteReg8(_fd, TSL2561_COMMAND_BIT | TSL2561_REGISTER_TIMING, time | _gain);

/* Update value placeholders */
_integrationtime = time;

disable();
}

void setGain(int gain) {

enable();
wiringPiI2CWriteReg8(_fd, TSL2561_COMMAND_BIT | TSL2561_REGISTER_TIMING, _integrationtime | gain);
_gain = gain;
disable();
}

void enableAutoGain(bool enable)
{
_autogain = enable ? true : false;
}

uint32_t getFullLuminosity()
{
enable();

switch (_integrationtime)
{
case TSL2561_INTEGRATIONTIME_13MS:
delay(14);
break;
case TSL2561_INTEGRATIONTIME_101MS:
delay(102);
break;
default:
delay(403);
break;
}

uint32_t x;
x = wiringPiI2CReadReg16(_fd,TSL2561_COMMAND_BIT | TSL2561_WORD_BIT | TSL2561_REGISTER_CHAN1_LOW);
x <<= 16;
x |= wiringPiI2CReadReg16(_fd,TSL2561_COMMAND_BIT | TSL2561_WORD_BIT | TSL2561_REGISTER_CHAN0_LOW);

disable();

return x;
}

void getLuminosity (uint16_t *broadband, uint16_t *ir)
{
bool valid = false;

/* If Auto gain disabled get a single reading and continue */
if(!_autogain)
{
getData (broadband, ir);
return;
}

/* Read data until we find a valid range */
bool _agcCheck = false;
do
{
uint16_t _b, _ir;
uint16_t _hi, _lo;
int _it = _integrationtime;

/* Get the hi/low threshold for the current integration time */
switch(_it)
{
case TSL2561_INTEGRATIONTIME_13MS:
_hi = TSL2561_AGC_THI_13MS;
_lo = TSL2561_AGC_TLO_13MS;
break;
case TSL2561_INTEGRATIONTIME_101MS:
_hi = TSL2561_AGC_THI_101MS;
_lo = TSL2561_AGC_TLO_101MS;
break;
default:
_hi = TSL2561_AGC_THI_402MS;
_lo = TSL2561_AGC_TLO_402MS;
break;
}

getData(&_b, &_ir);

/* Run an auto-gain check if we haven't already done so ... */
if (!_agcCheck)
{
if ((_b < _lo) && (_gain == TSL2561_GAIN_1X))
{
/* Increase the gain and try again */
setGain(TSL2561_GAIN_16X);
/* Drop the previous conversion results */
getData(&_b, &_ir);
/* Set a flag to indicate we've adjusted the gain */
_agcCheck = true;
}
else if ((_b > _hi) && (_gain == TSL2561_GAIN_16X))
{
/* Drop gain to 1x and try again */
setGain(TSL2561_GAIN_1X);
/* Drop the previous conversion results */
getData(&_b, &_ir);
/* Set a flag to indicate we've adjusted the gain */
_agcCheck = true;
}
else
{
/* Nothing to look at here, keep moving ....
Reading is either valid, or we're already at the chips limits */
*broadband = _b;
*ir = _ir;
valid = true;
}
}
else
{
/* If we've already adjusted the gain once, just return the new results.
This avoids endless loops where a value is at one extreme pre-gain,
and the the other extreme post-gain */
*broadband = _b;
*ir = _ir;
valid = true;
}
} while (!valid);
}

uint32_t calculateLux(uint16_t broadband, uint16_t ir)
{
unsigned long chScale;
unsigned long channel1;
unsigned long channel0;

/* Make sure the sensor isn't saturated! */
uint16_t clipThreshold;
switch (_integrationtime)
{
case TSL2561_INTEGRATIONTIME_13MS:
clipThreshold = TSL2561_CLIPPING_13MS;
break;
case TSL2561_INTEGRATIONTIME_101MS:
clipThreshold = TSL2561_CLIPPING_101MS;
break;
default:
clipThreshold = TSL2561_CLIPPING_402MS;
break;
}

/* Return 0 lux if the sensor is saturated */
if ((broadband > clipThreshold) || (ir > clipThreshold))
{
return 0;
}

/* Get the correct scale depending on the intergration time */
switch (_integrationtime)
{
case TSL2561_INTEGRATIONTIME_13MS:
chScale = TSL2561_LUX_CHSCALE_TINT0;
break;
case TSL2561_INTEGRATIONTIME_101MS:
chScale = TSL2561_LUX_CHSCALE_TINT1;
break;
default: /* No scaling ... integration time = 402ms */
chScale = (1 << TSL2561_LUX_CHSCALE);
break;
}

/* Scale for gain (1x or 16x) */
if (!_gain) chScale = chScale << 4;

/* Scale the channel values */
channel0 = (broadband * chScale) >> TSL2561_LUX_CHSCALE;
channel1 = (ir * chScale) >> TSL2561_LUX_CHSCALE;

/* Find the ratio of the channel values (Channel1/Channel0) */
unsigned long ratio1 = 0;
if (channel0 != 0) ratio1 = (channel1 << (TSL2561_LUX_RATIOSCALE+1)) / channel0;

/* round the ratio value */
unsigned long ratio = (ratio1 + 1) >> 1;

unsigned int b, m;

#ifdef TSL2561_PACKAGE_CS
if ((ratio >= 0) && (ratio <= TSL2561_LUX_K1C))
{b=TSL2561_LUX_B1C; m=TSL2561_LUX_M1C;}
else if (ratio <= TSL2561_LUX_K2C)
{b=TSL2561_LUX_B2C; m=TSL2561_LUX_M2C;}
else if (ratio <= TSL2561_LUX_K3C)
{b=TSL2561_LUX_B3C; m=TSL2561_LUX_M3C;}
else if (ratio <= TSL2561_LUX_K4C)
{b=TSL2561_LUX_B4C; m=TSL2561_LUX_M4C;}
else if (ratio <= TSL2561_LUX_K5C)
{b=TSL2561_LUX_B5C; m=TSL2561_LUX_M5C;}
else if (ratio <= TSL2561_LUX_K6C)
{b=TSL2561_LUX_B6C; m=TSL2561_LUX_M6C;}
else if (ratio <= TSL2561_LUX_K7C)
{b=TSL2561_LUX_B7C; m=TSL2561_LUX_M7C;}
else if (ratio > TSL2561_LUX_K8C)
{b=TSL2561_LUX_B8C; m=TSL2561_LUX_M8C;}
#else
if ((ratio >= 0) && (ratio <= TSL2561_LUX_K1T))
{b=TSL2561_LUX_B1T; m=TSL2561_LUX_M1T;}
else if (ratio <= TSL2561_LUX_K2T)
{b=TSL2561_LUX_B2T; m=TSL2561_LUX_M2T;}
else if (ratio <= TSL2561_LUX_K3T)
{b=TSL2561_LUX_B3T; m=TSL2561_LUX_M3T;}
else if (ratio <= TSL2561_LUX_K4T)
{b=TSL2561_LUX_B4T; m=TSL2561_LUX_M4T;}
else if (ratio <= TSL2561_LUX_K5T)
{b=TSL2561_LUX_B5T; m=TSL2561_LUX_M5T;}
else if (ratio <= TSL2561_LUX_K6T)
{b=TSL2561_LUX_B6T; m=TSL2561_LUX_M6T;}
else if (ratio <= TSL2561_LUX_K7T)
{b=TSL2561_LUX_B7T; m=TSL2561_LUX_M7T;}
else if (ratio > TSL2561_LUX_K8T)
{b=TSL2561_LUX_B8T; m=TSL2561_LUX_M8T;}
#endif

unsigned long temp;
temp = ((channel0 * b) - (channel1 * m));

/* Do not allow negative lux value */
if (temp < 0) temp = 0;

/* Round lsb (2^(LUX_SCALE-1)) */
temp += (1 << (TSL2561_LUX_LUXSCALE-1));

/* Strip off fractional portion */
uint32_t lux = temp >> TSL2561_LUX_LUXSCALE;

/* Signal I2C had no errors */
return lux;
}

/* main() */
void main(void) {
_addr = TSL2561_ADDR_FLOAT;
_fd = wiringPiI2CSetup(_addr);
_integrationtime = TSL2561_INTEGRATIONTIME_402MS;

uint32_t shot;
uint16_t broadband, ir;
int hits;

int forever = true;
int sensitivity = 100; /* this is a percentage */

wiringPiSetupGpio ();
setupLed(LED_PIN, OUTPUT);
setupStepperMotor();

setGain(TSL2561_GAIN_16X);

printf("Welcome to RaspberryHunt version %s\n",VER);
printf("By Russell \"ukscone\" Davis 2013-03-22\n");

uint32_t baseline_lux;
getLuminosity(&broadband, &ir);
baseline_lux = calculateLux(broadband, ir);

hits = 0;