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
  28 void killHandler(int i)
  29 {
  30         printf("%s caught, Bye...\n", strsignal(i));
  31         exit(1);
  32 }
  33
  34 bool input_available(int fd){
  35         struct timeval tv;
  36         fd_set fds;
  37         tv.tv_sec = 0;
  38         tv.tv_usec = 0;
  39         FD_ZERO(&fds);
  40         FD_SET(fd, &fds);
  41         if(select(fd+1, &fds, NULL, NULL, &tv) == -1){
  42                 pdie("select");
  43         }
  44         return FD_ISSET(fd, &fds);
  45 }
  46
  47 int main(void)
  48 {
  49         uint8_t c;
  50 //      char taskindex = 0;
  51 //      int pl, sp, pc;
  52 //
  53         int fd_in = 0;
  54         int next_free_new_task = 0;
  55         uint16_t tasklen = 0;
  56
  57         //Register signal handler
  58         if(signal(SIGINT, killHandler) == SIG_ERR){
  59                 die("Couldn't register signal handler...\n");
  60         }
  61         if(signal(SIGTERM, killHandler) == SIG_ERR){
  62                 die("Couldn't register signal handler...\n");
  63         }
  64
  65         while(true){
  66                 if(input_available(fd_in)){
  67                         printf("Receiving input\n");
  68                         read(fd_in, &c, 1);
  69                         if((char) c == 's'){
  70                                 debug("Receiving an sds\n");
  71                         } else if((char) c == 't'){
  72                                 read(fd_in, &c, 1);
  73                                 tasklen = 256*c;
  74                                 read(fd_in, &c, 1);
  75                                 tasklen += c;
  76                                 if(tasklen > MAXTASKSIZE){
  77                                         die("Task is too long: %d\n", tasklen);
  78                                 }
  79                                 for(int i = 0; i<tasklen; i++){
  80                                         debug("Read %d\n", i);
  81                                         read(fd_in, tasks[next_free_new_task]+i, 1);
  82                                         read(fd_in, tasks[next_free_new_task]+i, 1);
  83                                         debug("t[][%i]: %d\n", i, tasks[next_free_new_task][i]);
  84                                 }
  85                                 debug("Receiving a task of length %d\n", tasklen);
  86                         } else {
  87                                 die("Unknown message: %c?\n", c);
  88                         }
  89                         exit(1);
  90                 }
  91                 usleep(1);
  92         }
  93
  94 /*      //Read program
  95         pc = 0;
  96         while ((c = getchar()) != EOF && pc < PROGRAMSIZE)
  97                 program[pc++] = c;
  98         if (pc >= PROGRAMSIZE)
  99                 die("Max program size: %d\n", PROGRAMSIZE);
 100         pl = pc;
 101         debug("Done reading, program length: %d\n", pl);
 102
 103         //Evaluate program
 104         //Reset program counter and stack counter
 105         pc = 0;
 106         sp = 0;
 107         while(pc != pl){
 108                 switch(program[pc++]){
 109                 case BCNOP:;
 110                         break;
 111                 case BCPUSH:
 112                         stack[sp++] = program[pc++];
 113                         break;
 114                 case BCPOP:
 115                         sp--;
 116                         break;
 117                 case BCNOT:
 118                         stack[sp] = stack[sp] > 0 ? 0 : 1;
 119                         break;
 120                 case BCADD:
 121                         stack[sp-1] = stack[sp] + stack[sp-1];
 122                         sp -= 1;
 123                         break;
 124                 case BCSUB:
 125                         stack[sp-1] = stack[sp] - stack[sp-1];
 126                         sp -= 1;
 127                         break;
 128                 case BCMUL:
 129                         stack[sp-1] = stack[sp] * stack[sp-1];
 130                         sp -= 1;
 131                         break;
 132                 case BCDIV:
 133                         stack[sp-1] = stack[sp] / stack[sp-1];
 134                         sp -= 1;
 135                         break;
 136                 case BCAND:
 137                         stack[sp-1] = stack[sp] && stack[sp-1];
 138                         sp -= 1;
 139                         break;
 140                 case BCOR:
 141                         stack[sp-1] = stack[sp] || stack[sp-1];
 142                         sp -= 1;
 143                         break;
 144                 case BCEQ:
 145                         stack[sp-1] = stack[sp] == stack[sp-1];
 146                         sp -= 1;
 147                         break;
 148                 case BCNEQ:
 149                         stack[sp-1] = stack[sp] != stack[sp-1];
 150                         sp -= 1;
 151                         break;
 152                 case BCLES: stack[sp-1] = stack[sp] < stack[sp-1];
 153                         sp -= 1;
 154                         break;
 155                 case BCGRE:
 156                         stack[sp-1] = stack[sp] > stack[sp-1];
 157                         sp -= 1;
 158                         break;
 159                 case BCLEQ:
 160                         stack[sp-1] = stack[sp] <= stack[sp-1];
 161                         sp -= 1;
 162                         break;
 163                 case BCGEQ:
 164                         stack[sp-1] = stack[sp] >= stack[sp-1];
 165                         sp -= 1;
 166                         break;
 167                 case BCJMP:
 168                         pc = pc + program[pc];
 169                         break;
 170                 case BCJMPT:
 171                         pc += stack[sp] ? program[pc] : 1;
 172                         break;
 173                 case BCJMPF:
 174                         pc += stack[sp] ? 1 : program[pc];
 175                         break;
 176                 case BCSERIALAVAIL:
 177                         printf("SerialAvailable()\n");
 178                         break;
 179                 case BCSERIALPRINT:
 180                         printf("SerialPrint()\n");
 181                         break;
 182                 case BCSERIALPRINTLN:
 183                         printf("SerialPrintln()\n");
 184                         break;
 185                 case BCSERIALREAD:
 186                         printf("SerialRead()\n");
 187                         break;
 188                 case BCSERIALPARSEINT:
 189                         printf("SerialParseInt()\n");
 190                         break;
 191                 case BCANALOGREAD:
 192                         printf("AnalogRead()\n");
 193                         break;
 194                 case BCANALOGWRITE:
 195                         printf("AnalogWrite()\n");
 196                 default:
 197                         die("Unrecognized command: %X\n", program[--pc]);
 198                 }
 199         }
 200 */
 201         return 0;
 202 }