int/int.c

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