git.gag.com Git - fw/altos/blob - src/cc1111/ao_ignite.c

   1 /*
   2  * Copyright © 2009 Keith Packard <keithp@keithp.com>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; version 2 of the License.
   7  *
   8  * This program is distributed in the hope that it will be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along
  14  * with this program; if not, write to the Free Software Foundation, Inc.,
  15  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  16  */
  17
  18 #include "ao.h"
  19 #include <ao_data.h>
  20
  21 __xdata struct ao_ignition ao_ignition[2];
  22
  23 void
  24 ao_ignite(enum ao_igniter igniter) __critical
  25 {
  26         ao_ignition[igniter].request = 1;
  27         ao_wakeup(&ao_ignition);
  28 }
  29
  30 enum ao_igniter_status
  31 ao_igniter_status(enum ao_igniter igniter)
  32 {
  33         __xdata struct ao_data packet;
  34         __pdata int16_t value;
  35         __pdata uint8_t request, firing, fired;
  36
  37         __critical {
  38                 ao_data_get(&packet);
  39                 request = ao_ignition[igniter].request;
  40                 fired = ao_ignition[igniter].fired;
  41                 firing = ao_ignition[igniter].firing;
  42         }
  43         if (firing || (request && !fired))
  44                 return ao_igniter_active;
  45
  46         value = (AO_IGNITER_CLOSED>>1);
  47         switch (igniter) {
  48         case ao_igniter_drogue:
  49                 value = packet.adc.sense_d;
  50                 break;
  51         case ao_igniter_main:
  52                 value = packet.adc.sense_m;
  53                 break;
  54         }
  55         if (value < AO_IGNITER_OPEN)
  56                 return ao_igniter_open;
  57         else if (value > AO_IGNITER_CLOSED)
  58                 return ao_igniter_ready;
  59         else
  60                 return ao_igniter_unknown;
  61 }
  62
  63 void
  64 ao_igniter_fire(enum ao_igniter igniter) __critical
  65 {
  66         ao_mutex_get(&ao_radio_mutex);
  67         ao_ignition[igniter].firing = 1;
  68         switch(ao_config.ignite_mode) {
  69         case AO_IGNITE_MODE_DUAL:
  70                 switch (igniter) {
  71                 case ao_igniter_drogue:
  72                         AO_IGNITER_DROGUE = 1;
  73                         ao_delay(AO_IGNITER_FIRE_TIME);
  74                         AO_IGNITER_DROGUE = 0;
  75                         break;
  76                 case ao_igniter_main:
  77                         AO_IGNITER_MAIN = 1;
  78                         ao_delay(AO_IGNITER_FIRE_TIME);
  79                         AO_IGNITER_MAIN = 0;
  80                         break;
  81                 }
  82                 break;
  83         case AO_IGNITE_MODE_APOGEE:
  84                 switch (igniter) {
  85                 case ao_igniter_drogue:
  86                         AO_IGNITER_DROGUE = 1;
  87                         ao_delay(AO_IGNITER_FIRE_TIME);
  88                         AO_IGNITER_DROGUE = 0;
  89                         ao_delay(AO_IGNITER_CHARGE_TIME);
  90                         AO_IGNITER_MAIN = 1;
  91                         ao_delay(AO_IGNITER_FIRE_TIME);
  92                         AO_IGNITER_MAIN = 0;
  93                         break;
  94                 }
  95                 break;
  96         case AO_IGNITE_MODE_MAIN:
  97                 switch (igniter) {
  98                 case ao_igniter_main:
  99                         AO_IGNITER_DROGUE = 1;
 100                         ao_delay(AO_IGNITER_FIRE_TIME);
 101                         AO_IGNITER_DROGUE = 0;
 102                         ao_delay(AO_IGNITER_CHARGE_TIME);
 103                         AO_IGNITER_MAIN = 1;
 104                         ao_delay(AO_IGNITER_FIRE_TIME);
 105                         AO_IGNITER_MAIN = 0;
 106                         break;
 107                 }
 108                 break;
 109         }
 110         ao_ignition[igniter].firing = 0;
 111         ao_mutex_put(&ao_radio_mutex);
 112 }
 113
 114 void
 115 ao_igniter(void)
 116 {
 117         __xdata enum ao_ignter igniter;
 118
 119         ao_config_get();
 120         for (;;) {
 121                 ao_sleep(&ao_ignition);
 122                 for (igniter = ao_igniter_drogue; igniter <= ao_igniter_main; igniter++) {
 123                         if (ao_ignition[igniter].request && !ao_ignition[igniter].fired) {
 124                                 if (igniter == ao_igniter_drogue && ao_config.apogee_delay)
 125                                         ao_delay(AO_SEC_TO_TICKS(ao_config.apogee_delay));
 126
 127                                 ao_igniter_fire(igniter);
 128                                 ao_delay(AO_IGNITER_CHARGE_TIME);
 129                                 ao_ignition[igniter].fired = 1;
 130                         }
 131                 }
 132         }
 133 }
 134
 135 void
 136 ao_ignite_manual(void)
 137 {
 138         ao_cmd_white();
 139         if (!ao_match_word("DoIt"))
 140                 return;
 141         ao_cmd_white();
 142         if (ao_cmd_lex_c == 'm') {
 143                 if(ao_match_word("main"))
 144                         ao_igniter_fire(ao_igniter_main);
 145         } else {
 146                 if(ao_match_word("drogue"))
 147                         ao_igniter_fire(ao_igniter_drogue);
 148         }
 149 }
 150
 151 static __code char * __code igniter_status_names[] = {
 152         "unknown", "ready", "active", "open"
 153 };
 154
 155 void
 156 ao_ignite_print_status(enum ao_igniter igniter, __code char *name) __reentrant
 157 {
 158         enum ao_igniter_status status = ao_igniter_status(igniter);
 159         printf("Igniter: %6s Status: %s\n",
 160                name,
 161                igniter_status_names[status]);
 162 }
 163
 164 void
 165 ao_ignite_test(void)
 166 {
 167         ao_ignite_print_status(ao_igniter_drogue, "drogue");
 168         ao_ignite_print_status(ao_igniter_main, "main");
 169 }
 170
 171 __code struct ao_cmds ao_ignite_cmds[] = {
 172         { ao_ignite_manual,     "i <key> {main|drogue}\0Fire igniter. <key> is doit with D&I" },
 173         { ao_ignite_test,       "t\0Test igniter" },
 174         { 0,    NULL },
 175 };
 176
 177 __xdata struct ao_task ao_igniter_task;
 178
 179 void
 180 ao_ignite_set_pins(void)
 181 {
 182         AO_IGNITER_DROGUE = 0;
 183         AO_IGNITER_MAIN = 0;
 184         AO_IGNITER_DIR |= AO_IGNITER_DROGUE_BIT | AO_IGNITER_MAIN_BIT;
 185 }
 186
 187 void
 188 ao_igniter_init(void)
 189 {
 190         ao_ignite_set_pins();
 191         ao_cmd_register(&ao_ignite_cmds[0]);
 192         ao_add_task(&ao_igniter_task, ao_igniter, "igniter");
 193 }