int/int.c

   1 #include <stdio.h>
   2 #include <stdbool.h>
   3 #include <stdlib.h>
   4 #include <signal.h>
   5 #include <string.h>
   6 #include <unistd.h>
   7 #include <stdint.h>
   8
   9 #include "mTaskSymbols.h"
  10
  11 #define MAXTASKS 5
  12 #define MAXTASKSIZE 1024
  13 #define MAXSDS 50
  14 #define STACKSIZE 1024
  15
  16 #define DEBUG
  17 #ifdef DEBUG
  18 #define debug(s, ...) printf(s, ##__VA_ARGS__);
  19 #else
  20 #define debug(s, ...) ;
  21 #endif
  22
  23 #define pdie(s) {perror(s); exit(1);}
  24 #define die(s, ...) {fprintf(stderr, s, ##__VA_ARGS__); exit(1);}
  25
  26 char tasks[MAXTASKS][MAXTASKSIZE] = {0};
  27 bool tasks_used[MAXTASKS] = {0};
  28
  29 void killHandler(int i)
  30 {
  31         printf("%s caught, Bye...\n", strsignal(i));
  32         exit(1);
  33 }
  34
  35 bool input_available(int fd){
  36         struct timeval tv;
  37         fd_set fds;
  38         tv.tv_sec = 0;
  39         tv.tv_usec = 0;
  40         FD_ZERO(&fds);
  41         FD_SET(fd, &fds);
  42         if (select(fd+1, &fds, NULL, NULL, &tv) == -1)
  43                 pdie("select");
  44         return FD_ISSET(fd, &fds);
  45 }
  46
  47 void read_message(int fd_in, int fd_out)
  48 {
  49         //Find next task
  50         uint8_t c, ct;
  51         uint16_t tasklen;
  52
  53         for(ct = 0; ct<MAXTASKS; ct++)
  54                 if(!tasks_used[ct])
  55                         break;
  56         if(ct == MAXTASKS)
  57                 die("Trying to add too much tasks...\n");
  58
  59         debug("Receiving input for task %d\n", ct);
  60         read(fd_in, &c, 1);
  61         if(c == 's') {
  62                 debug("Receiving an sds\n");
  63         } else if(c == 't'){
  64                 read(fd_in, &c, 1);
  65                 tasklen = 256*c;
  66                 read(fd_in, &c, 1);
  67                 tasklen += c;
  68                 if(tasklen > MAXTASKSIZE)
  69                         die("Task is too long: %d\n", tasklen);
  70                 for(int i = 0; i<tasklen; i++){
  71                         debug("Read %d\n", i);
  72                         read(fd_in, tasks[ct]+i, 1);
  73                         debug("t[][%i]: %d\n", i,
  74                                 tasks[ct][i]);
  75                 }
  76                 //Return the task number for later removal
  77                 write(fd_out, (void *)&ct, 1);
  78                 debug("Received a task of length %d\n", tasklen);
  79                 tasks_used[ct] = true;
  80         } else {
  81                 debug("Unknown message: %X?\n", c);
  82         }
  83 }
  84
  85 void run_task(char *program)
  86 {
  87         int pc = 0;
  88         int sp = 0;
  89         int plen = strlen(program);
  90         char stack[1024] = {0};
  91         while(pc != plen){
  92                 switch(program[pc++]){
  93                 case BCNOP:
  94                         break;
  95                 case BCPUSH:
  96                         stack[sp++] = program[pc++];
  97                         break;
  98                 case BCPOP:
  99                         sp--;
 100                         break;
 101                 case BCNOT:
 102                         stack[sp] = stack[sp] > 0 ? 0 : 1;
 103                         break;
 104                 case BCADD:
 105                         stack[sp-1] = stack[sp] + stack[sp-1];
 106                         sp -= 1;
 107                         break;
 108                 case BCSUB:
 109                         stack[sp-1] = stack[sp] - stack[sp-1];
 110                         sp -= 1;
 111                         break;
 112                 case BCMUL:
 113                         stack[sp-1] = stack[sp] * stack[sp-1];
 114                         sp -= 1;
 115                         break;
 116                 case BCDIV:
 117                         stack[sp-1] = stack[sp] / stack[sp-1];
 118                         sp -= 1;
 119                         break;
 120                 case BCAND:
 121                         stack[sp-1] = stack[sp] && stack[sp-1];
 122                         sp -= 1;
 123                         break;
 124                 case BCOR:
 125                         stack[sp-1] = stack[sp] || stack[sp-1];
 126                         sp -= 1;
 127                         break;
 128                 case BCEQ:
 129                         stack[sp-1] = stack[sp] == stack[sp-1];
 130                         sp -= 1;
 131                         break;
 132                 case BCNEQ:
 133                         stack[sp-1] = stack[sp] != stack[sp-1];
 134                         sp -= 1;
 135                         break;
 136                 case BCLES: stack[sp-1] = stack[sp] < stack[sp-1];
 137                         sp -= 1;
 138                         break;
 139                 case BCGRE:
 140                         stack[sp-1] = stack[sp] > stack[sp-1];
 141                         sp -= 1;
 142                         break;
 143                 case BCLEQ:
 144                         stack[sp-1] = stack[sp] <= stack[sp-1];
 145                         sp -= 1;
 146                         break;
 147                 case BCGEQ:
 148                         stack[sp-1] = stack[sp] >= stack[sp-1];
 149                         sp -= 1;
 150                         break;
 151                 case BCJMP:
 152                         pc = pc + program[pc];
 153                         break;
 154                 case BCJMPT:
 155                         pc += stack[sp] ? program[pc] : 1;
 156                         break;
 157                 case BCJMPF:
 158                         pc += stack[sp] ? 1 : program[pc];
 159                         break;
 160                 case BCSERIALAVAIL:
 161                         printf("SerialAvailable()\n");
 162                         break;
 163                 case BCSERIALPRINT:
 164                         printf("SerialPrint()\n");
 165                         break;
 166                 case BCSERIALPRINTLN:
 167                         printf("SerialPrintln()\n");
 168                         break;
 169                 case BCSERIALREAD:
 170                         printf("SerialRead()\n");
 171                         break;
 172                 case BCSERIALPARSEINT:
 173                         printf("SerialParseInt()\n");
 174                         break;
 175                 case BCANALOGREAD:
 176                         printf("AnalogRead(%d)\n", program[pc++]);
 177                         break;
 178                 case BCANALOGWRITE:
 179                         printf("AnalogWrite(%d)\n", program[pc++]);
 180                         break;
 181                 case BCDIGITALREAD:
 182                         printf("DigitalRead(%d)\n", program[pc++]);
 183                         break;
 184                 case BCDIGITALWRITE:
 185                         printf("DigitalWrite(%d)\n", program[pc++]);
 186                         break;
 187                 default:
 188                         die("Unrecognized command: %d\n", program[--pc]);
 189                 }
 190         }
 191 }
 192
 193 int main(void)
 194 {
 195         int fd_in, fd_out;
 196         int ct;
 197
 198         fd_in = fileno(stdin);
 199         fd_out = fileno(stdout);
 200
 201         //Register signal handler
 202         if(signal(SIGINT, killHandler) == SIG_ERR){
 203                 die("Couldn't register signal handler...\n");
 204         }
 205         if(signal(SIGTERM, killHandler) == SIG_ERR){
 206                 die("Couldn't register signal handler...\n");
 207         }
 208
 209         while(true){
 210                 //Check for new tasks
 211                 if(input_available(fd_in)){
 212                         read_message(fd_in, fd_out);
 213                 }
 214                 //Run tasks
 215                 for(ct = 0; ct<MAXTASKS; ct++){
 216                         if(!tasks_used[ct]){
 217                                 debug("Task %d not implemented\n", ct);
 218                                 continue;
 219                         }
 220                         debug("Going to execute task %d\n", ct);
 221                         run_task(tasks[ct]);
 222                         exit(1);
 223                 }
 224 //              exit(1);
 225                 usleep(10);
 226         }
 227
 228 /*      //Read program
 229         pc = 0;
 230         while ((c = getchar()) != EOF && pc < PROGRAMSIZE)
 231                 program[pc++] = c;
 232         if (pc >= PROGRAMSIZE)
 233                 die("Max program size: %d\n", PROGRAMSIZE);
 234         pl = pc;
 235         debug("Done reading, program length: %d\n", pl);
 236
 237         //Evaluate program
 238         //Reset program counter and stack counter
 239         pc = 0;
 240         sp = 0;
 241         while(pc != pl){
 242         }
 243 */
 244         return 0;
 245 }