void Adafruit_MCP23008::digitalWrite(uint8_t p, uint8_t d) {
uint8_t gpio;
// only 8 bits!
if (p > 7)
return;
// read the current GPIO output latches
gpio = readGPIO();
// set the pin and direction
if (d == HIGH) {
gpio |= 1 << p;
} else {
gpio &= ~(1 << p);
}
// write the new GPIO
writeGPIO(gpio);
}
int main(void)
{
int fileHandleGPIO_LED;
int fileHandleGPIO_PROXY;
int i=0;
puts("Starting proximity reader on Galileo board.");
fileHandleGPIO_PROXY = openGPIO(GP_PROXY, GPIO_DIRECTION_IN);
if(ERROR == fileHandleGPIO_PROXY)
{
puts("Unable to open toggle Proximity port #8");
return(-1);
}
fileHandleGPIO_LED = openGPIO(GP_LED, GPIO_DIRECTION_OUT);
if(ERROR == fileHandleGPIO_LED)
{
puts("Unable to open toggle LED port #13");
return(-1);
}
//Switch off the LED before starting.
writeGPIO(fileHandleGPIO_LED, 0);
//set PWM parameters
openPWM(GP_PWM);
setPWMPeriod(1000000,GP_PWM);
enablePWM(1,GP_PWM);
setPWMDutyCycle(0,GP_PWM);
//Start an infinite loop to keep polling for proximity info
int proxyValue = 0;
while(1==1)
{
proxyValue = readGPIO(fileHandleGPIO_PROXY,GP_PROXY);
if(proxyValue == 1)
{
if(duty_cycle == 500000)
{
duty_cycle = 200000;
writeGPIO(fileHandleGPIO_LED, 0);
}
else
{
duty_cycle = 500000;
writeGPIO(fileHandleGPIO_LED, 1);
}
setPWMDutyCycle(duty_cycle,GP_PWM);
}
else
{
duty_cycle = 50000;
setPWMDutyCycle(0,GP_PWM);
writeGPIO(fileHandleGPIO_LED, 0);
}
usleep(1000*400);
}
closeGPIO(GP_LED, fileHandleGPIO_LED);
closeGPIO(GP_PROXY, fileHandleGPIO_PROXY);
closePWM(GP_PWM);
puts("Finished BURGLER ALARM on Galileo board.");
return 0;
}
void get()
{
int GetVal = 0;
printf("Sending Get Command\n");
writeGPIO(fileHandleGPIO_4, 0); //LSB
writeGPIO(fileHandleGPIO_5, 1);
writeGPIO(fileHandleGPIO_6, 0);
writeGPIO(fileHandleGPIO_7, 0); //MSB
sleep(1);
writeGPIO(fileHandleGPIO_S, 0);//PIC reads command
sleep(1);
writeGPIO(fileHandleGPIO_4, 0); //LSB
writeGPIO(fileHandleGPIO_5, 0);
writeGPIO(fileHandleGPIO_6, 0);
writeGPIO(fileHandleGPIO_7, 0); //MSB
closeGPIO(GP_4,fileHandleGPIO_4);
closeGPIO(GP_5,fileHandleGPIO_5);
closeGPIO(GP_6,fileHandleGPIO_6);
closeGPIO(GP_7,fileHandleGPIO_7);
sleep(1);
writeGPIO(fileHandleGPIO_S, 1);
sleep(1);//Wait for pic to output
fileHandleGPIO_4 = openGPIO(GP_4, GPIO_DIRECTION_IN);
fileHandleGPIO_5 = openGPIO(GP_5, GPIO_DIRECTION_IN);
fileHandleGPIO_6 = openGPIO(GP_6, GPIO_DIRECTION_IN);
fileHandleGPIO_7 = openGPIO(GP_7, GPIO_DIRECTION_IN);
sleep(1);
printf("Recieving First Nibble\n");
GetVal = ReadAndConvertVals();
closeGPIO(GP_4,fileHandleGPIO_4);
closeGPIO(GP_5,fileHandleGPIO_5);
closeGPIO(GP_6,fileHandleGPIO_6);
closeGPIO(GP_7,fileHandleGPIO_7);
sleep(1);
writeGPIO(fileHandleGPIO_S, 0);
sleep(1);
fileHandleGPIO_4 = openGPIO(GP_4, GPIO_DIRECTION_IN);
fileHandleGPIO_5 = openGPIO(GP_5, GPIO_DIRECTION_IN);
fileHandleGPIO_6 = openGPIO(GP_6, GPIO_DIRECTION_IN);
fileHandleGPIO_7 = openGPIO(GP_7, GPIO_DIRECTION_IN);
sleep(1);
printf("Recieving Second Nibble\n");
GetVal += ReadAndConvertVals2();
closeGPIO(GP_4,fileHandleGPIO_4);
closeGPIO(GP_5,fileHandleGPIO_5);
closeGPIO(GP_6,fileHandleGPIO_6);
closeGPIO(GP_7,fileHandleGPIO_7);
writeGPIO(fileHandleGPIO_S, 1);
sleep(1);
fileHandleGPIO_4 = openGPIO(GP_4, GPIO_DIRECTION_IN);
fileHandleGPIO_5 = openGPIO(GP_5, GPIO_DIRECTION_IN);
fileHandleGPIO_6 = openGPIO(GP_6, GPIO_DIRECTION_IN);
fileHandleGPIO_7 = openGPIO(GP_7, GPIO_DIRECTION_IN);
sleep(1);
printf("Recieving Last Crumb\n");
GetVal += ReadAndConvertVals3();
closeGPIO(GP_4,fileHandleGPIO_4);
closeGPIO(GP_5,fileHandleGPIO_5);
closeGPIO(GP_6,fileHandleGPIO_6);
closeGPIO(GP_7,fileHandleGPIO_7);
sleep(1);
writeGPIO(fileHandleGPIO_S, 0);
sleep(1);
fileHandleGPIO_4 = openGPIO(GP_4, GPIO_DIRECTION_IN);
fileHandleGPIO_5 = openGPIO(GP_5, GPIO_DIRECTION_IN);
fileHandleGPIO_6 = openGPIO(GP_6, GPIO_DIRECTION_IN);
fileHandleGPIO_7 = openGPIO(GP_7, GPIO_DIRECTION_IN);
double volts;
volts = (GetVal / 1023.0) * 5.0;
if(ReadAndConvertVals() == 14)
{
printf("ADC Value Acquisition Complete\n");
printf("ADC Value = %d\n", GetVal);
printf("Volts: %lf\n", volts);
}
else
{
printf("ADC Value Acquisition Failed\n");
}
return;
}
int clock(){
int i2cHandle;
printf("We're doing things!\n");
int deviceHandle;
initiateGPIO(GP_I2C);
i2cHandle = openGPIO(GP_I2C, GPIO_DIRECTION_OUT);
writeGPIO(i2cHandle, 0);
close(i2cHandle);
int readStatus;
int status;
char buffer[7];
buffer[0] = 0x00;
int deviceI2CAddress = 0x68;
if ((deviceHandle = open("/dev/i2c-0", O_RDWR)) < 0){
printf("Turns out we're not.\n");
return 1;
}
if(ioctl(deviceHandle, I2C_SLAVE, deviceI2CAddress) < 0){
printf("Error in ioctl\n");
return 1;
}
time_t result = time(NULL);
int sysSeconds, sysMinutes, sysHours, sysYears, sysDays, sysMonths;
if(result != -1)
{
struct tm *timeInfo;
timeInfo = gmtime(&result);
sysSeconds = timeInfo->tm_sec;
sysMinutes = timeInfo->tm_min;
sysHours = (timeInfo->tm_hour)%24;//HOUR
sysYears = (timeInfo->tm_year+1900) %100 ;
sysDays = timeInfo->tm_mday;
sysMonths = (timeInfo->tm_mon+1);
}
int lowSec = sysSeconds % 10;
lowSec &= 0x0f;
int highSec = (sysSeconds/10) << 4;
highSec &= 0x70;
int lowMin = sysMinutes % 10;
lowMin &= 0x0f;
int highMin = (sysMinutes/10) << 4;
highMin &= 0x70;
int miltime = 0b10111111;
int lowHour = sysHours % 10;
lowHour &= 0x0f;
int highHour = (sysHours /10) << 4;
highHour &= 0x30;
int lowDay = sysDays % 10;
lowDay &= 0x0f;
int highDay = (sysDays /10) <<4;
highDay &= 0x30;
int lowMonth = sysMonths % 10;
lowMonth &= 0x0f;
int highMonth = (sysMonths / 10) << 4;
highMonth &= 0x10;
int lowYear = sysYears % 10;
lowYear &= 0x0f;
int highYear = (sysYears / 10 ) << 4;
highYear &= 0xf0;
buffer[0] = 0x00; //first word, before we start writing data
buffer[1] = ( highSec | lowSec );
buffer[2] = ( highMin | lowMin); //
buffer[3] = ( highHour | lowHour);
buffer[4] = 0x01;
buffer[5] = (lowDay | highDay);
buffer[6] = (lowMonth | highMonth);
buffer[7] = (lowYear | highYear);
//Enable these lines to see time data while storing it
//printf("Date: %d - %d - %d\n", sysYears, sysMonths, sysDays);
//printf("Time: %d : %d : %d\n", sysHours, sysMinutes, sysSeconds);
status = write(deviceHandle, buffer, 7);
if(status != 7){
printf("Error: more error! (no ack bit)\n");
return 0;
}
buffer[0] = 0x00;
status = write (deviceHandle, buffer, 1);
if(status != 1){
printf("information!\n");
return -1;
}else{
status = read(deviceHandle, buffer, 7);
if(status != 7){
printf("Something's gone wrong again.\n");
return -1;
}
}
int year, month, day, hours, minutes, seconds;
highSec = (0x70 & buffer[0])>>4;
lowSec = 0x0f & buffer[0];
lowMin = 0x0f & buffer[1];
highMin = (0x70 & buffer[1])>>4;
lowHour = 0x0f & buffer[2];
highHour = (0x30 & buffer[2])>>4;
lowDay = 0x0f & buffer[4];
highDay = (0x30 & buffer[4])>>4;
lowMonth = 0x0f & buffer[5];
highMonth = (0x10 & buffer[5])>>4;
lowYear = 0x0f & buffer[6];
highYear = (0xf0 & buffer[6])>>4;
printf("Date: %d%d - %d%d - %d%d\n", highYear,lowYear,highMonth,lowMonth, highDay,lowDay);
printf("Time: %d%d : %d%d : %d%d\n", highHour,lowHour, highMin,lowMin, highSec, lowSec);
//More basic data to possibly print
//printf("Date: %d - %d - %d\n", year, month, day);
//printf("Time: %d : %d : %d\n", hours, minutes, seconds);
/*
int i;
for(i = 0; i < 7; i++){
printf("buffer[%d]: %d\n", i, buffer[i]);
}
*/
}
/* Function: main
Purpose: main program performs UI controls and forwards cmd
through function calls
Input:
void
Returns: o if clean termnation
*/
int main (void)
{
char cmd;
message msgOut;
message msgIn;
int i;
int strobeHandle;
int adcValue;
float voltage;
int dataPath[DATA_PATH_SIZE] = {GP_4, GP_5, GP_6, GP_7};
pthread_t displayThread;
pthread_mutex_init (&cGmutex, NULL);
initiateGPIO(Strobe);
initiateGPIOArray(dataPath, DATA_PATH_SIZE);
strobeHandle = openGPIO(Strobe, GPIO_DIRECTION_OUT);
writeGPIO(strobeHandle,1);
close(strobeHandle);
clearPAGE();
while (1)
{
printMenu();
cmd = getchar();
clearInputBuffer();
clearBelowLine(MSG_Y);
saveCursor();
switch (cmd)
{
case 'L':
{
msgOut.data = 0xD;
sendMessage(msgOut, dataPath);
msgIn = receiveMessage(dataPath);
gotoXY(MSG_X,MSG_Y);
clearLine(MSG_Y);
printf("Message Received: %X", msgIn.data);
gotoXY(STATUS_X,STATUS_Y);
clearLine(STATUS_Y);
setColor(RESET);
if (msgIn.data == 0xE)
{
printf("[\033[0;32m OK \033[m]\t LED Always On");
}
else if (msgIn.data == 0xC)
{
printf("[\033[0;32m OK \033[m]\t LED Triggered By Sensor");
}
else
{
printf("[\033[0;31m Error \033[m]\t Message Acknowledgment Failed");
}
break;
}
case 'P' :
{
msgOut.data = 0x1;
sendMessage(msgOut, dataPath);
msgIn = receiveMessage(dataPath);
gotoXY(MSG_X,MSG_Y);
clearLine(MSG_Y);
printf("Message Received: %X", msgIn.data);
gotoXY(STATUS_X,STATUS_Y);
clearLine(STATUS_Y);
setColor(RESET);
if (msgIn.data == 0xE)
{
printf("[\033[0;32m OK \033[m]\t Ping Successful");
}
else
{
printf("[\033[0;31m Error \033[m]\t Message Acknowledgment Failed");
}
break;
}
case 'R' :
{
msgOut.data = 0x0;
sendMessage(msgOut, dataPath);
msgIn = receiveMessage(dataPath);
gotoXY(MSG_X,MSG_Y);
clearLine(MSG_Y);
printf("Message Received: %X", msgIn.data);
gotoXY(STATUS_X,STATUS_Y);
clearLine(STATUS_Y);
setColor(RESET);
if (msgIn.data == 0xE)
{
printf("[\033[0;32m OK \033[m]\t Reset Successful");
}
else
{
printf("[\033[0;31m Error \033[m]\t Message Acknowledgment Failed");
}
break;
}
case 'G' :
{
adcValue = 0;
voltage = 0;
msgOut.data = 0x2;
sendMessage(msgOut, dataPath);
for (i = 2; i >= 0; i--)
{
msgIn = receiveMessage(dataPath);
adcValue |= (msgIn.data << (i * DATA_PATH_SIZE));
gotoXY(MSG_X,MSG_Y);
clearLine(MSG_Y);
printf("Message Received: %X", msgIn.data);
}
msgIn = receiveMessage(dataPath);
if (msgIn.data == 0xE)
{
adcValue &= 0x3FF;
voltage = (float) ((adcValue/1024.0) * 5.0);
setColor(YELLOW);
gotoXY(MSG_X,MSG_Y + 1);
printf("ADC Value: 0x%X", adcValue);
gotoXY(MSG_X,MSG_Y + 2);
printf("Voltage: %lf \033[u", voltage);
gotoXY(STATUS_X,STATUS_Y);
setColor(RESET);
printf("[\033[0;32m OK \033[m]\t ADC Read Successful \033[u");
}
else
{
gotoXY(STATUS_X,STATUS_Y);
clearLine(STATUS_Y);
setColor(RESET);
printf("[\033[0;31m Error \033[m]\t Message Acknowledgment Failed \033[u");
}
break;
}
case 'T' :
{
msgOut.data = 0x3;
sendMessage(msgOut, dataPath);
msgIn = receiveMessage(dataPath);
gotoXY(MSG_X,MSG_Y);
clearLine(MSG_Y);
printf("Message Received: %X", msgIn.data);
gotoXY(STATUS_X,STATUS_Y);
clearLine(STATUS_Y);
setColor(RESET);
if (msgIn.data == 0xE)
{
printf("[\033[0;32m OK \033[m]\t ADC Toggled On");
}
else if (msgIn.data == 0xC)
{
printf("[\033[0;32m OK \033[m]\t ADC Toggled Off");
}
break;
}
case 'D':
{
pthread_mutex_lock (&cGmutex);
continueGraphing = true;
pthread_mutex_unlock (&cGmutex);
pthread_create(&displayThread, NULL, graphVoltage, &dataPath);
getchar();
pthread_mutex_lock (&cGmutex);
continueGraphing = false;
pthread_mutex_unlock (&cGmutex);
pthread_join(displayThread, NULL);
clearPAGE();
break;
}
case 'Q':
{
gotoXY(MSG_X,MSG_Y);
clearLine(MSG_Y);
printf("[\033[0;32m OK \033[m]\t ThankYou For UsingLightSensor");
unexport(Strobe);
unexportArray(dataPath, DATA_PATH_SIZE);
printf("\033[2J\033[0;0H\033[m");
exit(0);
}
}
recallCursor();
}
return (0);
}
void updateLedBat(void){
static int time1 = 0, state_led_red = 1;
static int time0 = -1;
float tension;
// TODO accès concurentiel
tension = volt;
if(time0 < 0) time0 = millis();
if((time1 - time0) > (SEC_DSPL_TENSION * 1000) ){
time0 = time1;
printf("Battery's tension = %.1lf V\n", tension);
if(tension > MAX_THRESHOLD_TENS){
writeGPIO(GREEN_LED_BIC, "high");
writeGPIO(RED_LED_BIC, "low");
}
else{
if(tension > MIN_THRESHOLD_TENS){
writeGPIO(RED_LED_BIC, "high");
writeGPIO(GREEN_LED_BIC, "high");
}
else{
switch(state_led_red){
case 0 : writeGPIO(RED_LED_BIC, "low"); state_led_red = 1; break;
case 1 : writeGPIO(RED_LED_BIC, "high"); state_led_red = 0; break;
default : alert(); perror("Error in funcion ""updateLedBat"" for state_led_red"); break;
}
writeGPIO(GREEN_LED_BIC, "low");
}
}
}
time1 = millis();
/*
// Update orange led in function of button STOP
pthread_mutex_lock(&mtx_order);
if(order == MVT){
writeGPIO(ORANGE_LED, "low");
writeGPIO(GREEN_LED, "high");
}
else{
writeGPIO(ORANGE_LED, "high");
writeGPIO(GREEN_LED, "low");
}
pthread_mutex_unlock(&mtx_order);
// Update orange led in function of sonar
int stateLED_Sonar = 0;
static int time1Sonar = 0;
static int time0Sonar = -1;
int dst_sonar;
pthread_mutex_lock(&mtx_distSonar);
dst_sonar = distSonar;
pthread_mutex_unlock(&mtx_distSonar);
while(dst_sonar < DIST_MIN_SONAR){
time1Sonar = millis();
switch(stateLED_Sonar){
case 0: writeGPIO(ORANGE_LED, "high");
if((time1Sonar - time0Sonar) > TIME_BLINK_SONAR){
stateLED_Sonar = 1;
time0Sonar = millis();
}
break;
case 1: writeGPIO(ORANGE_LED, "low");
if((time1Sonar - time0Sonar) > TIME_BLINK_SONAR){
stateLED_Sonar = 0;
time0Sonar = millis();
}
break;
default: break;
}
}*/
}
