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