API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Oct 7th, 2013
641
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 23.69 KB | None | 0 0
raw download clone embed print report
  1. #include <SPI.h>
  2. #include <AdvButton.h>
  3. #include <ButtonManager.h>
  4.  
  5. #define ANALOG_DELAY 250
  6. #define NAV1 53 //ss
  7. #define STRLEN 30
  8.  
  9. char buffer[STRLEN];
  10. int  bufferIndex = 0;
  11. char buffer3[STRLEN];
  12. int  bufferIndex3 = 0;
  13. #define NAV1 1
  14. #define NAV2 0
  15. #define COM1 3
  16. #define COM2 2
  17.  
  18. #define ANALOG_SENSITIVITY 5
  19.  
  20. #define ADF1 0
  21. #define ADF2 1
  22. #define TRANSPONDER 2
  23. #define DME1 3
  24. #define DME1TIME 4
  25. #define DME2 5
  26. #define DME2TIME 6
  27.  
  28. #define OBS1 0
  29. #define OBS2 1
  30. #define ALTITUDE 0
  31. #define VERTICAL 1
  32.  
  33. #define BANK1CONTROL 0
  34. #define BANK2CONTROL 1
  35. #define ADFCONTROL 2
  36. #define OBSCONTROL 3
  37. #define APCONTROL 4
  38. #define MAGCONTROL 8
  39.  
  40.  
  41. #define BANK1MASTER 53
  42. #define BANK1SLAVE 49
  43. #define BANK2MASTER 48
  44. #define BANK2SLAVE 47
  45. #define ADF 46
  46. #define OBS 45
  47. #define ALTITUDE_PIN 44
  48. #define HEADING_PIN 43
  49.  
  50. #define FLAPS_PIN A5
  51. #define SPOILER_PIN A6
  52. #define AILERON_PIN A7
  53. #define RUDDER_PIN A3
  54.  
  55. #define SWAP_BANK1_PIN 12
  56. #define SWAP_BANK2_PIN 2
  57.  
  58. #define NAVIGATION_PIN 7
  59. #define BEACON_PIN 8
  60. #define LANDING_PIN 16
  61. #define TAXI_PIN 17
  62. #define STROBE_PIN 18
  63. #define INSTRUMENTS_PIN 19
  64. #define RECOGNITION_PIN 20
  65. #define WING_PIN 21
  66. #define LOGO_PIN 22
  67. #define CABIN_PIN 23
  68. #define BATTERY_PIN 24
  69. #define AVIONICS_PIN 25
  70. #define ALTERNATE_PIN 26
  71. #define FUEL_PIN 27
  72. #define DEICE_PIN 28
  73. #define PITOT_PIN 29
  74. #define NAV_GPS_PIN 30
  75. #define KEY_PIN 21
  76. #define MASTER_PIN 32
  77. #define THROTTLE_PIN 33
  78. #define HEADING_HOLD_PIN 34
  79. #define ALTITUDE_HOLD_PIN 35
  80. #define NAV_HOLD_PIN 36
  81. #define VERTICAL_SPEED_HOLD_PIN 37
  82. #define ATTITUDE_PIN 38
  83. #define APPROACH_MODE_PIN 39
  84. #define SPEED_HOLD_PIN 40
  85. #define GEAR_PIN 41
  86.  
  87. #define STEP_BANK1_PIN 42
  88.  
  89. #define PARKING_PIN 9
  90. int last_flaps = 0;
  91. int last_spoiler = 0;  
  92. int last_aileron = 0;
  93. int last_rudder = 0;
  94. unsigned long last_flaps_time = 0;
  95. unsigned long last_spoiler_time = 0;
  96. unsigned long last_aileron_time = 0;
  97. unsigned long last_rudder_time = 0;
  98. int step_bank1= 1;
  99. int step_bank2=1;
  100. int transponder_step = 10000;
  101.  
  102. char* radio_master[4] = {
  103.  "1111",  "2222", "3333", "4444"};
  104. char* radio_slave[4] = {
  105.  "5555",  "6666", "7777", "8888"};
  106. char* adf[7] = {
  107.  "0111",  "0222", "7333", "0444", "0555","0666", "0777"};
  108. char* obs[2] = {
  109.  "v333",  "v444"};
  110. char* autopilot_altitude[2] = {
  111.  "1111",  "2222"};
  112. char* heading = "v000";
  113. int active_bank_one=COM1;
  114. int active_bank_two=NAV1;
  115. int active_ADF = ADF1;
  116. int active_obs = OBS1;
  117. int active_altitude = ALTITUDE;
  118.  
  119. int8_t clicks=0;
  120. char rotary_id=0;
  121.  
  122.  
  123. AdvButton park=AdvButton(PARKING_PIN, "parkingb", NULL, single_button_on, single_button_off, btn_Digital);
  124. AdvButton swap_bank_one_button=AdvButton(SWAP_BANK1_PIN, "swapbank1", swap_bank1, btn_Digital);
  125. AdvButton swap_bank_to_button=AdvButton(SWAP_BANK2_PIN, "swapbank2", swap_bank2, btn_Digital);
  126. AdvButton step_bank_one_button=AdvButton(STEP_BANK1_PIN, "stepbank1", change_step_bank_one, btn_Digital);
  127.  
  128. AdvButton bank1com1=AdvButton(BANK1CONTROL, "mas3", NULL, select_bank1, NULL, btn_Analog, 0, 200);
  129. AdvButton bank1com2=AdvButton(BANK1CONTROL, "mas2", NULL, select_bank1, NULL, btn_Analog, 200, 400);
  130. AdvButton bank1nab1=AdvButton(BANK1CONTROL, "mas1", NULL, select_bank1, NULL, btn_Analog, 400, 600);
  131. AdvButton bank1nab2=AdvButton(BANK1CONTROL, "mas0", NULL, select_bank1, NULL, btn_Analog, 600, 800);
  132.  
  133. AdvButton bank_to_come1=AdvButton(BANK2CONTROL, "mas3", NULL, select_bank2, NULL, btn_Analog, 0, 200);
  134. AdvButton bank_to_commit_to=AdvButton(BANK2CONTROL, "mas2", NULL, select_bank2, NULL, btn_Analog, 200, 400);
  135. AdvButton bank2nav1=AdvButton(BANK2CONTROL, "mas1", NULL, select_bank2, NULL, btn_Analog, 400, 600);
  136. AdvButton bank2nav2=AdvButton(BANK2CONTROL, "mas0", NULL, select_bank2, NULL, btn_Analog, 600, 800);
  137.  
  138. AdvButton magoff=AdvButton(MAGCONTROL, "mas0", NULL, send_magneto, NULL, btn_Analog, 0, 100);
  139. AdvButton magone=AdvButton(MAGCONTROL, "mas1", NULL, send_magneto, NULL, btn_Analog, 100, 200);
  140. AdvButton magtwo=AdvButton(MAGCONTROL, "mas2", NULL, send_magneto, NULL, btn_Analog, 200, 350);
  141. AdvButton magboth=AdvButton(MAGCONTROL, "mas3", NULL, send_magneto, NULL, btn_Analog, 350, 500);
  142. AdvButton magstart=AdvButton(MAGCONTROL, "mas4", NULL, send_magneto, NULL, btn_Analog, 500, 1024);
  143.  
  144. AdvButton adfadf1=AdvButton(ADFCONTROL, "adf1", NULL, select_adf, NULL, btn_Analog, 0, 140);
  145. AdvButton adfadf2=AdvButton(ADFCONTROL, "adf0", NULL, select_adf, NULL, btn_Analog, 140, 280);
  146. AdvButton adfadf3=AdvButton(ADFCONTROL, "adf2", NULL, select_adf, NULL, btn_Analog, 280, 420);
  147. AdvButton adfadf4=AdvButton(ADFCONTROL, "adf3", NULL, select_adf, NULL, btn_Analog, 420, 560);
  148. AdvButton adfadf5=AdvButton(ADFCONTROL, "adf4", NULL, select_adf, NULL, btn_Analog, 560, 700);
  149. AdvButton adfadf6=AdvButton(ADFCONTROL, "adf5", NULL, select_adf, NULL, btn_Analog, 700, 840);
  150. AdvButton adfadf7=AdvButton(ADFCONTROL, "adf6", NULL, select_adf, NULL, btn_Analog, 840, 980);
  151.  
  152. //AdvButton obs1=AdvButton(OBSCONTROL, "obs0", NULL, select_obs, NULL, btn_Analog, 0, 400);
  153. //AdvButton obs2=AdvButton(OBSCONTROL, "obs1", NULL, select_obs, NULL, btn_Analog, 400, 800);
  154.  
  155. AdvButton alt=AdvButton(APCONTROL, "alt0", NULL, select_altitude, NULL, btn_Analog, 0, 400);
  156. AdvButton vspd=AdvButton(APCONTROL, "vsp1", NULL, select_altitude, NULL, btn_Analog, 600, 1024);
  157.  
  158. //lights
  159. int lights = 0;
  160. AdvButton navigation_lights = AdvButton(NAVIGATION_PIN, "navigation" , NULL, lights_on, lights_off, btn_Digital, 0, 0, &lights, 0);
  161. AdvButton beacon_lights = AdvButton(BEACON_PIN, "beacon" , NULL, lights_on, lights_off, btn_Digital, 0, 0, &lights, 1);
  162. AdvButton landing_lights = AdvButton(LANDING_PIN, "landing" , NULL, lights_on, lights_off, btn_Digital, 0, 0, &lights, 2);
  163. AdvButton taxi_lights = AdvButton(TAXI_PIN, "taxi" , NULL, lights_on, lights_off, btn_Digital, 0, 0, &lights, 3);
  164. AdvButton strobe_lights = AdvButton(STROBE_PIN, "strobe" , NULL, lights_on, lights_off, btn_Digital, 0, 0, &lights, 4);
  165. AdvButton instrument_lights = AdvButton(INSTRUMENTS_PIN, "instrument" , NULL, lights_on, lights_off, btn_Digital, 0, 0, &lights, 5);
  166. AdvButton recognition_lights = AdvButton(RECOGNITION_PIN, "recognition" , NULL, lights_on, lights_off, btn_Digital, 0, 0, &lights, 6);
  167. AdvButton wing_lights=AdvButton(WING_PIN,  "wing" ,NULL, lights_on, lights_off, btn_Digital, 0, 0, &lights, 7);
  168. AdvButton logo_lights = AdvButton(LOGO_PIN, "logo" , NULL, lights_on, lights_off, btn_Digital, 0, 0, &lights, 8);
  169. AdvButton cabin_lights = AdvButton(CABIN_PIN, "cabin" , NULL, lights_on, lights_off, btn_Digital, 0, 0, &lights, 9);
  170.  
  171.  
  172. //systems
  173. AdvButton battery_but_in = AdvButton(BATTERY_PIN, "battery" , NULL, single_button_on, single_button_off, btn_Digital);
  174. AdvButton avionics_button = AdvButton(AVIONICS_PIN, "avionics" , NULL, single_button_on, single_button_off, btn_Digital);
  175. AdvButton alternator_but_will=AdvButton(ALTERNATE_PIN, "alternator" , NULL, single_button_on, single_button_off, btn_Digital);
  176. AdvButton fuel_button = AdvButton(FUEL_PIN, "fuel" , NULL, single_button_on, single_button_off, btn_Digital);
  177. AdvButton deice_but_in = AdvButton(DEICE_PIN, "deice" , NULL, single_button_on, single_button_off, btn_Digital);
  178. AdvButton peter_heat = AdvButton(PITOT_PIN, "pitot" , NULL, single_button_on, single_button_off, btn_Digital);
  179. AdvButton nav_gps = AdvButton(NAV_GPS_PIN, "nav_gps" , NULL, single_button_on, single_button_off, btn_Digital);
  180. AdvButton gear = AdvButton(GEAR_PIN, "gear" , NULL, single_button_on, single_button_off, btn_Digital);
  181.  
  182. AdvButton key_lock = AdvButton(KEY_PIN, "init" , NULL, single_button_on, single_button_off, btn_Digital);
  183.  
  184. //autopilot
  185. AdvButton master_autopilot = AdvButton(MASTER_PIN, "master" , NULL, single_button_on, single_button_off, btn_Digital);
  186. AdvButton throttle = AdvButton(THROTTLE_PIN, "throttle" , NULL, single_button_on, single_button_off, btn_Digital);
  187. AdvButton heading_hold = AdvButton(HEADING_HOLD_PIN, "hhold" , toggle_button, btn_Digital);
  188. AdvButton altitude_hold = AdvButton(ALTITUDE_HOLD_PIN, "ahold" , toggle_button, btn_Digital);
  189. AdvButton nav_hold = AdvButton(NAV_HOLD_PIN, "navhold" , toggle_button, btn_Digital);
  190. AdvButton vs_hold = AdvButton(VERTICAL_SPEED_HOLD_PIN, "vshold" , toggle_button, btn_Digital);
  191. AdvButton attitude = AdvButton(ATTITUDE_PIN, "winglevel" , toggle_button, btn_Digital);
  192.  
  193. AdvButton approach = AdvButton(APPROACH_MODE_PIN, "approachhold" , toggle_button, btn_Digital);
  194. AdvButton speedds = AdvButton(SPEED_HOLD_PIN, "speedhold" , toggle_button, btn_Digital);
  195.  
  196. //AdvButton gear = AdvButton(GEAR_PIN, "gear" , NULL, single_button_on, single_button_off, btn_Digital);
  197. void setup()
  198. {
  199.  Serial.begin(115200);
  200.  Serial.flush();
  201.  Serial3.begin(9600);
  202.  Serial3.flush();
  203.  pinMode (BANK1MASTER,OUTPUT);
  204.  pinMode (BANK1SLAVE,OUTPUT);
  205.  pinMode (BANK2MASTER,OUTPUT);
  206.  pinMode (BANK2SLAVE,OUTPUT);
  207.  
  208.  pinMode (ADF,OUTPUT);
  209.  pinMode (OBS,OUTPUT);
  210.  pinMode (HEADING_PIN,OUTPUT);
  211.  pinMode (ALTITUDE_PIN,OUTPUT);
  212.  pinMode(FLAPS_PIN, INPUT);
  213.  pinMode(SPOILER_PIN, INPUT);
  214.  pinMode(AILERON_PIN, INPUT);
  215.  pinMode(RUDDER_PIN, INPUT);  
  216.  SPI.begin();
  217.  SPI.setDataMode(SPI_MODE0);
  218.  SPI.setClockDivider(SPI_CLOCK_DIV32);
  219.  reset7seg(BANK1MASTER);
  220.  reset7seg(BANK1SLAVE);
  221.  reset7seg(BANK2MASTER);
  222.  reset7seg(BANK2SLAVE);  
  223.  reset7seg(ADF);
  224.  reset7seg(OBS);
  225.  reset7seg(HEADING_PIN);
  226.  reset7seg(ALTITUDE_PIN);
  227.  
  228.  write_led_decimals(BANK1MASTER,0x2);
  229.  write_led_decimals(BANK1SLAVE,0x2);
  230.  write_led_decimals(BANK2MASTER,0x2);
  231.  write_led_decimals(BANK2SLAVE,0x2);
  232.  write_led_decimals(ADF,0x0);
  233.  //write_led_numbers(NAV1, 0x78,0x78,0x78,0x78); //Blank display
  234.  //write_led_numbers(ADF,1,2,3,4);
  235. }
  236.  
  237. void loop()
  238. {
  239.  //  delay (10000);
  240.  //Serial.print (digitalRead (GEAR_PIN));
  241.  if( Serial.available())
  242.  {
  243.    char ch = Serial.read();
  244.    if( ch == '\n')  // is this the terminating carriage return
  245.    {
  246.      buffer[ bufferIndex ] = 0; // terminate the strin
  247.      bufferIndex = 0;  // reset the index ready for another string
  248.      parse_string(buffer);
  249.      // do something with the string
  250.    }
  251.    else
  252.      buffer[ bufferIndex++ ] = ch; // add the character into the buffer
  253.  }
  254.  if( Serial3.available())
  255.  {
  256.    char ch = Serial3.read();
  257.    if( ch == '\n')  // is this the terminating carriage return
  258.    {
  259.      buffer3[ bufferIndex3 ] = 0; // terminate the strin
  260.      bufferIndex3 = 0;  // reset the index ready for another string
  261.      //Serial.print(buffer3);
  262.      send_rotary(buffer3);
  263.  
  264.      // do something with the string
  265.    }
  266.    else
  267.      buffer3[ bufferIndex3++ ] = ch; // add the character into the buffer
  268.  }
  269.  ButtonManager::instance()->checkButtons();  
  270.  check_input();
  271.  
  272.  send_analog("flaps" , FLAPS_PIN, &last_flaps, &last_flaps_time);
  273.  send_analog_trim("ailtrim" , AILERON_PIN, &last_aileron, &last_aileron_time);
  274.  send_analog_trim("ruddertrim" , RUDDER_PIN, &last_rudder, &last_rudder_time);
  275.  send_analog("spoilers" , SPOILER_PIN, &last_spoiler, &last_spoiler_time);
  276. }
  277.  
  278. void send_analog(char* name, int pin, int* last, unsigned long *last_change)
  279. {
  280.  int current = analogRead(pin);
  281.  if (current <100) current = 0;
  282.  
  283.  if (current >950)  current = 1024;  
  284.  if (current - ANALOG_SENSITIVITY > *last || current + ANALOG_SENSITIVITY < *last)
  285.  {
  286.  
  287.  
  288.    if (millis() - *last_change > ANALOG_DELAY){
  289.      *last_change =  millis();
  290.  
  291.      *last = current;
  292.      send_value(name, map(current, 0, 1024, -16383, 16383));
  293.  
  294.    }
  295.  
  296.  }
  297. }
  298.  
  299. void send_analog_trim(char* name, int pin, int* last, unsigned long *last_change)
  300. {
  301.  int current = analogRead(pin);
  302.  if (current <50) current = 0;
  303.  
  304.  if (current >950)  current = 1024;
  305.  if (current - ANALOG_SENSITIVITY > *last || current + ANALOG_SENSITIVITY < *last)
  306.  {
  307.  
  308.  
  309.  
  310.    if (millis() - *last_change > ANALOG_DELAY)
  311.    {
  312.      *last = current;
  313.      *last_change =  millis();
  314.      send_value(name, map(current, 0, 1024, -16383, 16383));
  315.  
  316.    }
  317.  
  318.  
  319.  }
  320. }
  321.  
  322. void send_spoiler(char* name, int pin, int* last, unsigned long *last_change)
  323. {
  324.  int current = analogRead(pin), spoilers;
  325.  if (current - ANALOG_SENSITIVITY > *last || current + ANALOG_SENSITIVITY < *last)
  326.  {
  327.    spoilers = map(current, 0, 1024, 0, 16383);
  328.    if (spoilers > 4000 && spoilers < 5620)
  329.    {
  330.      spoilers = 4800;
  331.    }
  332.    if (spoilers <= 4000)
  333.    {
  334.      spoilers = 0;
  335.    }
  336.    if (millis() - *last_change > ANALOG_DELAY){
  337.      *last_change =  millis();
  338.      send_value(name, spoilers);
  339.      *last = current;
  340.    }
  341.  
  342.  }
  343. }
  344.  
  345.  
  346.  
  347. void parse_string (char* buffer)
  348. {
  349.  char *name = NULL, *value = NULL;
  350.  //Serial.write(buffer);
  351.  name =strtok (buffer, ":");
  352.  value =strtok( NULL, ":");
  353.  if (name && value) {
  354.    handle_command (name, value);
  355.  }
  356. }
  357.  
  358. void update_display (int num)
  359. {
  360.  if (num == 0 || num == 1)
  361.  {
  362.    write_string (BANK1SLAVE, radio_slave [active_bank_one]);
  363.    write_string (BANK1MASTER, radio_master [active_bank_one]);
  364.    write_string (BANK2MASTER, radio_master [active_bank_two]);
  365.    write_string (BANK2SLAVE, radio_slave [active_bank_two]);
  366.  }
  367.  
  368.  else if (num == 2)
  369.  {
  370.    write_string (ADF, adf [active_ADF]);
  371.  }
  372.  
  373.  else if (num == 3)
  374.  {
  375.    write_string (OBS, obs [active_obs]);
  376.  
  377.  }
  378.  
  379.  else if (num == 4)
  380.  {
  381.    write_string (ALTITUDE_PIN, autopilot_altitude [active_altitude]);
  382.  
  383.  }
  384.  
  385.  else if (num == 5)
  386.  {
  387.    write_string (HEADING_PIN, heading);
  388.  
  389.  }
  390.  
  391.  
  392.  
  393. }
  394.  
  395.  
  396. void my_copy (char* target,char* source,int len)
  397. {
  398.  for(int i=0; i<len;i++){
  399.    target [i] =source [i];
  400.  }
  401. }
  402.  
  403. void handle_command (char* name,char* value)
  404. {
  405.  if(strcmp(name, "resend")== 0)
  406.  {
  407.    ButtonManager::instance()->triggerAll();
  408.  }
  409.  if (strcmp( name, "nav1m")== 0)  {
  410.    my_copy(radio_master[NAV1], value,4);
  411.    update_display (1);
  412.    //write_string (NAV1, value);
  413.  }
  414.  if (strcmp( name, "nav2m")== 0)
  415.  {
  416.    my_copy(radio_master[NAV2], value,4);
  417.    update_display (1);
  418.  }
  419.  if (strcmp( name, "com1m")== 0)
  420.  {
  421.    my_copy(radio_master[COM1], value,4);
  422.    update_display (0);
  423.  }
  424.  if (strcmp( name, "com2m")== 0)
  425.  {
  426.    my_copy(radio_master[COM2], value,4);
  427.    update_display (0);
  428.  }
  429.  if (strcmp( name, "nav1s")== 0)
  430.  {
  431.    my_copy(radio_slave[NAV1], value,4);
  432.    update_display (1);
  433.    //write_string (NAV1,  value, 4);
  434.  }
  435.  if (strcmp( name, "nav2s")== 0)
  436.  {
  437.    my_copy(radio_slave[NAV2],  value, 4);
  438.    update_display (1);
  439.  }
  440.  if (strcmp( name, "com1s")== 0)
  441.  {
  442.    my_copy(radio_slave[COM1],  value, 4);
  443.    update_display (0);
  444.  }
  445.  if (strcmp( name, "com2s")== 0)
  446.  {
  447.    my_copy(radio_slave[COM2],  value, 4);
  448.    update_display (0);
  449.  }
  450.  if (strcmp( name, "adf1")== 0)
  451.  {
  452.    my_copy(adf[ADF1],  value, 4);
  453.    update_display (2);
  454.  }
  455.  if (strcmp( name, "adf2")== 0)
  456.  {
  457.    my_copy(adf[ADF2],  value, 4);
  458.    update_display (2);
  459.  }
  460.  if (strcmp( name, "trans")== 0)
  461.  {
  462.    my_copy(adf[TRANSPONDER],  value, 4);
  463.    update_display (2);
  464.  }
  465.  if (strcmp( name, "dme1")== 0)
  466.  {
  467.    my_copy(adf[DME1],  value, 4);
  468.    update_display (2);
  469.  }
  470.  if (strcmp( name, "dme2")== 0)
  471.  {
  472.    my_copy(adf[DME2],  value, 4);
  473.    update_display (2);
  474.  }
  475.  if (strcmp( name, "dme1time")== 0)
  476.  {
  477.    my_copy(adf[DME1TIME],  value, 4);
  478.    update_display (2);
  479.  }
  480.  if (strcmp( name, "dme2time")== 0)
  481.  {
  482.    my_copy(adf[DME2TIME],  value, 4);
  483.    update_display (2);
  484.  }
  485.  if (strcmp( name, "obs1")== 0)
  486.  {
  487.    my_copy(obs[OBS1],  value, 4);
  488.    update_display (3);
  489.  }
  490.  if (strcmp( name, "obs2")== 0)
  491.  {
  492.    my_copy(obs[OBS2],  value, 4);
  493.    update_display (3);
  494.  }
  495.  if (strcmp( name, "altitude")== 0)
  496.  {
  497.    my_copy(autopilot_altitude[ALTITUDE],  value, 4);
  498.    update_display (4);
  499.  }
  500.  if (strcmp( name, "vertical")== 0)
  501.  {
  502.    my_copy(autopilot_altitude[VERTICAL],  value, 4);
  503.    update_display (4);
  504.  }
  505.  if (strcmp( name, "heading")== 0)
  506.  {
  507.    my_copy(heading,  value, 4);
  508.    update_display (5);
  509.  }
  510. }
  511.  
  512. void send_value ( char* name,int value)
  513. {
  514.  char buffer [20];
  515.  sprintf (buffer, "%s:%d\n", name, value);
  516.  Serial.write (buffer);
  517. }
  518.  
  519. void send_string (char* name,char* value)
  520. {
  521.  char buffer [20];
  522.  sprintf (buffer, "%s:%s\n", name, value);
  523.  Serial.write (buffer);
  524. }
  525. void send_rotary(char* input)
  526. {
  527.  char *name = NULL, *value = NULL;
  528.  //Serial.write(buffer);
  529.  name =strtok (input, ":");
  530.  value =strtok( NULL, ":");
  531.  int val=atoi (value);
  532.  if (name && value) {
  533.    char buffer[20];
  534.    uint16_t num;
  535.    if (strcmp(name,"bank1")==0)
  536.    {
  537.      float  step = 2.5;
  538.      int last_ditch_it= atoi(&radio_slave[active_bank_one][3]);
  539.      float increasing  = 2.0;
  540.      if (last_ditch_it == 2 || last_ditch_it == 7)
  541.      {
  542.        increasing = 3.0;
  543.      }
  544.      num = atoi(radio_slave[active_bank_one]);
  545.      //navigation_radios uses50kilohertz_spacing
  546.      if (active_bank_one  == NAV1 || active_bank_one  == NAV2)
  547.      {
  548.        increasing = 5.0;
  549.        step = 5.0;
  550.      }
  551.      if (step_bank1 == 1)
  552.      {
  553.        increasing = increasing + ((val - 1) * step);
  554.        num += (int)increasing;
  555.      }
  556.  
  557.      else
  558.      {
  559.        num += val * step_bank1;
  560.      }
  561.  
  562.      if (active_bank_one == NAV1)
  563.      {
  564.        sprintf(buffer, "nav1s:%04d\n" , num);
  565.      }
  566.  
  567.      else if (active_bank_one == NAV2)
  568.      {
  569.        sprintf(buffer, "nav2s:%04d\n" , num);
  570.      }
  571.      else if (active_bank_one == COM1)
  572.      {
  573.        sprintf(buffer, "com1s:%04d\n" , num);
  574.      }
  575.      else if (active_bank_one == COM2)
  576.      {
  577.        sprintf(buffer, "com2s:%04d\n" , num);
  578.      }
  579.    }
  580.    else if (strcmp(name, "bank2")==0)
  581.    {
  582.      num = atoi(radio_slave[active_bank_two]);
  583.      num += val  *step_bank2;
  584.  
  585.      if (active_bank_two == NAV1)
  586.      {
  587.        sprintf(buffer, "nav1s:%04d\n" , num);
  588.      }
  589.  
  590.      else if (active_bank_two == NAV2)
  591.      {
  592.        sprintf(buffer, "nav2s:%04d\n" , num);
  593.      }
  594.      else if (active_bank_two == COM1)
  595.      {
  596.        sprintf(buffer, "com1s:%04d\n" , num);
  597.      }
  598.      else if (active_bank_two == COM2)
  599.      {
  600.        sprintf(buffer, "com2s:%04d\n" , num);
  601.      }
  602.    }
  603.  
  604.    else if (strcmp(name,"heading")==0)
  605.    {
  606.      sprintf(buffer, "heading:%d\n" , val);
  607.    }
  608.  
  609.    else if (strcmp(name, "obs")==0)
  610.    {
  611.      if (active_obs == OBS1)
  612.      {
  613.        sprintf(buffer, "obs1:%d\n" , val);
  614.      }
  615.  
  616.      else if (active_obs == OBS2)
  617.      {
  618.        sprintf(buffer, "obs2:%d\n" , val);
  619.      }
  620.    }
  621.    else if (strcmp(name, "ap")==0)
  622.    {
  623.      if (active_altitude == ALTITUDE)
  624.      {
  625.        sprintf(buffer, "altitude:%d\n" , val);
  626.      }
  627.  
  628.      else if (active_altitude == VERTICAL)
  629.      {
  630.        sprintf(buffer, "vertical:%d\n" , val *100);
  631.      }
  632.    }
  633.  
  634.    else if (strcmp(name, "adf")==0)
  635.    {
  636.      if (active_ADF == ADF1)
  637.      {
  638.        num = atoi(adf[active_ADF]);
  639.        num += val;
  640.        sprintf(buffer, "adf1:%04d\n",  num);
  641.      }
  642.  
  643.      else if (active_ADF == ADF2)
  644.      {
  645.        num = atoi(adf[active_ADF]);
  646.        num += val;
  647.        sprintf(buffer, "adf2:%04d\n",  num);
  648.      }
  649.  
  650.      else if (active_ADF == TRANSPONDER)
  651.      {
  652.        num = atoi(adf[active_ADF]);
  653.        num+=val;
  654.        sprintf(buffer, "trans:%04d\n" , num);
  655.      }
  656.    }
  657.    Serial.write(buffer);
  658.  }
  659. }
  660.  
  661.  
  662. void send_hex( char* name, int val, int len)
  663. {
  664.  char buffer[20];
  665.  if (len == 1)
  666.  {
  667.    sprintf(buffer, "%s:0x%x\n" , name, val);
  668.  
  669.  }
  670.  
  671.  else if (len == 2)
  672.  {
  673.    sprintf(buffer, "%s:0x%02x\n" ,name, val);
  674.  
  675.  }
  676.  
  677.  else if (len == 3)
  678.  {
  679.    sprintf(buffer, "%s:%03x\n" ,name, val);
  680.  }
  681.  
  682.  else if (len == 4)
  683.  {
  684.    sprintf(buffer, "%s:%04x\n" ,name, val);
  685.  }
  686.  Serial.write(buffer);
  687. }
  688.  
  689. void check_input ()
  690. {
  691. }
  692.  
  693. void toggle_button(AdvButton* but)
  694. {
  695.  send_string(but->getName(), "toggle");
  696. }
  697.  
  698. void single_button_on(AdvButton *but)
  699. {
  700.  send_string(but->getName(), "on");
  701. }
  702.  
  703. void single_button_off(AdvButton *but)
  704. {
  705.  send_string(but->getName(), "off");
  706. }
  707.  
  708. void lights_on(AdvButton *but)
  709. {
  710.  but->setBit();
  711.  send_hex ("lights", but->getBytes(), 2);
  712. }
  713.  
  714. void change_step_bank_one(AdvButton* but)
  715. {
  716.  if (step_bank1 == 1)
  717.  {
  718.    step_bank1 =100;
  719.  }
  720.  
  721.  else
  722.  {
  723.    step_bank1 = 1;
  724.  }
  725. }
  726.  
  727. void change_stepped_transponder(AdvButton* but)
  728. {
  729.  if (transponder_step == 1)
  730.  {
  731.    transponder_step = 10000;
  732.  }
  733.  transponder_step /= 10;
  734. }
  735.  
  736. void swap_bank1(AdvButton* but)
  737. {
  738.  int  beats = 1 << active_bank_one;
  739.  send_hex("swap" , beats, 1);
  740. }
  741.  
  742. void swap_bank2(AdvButton* but)
  743. {
  744.  int  beats = 1 << active_bank_two;
  745.  send_hex("swap" , beats, 1);
  746. }
  747.  
  748. void lights_off(AdvButton *but)
  749. {
  750.  but->clearBit();
  751.  send_hex ("lights", but->getBytes(), 2);
  752. }
  753.  
  754. void select_bank1(AdvButton *but)
  755. {
  756.  active_bank_one= atoi(&but->getName()[3]);
  757.  update_display(0);
  758. }
  759.  
  760. void select_bank2(AdvButton *but)
  761. {
  762.  active_bank_two= atoi(&but->getName()[3]);
  763.  update_display(1);
  764. }
  765.  
  766. void select_adf(AdvButton *but)
  767. {
  768.  active_ADF = atoi(&but->getName()[3]);
  769.  update_display(2);
  770. }
  771.  
  772. void select_obs(AdvButton *but)
  773. {
  774.  active_obs = atoi(&but->getName()[3]);
  775.  update_display(3);
  776. }
  777.  
  778. void select_altitude (AdvButton *but)
  779. {
  780.  active_altitude = atoi(&but->getName()[3]);
  781.  update_display(4);
  782. }
  783.  
  784. void send_magneto(AdvButton *but)
  785. {
  786. int mcmd= atoi(&but->getName()[3]);
  787. send_value("magneto",mcmd);
  788. }
  789.  
  790. void write_led_decimals(int display, int value)
  791. {
  792.  digitalWrite (display, LOW);
  793.  delay(10);
  794.  SPI.transfer(0x77);     // Decimal Point OpCode
  795.  SPI.transfer(value);    // Decimal Point Values
  796.  digitalWrite (display, HIGH); //release chip, signal end transfer
  797. }
  798.  
  799. void reset7seg(int display)
  800. {
  801.  digitalWrite (display, LOW);
  802.  delay(100);
  803.  SPI.transfer(0x76);    // Decimal Point Values
  804.  //SPI.transfer(0x0);
  805.  digitalWrite (display, HIGH); //release chip, signal end transfer
  806. }
  807.  
  808. void write_string (int display,char*  s) {
  809.  write_led_numbers(display,(s [0]),(s [1]),(s [2]),(s [3]));
  810. }  
  811.  
  812. void write_led_numbers(int display, char digit1, char digit2, char digit3, char digit4)
  813. {
  814.  digitalWrite (display, LOW);
  815.  delay(10);
  816.  SPI.transfer(digit1);    // Thousands Digit
  817.  delay(10);
  818.  SPI.transfer(digit2);    // Hundreds Digit
  819.  delay(10);
  820.  SPI.transfer(digit3);    // Tens Digit
  821.  delay(10);
  822.  SPI.transfer(digit4);    // Ones Digit
  823.  digitalWrite (display, HIGH); //release chip, signal end transfer
  824.  
  825. }
  826. void write_led(int display, unsigned short num, unsigned short base, unsigned short pad)
  827. {
  828.  unsigned short digit[4] = {
  829.    0, ' ', ' ', ' '                                   };
  830.  unsigned short place = 0;
  831.  
  832.  if ( (base<2) || (base>16) || (num>(base*base*base*base-1)) ) {
  833.    write_led_numbers(display,' ', 0x00, 0x0f, ' ');  // indicate overflow
  834.  }
  835.  else {
  836.    while ( (num || pad) && (place<4) ) {
  837.      if ( (num>0)  || pad )
  838.        digit[place++] = num % base;
  839.      num /= base;
  840.    }
  841.    write_led_numbers(display, digit[3], digit[2], digit[1], digit[0]);
  842.  }
  843. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!