X-Git-Url: https://git.ucc.asn.au/?p=tpg%2Fopendispense2.git;a=blobdiff_plain;f=src%2Fserver%2Fhandler_coke.c;h=09bcc8e95d4482feb17346a6c77b962a1875541d;hp=cd02fa737355516e12ccea76c3f8e7d50aa00056;hb=ec400f11ebc2e81079e464145915fb2d25602fbc;hpb=94a66383f886eaecb7ff641785117247784900c8 diff --git a/src/server/handler_coke.c b/src/server/handler_coke.c index cd02fa7..09bcc8e 100644 --- a/src/server/handler_coke.c +++ b/src/server/handler_coke.c @@ -6,6 +6,9 @@ * * This file is licenced under the 3-clause BSD Licence. See the file * COPYING for full details. + * + * NOTES: + * - Remember, the coke machine echoes your text back to you! */ #include "common.h" #include @@ -14,13 +17,21 @@ #include #include #include +#include +#include + +#define READ_TIMEOUT 2 // 2 seconds for ReadChar +#define TRACE_COKE 1 // === IMPORTS === // === PROTOTYPES === int Coke_InitHandler(); + int Coke_int_GetSlotStatus(char *Buffer, int Slot); +void Coke_int_UpdateSlotStatuses(void); int Coke_CanDispense(int User, int Item); int Coke_DoDispense(int User, int Item); + int Writef(const char *Format, ...); int WaitForColon(); int ReadLine(int len, char *output); @@ -34,6 +45,8 @@ tHandler gCoke_Handler = { char *gsCoke_SerialPort = "/dev/ttyS0"; int giCoke_SerialFD; regex_t gCoke_StatusRegex; + int gaCoke_CachedStatus[7]; +pthread_mutex_t gCoke_Mutex = PTHREAD_MUTEX_INITIALIZER; // == CODE === int Coke_InitHandler() @@ -44,41 +57,162 @@ int Coke_InitHandler() if( giCoke_SerialFD == -1 ) { fprintf(stderr, "ERROR: Unable to open coke serial port ('%s')\n", gsCoke_SerialPort); } + else { + // Reset the slot names. + // - Dunno why this is needed, but the machine plays silly + // sometimes. + Writef("n0 Slot0\n"); + if( !WaitForColon() ) + { + Writef("n1 Slot1\n"); + WaitForColon(); + Writef("n2 Slot2\n"); + WaitForColon(); + Writef("n3 Slot3\n"); + WaitForColon(); + Writef("n4 Slot4\n"); + WaitForColon(); + Writef("n5 Slot5\n"); + WaitForColon(); + Writef("n6 Coke\n"); + + Coke_int_UpdateSlotStatuses(); + } + } + + AddPeriodicFunction(Coke_int_UpdateSlotStatuses); - CompileRegex(&gCoke_StatusRegex, "^slot\\s+(\\d)\\s+([^:]+):([a-zA-Z]+)\\s*", REG_EXTENDED); + CompileRegex(&gCoke_StatusRegex, "^slot\\s+([0-9]+)\\s+([^:]+):([a-zA-Z]+)\\s*", REG_EXTENDED); return 0; } -int Coke_CanDispense(int User, int Item) +int Coke_int_GetSlotStatus(char *Buffer, int Slot) +{ + regmatch_t matches[4]; + int ret; + char *status; + + // Parse status response + ret = RunRegex(&gCoke_StatusRegex, Buffer, sizeof(matches)/sizeof(matches[0]), matches, "Bad Response"); + if( ret ) { + return -1; + } + + // Get slot status + Buffer[ matches[3].rm_eo ] = '\0'; + status = &Buffer[ matches[3].rm_so ]; + + #if TRACE_COKE + printf("Coke_CanDispense: Machine responded slot status '%s'\n", status); + #endif + + if( strcmp(status, "full") == 0 ) { + gaCoke_CachedStatus[Slot] = 0; // 0: Avaliiable + return 0; + } + else { + gaCoke_CachedStatus[Slot] = 1; // 1: Empty + return 1; + } +} + +void Coke_int_UpdateSlotStatuses(void) +{ + int i; + int len; + char tmp[40]; + + pthread_mutex_lock(&gCoke_Mutex); + + if( WaitForColon() ) return ; + Writef("d7\r\n"); // Update slot statuses + WaitForColon(); + Writef("s\n"); + ReadLine(sizeof tmp, tmp); // Read back what we just said + + for( i = 0; i <= 6; i ++ ) + { + len = ReadLine(sizeof tmp, tmp); + if( len == -1 ) return ; // I give up :( + Coke_int_GetSlotStatus(tmp, i); + } + pthread_mutex_unlock(&gCoke_Mutex); +} + +int Coke_CanDispense(int UNUSED(User), int Item) { - char tmp[32], *status; + // Disabled in favor of caching + #if 0 + char tmp[40], *status; regmatch_t matches[4]; int ret; // Sanity please if( Item < 0 || Item > 6 ) return -1; // -EYOURBAD - write(giCoke_SerialFD, "d7\r\n", 4); - write(giCoke_SerialFD, "d7\r\n", 4); - write(giCoke_SerialFD, "d7\r\n", 4); + // Can't dispense if the machine is not connected + if( giCoke_SerialFD == -1 ) + return -2; - if( WaitForColon() ) { + #if TRACE_COKE + printf("Coke_CanDispense: Flushing\n"); + #endif + + + // Wait for a prompt + ret = 0; + while( WaitForColon() && ret < 3 ) + { + // Flush the input buffer + char tmpbuf[512]; + read(giCoke_SerialFD, tmpbuf, sizeof(tmpbuf)); + #if TRACE_COKE + printf("Coke_CanDispense: sending 'd7'\n"); + #endif + Writef("d7\r\n"); + ret ++; + } + // Check for a timeout error + if( !(ret < 3) ) { fprintf(stderr, "Coke machine timed out\n"); return -2; // -EMYBAD } - // Ask the coke machine - sprintf(tmp, "s%i\r\n", Item); - write(giCoke_SerialFD, tmp, 4); - - if( WaitForColon() ) { - fprintf(stderr, "Coke machine timed out (after initial)\n"); - return -2; // -EMYBAD + // You need to do a 'd7' before reading the status + // - Otherwise it sometimes reports a full slot as empty + // [TPG] (2011-02-19) + if( ret == 0 ) + { + Writef("d7\r\n"); + WaitForColon(); } - ret = ReadLine(sizeof(tmp)-1, tmp); - printf("ret = %i, tmp = '%s'\n", ret, tmp); + // TODO: Handle "not ok" response to D7 + #if TRACE_COKE + printf("Coke_CanDispense: sending 's%i'\n", Item); + #endif + + // Ask the coke machine + Writef("s%i\r\n", Item); + + #if TRACE_COKE + printf("Coke_CanDispense: reading response\n"); + #endif + // Read from the machine (ignoring empty lines) + while( (ret = ReadLine(sizeof(tmp)-1, tmp)) == 0 ); + #if TRACE_COKE + printf("ret = %i, tmp = '%s'\n", ret, tmp); + #endif + // Read back-echoed lines + while( tmp[0] == ':' || tmp[1] != 'l' ) + { + ret = ReadLine(sizeof(tmp)-1, tmp); + if( ret == -1 ) return -1; + printf("ret = %i, tmp = '%s'\n", ret, tmp); + } + + // Catch an error if( ret <= 0 ) { fprintf(stderr, "Coke machine is not being chatty (read = %i)\n", ret); if( ret == -1 ) { @@ -86,50 +220,108 @@ int Coke_CanDispense(int User, int Item) } return -1; } - ret = RunRegex(&gCoke_StatusRegex, tmp, sizeof(matches)/sizeof(matches[0]), matches, "Bad Response"); - if( ret ) { - return -1; - } - - tmp[ matches[3].rm_eo ] = '\0'; - status = &tmp[ matches[3].rm_so ]; - - printf("Machine responded slot status '%s'\n", status); + + #if TRACE_COKE + printf("Coke_CanDispense: wait for the prompt again\n"); + #endif - if( strcmp(status, "full") == 0 ) - return 0; + // Eat rest of response + WaitForColon(); - return 1; + return Coke_GetSlotStatus(tmp, Item); + #else + // Sanity please + if( Item < 0 || Item > 6 ) return -1; // -EYOURBAD + + // Can't dispense if the machine is not connected + if( giCoke_SerialFD == -1 ) + return -2; + + return gaCoke_CachedStatus[Item]; + #endif } /** * \brief Actually do a dispense from the coke machine */ -int Coke_DoDispense(int User, int Item) +int Coke_DoDispense(int UNUSED(User), int Item) { - char tmp[32], *status; - regmatch_t matches[4]; + char tmp[32]; + int ret, len; // Sanity please if( Item < 0 || Item > 6 ) return -1; - WaitForColon(); + // Can't dispense if the machine is not connected + if( giCoke_SerialFD == -1 ) + return -2; + + // LOCK + pthread_mutex_lock(&gCoke_Mutex); + + #if TRACE_COKE + printf("Coke_DoDispense: flushing input\n"); + #endif + + // Wait for prompt + ret = 0; + while( WaitForColon() && ret < 3 ) + { + // Flush the input buffer + char tmpbuf[512]; + read(giCoke_SerialFD, tmpbuf, sizeof(tmpbuf)); + #if TRACE_COKE + printf("Coke_DoDispense: sending 'd7'\n"); + #endif + Writef("d7\r\n"); + } + #if TRACE_COKE + printf("Coke_DoDispense: sending 'd%i'\n", Item); + #endif // Dispense - sprintf(tmp, "d%i\r\n", Item); - write(giCoke_SerialFD, tmp, 4); + Writef("d%i\r\n", Item); - WaitForColon(); + // Read empty lines and echo-backs + do { + ret = ReadLine(sizeof(tmp)-1, tmp); + if( ret == -1 ) { + pthread_mutex_unlock(&gCoke_Mutex); + return -1; + } + #if TRACE_COKE + printf("Coke_DoDispense: read %i '%s'\n", ret, tmp); + #endif + } while( ret == 0 || tmp[0] == ':' || tmp[0] == 'd' ); - // Get status - ReadLine(sizeof(tmp)-1, tmp); + WaitForColon(); // Eat up rest of response - tmp[ matches[3].rm_eo ] = '\0'; - status = &tmp[ matches[3].rm_so ]; - - printf("Machine responded slot status '%s'\n", status); + #if TRACE_COKE + printf("Coke_DoDispense: done\n"); + #endif - return 0; + // TODO: Regex + if( strcmp(tmp, "ok") == 0 ) { + // We think dispense worked + // - The machine returns 'ok' if an empty slot is dispensed, even if + // it doesn't actually try to dispense (no sound) + ret = 0; + } + else { + printf("Machine returned unknown value '%s'\n", tmp); + ret = -1; + } + + // Update status + Writef("s%i\r\n", Item); + len = ReadLine(sizeof tmp, tmp); + if(len == -1) gaCoke_CachedStatus[Item] = -1; + Coke_int_GetSlotStatus(tmp, Item); + + + pthread_mutex_unlock(&gCoke_Mutex); + + return ret; } char ReadChar() @@ -139,7 +331,7 @@ char ReadChar() int ret; struct timeval timeout; - timeout.tv_sec = 5; // 5 second timeout + timeout.tv_sec = READ_TIMEOUT; timeout.tv_usec = 0; FD_ZERO(&readfs); @@ -161,6 +353,30 @@ char ReadChar() return ch; } +int Writef(const char *Format, ...) +{ + va_list args; + int len; + + va_start(args, Format); + len = vsnprintf(NULL, 0, Format, args); + va_end(args); + + { + char buf[len+1]; + va_start(args, Format); + vsnprintf(buf, len+1, Format, args); + va_end(args); + + #if DEBUG + printf("Writef: %s", buf); + #endif + + return write(giCoke_SerialFD, buf, len); + } + +} + int WaitForColon() { fd_set readfs; @@ -183,20 +399,24 @@ int ReadLine(int len, char *output) for(;;) { ch = ReadChar(); - - + if( i < len ) output[i++] = ch; if( ch == '\0' ) { - return -1; + break; } if( ch == '\n' || ch == '\r' ) { if( i < len ) output[--i] = '\0'; - return i; + break; } } + + //printf("ReadLine: output=%s\n", output); + + if( !ch ) return -1; + return i; }