src/server/handler_coke.c

   1 /*
   2  * OpenDispense 2
   3  * UCC (University [of WA] Computer Club) Electronic Accounting System
   4  *
   5  * handler_coke.c - Coke controller code
   6  *
   7  * This file is licenced under the 3-clause BSD Licence. See the file
   8  * COPYING for full details.
   9  *
  10  * NOTES:
  11  * - Remember, the coke machine echoes your text back to you!
  12  */
  13 #include "common.h"
  14 #include <stdio.h>
  15 #include <string.h>
  16 #include <unistd.h>
  17 #include <sys/stat.h>
  18 #include <fcntl.h>
  19 #include <regex.h>
  20
  21 #define READ_TIMEOUT    2       // 2 seconds for ReadChar
  22 #define TRACE_COKE      1
  23
  24 // === IMPORTS ===
  25
  26 // === PROTOTYPES ===
  27  int    Coke_InitHandler();
  28  int    Coke_CanDispense(int User, int Item);
  29  int    Coke_DoDispense(int User, int Item);
  30  int    WaitForColon();
  31  int    ReadLine(int len, char *output);
  32
  33 // === GLOBALS ===
  34 tHandler        gCoke_Handler = {
  35         "coke",
  36         Coke_InitHandler,
  37         Coke_CanDispense,
  38         Coke_DoDispense
  39 };
  40 char    *gsCoke_SerialPort = "/dev/ttyS0";
  41  int    giCoke_SerialFD;
  42 regex_t gCoke_StatusRegex;
  43
  44 // == CODE ===
  45 int Coke_InitHandler()
  46 {
  47         printf("connecting to coke machine...\n");
  48
  49         giCoke_SerialFD = InitSerial(gsCoke_SerialPort, 9600);
  50         if( giCoke_SerialFD == -1 ) {
  51                 fprintf(stderr, "ERROR: Unable to open coke serial port ('%s')\n", gsCoke_SerialPort);
  52         }
  53
  54         CompileRegex(&gCoke_StatusRegex, "^slot\\s+([0-9]+)\\s+([^:]+):([a-zA-Z]+)\\s*", REG_EXTENDED);
  55         return 0;
  56 }
  57
  58 int Coke_CanDispense(int UNUSED(User), int Item)
  59 {
  60         char    tmp[40], *status;
  61         regmatch_t      matches[4];
  62          int    ret;
  63
  64         // Sanity please
  65         if( Item < 0 || Item > 6 )      return -1;      // -EYOURBAD
  66
  67         // Can't dispense if the machine is not connected
  68         if( giCoke_SerialFD == -1 )
  69                 return -2;
  70
  71         #if TRACE_COKE
  72         printf("Coke_CanDispense: Flushing");
  73         #endif
  74
  75         // Flush the input buffer
  76         {
  77                 char    tmpbuf[512];
  78                 read(giCoke_SerialFD, tmpbuf, sizeof(tmpbuf));
  79         }
  80
  81         // Wait for a prompt
  82         ret = 0;
  83         do {
  84                 #if TRACE_COKE
  85                 printf("Coke_DoDispense: sending 'd7'");
  86                 #endif
  87                 write(giCoke_SerialFD, "d7\r\n", 4);
  88         } while( WaitForColon() && ret++ < 3 );
  89
  90         if( ret == 3 ) {
  91                 fprintf(stderr, "Coke machine timed out\n");
  92                 return -2;      // -EMYBAD
  93         }
  94
  95         // TODO: Handle "not ok" response to D7
  96
  97         #if TRACE_COKE
  98         printf("Coke_CanDispense: sending 's%i'", Item);
  99         #endif
 100
 101         // Ask the coke machine
 102         sprintf(tmp, "s%i\r\n", Item);
 103         write(giCoke_SerialFD, tmp, 4);
 104
 105         #if TRACE_COKE
 106         printf("Coke_CanDispense: reading response");
 107         #endif
 108         // Read from the machine (ignoring empty lines)
 109         while( (ret = ReadLine(sizeof(tmp)-1, tmp)) == 0 );
 110         printf("ret = %i, tmp = '%s'\n", ret, tmp);
 111         if( tmp[0] == ':' ) {
 112                 ret = ReadLine(sizeof(tmp)-1, tmp);
 113                 printf("ret = %i, tmp = '%s'\n", ret, tmp);
 114         }
 115
 116         // Catch an error
 117         if( ret <= 0 ) {
 118                 fprintf(stderr, "Coke machine is not being chatty (read = %i)\n", ret);
 119                 if( ret == -1 ) {
 120                         perror("Coke Machine");
 121                 }
 122                 return -1;
 123         }
 124
 125         #if TRACE_COKE
 126         printf("Coke_CanDispense: wait for the prompt again");
 127         #endif
 128
 129         // Eat rest of response
 130         WaitForColon();
 131
 132         // Parse status response
 133         ret = RunRegex(&gCoke_StatusRegex, tmp, sizeof(matches)/sizeof(matches[0]), matches, "Bad Response");
 134         if( ret ) {
 135                 return -1;
 136         }
 137
 138         // Get slot status
 139         tmp[ matches[3].rm_eo ] = '\0';
 140         status = &tmp[ matches[3].rm_so ];
 141
 142         printf("Machine responded slot status '%s'\n", status);
 143
 144         #if TRACE_COKE
 145         printf("Coke_CanDispense: done");
 146         #endif
 147
 148         if( strcmp(status, "full") == 0 )
 149                 return 0;
 150
 151         return 1;
 152 }
 153
 154 /**
 155  * \brief Actually do a dispense from the coke machine
 156  */
 157 int Coke_DoDispense(int UNUSED(User), int Item)
 158 {
 159         char    tmp[32];
 160          int    i, ret;
 161
 162         // Sanity please
 163         if( Item < 0 || Item > 6 )      return -1;
 164
 165         // Can't dispense if the machine is not connected
 166         if( giCoke_SerialFD == -1 )
 167                 return -2;
 168
 169         #if TRACE_COKE
 170         printf("Coke_DoDispense: flushing input");
 171         #endif
 172         // Flush the input buffer
 173         {
 174                 char    tmpbuf[512];
 175                 read(giCoke_SerialFD, tmpbuf, sizeof(tmpbuf));
 176         }
 177
 178         // Wait for prompt
 179         i = 0;
 180         do {
 181                 #if TRACE_COKE
 182                 printf("Coke_DoDispense: sending 'd7'");
 183                 #endif
 184                 write(Item, "d7\r\n", 4);
 185         } while( WaitForColon() && i++ < 3 );
 186
 187         #if TRACE_COKE
 188         printf("Coke_DoDispense: sending 'd%i'", Item);
 189         #endif
 190         // Dispense
 191         sprintf(tmp, "d%i\r\n", Item);
 192         write(giCoke_SerialFD, tmp, 4);
 193
 194         // Read empty lines
 195         while( (ret = ReadLine(sizeof(tmp)-1, tmp)) == -1 );
 196         if( ret == -1 ) return -1;
 197         // Read d%i
 198         while( tmp[0] == ':' ) {
 199                 ret = ReadLine(sizeof(tmp)-1, tmp);
 200                 if( ret == -1 ) return -1;
 201         }
 202         // Get status
 203         ret = ReadLine(sizeof(tmp)-1, tmp);
 204         if( ret == -1 ) return -1;
 205
 206         WaitForColon(); // Eat up rest of response
 207
 208         #if TRACE_COKE
 209         printf("Coke_DoDispense: done");
 210         #endif
 211
 212         // TODO: Regex
 213         if( strcmp(tmp, "ok") == 0 ) {
 214                 // We think dispense worked
 215                 // - The machine returns 'ok' if an empty slot is dispensed, even if
 216                 //   it doesn't actually try to dispense (no sound)
 217                 return 0;
 218         }
 219
 220         printf("Machine returned unknown value '%s'\n", tmp);
 221
 222         return -1;
 223 }
 224
 225 char ReadChar()
 226 {
 227         fd_set  readfs;
 228         char    ch = 0;
 229          int    ret;
 230         struct timeval  timeout;
 231
 232         timeout.tv_sec = READ_TIMEOUT;
 233         timeout.tv_usec = 0;
 234
 235         FD_ZERO(&readfs);
 236         FD_SET(giCoke_SerialFD, &readfs);
 237
 238         ret = select(giCoke_SerialFD+1, &readfs, NULL, NULL, &timeout);
 239         if( ret == 0 )  return 0;       // Timeout
 240         if( ret != 1 ) {
 241                 printf("readchar return %i\n", ret);
 242                 return 0;
 243         }
 244
 245         ret = read(giCoke_SerialFD, &ch, 1);
 246         if( ret != 1 ) {
 247                 printf("ret = %i\n", ret);
 248                 return 0;
 249         }
 250
 251         return ch;
 252 }
 253
 254 int WaitForColon()
 255 {
 256         fd_set  readfs;
 257         char    ch = 0;
 258
 259         FD_SET(giCoke_SerialFD, &readfs);
 260
 261         while( (ch = ReadChar()) != ':' && ch != 0);
 262
 263         if( ch == 0 )   return -1;      // Timeout
 264
 265         return 0;
 266 }
 267
 268 int ReadLine(int len, char *output)
 269 {
 270         char    ch;
 271          int    i = 0;
 272
 273         for(;;)
 274         {
 275                 ch = ReadChar();
 276
 277                 if( i < len )
 278                         output[i++] = ch;
 279
 280                 if( ch == '\0' ) {
 281                         break;
 282                 }
 283                 if( ch == '\n' || ch == '\r' ) {
 284                         if( i < len )
 285                                 output[--i] = '\0';
 286                         break;
 287                 }
 288         }
 289
 290         //printf("ReadLine: output=%s\n", output);
 291
 292         if( !ch )       return -1;
 293         return i;
 294 }
 295
 296