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         { 3, D_1 }, // FIXME: will be 4, but let's be safe while testing
   8         { 0, D_1 },
   9         { 3, D_1 },
  10         { 0, D_1 },
  11         { 3, D_1 },
  12         { 0, D_1 },
  13         { 3, D_1 },
  14         { 0, D_1 },
  15         { 3, D_1 },
  16         { 0, D_1 },
  17         { 3, D_1 },
  18         { 0, D_1 },
  19         { 3, D_1 },
  20         { 0, D_1 },
  21         { 3, D_1 },
  22         { 0, D_1 },
  23         { 3, D_1 },
  24         { 0, D_1 },
  25         { 3, D_1 },
  26         { 0, D_1 },
  27         { 3, D_1 },
  28         { 0, D_1 },
  29         PATTERN_END
  30 };
  31
  32 pattern_t on1_pattern [] = {
  33         { 1, D_8 },
  34         PATTERN_END
  35 };
  36
  37 static pattern_t on2_pattern [] = {
  38         { 2, D_8 },
  39         PATTERN_END
  40 };
  41
  42 static pattern_t on3_pattern [] = {
  43         { 3, D_8 },
  44         PATTERN_END
  45 };
  46
  47 static pattern_t brake_pattern [] = {
  48         { 4, D_2 },
  49         { 3, D_8 },
  50         PATTERN_END
  51 };
  52
  53 static pattern_t normal2_pattern[] = {
  54         { 2, D_1 },
  55         { 0, D_1 },
  56         { 2, D_1 },
  57         { 0, D_8 },
  58         { 1, D_1 },
  59         { 0, D_1 },
  60         { 1, D_1 },
  61         { 0, D_8 },
  62         PATTERN_END
  63 };
  64
  65 static pattern_t normal3_pattern[] = {
  66         { 3, D_1 },
  67         { 0, D_1 },
  68         { 3, D_1 },
  69         { 0, D_8 },
  70         { 1, D_1 },
  71         { 0, D_1 },
  72         { 1, D_1 },
  73         { 0, D_8 },
  74         PATTERN_END
  75 };
  76
  77 static pattern_t normal4_pattern[] = {
  78         { 4, D_1 },
  79         { 0, D_1 },
  80         { 4, D_1 },
  81         { 0, D_8 },
  82         { 1, D_1 },
  83         { 0, D_1 },
  84         { 1, D_1 },
  85         { 0, D_8 },
  86         PATTERN_END
  87 };
  88
  89 static pattern_t slow1_pattern[] = {
  90         { 1, D_1 },
  91         { 0, D_13 },
  92         PATTERN_END
  93 };
  94
  95 static pattern_t slow2_pattern[] = {
  96         { 2, D_1 },
  97         { 0, D_13 },
  98         PATTERN_END
  99 };
 100
 101 static pattern_t slow3_pattern[] = {
 102         { 3, D_1 },
 103         { 0, D_13 },
 104         PATTERN_END
 105 };
 106
 107 static pattern_t tmp1_pattern[] = {
 108         { PWM_PAT(3, 0, 0), D_1 },
 109         { PWM_PAT(0, 0, 1), D_1 },
 110         { PWM_PAT(3, 0, 0), D_1 },
 111         { PWM_PAT(0, 0, 1), D_1 },
 112         { PWM_PAT(0, 0, 0), D_3 },
 113         { PWM_PAT(0, 1, 0), D_1 },
 114         { PWM_PAT(0, 0, 0), D_5 },
 115         { PWM_PAT(1, 0, 0), D_1 },
 116         { PWM_PAT(0, 0, 3), D_1 },
 117         { PWM_PAT(1, 0, 0), D_1 },
 118         { PWM_PAT(0, 0, 3), D_1 },
 119         { PWM_PAT(0, 0, 0), D_5 },
 120         { PWM_PAT(0, 1, 0), D_1 },
 121         { PWM_PAT(0, 0, 0), D_3 },
 122         PATTERN_END
 123 };
 124
 125 static unsigned char dim_mode, towbar_mode, braking;
 126
 127 void init_control()
 128 {
 129         dim_mode = 0;
 130         towbar_mode = 0;
 131         braking = 0;
 132 }
 133
 134 void brake_on()
 135 {
 136         braking = 1;
 137         gpio_set(0, 1);
 138         led_set_pattern(N_STATUS_LED, status_led_pattern_select());
 139         led_set_pattern(0, pwmled_pattern_select());
 140 }
 141
 142 void brake_off()
 143 {
 144         braking = 0;
 145         gpio_set(0, 0);
 146         led_set_pattern(N_STATUS_LED, status_led_pattern_select());
 147         led_set_pattern(0, pwmled_pattern_select());
 148 }
 149
 150 void toggle_dim_mode()
 151 {
 152         dim_mode = !dim_mode;
 153         pattern_reload();
 154 }
 155
 156 void set_panic_mode()
 157 {
 158         led_set_pattern(0, panic_pattern);
 159         led_set_pattern(N_ILLUM_LED, panic_pattern);
 160 }
 161
 162 pattern_t *pwmled_pattern_select()
 163 {
 164         return tmp1_pattern;
 165
 166         if (battery_critical)
 167                 return on1_pattern;
 168
 169         if (towbar_mode)
 170                 return NULL;
 171
 172         if (braking)
 173                 return brake_pattern;
 174
 175         switch (ambient_zone) {
 176         case 0: return dim_mode ? NULL : number_pattern(2, 1);
 177         case 1: return dim_mode ? slow1_pattern : normal2_pattern;
 178         case 2: return dim_mode ? slow2_pattern : normal3_pattern;
 179         case 3:
 180         default: return dim_mode ? slow3_pattern : normal4_pattern;
 181         }
 182 }
 183
 184 pattern_t *status_led_pattern_select()
 185 {
 186         if (braking)
 187                 return on1_pattern;
 188
 189         if (buttons_setup_in_progress())
 190                 return buttons_setup_status0_pattern_select();
 191
 192         // FIXME: do something sane
 193         return number_pattern(battery_gauge(), 0);
 194 }
 195
 196 pattern_t *illumination_led_pattern_select()
 197 {
 198         if (battery_critical)
 199                 return NULL;
 200
 201         switch (ambient_zone) {
 202         case 0: return dim_mode
 203                 ? number_pattern(1, 1)
 204                 : on1_pattern;
 205         case 1: return dim_mode
 206                 ? number_pattern(2, 1)
 207                 : number_pattern(3, 1);
 208         case 2: return dim_mode
 209                 ? number_pattern(1, 0)
 210                 : number_pattern(2, 0);
 211         case 3:
 212         default: return dim_mode
 213                 ? number_pattern(3, 0)
 214                 : number_pattern(4, 0);
 215         }
 216 }
 217
 218 pattern_t *laser_pattern_select()
 219 {
 220         if (!dim_mode && ambient_zone <= 1)
 221                 return number_pattern(2, 1);
 222         else
 223                 return NULL;
 224 }