robinkrens.nl - git repository - cortex-from-scratch/blob - drivers/tsensor.c

   1 /* (CC-BY-NC-SA) ROBIN KRENS - ROBIN @ ROBINKRENS.NL
   2  *
   3  * $LOG$
   4  * 2019/8/28 - ROBIN KRENS
   5  * PreInitial version
   6  *
   7  * $DESCRIPTION$
   8  * TIMERS, non-blocking...
   9  *
  10  * */
  11
  12 #include <stdbool.h>
  13 #include <stddef.h>
  14 #include <stdint.h>
  15
  16 #include <sys/mmap.h>
  17 #include <sys/robsys.h>
  18
  19 #include <lib/regfunc.h>
  20 #include <lib/string.h>
  21 #include <lib/tinyprintf.h>
  22
  23 #include <drivers/tsensor.h>
  24
  25 #define PRESCALER 0xFFFF // 1 MHz (1 microsecond)
  26 #define MAXBUF 10
  27
  28 int cnt;
  29 enum status { INIT, WAIT_INIT, INIT_DONE } init_status;
  30 enum rstatus { READ, READ_INIT, READ_DONE } read_status;
  31
  32 static struct {
  33         uint8_t buf[MAXBUF];
  34         uint8_t pos;
  35 } readbuf;
  36
  37 static struct {
  38         char cmd;
  39         uint8_t pos;
  40 } sensor_cmd;
  41
  42 //
  43 void read_init();
  44
  45 static void in_conf() {
  46         rwrite(GPIOB_CRL, 0x44444444);
  47 }
  48
  49 static void out_conf() {
  50         rwrite(GPIOB_CRL, 0x46444444); // open drain (with pullup resistor)
  51 }
  52
  53 /* set preload and generate update event */
  54 static void timer_config(uint16_t preload) {
  55         rwrite(TIM4_ARR, preload);
  56         rsetbit(TIM4_EGR, 0);
  57 }
  58
  59 /* static void presence_pulse_conf() {
  60
  61         current_status = INIT;
  62         out_conf();
  63         rclrbit(GPIOB_ODR, 6); // low
  64         timer_config(480); // > 480 us
  65 }
  66
  67 static void presence_reply_conf() {
  68
  69         current_status = WAIT_INIT;
  70         in_conf();
  71         timer_config(100); // > 60 us
  72 }
  73
  74 static void finish_init() {
  75         current_status = INIT_FINISH;
  76         timer_config(480);
  77 } */
  78
  79 /* static void terminate() {
  80 //      current_status = NULL;
  81         in_conf();
  82         rclrbit(TIM4_DIER, 0);
  83         rclrbit(TIM4_CR1, 0);
  84 } */
  85
  86
  87 /* void tsensor_cmd_init() {
  88         current_status = WRITE;
  89         out_conf();
  90         timer_config(60);
  91         //rsetbit(TIM4_DIER, 0);
  92         //rsetbit(TIM4_CR1, 0); // start
  93 } */
  94
  95 void write0() {
  96         out_conf();
  97         rclrbit(GPIOB_ODR, 6); // low
  98         timer_config(60);
  99 }
 100
 101
 102 /* Handlers for read, write and init pulses */
 103
 104 void * write_handler() {
 105
 106         rclrbit(TIM4_SR1, 0);
 107         rclrbit(TIM4_SR1, 1);
 108         if (sensor_cmd.pos < 7) {
 109
 110                 if ((sensor_cmd.cmd >> sensor_cmd.pos+1) & 0x01) {
 111                         printf("1\n");
 112                         rwrite(TIM4_CCR1, 150);
 113                         rsetbit(TIM4_EGR, 0);
 114                 }
 115
 116                 else {
 117                         printf("0");
 118                         rwrite(TIM4_CCR1, 600);
 119                         rsetbit(TIM4_EGR, 0);
 120
 121                 }
 122                 sensor_cmd.pos++;
 123         }
 124         else {
 125
 126                 read_init();
 127         }
 128
 129 }
 130
 131 void * reply_handler() {
 132
 133         rclrbit(TIM4_SR1, 0);
 134         rclrbit(TIM4_SR1, 1);
 135         switch(read_status) {
 136                 case(READ_INIT):
 137                         in_conf();
 138                         read_status = READ;
 139                         rsetbit(GPIOB_BSRR, 22); // low (<- reset)
 140                         if (rchkbit(GPIOB_IDR, 6)) {
 141                                         printf("high");
 142                         }
 143                         else {
 144                                 printf("low");
 145                         }
 146                         timer_config(600);
 147                         break;
 148                 case(READ):
 149                         out_conf();
 150                         read_status = READ_INIT;
 151                         timer_config(1);
 152                         break;
 153                 case(READ_DONE):
 154                         // terminate
 155                         break;
 156         }
 157
 158
 159 }
 160
 161
 162 void read_init() {
 163
 164
 165         rclrbit(TIM4_CR1, 0); // stop
 166         rclrbit(TIM4_CCER, 0);
 167         rclrbit(TIM4_CCER, 1);
 168
 169         //rwrite(GPIOB_CRL, 0x46444444); // floating
 170         out_conf();
 171         rsetbit(TIM4_CR1, 2); // only overflow generates update
 172         read_status = READ_INIT;
 173         timer_config(1); // init 1us
 174
 175         ivt_set_gate(46, reply_handler, 0);
 176         rsetbit(NVIC_ISER0, 30); // interupt 41 - 32
 177
 178         //rclrbit(TIM4_DIER, 0);
 179
 180         rclrbit(GPIOB_ODR, 6); // low
 181         rsetbit(TIM4_DIER, 0);
 182
 183         rsetbit(TIM4_CR1, 0);
 184
 185 }
 186
 187
 188 void write_init() {
 189
 190         sensor_cmd.cmd = 0x33;
 191         sensor_cmd.pos = 0;
 192
 193         rsetbit(RCC_APB2ENR, 3); // GPIOB enable
 194         rsetbit(RCC_APB1ENR, 2); // TIM4 enable
 195         rsetbitsfrom(TIM4_CR1, 5, 0x00); // edge-aligned mode
 196         rclrbit(TIM4_CR1, 4); // upcounter (clrbit! not needed to set)
 197         rsetbit(TIM4_CR1, 2); // only overflow generates update
 198         rwrite(TIM4_PSC, PRESCALER - 1);
 199         rwrite(GPIOB_CRL, 0x4A444444);
 200
 201
 202         timer_config(610);
 203
 204         if ((sensor_cmd.cmd >> sensor_cmd.pos) & 0x01) {
 205                 printf("1\n");
 206                 rwrite(TIM4_CCR1, 150);
 207         }
 208         else {
 209                 printf("0\n");
 210                 rwrite(TIM4_CCR1, 600);
 211         }
 212
 213         rsetbitsfrom(TIM4_CCMR1, 4, 0x6); // forced high on match
 214
 215         rsetbit(TIM4_CCER, 0);
 216         rsetbit(TIM4_CCER, 1);
 217
 218         // set write handler
 219         ivt_set_gate(46, write_handler, 0);
 220         rsetbit(NVIC_ISER0, 30); // interupt 41 - 32
 221
 222         //rsetbit(TIM4_DIER, 1);
 223         rsetbit(TIM4_DIER, 0);
 224         rsetbit(TIM4_CR1, 0);
 225
 226 }
 227
 228
 229 /* void * init_handler() {
 230
 231         switch(current_status) {
 232                         case (INIT):
 233                                 printf("M: reset\n");
 234                                 presence_reply_conf();
 235                                 break;
 236                         case (WAIT_INIT):
 237                                 if (!rchkbit(GPIOB_IDR, 6)) {
 238                                         printf("S: yes\n");
 239                                 }
 240                                 else {
 241                                         printf("S: no\n");
 242                                 }
 243                                 finish_init();
 244                                 break;
 245
 246                         case (INIT_FINISH):
 247                                 printf("M: fin\n");
 248                                 tsensor_cmd_init();
 249                                 break;
 250
 251                         case (WRITE):
 252                                 printf("M: write\n");
 253                                 if (sensor_cmd.pos > 7)
 254                                         terminate();
 255                                 else {
 256                                         if ((sensor_cmd.cmd >> sensor_cmd.pos) & 0x01) {
 257
 258                                                 printf("1\n");
 259                                         }
 260                                         else {
 261                                                 printf("0\n");
 262                                         }
 263                                 }
 264                                 sensor_cmd.pos++;
 265                                 break;
 266
 267                         default:
 268                                 printf("no status\n");
 269                         }
 270
 271         rclrbit(TIM4_SR1, 0);
 272 } */
 273
 274 /* TODO: write
 275  * uint8_t cmd = 0x33
 276  * if (cmd & 0x01)
 277  *      1 slot
 278  * else 0 slot
 279  * cmd = cmd >> 1
 280  *
 281  * read, similar as pulse response */
 282
 283
 284 void * bare_handler() {
 285
 286 //w2    cnt += 1;
 287 //w2    printf("CHECKING STATUS\n");
 288 //w2
 289 //w2    if(rchkbit(GPIOB_IDR, 6)) {
 290 //w2            printf("port high\n");
 291 //w2    }
 292 //w2    else {
 293 //w2            printf("port low\n");
 294 //w2    }
 295
 296
 297         cnt += 1;
 298         printf("Count event %d\n", cnt);
 299         int switchled = cnt % 2;
 300         if (switchled) {
 301                 rwrite(GPIOB_CRL, 0x46444444); //  open drain general for sensor?
 302                 printf("setting low\n");
 303                 rclrbit(GPIOB_ODR, 6); // low
 304         }
 305         else {
 306                 printf("pulling high \n");
 307                 rwrite(GPIOB_CRL, 0x44444444); //  open drain general for sensor?
 308                 //rsetbit(GPIOB_ODR, 6); // high
 309
 310         }
 311         rclrbit(TIM4_SR1, 0);
 312 }
 313
 314
 315 /* void tsensor_init() {
 316
 317         sensor_cmd.cmd = 0x33;
 318         sensor_cmd.pos = 0;
 319
 320         rsetbit(RCC_APB2ENR, 3); // GPIOB enable
 321         rsetbit(RCC_APB1ENR, 2); // TIM4 enable
 322
 323         rsetbitsfrom(TIM4_CR1, 5, 0x00); // edge-aligned mode
 324         rclrbit(TIM4_CR1, 4); // upcounter (clrbit! not needed to set)
 325         rsetbit(TIM4_CR1, 2); // only overflow generates update
 326
 327         rwrite(TIM4_PSC, PRESCALER - 1);
 328         presence_pulse_conf();
 329 //      rwrite(TIM4_ARR, preload);
 330 //      rsetbit(TIM4_EGR, 0);
 331
 332         ivt_set_gate(46, init_handler, 0);
 333         rsetbit(NVIC_ISER0, 30); // interupt 41 - 32
 334
 335 //w     rsetbit(GPIOB_ODR, 6); //
 336         rsetbit(TIM4_DIER, 0);
 337         rsetbit(TIM4_CR1, 0); // start
 338
 339 } */
 340
 341
 342 void run() {
 343
 344 //w2    cnt = 0;
 345 //w2    rsetbit(RCC_APB2ENR, 3);
 346 //w2    rwrite(GPIOB_CRL, 0x48444444); // input with pull up down
 347 //w2    tsensor_simple(5000);
 348
 349         //cnt = 0;
 350         //rsetbit(RCC_APB2ENR, 3); // GPIOB enable
 351         //rwrite(GPIOB_CRL, 0x46444444); //  open drain general for sensor?
 352
 353         //rsetbit(GPIOB_BSRR, 22); // low (<- reset)
 354
 355 //      tsensor_init();
 356         write_init();
 357
 358 //      tsensor_output(580, 520);
 359 //      reset();
 360 //      tsensor_simple(580);
 361 }
 362
 363 //void tsensor_output(uint16_t preload, uint16_t compare/*, uint16_t pulses */) {
 364 //      /* GPIO AND CLOCK */
 365 //      rsetbit(RCC_APB2ENR, 3); // GPIOB enable
 366 //      rwrite(GPIOB_CRL, 0x4A444444); // PB6 for Channel 1 TIM4 alternate
 367 //      rsetbit(RCC_APB1ENR, 2); // TIM4 enable
 368 //
 369 //      rsetbitsfrom(TIM4_CR1, 5, 0x00); // edge-aligned mode
 370 //      rclrbit(TIM4_CR1, 4); // upcounter (clrbit! not needed to set)
 371 //      rsetbit(TIM4_CR1, 2); // only overflow generates update
 372 //
 373 //      rwrite(TIM4_PSC, PRESCALER - 1); // 1 MHz
 374 //      rwrite(TIM4_ARR, preload); // preload
 375 //      rwrite(TIM4_CCR1, compare); // compare
 376 //      //rwrite(TIM4_RCR, pulses - 1); /* repeat ONLY IN ADVANCED TIMER */
 377 //
 378 //      rsetbit(TIM4_EGR, 0); // update generation
 379 //
 380 //      rsetbit(TIM4_CR1, 3); // one pulse mode
 381 //      rsetbitsfrom(TIM4_CCMR1, 4, 0x6); // mode
 382 //
 383 //      //rsetbit(TIM4_CCMR1, 3); // preload enable
 384 //      //rsetbit(TIM4_CR1, 7); // buffered
 385 //
 386 //      rsetbit(TIM4_CCER, 0); // enable output channeli 1
 387 //      rsetbit(TIM4_CCER, 1); // active low
 388 //      rsetbit(TIM4_CR1, 0); // start counter
 389 //
 390 //      /* INTERRUPTS */
 391 //      ivt_set_gate(46, tmp_update_handler, 0);
 392 //
 393 //      rsetbit(TIM4_DIER, 1);
 394 //      rsetbit(NVIC_ISER0, 30); // interupt 41 - 32
 395 //
 396 //}