API tools faq
paste
Guest User

combined

a guest
Mar 9th, 2015
96
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 31.31 KB | None | 0 0
raw download clone embed print report
  1. #include <DcsBios.h>
  2. #include <Servo.h>
  3. #include <LedControl.h>
  4.  
  5.  
  6.                                                                                                  /* BEGIN 74HC165 SHIFT REGISTER PART */
  7.              
  8.                    
  9.                /* BEGIN DEFINE THE PINS CONNECTED TO THE ARDUINO FOR THE 74HC165 SHIFT REGISTERS */
  10.  
  11. int ploadPin74HC165        = 2;  // Connects to Parallel load pin the 165
  12. int dataPin74HC165         = 3; // Connects to the Q7 pin the 165
  13. int clockPin74HC165        = 4; // Connects to the Clock pin the 165
  14. //int clockEnablePin74HC165  = 5;  // Connects to Clock Enable pin the 165   // NOT NEEDED SAVES A PIN
  15.  
  16.  
  17.  
  18.                                       /* END DEFINE THE PINS CONNECTED TO THE ARDUINO FOR THE 74HC165 SHIFT REGISTERS */        
  19.                    
  20.                    
  21.                         /* BEGIN 74HC165 SHIFT REGISTER VARIABLES PART */
  22.  
  23.  
  24.  
  25. unsigned long long pinValues = read_shift_regs();  // FIRST VARIABLE TO STORE THE BITS FROM THE FIRST SERIES OF SHIFT REGISTERS. 64BITS VARIABLE (LONG LONG)
  26.  
  27. unsigned long long oldPinValues; // 64B VARIABLE FOR PREVIOUS STATE OF BITS FOR FIRST SERIES OF SHIFT REGISTERS
  28.  
  29. unsigned long long pinValues2 = read_shift_regs2(); // SECOND VARIABLE TO STORE THE BITS FROM THE SECOND SERIES OF SHIFT REGISTERS. 64BITS VARIABLE (LONG LONG)
  30.  
  31. unsigned long long oldPinValues2; // 64B VARIABLE FOR PREVIOUS STATE OF BITS FOR SECOND SERIES OF SHIFT REGISTERS
  32.  
  33.  
  34.                         /* END 74HC165 SHIFT REGISTER VARIABLES PART */
  35.                        
  36.                        
  37.                        
  38.                        
  39.                        
  40.                        
  41.                        
  42.                        
  43.                        
  44.                        
  45.                        
  46.                        
  47.                        
  48.                                                           // BEGIN INPUTS FOR 74HC165 SHIFT REGISTERS//
  49.  
  50. /* INSERT THE CODE FOR INPUTS DIRECTLY FROM THE CONTROL REFERENCE. TO USE WITH SHIFT REGISTERS THE FOLLOWING MODIFICATIONS ARE NEEDED IN THE CONSTRUCTOR:
  51. - "SR" AFTER THE TYPE OF INPUT .
  52. - THE PINS USED BY YOUR SHIFT REGISTERS. O-7 FOR THE FIRST SHIFT REGISTER, 8-15 FOR THE SECOND AND SO ON. RESET THE COUNT OF PINS FOR EACH VARIABLE/SERIES OF IC (SO START AGAIN AT PIN 0 FOR THE FIRST PIN ON THE FIRST SHIFT REGISTER OF EACH VARIABLE)
  53. - POINT TO THE VARIABLE WHERE THE BITS ARE STORED.
  54. EXAMPLE:
  55. DEFAULT VERSION :  DcsBios::Switch2Pos eppApuGenPwr("EPP_APU_GEN_PWR", PIN);
  56. SHIFT REGISTER VERSION : DcsBios::Switch2PosSR eppApuGenPwr("EPP_APU_GEN_PWR", 0, &VARIABLE_NAME );  // "Switch2PosSR" NOTICE THE "SR" AFTER THE DEFAULT "Switch2Pos". DIG0 (FIRST INPUT) ON THE SHIFT REGISTER. "VARIABLE_NAME" IS WHATEVER YOU'VE CALLED YOUR VARIABLE WHERE THE SHIFT REGISTER INFO IS STORED.
  57. SHIFT REGISTER VERSION : DcsBios::ActionButtonSR eppApuGenPwrToggle("EPP_APU_GEN_PWR", "TOGGLE", 1, &VARIABLE_NAME);
  58.  
  59.  
  60. RESET COUNT OF PINS EXAMPLE:
  61. FIRST VARIABLE : DcsBios::Switch2PosSR eppApuGenPwr("EPP_APU_GEN_PWR", 0, &VARIABLE_NAME_1 ) // THE SWITCH/BUTTON/WHATVER IS CONNECTED TO THE FIRST INPUT (DIG0) OF THE FIRST SHIFT REGISTER READ TO THE FIRST VARIABLE.
  62. SECOND VARIABLE : DcsBios::Switch2PosSR eppBatteryPwr("EPP_BATTERY_PWR", 0, &VARIABLE_NAME_2 ) // THE SWITCH/BUTTON/WHATVER IS CONNECTED TO THE FIRST INPUT (DIG0) OF THE FIRST SHIFT REGISTER READ TO THE SECOND VARIABLE. IF USING 64B VARIABLES, THIS IS THE 9TH SHIFT REGISTER.
  63. THIRD VARIABLE : DcsBios::Switch2PosSR eppAcGenPwrL("EPP_AC_GEN_PWR_L", 0, &VARIABLE_NAME_3 ) // THE SWITCH/BUTTON/WHATVER IS CONNECTED TO THE FIRST INPUT (DIG0) OF THE FIRST SHIFT REGISTER READ TO THE THIRD VARIABLE. IF USING 64B VARIABLES, THIS IS THE 17TH SHIFT REGISTER.
  64.  
  65.  
  66. */  
  67.                                                        // BEGIN ROTARIES FOR RADIOS//
  68.  
  69.                       //1. VHF AM//
  70.  
  71. DcsBios::RotaryEncoderSR vhfamFreq1("VHFAM_FREQ1", "DEC", "INC",0, 1, &pinValues);
  72. DcsBios::RotaryEncoderSR vhfamFreq2("VHFAM_FREQ2", "DEC", "INC", 2, 3, &pinValues );
  73. DcsBios::RotaryEncoderSR vhfamFreq3("VHFAM_FREQ3", "DEC", "INC", 5, 6, &pinValues);
  74. DcsBios::RotaryEncoderSR vhfamFreq4("VHFAM_FREQ4", "DEC", "INC", 7, 8, &pinValues );
  75.  
  76.                       //2. VHF FM//
  77.  
  78. DcsBios::RotaryEncoderSR vhffmFreq1("VHFFM_FREQ1", "DEC", "INC", 9, 10, &pinValues );
  79. DcsBios::RotaryEncoderSR vhffmFreq2("VHFFM_FREQ2", "DEC", "INC", 11, 12, &pinValues );
  80. DcsBios::RotaryEncoderSR vhffmFreq3("VHFFM_FREQ3", "DEC", "INC", 13, 14, &pinValues );
  81. DcsBios::RotaryEncoderSR vhffmFreq4("VHFFM_FREQ4", "DEC", "INC", 16, 17, &pinValues );
  82.  
  83.                       //3. UHF//
  84.  
  85. DcsBios::RotaryEncoderSR uhf100mhzSel("UHF_100MHZ_SEL", "DEC", "INC", 18, 19, &pinValues );
  86. DcsBios::RotaryEncoderSR uhf10mhzSel("UHF_10MHZ_SEL", "DEC", "INC", 20, 21, &pinValues );
  87. DcsBios::RotaryEncoderSR uhf1mhzSel("UHF_1MHZ_SEL", "DEC", "INC", 22, 23, &pinValues );
  88. DcsBios::RotaryEncoderSR uhfPoint1mhzSel("UHF_POINT1MHZ_SEL", "DEC", "INC", 24, 25, &pinValues );
  89. DcsBios::RotaryEncoderSR uhfPoint25Sel("UHF_POINT25_SEL", "DEC", "INC", 26, 27, &pinValues );
  90.  
  91.  
  92.  
  93.                                                       // END ROTARIES FOR RADIOS//
  94.  
  95.  
  96.  
  97.                                                       // BEGIN OTHER INPUTS//
  98.  
  99.  
  100. DcsBios::Switch2PosSR efcpSpdbkEmerRetr("EFCP_SPDBK_EMER_RETR", 0, &pinValues2);
  101. DcsBios::Switch2PosSR efcpFlapsEmerRetr("EFCP_FLAPS_EMER_RETR", 1, &pinValues2);
  102. DcsBios::ActionButtonSR eppAcGenPwrLToggle("EPP_AC_GEN_PWR_L", "TOGGLE", 7, &pinValues2);
  103. DcsBios::ActionButtonSR eppAcGenPwrRToggle("EPP_AC_GEN_PWR_R", "TOGGLE", 8, &pinValues2);
  104. DcsBios::ActionButtonSR eppApuGenPwrToggle("EPP_APU_GEN_PWR", "TOGGLE", 9, &pinValues2);
  105. DcsBios::ActionButtonSR eppBatteryPwrToggle("EPP_BATTERY_PWR", "TOGGLE", 15, &pinValues2);
  106. DcsBios::ActionButtonSR eppEmerFloodToggle("EPP_EMER_FLOOD", "TOGGLE", 16, &pinValues2);
  107. DcsBios::Switch3PosSR eppInverter("EPP_INVERTER", 17, 23, &pinValues2);
  108. //DcsBios::ActionButtonSR efcpFlapsEmerRetrToggle("EFCP_FLAPS_EMER_RETR", "TOGGLE", 24);
  109. DcsBios::Switch3PosSR efcpAileronEmerDisengage("EFCP_AILERON_EMER_DISENGAGE", 24, 31, &pinValues2);
  110. DcsBios::Switch3PosSR efcpElevatorEmerDisengage("EFCP_ELEVATOR_EMER_DISENGAGE", 32, 39, &pinValues2);
  111. //DcsBios::ActionButtonSR efcpMrfcsToggle("EFCP_MRFCS", "TOGGLE", 40);
  112.  
  113. //const byte efcpMrfcsPins[2] = {28, 29};
  114. //DcsBios::SwitchMultiPosSR efcpMrfcs("EFCP_MRFCS", efcpMrfcsPins, 2);
  115.  
  116.  
  117. const byte envcpAcOperPins[4] = {40, 41, 47, 48};
  118. DcsBios::SwitchMultiPosSR envcpAcOper("ENVCP_AC_OPER", envcpAcOperPins, 4, &pinValues2);
  119.  
  120.                                                           // END OTHER INPUTS//
  121.  
  122.                                                  
  123.                                                  
  124.                                                  
  125.                                                   // END INPUTS FOR 74HC165 SHIFT REGISTERS//
  126.  
  127.  
  128.  
  129.                                    
  130.                                     // **********************  //
  131.                                    
  132.                                    
  133.                                    
  134.                                    
  135.                                    
  136.                                    
  137.                                    
  138.                                    
  139.                                    
  140.                                  
  141.  
  142.  
  143.  
  144.                                                             /* BEGIN MAIN ROUTINES FOR 74HC165 SHIFT REGISTERS */
  145.  
  146.  
  147.  
  148.  
  149.                                 /* BEGIN ROUTINE 1 */
  150.  
  151.  
  152.  
  153. unsigned long long read_shift_regs()   //  ROUTINE FOR READING/STORING FIRST SERIES OF 74HC165 SHIFT REGISTERS. MAX 8 CHIPS. "LONG LONG" = 64BITS"
  154. {
  155.      long long bitVal;  // 64B VARIABLE FOR READING THE DATA
  156.      unsigned long long bytesVal = 0;  //64B VARIABLE FOR STORING THE DATA
  157.  
  158.     /* Trigger a parallel Load to latch the state of the data lines,
  159.     */
  160.     //digitalWrite(clockEnablePin, HIGH); // NOT NEEDED SAVES A PIN
  161.     digitalWrite(ploadPin74HC165, LOW);
  162.     delayMicroseconds(5);
  163.     digitalWrite(ploadPin74HC165, HIGH);
  164. //digitalWrite(clockEnablePin, LOW); // NOT NEEDED SAVES A PIN
  165.  
  166.  
  167.     /* Loop to read each bit value from the serial out line
  168.      * of the SN74HC165N.
  169.     */
  170.     for(int i = 0; i < 112; i++) // I=0 AND < NUMBER OF TOTAL INPUTS NEEDED FOR ALL IC ROUTINES. SO MULTIPLY TOTAL NUMBER OF SHIFT REGISTERS IN THE CIRCUIT BY NUMBER OF INPUTS USED ON EACH (100 SHIFT REGISTERS X 8 = 800)
  171.     {
  172.         bitVal = digitalRead(dataPin74HC165);
  173.  
  174.         /* Set the corresponding bit in bytesVal.
  175.         */
  176.         bytesVal |= (bitVal << ((112-1) - i));  // NUMBER OF TOTAL INPUTS NEEDED - 1
  177.  
  178.         /* Pulse the Clock (rising edge shifts the next bit).
  179.         */
  180.         digitalWrite(clockPin74HC165, HIGH);
  181.         delayMicroseconds(5);
  182.         digitalWrite(clockPin74HC165, LOW);
  183.     }
  184.  
  185.     return(bytesVal);
  186. }
  187.  
  188.  
  189.                                     /* END ROUTINE 1 */
  190.  
  191.  
  192.  
  193.                                     /* BEGIN ROUTINE 2 */
  194.                                    
  195.  
  196. unsigned long long read_shift_regs2()  //  ROUTINE FOR READING/STORING SECOND SERIES OF 74HC165 SHIFT REGISTERS. MAX 8 CHIPS. "LONG LONG" = 64BITS". ADD MORE ROUTINES FOR MORE SERIES OF CHIPS
  197. {
  198.      long long bitVal; // 64B VARIABLE FOR READING THE DATA
  199.      unsigned long long bytesVal = 0; //64B VARIABLE FOR STORING THE DATA
  200.  
  201.     /* Trigger a parallel Load to latch the state of the data lines,
  202.     */
  203.  //   digitalWrite(clockEnablePin74HC165, HIGH); // NOT NEEDED SAVES A PIN
  204.     digitalWrite(ploadPin74HC165, LOW);
  205.     delayMicroseconds(5);
  206.     digitalWrite(ploadPin74HC165, HIGH);
  207. //digitalWrite(clockEnablePin, LOW); // NOT NEEDED SAVES A PIN
  208.  
  209.  
  210.     /* Loop to read each bit value from the serial out line
  211.      * of the SN74HC165N.
  212.     */
  213.     for(int i = 64; i < 112; i++)  //I=64 (NUMBER OF BITS READ IN THE FIRST ROUTINE/SERIES OF CHIPS. SO IF USING 32B VARIABLE, I=32) AND < NUMBER OF TOTAL INPUTS NEEDED FOR ALL IC ROUTINES. SO MULTIPLY TOTAL NUMBER OF SHIFT REGISTERS IN THE CIRCUIT BY NUMBER OF INPUTS USED ON EACH (100 SHIFT REGISTERS X 8 = 800)
  214.     {
  215.         bitVal = digitalRead(dataPin74HC165);
  216.  
  217.         /* Set the corresponding bit in bytesVal.
  218.         */
  219.         bytesVal |= (bitVal << ((112-1) - i)); // NUMBER OF TOTAL INPUTS NEEDED - 1
  220.  
  221.         /* Pulse the Clock (rising edge shifts the next bit).
  222.         */
  223.         digitalWrite(clockPin74HC165, HIGH);
  224.         delayMicroseconds(5);
  225.         digitalWrite(clockPin74HC165, LOW);
  226.     }
  227.  
  228.     return(bytesVal);
  229. }
  230.  
  231.                                   /* END ROUTINE 2 */
  232.  
  233.  
  234.  
  235.  
  236.  
  237.  
  238.                                                                              /* END MAIN ROUTINES FOR 74HC165 SHIFT REGISTERS */
  239.  
  240.                                                                                  
  241.                                                                                   /* END 74HC165 SHIFT REGISTER PART */
  242.  
  243.  
  244.  
  245.  
  246.  
  247.  
  248.  
  249.  
  250.  
  251.  
  252.  
  253.  
  254.  
  255.  
  256.  
  257.  
  258.  
  259.  
  260.  
  261.  
  262.  
  263.                                                                                     /* BEGIN MAX 7219 PART */
  264.                            
  265. /* BEGIN MAX7219 PIN DEFINITION */
  266.  
  267.  
  268. LedControl lc=LedControl(10,9,8,3); // DATAIN TO ARDUINO PIN 10, CLOCK TO ARDUINO PIN 9, LOAD TO ARDUINO PIN 8, NUMBER OF MAX7219 USED = 3 MAX7219.  CHANGE THESE ACCORDINGLY
  269. /* we always wait a bit between updates of the display */
  270. unsigned long delaytime=500;
  271.                            
  272. /* END MAX7219 PIN DEFINITION */
  273.  
  274.  
  275.  
  276.  
  277.  
  278.  
  279.  
  280.  
  281.                                                                                   /* BEGIN EXPORT TO 7SEG . FREQUENCIES WITH MORE THAN ONE BIT (DIGIT) ARE EXPORTED AS STRINGS AND GO HERE. 0-9 = 1BIT, 10-99 = 2BITS, 100-999 = 3BITS ETC*/
  282.                                                                                  
  283.                                                                                  
  284.  
  285.  
  286.                                     /* VHF AM FREQUENCIES */
  287.  
  288. // 1. VHF AM 1
  289.  
  290. void onVhfamFreq1Change(char* newValue) {
  291.   for(int i=0;i<2;i++) {   //I< THE NUMBER OF BITS TO BE DISPLAYED.0-9 = 1BIT, 10-99 = 2BITS, 100-999 = 3BITS ETC. HERE I<NUMBER OF BITS SO I<2 BECAUSE VHF AM 1 CAN RANGE FROM  3-15
  292.     lc.setChar(0,i,newValue[i],false); // THE MAX7219 TO USE, DIGIT NUMBER ON THE 7SEG DISPLAY, VALUE TO SHOW, DECIMAL POINT ON/OFF. DIGIT 1 AND 2 ON THE FIRST DISPLAY WILL BE USED TO SHOW THE 2BIT NUMBER EXPORTED
  293. }
  294.  }
  295. DcsBios::StringBuffer<2> vhfamFreq1StrBuffer(0x1190, onVhfamFreq1Change);
  296.  
  297. // 1. VHF AM 4
  298.  
  299.  
  300.  void onVhfamFreq4Change(char* newValue) {
  301.     for(int i=0;i<2;i++) {   //I< THE NUMBER OF BITS TO BE DISPLAYED.0-9 = 1BIT, 10-99 = 2BITS, 100-999 = 3BITS ETC. HERE I<NUMBER OF BITS SO I<2 BECAUSE VHF AM 4 CAN RANGE FROM   "00" "25" "50" "75"
  302.    lc.setChar(0,i+4,newValue[i],false); // I+4 MEANS THAT DIGIT 5 AND 6 ON THE  FIRST DISPLAY WILL BE USED TO SHOW THE 2BIT NUMBER EXPORTED
  303. }
  304. }
  305. DcsBios::StringBuffer<2> vhfamFreq4StrBuffer(0x1192, onVhfamFreq4Change);
  306.  
  307.  
  308.                                     /* VHF FM FREQUENCIES */
  309.  
  310.               // 1. VHF FM 1
  311.  
  312.  
  313. void onVhffmFreq1Change(char* newValue) {
  314.     for(int i=0;i<2;i++) {   //I< THE NUMBER OF BITS TO BE DISPLAYED.0-9 = 1BIT, 10-99 = 2BITS, 100-999 = 3BITS ETC. HERE I<NUMBER OF BITS SO I<2 BECAUSE VHF FM 1 CAN RANGE FROM  3-15
  315.     lc.setChar(1,i,newValue[i],false); // THE MAX7219 TO USE, DIGIT NUMBER ON THE 7SEG DISPLAY, VALUE TO SHOW, DECIMAL POINT ON/OFF. DIGIT 1 AND 2 ON THE SECOND DISPLAY WILL BE USED TO SHOW THE 2BIT NUMBER EXPORTED
  316. }
  317. }
  318. DcsBios::StringBuffer<2> vhffmFreq1StrBuffer(0x119a, onVhffmFreq1Change);
  319.  
  320.  
  321.               // 2. VHF FM 4
  322.  
  323. void onVhffmFreq4Change(char* newValue) {
  324.     for(int i=0;i<2;i++) {   //I< THE NUMBER OF BITS TO BE DISPLAYED.0-9 = 1BIT, 10-99 = 2BITS, 100-999 = 3BITS ETC. HERE I<NUMBER OF BITS SO I<2 BECAUSE VHF FM 4 CAN RANGE FROM   "00" "25" "50" "75"
  325.    lc.setChar(1,i+4,newValue[i],false); // I+4 MEANS THAT DIGIT 5 AND 6 ON THE SECOND DISPLAY WILL BE USED TO SHOW THE 2BIT NUMBER EXPORTED
  326. }
  327. }
  328. DcsBios::StringBuffer<2> vhffmFreq4StrBuffer(0x119e, onVhffmFreq4Change);
  329.  
  330.  
  331.                                    
  332.                                     /* UHF FREQUENCIES */
  333.  
  334.               // 1. UHF 1
  335.  
  336. void onUhf100mhzSelChange(char* newValue) {
  337.     for(int i=0;i<1;i++) {        // 100MHZ SELECTOR IS EXPORTED AS STRING BECAUSE IT CONTAINS A POSSIBLE VALUE OF "A" THEREFORE CANNOT BE EXPORTED AS INTEGER AND MUST GO HERE. IT'S ONE BIT SO i<1
  338.     lc.setChar(2,i,newValue[i],false);   // THE MAX7219 TO USE, DIGIT NUMBER ON THE 7SEG DISPLAY, VALUE TO SHOW, DECIMAL POINT ON/OFF. DIGIT 1 WILL BE USED TO SHOW THE 1BIT NUMBER EXPORTED
  339. }
  340.  
  341.  
  342. }
  343. DcsBios::StringBuffer<1> uhf100mhzSelStrBuffer(0x1178, onUhf100mhzSelChange);
  344.  
  345.  
  346.               // 2. UHF 5
  347.  
  348.  
  349.  
  350.  
  351. void onUhfPoint25SelChange(char* newValue) {
  352.     for(int i=0;i<2;i++) {   //I< THE NUMBER OF BITS TO BE DISPLAYED.0-9 = 1BIT, 10-99 = 2BITS, 100-999 = 3BITS ETC. HERE I<NUMBER OF BITS SO I<2 BECAUSE UHF .25MHZ CAN RANGE FROM   "00" "25" "50" "75"
  353.     lc.setChar(2,i+4,newValue[i],false); // I+4 MEANS THAT DIGIT 5 AND 6 ON THE THIRD DISPLAY WILL BE USED TO SHOW THE 2BIT NUMBER EXPORTED
  354. }
  355. }
  356.  
  357. DcsBios::StringBuffer<2> uhfPoint25SelStrBuffer(0x117a, onUhfPoint25SelChange);
  358.  
  359.  
  360.  
  361.  
  362.  
  363.  
  364.  
  365.                                                                     /* END EXPORT TO 7SEG . FREQUENCIES WITH MORE THAN ONE BIT (DIGIT) ARE EXPORTED AS STRINGS AND GO HERE. 0-9 = 1BIT, 10-99 = 2BITS, 100-999 = 3BITS ETC*/
  366.                                                                    
  367.                                                                    
  368.                                                                    
  369.                                                                    
  370.                                                                                           /* END MAX 7219 PART */
  371.                                                                    
  372.                                                              
  373.                                                              
  374.                                                              
  375.                                                              
  376.                                                              
  377.                                                              
  378.                                                              
  379.                                                              
  380.                                                              
  381.                                                              
  382.                                                              
  383.                                                              
  384.                                                              
  385.                                                              
  386.                                                              
  387.                                                              
  388.                                                              
  389.                                                              
  390.                                                              
  391.                                                              
  392.                                                              
  393.                                                              
  394.                                                              
  395.                                                              
  396.                                                              
  397.                                                              
  398.                                                              
  399.                                                              
  400.                                                                /* BEGIN 74HC595 SHIFT REGISTER PART */    
  401.                                                                
  402.                                                                
  403.                                                                    
  404.                   /* BEGIN DEFINE THE PINS CONNECTED TO THE ARDUINO FOR THE 74HC595 SHIFT REGISTERS */                                                  
  405.                                                                    
  406. int latchPin74HC595 = 5;  // 74HC595 LATCH PIN GOES TO ARDUINO PIN 5. CHANGE ACCORDINGLY!
  407. int clockPin74HC595 = 6;  // 74HC595 CLOCK PIN GOES TO ARDUINO PIN 6. CHANGE ACCORDINGLY!
  408. int dataPin74HC595 = 7;   // 74HC595 DATA PIN GOES TO ARDUINO PIN 7. CHANGE ACCORDINGLY!                                                                
  409.                                                                    
  410.                   /* END DEFINE THE PINS CONNECTED TO THE ARDUINO FOR THE 74HC595 SHIFT REGISTERS */                                                  
  411.                                                                    
  412.  
  413.  
  414.                 /* BEGIN 74HC595 SHIFT REGISTER VARIABLES PART */
  415.  
  416. // EACH 74HC595 NEEDS A SEPARATE VARIABLE. WE HAVE THREE 74HC595 SO WE USE THREE VARIABLES.
  417.  
  418. unsigned int leds =0;
  419. unsigned int leds2 =0;
  420. unsigned int leds3 =0;
  421.  
  422.  
  423.               /* END 74HC595 SHIFT REGISTER VARIABLES PART */
  424.  
  425.  
  426.  
  427.  
  428.  
  429.  
  430.  
  431.  
  432.  
  433.  
  434.  
  435.  
  436.  
  437.                                                                                                     /* BEGIN OUTPTUS FOR 74HC595 SHIFT REGISTERS */
  438.                                                                                                    
  439.                                                                                                    
  440.  
  441. /* INSERT THE CODE FOR OUTPTUS DIRECTLY FROM THE CONTROL REFERENCE. TO USE WITH SHIFT REGISTERS THE FOLLOWING MODIFICATIONS ARE NEEDED IN THE CONSTRUCTOR:
  442. - "SR" AFTER THE TYPE OF INPUT .
  443. - THE PINS USED BY YOUR SHIFT REGISTERS. O-7 FOR  EACH 8BIT SHIFT REGISTER (SO START AGAIN AT PIN 0 FOR EACH SHIFT REGISTER AND EACH VARIABLE)
  444. - POINT TO THE VARIABLE WHERE THE BITS ARE STORED. REMEMBER THAT EACH 74HC595 NEEDS ITS OWN DIFFERENT VARIABLE!
  445.  
  446. EXAMPLE:
  447. DEFAULT VERSION :  DcsBios::LED canopyUnlocked(0x10da, 0x0004, PIN);;
  448. SHIFT REGISTER VERSION : DcsBios::LEDSR2 canopyUnlocked(0x10da, 0x0004, 0, &VARIABLE_NAME);  // "LEDSR2" NOTICE THE "SR" AFTER THE DEFAULT "LED". '0' (FIRST OUTPUT) ON THE SHIFT REGISTER. "VARIABLE_NAME" IS WHATEVER YOU'VE CALLED YOUR VARIABLE WHERE THE SHIFT REGISTER INFO IS STORED.
  449. SHIFT REGISTER VERSION : DcsBios::LEDSR2 gunReady(0x1026, 0x8000, 2, &VARIABLE_NAME);
  450.  
  451.  
  452. RESET COUNT OF PINS EXAMPLE:
  453. FIRST VARIABLE : DcsBios::LEDSR2 gunReady(0x1026, 0x8000, 0, &VARIABLE_NAME_1); // THE LED IS CONNECTED TO THE FIRST OUTPUT (DIG0) OF THE FIRST SHIFT REGISTER AND THE FIRST VARIABLE.
  454. SECOND VARIABLE : DcsBios::LEDSR2 canopyUnlocked(0x10da, 0x0004, 0, &VARIABLE_NAME_2 ) // THE LED IS CONNECTED TO THE FIRST OUTPUT (DIG0) OF THE SECOND SHIFT REGISTER AND THE FIRST VARIABLE.
  455. THIRD VARIABLE : DcsBios::LEDSR2 handleGearWarning(0x1026, 0x4000, 0, &VARIABLE_NAME_3 ) // THE LED IS CONNECTED TO THE FIRST OUTPUT (DIG0) OF THE THIRD SHIFT REGISTER AND THE FIRST VARIABLE.
  456.  
  457.  
  458. */  
  459.  
  460.  
  461.  
  462. DcsBios::LEDSR2 gunReady(0x1026, 0x8000, 2, &leds);
  463. DcsBios::LEDSR2 canopyUnlocked(0x10da, 0x0004, 2, &leds2);
  464. DcsBios::LEDSR2 handleGearWarning(0x1026, 0x4000, 2, &leds3 );
  465. DcsBios::LEDSR2 masterCaution(0x1012, 0x0800, 4, &leds3);
  466. DcsBios::LEDSR2 oxyFlow(0x112a, 0x0800, 5, &leds3);
  467. //DcsBios::LEDSR lEngFire(0x10da, 0x0008, 2);
  468. //DcsBios::LEDSR rEngFire(0x10da, 0x0020, 3);
  469. DcsBios::LEDSR2 dvadrRec(0x11ba, 0x0080, 4, &leds);
  470. DcsBios::LEDSR2 gearLSafe(0x1026, 0x1000, 5, &leds2);
  471. DcsBios::LEDSR2 gearNSafe(0x1026, 0x0800, 6, &leds3);
  472. DcsBios::LEDSR2 gearRSafe(0x1026, 0x2000, 7, &leds);
  473.  
  474.                                                          
  475.                                                          
  476.                                                           /* END OUTPTUS FOR 74HC595 SHIFT REGISTERS */
  477.                                                          
  478.                                                          
  479.                                                          
  480.                                                          
  481.                                                          
  482.                                                          
  483.  
  484.  
  485. /**** In most cases, you do not have to change anything below this line ****/
  486.  
  487. /* Instantiate a ProtocolParser object to parse the DCS-BIOS export stream */
  488. DcsBios::ProtocolParser parser;
  489.  
  490. void setup() {
  491.   Serial.begin(115000);   // DONT GO TOO FAST OR STRANGE THINGS WILL HAPPEN. REMEMBER TO SET MATCHING BAUD RATE IN DCSBIOS
  492.  
  493.    
  494.                                                            /* BEGIN 74HC165 PART */
  495.    
  496.                            /* INITIALIZE 74HC165 SHIFT REGISTER ARDUINO PINS */
  497.    
  498.     pinMode(ploadPin74HC165, OUTPUT);
  499.   //  pinMode(clockEnablePin, OUTPUT);  // NOT NEEDED SAVES A PIN
  500.     pinMode(clockPin74HC165, OUTPUT);
  501.     pinMode(dataPin74HC165, INPUT);
  502.  
  503.     digitalWrite(clockPin74HC165, LOW);
  504.     digitalWrite(ploadPin74HC165, HIGH);
  505.  
  506.     /* Read in and display the pin states at startup.
  507.     */
  508.     pinValues = read_shift_regs();    // READ ONCE THE FIRST SERIES OF SHIFT REGISTERS (FIRST VARIABLE)
  509.    
  510.     oldPinValues = pinValues;
  511.    
  512.     pinValues2 = read_shift_regs2(); // READ ONCE THE SECOND SERIES OF SHIFT REGISTERS (SECOND VARIABLE)
  513.    
  514.     oldPinValues2 = pinValues2;
  515.    
  516.    
  517.                                                        /* END 74HC165 PART */
  518.    
  519.    
  520.    
  521.    
  522.    
  523.    
  524.    
  525.    
  526.    
  527.                                                    /* BEGIN MAX7219 PART */
  528.    
  529.    
  530.    /*
  531.    The MAX72XX is in power-saving mode on startup,
  532.    we have to do a wakeup call
  533.    */
  534.  
  535.   /* FIRST MAX7219 */
  536.  
  537.   lc.shutdown(0,false);
  538.   /* Set the brightness to a medium values. POSSIBLE VALUES 0-15 */
  539.   lc.setIntensity(0,1);
  540.   /* and clear the display */
  541.   lc.clearDisplay(0);
  542.  
  543.  
  544.    /* SECOND MAX7219 */
  545.  
  546.   lc.shutdown(1,false);
  547.   /* Set the brightness to a medium values. POSSIBLE VALUES 0-15 */
  548.   lc.setIntensity(1,1);
  549.   /* and clear the display */
  550.   lc.clearDisplay(1);
  551.  
  552.  
  553.    /* THIRD MAX7219 */
  554.  
  555.   lc.shutdown(2,false);
  556.   /* Set the brightness to a medium values. POSSIBLE VALUES 0-15 */
  557.   lc.setIntensity(2,1);
  558.   /* and clear the display */
  559.   lc.clearDisplay(2);
  560.  
  561.  
  562.                                                         /* END MAX7219 PART */
  563.  
  564.  
  565.  
  566.  
  567.  
  568.                                                       /* BEGIN 74HC595 PART */
  569.  
  570.         /* INITIALIZE 74HC595 SHIFT REGISTER ARDUINO PINS */
  571.            
  572.    
  573.  
  574.   pinMode(latchPin74HC595, OUTPUT);
  575.   pinMode(dataPin74HC595, OUTPUT);  
  576.   pinMode(clockPin74HC595, OUTPUT);
  577.  
  578.                                                     /* END 74HC595 PART */
  579.  
  580.  
  581.  
  582.  
  583.  
  584.  
  585.  
  586.  
  587.  
  588.  
  589. }
  590.  
  591.  
  592. /*
  593. Your main loop needs to pass data from the DCS-BIOS export
  594. stream to the parser object you instantiated above.
  595.  
  596. It also needs to call DcsBios::PollingInput::pollInputs()
  597. to detect changes in the state of connected controls and
  598. pass them on to DCS.
  599. */
  600. void loop() {
  601.   // feed incoming data to the parser
  602.   while (Serial.available()) {
  603.       parser.processChar(Serial.read());
  604.   }
  605.  
  606.   // poll inputs
  607.   DcsBios::PollingInput::pollInputs();
  608.  
  609.  
  610.                                                                       /* BEGIN 74HC165 SHIFT REGISTER PART */
  611.  
  612.   /* ENTER HERE ALL THE READING ROUTINES NEEDED FOR THE SHIFT REGISTERS */
  613.  
  614.    pinValues = read_shift_regs(); // CONTINUOUSLY READ THE SHIFT REGISTER BITS IN THE FIRST SERIES OF IC TO THE FIRST VARIABLE
  615.    
  616.    oldPinValues = pinValues;
  617.  
  618.    pinValues2 = read_shift_regs2(); // CONTINUOUSLY READ THE SHIFT REGISTER BITS IN THE SECOND SERIES OF IC TO THE SECOND VARIABLE
  619.    
  620.    oldPinValues2 = pinValues2;
  621.  
  622.                                                                   /* END 74HC165 SHIFT REGISTER PART */
  623.  
  624.  
  625.  
  626.  
  627.  
  628.  
  629.  
  630.  
  631.  
  632.  
  633.  
  634.  
  635.  
  636.  
  637.  
  638.  
  639. }
  640.  
  641. /*
  642. You need to define
  643. void sendDcsBiosMessage(const char* msg, const char* arg)
  644. so that the string msg, followed by a space, the string arg
  645. and a newline gets sent to the DCS-BIOS import stream.
  646.  
  647. In this example we send it to the serial port, so you need to
  648. run socat to read the data from the serial port and send it
  649. over UDP to DCS-BIOS.
  650.  
  651. If you are using an Ethernet Shield, you would probably want
  652. to send a UDP packet from this subroutine.
  653. */
  654. void sendDcsBiosMessage(const char* msg, const char* arg) {
  655.   Serial.write(msg);
  656.   Serial.write(' ');
  657.   Serial.write(arg);
  658.   Serial.write('\n');
  659. }
  660.  
  661. /*
  662. This subroutine gets called every time a message is received
  663. from the export stream (you need to define it even if it
  664. does nothing).
  665.  
  666. Use this to handle outputs which are not covered by the
  667. DcsBios Arduino library (e.g. displays).
  668. */
  669.  
  670.  
  671.  
  672. void onDcsBiosWrite(unsigned int address, unsigned int value) {
  673.  
  674.  
  675.  
  676.  
  677.  
  678.  
  679.                                                                                              /* BEGIN MAX 7219 PART */
  680.  
  681.  
  682.                                                               /* BEGIN EXPORT TO 7SEG . FREQUENCIES WITH ONE BIT (DIGIT) ARE EXPORTED AS STRINGS AND GO HERE. 0-9 = 1BIT, 10-99 = 2BITS, 100-999 = 3BITS ETC*/
  683.  
  684.                                           /* VHF AM FREQUENCIES */
  685.  
  686.   // 1. VHF AM 2
  687.  
  688.   if (address == 0x118e) {
  689.     unsigned int vhfamFreq2Value = (value & 0x00f0) >> 4;
  690.     lc.setChar(0,2,vhfamFreq2Value,true); // THE MAX7219 TO USE, DIGIT NUMBER ON THE 7SEG DISPLAY, VALUE TO SHOW, DECIMAL POINT ON/OFF
  691. }
  692.  
  693.   // 2. VHF AM 3
  694.  
  695.   if (address == 0x118e) {
  696.     unsigned int vhfamFreq3Value = (value & 0x0f00) >> 8;
  697.     lc.setChar(0,3,vhfamFreq3Value,false); // THE MAX7219 TO USE, DIGIT NUMBER ON THE 7SEG DISPLAY, VALUE TO SHOW, DECIMAL POINT ON/OFF
  698. }
  699.  
  700.  
  701.                                           /* VHF FM FREQUENCIES */
  702.  
  703.   // 1. VHF FM 2
  704.  
  705.  if (address == 0x119c) {
  706.     unsigned int vhffmFreq2Value = (value & 0x000f) >> 0;
  707.     lc.setChar(1,2,vhffmFreq2Value,true); // THE MAX7219 TO USE, DIGIT NUMBER ON THE 7SEG DISPLAY, VALUE TO SHOW, DECIMAL POINT ON/OFF
  708. }
  709.  
  710.  
  711.    // 2. VHF FM 3
  712.  
  713.   if (address == 0x119c) {
  714.     unsigned int vhffmFreq3Value = (value & 0x00f0) >> 4;
  715.     lc.setChar(1,3,vhffmFreq3Value,false); // THE MAX7219 TO USE, DIGIT NUMBER ON THE 7SEG DISPLAY, VALUE TO SHOW, DECIMAL POINT ON/OFF
  716. }
  717.  
  718.  
  719.  
  720.                                           /* UHF FREQUENCIES */
  721.  
  722.     // 1. UHF 2
  723.  
  724.     if (address == 0x1170) {
  725.     unsigned int uhf10mhzSelValue = (value & 0x3c00) >> 10;
  726.     lc.setChar(2,1,uhf10mhzSelValue,false); // THE MAX7219 TO USE, DIGIT NUMBER ON THE 7SEG DISPLAY, VALUE TO SHOW, DECIMAL POINT ON/OFF
  727.  
  728. }
  729.  
  730.  
  731.  
  732.  // 2. UHF 3
  733.  
  734. if (address == 0x1178) {
  735.     unsigned int uhf1mhzSelValue = (value & 0x0f00) >> 8;
  736.     lc.setChar(2,2,uhf1mhzSelValue,false); // THE MAX7219 TO USE, DIGIT NUMBER ON THE 7SEG DISPLAY, VALUE TO SHOW, DECIMAL POINT ON/OFF
  737.    
  738. }
  739.  
  740.  
  741.  // 3. UHF 4
  742.  
  743.  
  744. if (address == 0x1178) {
  745.     unsigned int uhfPoint1mhzSelValue = (value & 0xf000) >> 12;
  746.     lc.setChar(2,3,uhfPoint1mhzSelValue,false); // THE MAX7219 TO USE, DIGIT NUMBER ON THE 7SEG DISPLAY, VALUE TO SHOW, DECIMAL POINT ON/OFF
  747. }
  748.  
  749.  
  750.  
  751.                                                                             /* END EXPORT TO 7SEG . FREQUENCIES WITH ONE BIT (DIGIT) ARE EXPORTED AS STRINGS AND GO HERE. 0-9 = 1BIT, 10-99 = 2BITS, 100-999 = 3BITS ETC*/
  752.                                                                                                            
  753.                                                                                                             /* END MAX 7219 PART */
  754.  
  755.  
  756.                                                                                              
  757.                                                                                              
  758.                                                                                              
  759.                                                                                              
  760.                                                                                              
  761.                                                                                               /* BEGIN 74HC595 SHIFT REGISTER PART */  
  762.  
  763.  
  764.  
  765. if (address == 0xfffe) {
  766.         updateShiftRegister();  //CALL THE 74HC595 SHIFTOUT ROUTINE WHEN THE LAST DATA FOR EACH FRAME BY THE UPDATE COUNTER IS SENT OUT. ~30MS
  767.     }
  768.  
  769.  
  770.                                                                                             /* END 74HC595 SHIFT REGISTER PART */  
  771.  
  772.  
  773.  
  774.  
  775. }
  776.  
  777.  
  778.  
  779.  
  780.  
  781.  
  782.  
  783.  
  784.  
  785.                                                                                   /* BEGIN SHIFTOUT FOR 74HC595 SHIFT REGISTER PART */  
  786.  
  787.  
  788.  
  789. void updateShiftRegister()
  790. {
  791.    digitalWrite(latchPin74HC595, LOW);
  792.    shiftOut(dataPin74HC595, clockPin74HC595, MSBFIRST, leds);   // EACH 74HC595 AND VARIABLE NEEDS ITS OWN SHIFTOUT. MSBFIRST = SHIFT BITS FROM THE LEFT. LSBFIRST = SHIFT BITS FROM THE RIGHT
  793.    shiftOut(dataPin74HC595, clockPin74HC595, MSBFIRST, leds2);  // EACH 74HC595 AND VARIABLE NEEDS ITS OWN SHIFTOUT. MSBFIRST = SHIFT BITS FROM THE LEFT. LSBFIRST = SHIFT BITS FROM THE RIGHT
  794.    shiftOut(dataPin74HC595, clockPin74HC595, MSBFIRST, leds3);  // EACH 74HC595 AND VARIABLE NEEDS ITS OWN SHIFTOUT. MSBFIRST = SHIFT BITS FROM THE LEFT. LSBFIRST = SHIFT BITS FROM THE RIGHT
  795.    digitalWrite(latchPin74HC595, HIGH);
  796. }
  797.  
  798.                                                                                       /* END SHIFTOUT FOR 74HC595 SHIFT REGISTER PART */
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
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!