firmware/control.c

   1 #include <inttypes.h>
   2 #include <stdlib.h> // for NULL
   3
   4 #include "lights.h"
   5
   6 static pattern_t panic_pattern[] = {
   7         { PWM_PAT(2, 0, 0), D_1 },
   8         { PWM_PAT(0, 0, 2), D_1 },
   9         { PWM_PAT(0, 0, 0), D_1 },
  10         { PWM_PAT(2, 0, 0), D_1 },
  11         { PWM_PAT(0, 0, 2), D_1 },
  12         { PWM_PAT(0, 0, 0), D_1 },
  13         { PWM_PAT(2, 0, 0), D_1 },
  14         { PWM_PAT(0, 0, 2), D_1 },
  15         { PWM_PAT(0, 0, 0), D_1 },
  16         { PWM_PAT(2, 0, 0), D_1 },
  17         { PWM_PAT(0, 0, 2), D_1 },
  18         { PWM_PAT(0, 0, 0), D_1 },
  19         { PWM_PAT(2, 0, 0), D_1 },
  20         { PWM_PAT(0, 0, 2), D_1 },
  21         { PWM_PAT(0, 0, 0), D_1 },
  22         { PWM_PAT(2, 0, 0), D_1 },
  23         { PWM_PAT(0, 0, 2), D_1 },
  24         { PWM_PAT(0, 0, 0), D_1 },
  25         { PWM_PAT(2, 0, 0), D_1 },
  26         { PWM_PAT(0, 0, 2), D_1 },
  27         { PWM_PAT(0, 0, 0), D_1 },
  28         PATTERN_END
  29 };
  30
  31 static pattern_t slow_pattern[] = {
  32         { PWM_PAT(1, 0, 0), D_1 },
  33         { PWM_PAT(0, 0, 1), D_1 },
  34         { PWM_PAT(0, 0, 0), D_13 },
  35         PATTERN_END
  36 };
  37
  38 static pattern_t fast_pattern[] = {
  39         { PWM_PAT(2, 0, 0), D_1 },
  40         { PWM_PAT(0, 0, 2), D_1 },
  41         { PWM_PAT(2, 0, 0), D_1 },
  42         { PWM_PAT(0, 0, 2), D_1 },
  43         { PWM_PAT(0, 0, 0), D_8 },
  44         { PWM_PAT(1, 0, 0), D_1 },
  45         { PWM_PAT(0, 0, 1), D_1 },
  46         { PWM_PAT(1, 0, 0), D_1 },
  47         { PWM_PAT(0, 0, 1), D_1 },
  48         { PWM_PAT(0, 0, 0), D_8 },
  49         PATTERN_END
  50 };
  51
  52 static pattern_t night_pattern[] = {
  53         { PWM_PAT(3, 0, 1), D_3 },
  54         { PWM_PAT(2, 0, 0), D_8 },
  55         { PWM_PAT(3, 0, 1), D_1 },
  56         { PWM_PAT(2, 0, 0), D_2 },
  57         { PWM_PAT(3, 0, 1), D_1 },
  58         { PWM_PAT(2, 0, 0), D_8 },
  59         PATTERN_END
  60 };
  61
  62 pattern_t on_pattern[] = {
  63         { 1, D_8 },
  64         PATTERN_END
  65 };
  66
  67 // #define TEST_PATTERN 1
  68 #ifdef TEST_PATTERN
  69 pattern_t test_pattern[] = {
  70         { PWM_PAT(1, 0, 0), D_13 },
  71         { PWM_PAT(2, 0, 0), D_13 },
  72         { PWM_PAT(0, 0, 1), D_13 },
  73         { PWM_PAT(0, 0, 2), D_13 },
  74         PATTERN_END
  75 };
  76 #endif
  77
  78 volatile err_flags_t err_flags;
  79 static unsigned char dim_mode, towbar_mode;
  80
  81 void init_control()
  82 {
  83         dim_mode = 0;
  84         towbar_mode = 0;
  85         err_flags.any_flag = 0;
  86 #ifdef notyet
  87         err_flags.booting = 1;
  88 #endif
  89
  90         pwmled_select_brightness();
  91 }
  92
  93 void brake_on()
  94 {
  95         err_flags.braking = 1;
  96         gpio_set(0, 1);
  97         led_set_pattern(N_STATUS_LED, status_led_pattern_select());
  98         pwmleds_update_mode();
  99 }
 100
 101 void brake_off()
 102 {
 103         err_flags.braking = 0;
 104         gpio_set(0, 0);
 105         led_set_pattern(N_STATUS_LED, status_led_pattern_select());
 106         pwmleds_update_mode();
 107 }
 108
 109 void toggle_dim_mode()
 110 {
 111         dim_mode = !dim_mode;
 112         pwmled_select_brightness();
 113         pattern_reload();
 114 }
 115
 116 void set_panic_mode()
 117 {
 118         // if error, clean it up
 119         if (err_flags.booting)
 120                 err_flags.booting = 0;
 121         else if (err_flags.err_pwmled2)
 122                 err_flags.err_pwmled2 = 0;
 123         else if (err_flags.err_pwmled1)
 124                 err_flags.err_pwmled1 = 0;
 125         else if (err_flags.err_pwmled0)
 126                 err_flags.err_pwmled0 = 0;
 127         else if (err_flags.err_battery)
 128                 err_flags.err_battery = 0;
 129         else {
 130                 led_set_pattern(0, panic_pattern);
 131                 led_set_pattern(N_ILLUM_LED, panic_pattern);
 132         }
 133 }
 134
 135 pattern_t *pwmled_pattern_select()
 136 {
 137 #ifdef TEST_PATTERN
 138         return tmp_pattern;
 139 #endif
 140         if (err_flags.err_battery)
 141                 return slow_pattern;
 142
 143         switch (ambient_zone) {
 144         case 0: return night_pattern;
 145         case 1:
 146         case 2:
 147         case 3:
 148         default:
 149                 return dim_mode ? slow_pattern : fast_pattern;
 150         }
 151 }
 152
 153 pattern_t *status_led_pattern_select()
 154 {
 155         if (err_flags.booting)
 156                 return number_pattern(1, 1);
 157
 158         if (err_flags.err_pwmled2)
 159                 return number_pattern(5, 1);
 160
 161         if (err_flags.err_pwmled1)
 162                 return number_pattern(4, 1);
 163
 164         if (err_flags.err_pwmled0)
 165                 return number_pattern(3, 1);
 166
 167         if (err_flags.err_battery)
 168                 return number_pattern(2, 1);
 169
 170         if (err_flags.braking)
 171                 return on_pattern;
 172
 173         if (buttons_setup_in_progress())
 174                 return buttons_setup_status0_pattern_select();
 175
 176         // FIXME: do something sane
 177         return number_pattern(battery_gauge(), 0);
 178 }
 179
 180 pattern_t *illumination_led_pattern_select()
 181 {
 182         if (buttons_setup_in_progress())
 183                 return buttons_setup_status1_pattern_select();
 184
 185         if (err_flags.err_battery)
 186                 return NULL;
 187
 188         switch (ambient_zone) {
 189         case 0: return dim_mode
 190                 ? number_pattern(1, 1)
 191                 : on_pattern;
 192         case 1: return dim_mode
 193                 ? number_pattern(2, 1)
 194                 : number_pattern(3, 1);
 195         case 2: return dim_mode
 196                 ? number_pattern(1, 0)
 197                 : number_pattern(2, 0);
 198         case 3:
 199         default: return dim_mode
 200                 ? number_pattern(3, 0)
 201                 : number_pattern(4, 0);
 202         }
 203 }
 204
 205 pattern_t *laser_pattern_select()
 206 {
 207         if (!dim_mode && ambient_zone <= 1)
 208                 return number_pattern(2, 1);
 209         else
 210                 return NULL;
 211 }
 212
 213 void pwmled_select_brightness()
 214 {
 215         uint16_t brightness = PWMLED_BRIGHTNESS(0, 2, 1, 0, 2); // default
 216
 217         if (err_flags.err_battery) {
 218                 brightness = PWMLED_BRIGHTNESS(0, 0, 0, 0, 0);
 219         } else if (ambient_zone == 0) {
 220                 if (dim_mode)
 221                         brightness = PWMLED_BRIGHTNESS(0, 1, 0, 0, 1);
 222                 else
 223                         brightness = PWMLED_BRIGHTNESS(1, 3, 2, 1, 3);
 224         } else if (ambient_zone == 1) {
 225                 if (dim_mode)
 226                         brightness = PWMLED_BRIGHTNESS(0, 1, 0, 0, 1);
 227                 else
 228                         brightness = PWMLED_BRIGHTNESS(0, 2, 1, 0, 2);
 229         } else if (ambient_zone == 2) {
 230                 brightness = PWMLED_BRIGHTNESS(1, 3, 2, 1, 3);
 231         } else if (ambient_zone == 3) {
 232                 brightness = PWMLED_BRIGHTNESS(2, 4, 2, 2, 4);
 233         }
 234
 235         pwmled_set_brightness(brightness);
 236 }