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;
  51         uint16_t tasklen;
  52         uint8_t ct;
  53
  54         for(ct = 0; ct<MAXTASKS; ct++)
  55                 if(!tasks_used[ct])
  56                         break;
  57         if(ct == MAXTASKS)
  58                 die("Trying to add too much tasks...\n");
  59
  60         debug("Receiving input for task %d\n", ct);
  61         read(fd_in, &c, 1);
  62         if((char) c == 's') {
  63                 debug("Receiving an sds\n");
  64         } else if((char) c == 't'){
  65                 read(fd_in, &c, 1);
  66                 tasklen = 256*c;
  67                 read(fd_in, &c, 1);
  68                 tasklen += c;
  69                 if(tasklen > MAXTASKSIZE)
  70                         die("Task is too long: %d\n", tasklen);
  71                 for(int i = 0; i<tasklen; i++){
  72                         debug("Read %d\n", i);
  73                         read(fd_in, tasks[ct]+i, 1);
  74                         debug("t[][%i]: %d\n", i,
  75                                 tasks[ct][i]);
  76                 }
  77                 //Return the task number for later removal
  78                 write(fd_out, (void *)&ct, 1);
  79                 debug("Received a task of length %d\n", tasklen);
  80                 tasks_used[ct] = true;
  81         } else {
  82                 die("Unknown message: %c?\n", c);
  83         }
  84 }
  85
  86 void run_task(char *program)
  87 {
  88         int pc = 0;
  89         int sp = 0;
  90         int plen = strlen(program);
  91         char stack[1024] = {0};
  92         while(pc != plen){
  93                 switch(program[pc++]){
  94                 case BCNOP:;
  95                         break;
  96                 case BCPUSH:
  97                         stack[sp++] = program[pc++];
  98                         break;
  99                 case BCPOP:
 100                         sp--;
 101                         break;
 102                 case BCNOT:
 103                         stack[sp] = stack[sp] > 0 ? 0 : 1;
 104                         break;
 105                 case BCADD:
 106                         stack[sp-1] = stack[sp] + stack[sp-1];
 107                         sp -= 1;
 108                         break;
 109                 case BCSUB:
 110                         stack[sp-1] = stack[sp] - stack[sp-1];
 111                         sp -= 1;
 112                         break;
 113                 case BCMUL:
 114                         stack[sp-1] = stack[sp] * stack[sp-1];
 115                         sp -= 1;
 116                         break;
 117                 case BCDIV:
 118                         stack[sp-1] = stack[sp] / stack[sp-1];
 119                         sp -= 1;
 120                         break;
 121                 case BCAND:
 122                         stack[sp-1] = stack[sp] && stack[sp-1];
 123                         sp -= 1;
 124                         break;
 125                 case BCOR:
 126                         stack[sp-1] = stack[sp] || stack[sp-1];
 127                         sp -= 1;
 128                         break;
 129                 case BCEQ:
 130                         stack[sp-1] = stack[sp] == stack[sp-1];
 131                         sp -= 1;
 132                         break;
 133                 case BCNEQ:
 134                         stack[sp-1] = stack[sp] != stack[sp-1];
 135                         sp -= 1;
 136                         break;
 137                 case BCLES: stack[sp-1] = stack[sp] < stack[sp-1];
 138                         sp -= 1;
 139                         break;
 140                 case BCGRE:
 141                         stack[sp-1] = stack[sp] > stack[sp-1];
 142                         sp -= 1;
 143                         break;
 144                 case BCLEQ:
 145                         stack[sp-1] = stack[sp] <= stack[sp-1];
 146                         sp -= 1;
 147                         break;
 148                 case BCGEQ:
 149                         stack[sp-1] = stack[sp] >= stack[sp-1];
 150                         sp -= 1;
 151                         break;
 152                 case BCJMP:
 153                         pc = pc + program[pc];
 154                         break;
 155                 case BCJMPT:
 156                         pc += stack[sp] ? program[pc] : 1;
 157                         break;
 158                 case BCJMPF:
 159                         pc += stack[sp] ? 1 : program[pc];
 160                         break;
 161                 case BCSERIALAVAIL:
 162                         printf("SerialAvailable()\n");
 163                         break;
 164                 case BCSERIALPRINT:
 165                         printf("SerialPrint()\n");
 166                         break;
 167                 case BCSERIALPRINTLN:
 168                         printf("SerialPrintln()\n");
 169                         break;
 170                 case BCSERIALREAD:
 171                         printf("SerialRead()\n");
 172                         break;
 173                 case BCSERIALPARSEINT:
 174                         printf("SerialParseInt()\n");
 175                         break;
 176                 case BCANALOGREAD:
 177                         printf("AnalogRead()\n");
 178                         break;
 179                 case BCANALOGWRITE:
 180                         printf("AnalogWrite()\n");
 181                 default:
 182                         die("Unrecognized command: %X\n", program[--pc]);
 183                 }
 184         }
 185 }
 186
 187 int main(void)
 188 {
 189         int fd_in, fd_out;
 190         int ct;
 191
 192         fd_in = fileno(stdin);
 193         fd_out = fileno(stdout);
 194
 195         //Register signal handler
 196         if(signal(SIGINT, killHandler) == SIG_ERR){
 197                 die("Couldn't register signal handler...\n");
 198         }
 199         if(signal(SIGTERM, killHandler) == SIG_ERR){
 200                 die("Couldn't register signal handler...\n");
 201         }
 202
 203         while(true){
 204                 //Check for new tasks
 205                 if(input_available(fd_in)){
 206                         read_message(fd_in, fd_out);
 207                         exit(1);
 208                 }
 209                 //Run tasks
 210                 for(ct = 0; ct<MAXTASKS; ct++){
 211                         if(!tasks_used[ct]){
 212                                 debug("Task %d not implemented\n", ct);
 213                                 continue;
 214                         }
 215                         debug("Going to execute task %d\n", ct);
 216                         run_task(tasks[ct]);
 217                 }
 218                 usleep(10);
 219         }
 220
 221 /*      //Read program
 222         pc = 0;
 223         while ((c = getchar()) != EOF && pc < PROGRAMSIZE)
 224                 program[pc++] = c;
 225         if (pc >= PROGRAMSIZE)
 226                 die("Max program size: %d\n", PROGRAMSIZE);
 227         pl = pc;
 228         debug("Done reading, program length: %d\n", pl);
 229
 230         //Evaluate program
 231         //Reset program counter and stack counter
 232         pc = 0;
 233         sp = 0;
 234         while(pc != pl){
 235         }
 236 */
 237         return 0;
 238 }