API tools faq
paste
Advertisement
Guest User

DcsBios.cpp

a guest
Jan 30th, 2015
287
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 9.06 KB | None | 0 0
raw download clone embed print report
  1. #include "DcsBios.h"
  2. #include <stdlib.h>
  3. #include <Servo.h>
  4.  
  5. namespace DcsBios {
  6.  
  7. PollingInput* PollingInput::firstPollingInput = NULL;
  8. ExportStreamListener* ExportStreamListener::firstExportStreamListener = NULL;
  9.  
  10. ProtocolParser::ProtocolParser() {
  11.     state = DCSBIOS_STATE_WAIT_FOR_SYNC;
  12.     sync_byte_count = 0;
  13. }
  14.  
  15. void ProtocolParser::processChar(unsigned char c) {
  16.  
  17.   switch(state) {
  18.     case DCSBIOS_STATE_WAIT_FOR_SYNC:
  19.         /* do nothing */
  20.         break;
  21.        
  22.     case DCSBIOS_STATE_ADDRESS_LOW:
  23.         address = (unsigned int)c;
  24.         state = DCSBIOS_STATE_ADDRESS_HIGH;
  25.         break;
  26.        
  27.     case DCSBIOS_STATE_ADDRESS_HIGH:
  28.         address = (c << 8) | address;
  29.         if (address != 0x5555) {
  30.             state = DCSBIOS_STATE_COUNT_LOW;
  31.         } else {
  32.             state = DCSBIOS_STATE_WAIT_FOR_SYNC;
  33.         }
  34.         break;
  35.        
  36.     case DCSBIOS_STATE_COUNT_LOW:
  37.         count = (unsigned int)c;
  38.         state = DCSBIOS_STATE_COUNT_HIGH;
  39.         break;
  40.        
  41.     case DCSBIOS_STATE_COUNT_HIGH:
  42.         count = (c << 8) | count;
  43.         state = DCSBIOS_STATE_DATA_LOW;
  44.         break;
  45.        
  46.     case DCSBIOS_STATE_DATA_LOW:
  47.         data = (unsigned int)c;
  48.         count--;
  49.         state = DCSBIOS_STATE_DATA_HIGH;
  50.         break;
  51.        
  52.     case DCSBIOS_STATE_DATA_HIGH:
  53.         data = (c << 8) | data;
  54.         count--;
  55.         onDcsBiosWrite(address, data);
  56.         ExportStreamListener::handleDcsBiosWrite(address, data);
  57.         address += 2;
  58.         if (count == 0)
  59.             state = DCSBIOS_STATE_ADDRESS_LOW;
  60.         else
  61.             state = DCSBIOS_STATE_DATA_LOW;
  62.         break;
  63.   }
  64.  
  65.   if (c == 0x55)
  66.     sync_byte_count++;
  67.   else
  68.     sync_byte_count = 0;
  69.  
  70.   if (sync_byte_count == 4) {
  71.     state = DCSBIOS_STATE_ADDRESS_LOW;
  72.     sync_byte_count = 0;
  73.     ExportStreamListener::handleDcsBiosFrameSync();
  74.   }
  75.  
  76. }
  77.  
  78. ActionButton::ActionButton(char* msg, char* arg, char pin) {
  79.     msg_ = msg;
  80.     arg_ = arg;
  81.     pin_ = pin;
  82.     pinMode(pin_, INPUT_PULLUP);
  83.     lastState_ = digitalRead(pin_);
  84. }
  85. void ActionButton::pollInput() {
  86.     char state = digitalRead(pin_);
  87.     if (state != lastState_) {
  88.         if (lastState_ == HIGH && state == LOW) {
  89.             sendDcsBiosMessage(msg_, arg_);
  90.         }
  91.     }
  92.     lastState_ = state;
  93. }
  94.  
  95. ActionButtonSR::ActionButtonSR(char* msg, char* arg, char srinput) {
  96.     msg_ = msg;
  97.     arg_ = arg;
  98.     srinput_ = srinput;
  99.     pinValues_ = pinValues;
  100.     lastState_ = pinValues_ & (1<< srinput_);
  101. }
  102. void ActionButtonSR::pollInput() {
  103.      int state = pinValues  & (1<< srinput_);
  104.     if (state != lastState_) {
  105.         if (lastState_ != 0 && state == 0)  {
  106.             sendDcsBiosMessage(msg_, arg_);
  107.         }
  108.     }
  109.     lastState_ = state;
  110. }
  111.  
  112.  
  113.  
  114.  
  115.  
  116.  
  117.  
  118.  
  119.  
  120. Switch2Pos::Switch2Pos(char* msg, char pin) {
  121.     msg_ = msg;
  122.     pin_ = pin;
  123.     pinMode(pin_, INPUT_PULLUP);
  124.     lastState_ = digitalRead(pin_);
  125. }
  126. void Switch2Pos::pollInput() {
  127.     char state = digitalRead(pin_);
  128.     if (state != lastState_) {
  129.         sendDcsBiosMessage(msg_, state == HIGH ? "0" : "1");
  130.     }
  131.     lastState_ = state;
  132. }
  133.  
  134. Switch2PosSR::Switch2PosSR(char* msg, char srinput) {
  135.     msg_ = msg;
  136.     srinput_ = srinput;
  137.     pinValues_ = pinValues;
  138.     lastState_ = pinValues_ & (1<< srinput_);
  139. }
  140. void Switch2PosSR::pollInput() {
  141.    
  142.      int state = pinValues  & (1<< srinput_);
  143.    
  144.     if (state != lastState_) {
  145.    
  146.         sendDcsBiosMessage(msg_, state == 0 ? "0" : "1");
  147.     }
  148.     lastState_ = state;
  149. }
  150.  
  151.  
  152. Switch3Pos::Switch3Pos(char* msg, char pinA, char pinB) {
  153.     msg_ = msg;
  154.     pinA_ = pinA;
  155.     pinB_ = pinB;
  156.     pinMode(pinA_, INPUT_PULLUP);
  157.     pinMode(pinB_, INPUT_PULLUP);
  158.     lastState_ = readState();
  159. }
  160. char Switch3Pos::readState() {
  161.     if (digitalRead(pinA_) == LOW) return 0;
  162.     if (digitalRead(pinB_) == LOW) return 2;
  163.     return 1;
  164. }
  165. void Switch3Pos::pollInput() {
  166.     char state = readState();
  167.     if (state != lastState_) {
  168.         if (state == 0)
  169.             sendDcsBiosMessage(msg_, "0");
  170.         if (state == 1)
  171.             sendDcsBiosMessage(msg_, "1");
  172.         if (state == 2)
  173.             sendDcsBiosMessage(msg_, "2");
  174.     }
  175.     lastState_ = state;
  176. }
  177.  
  178.  
  179.  
  180.  
  181.  
  182. Switch3PosSR::Switch3PosSR(char* msg, char srinputA, char srinputB) {
  183.     msg_ = msg;
  184.     srinputA_ = srinputA;
  185.     srinputB_ = srinputB;
  186.     pinValues_ = pinValues;
  187.     lastState_ = readState();
  188. }
  189. int Switch3PosSR::readState() {
  190.     if ((pinValues & (1<< srinputA_)) != 0) return 0;
  191.     if ((pinValues & (1<< srinputB_)) != 0) return 2;
  192.     return 1;
  193. }
  194. void Switch3PosSR::pollInput() {
  195.     int state = readState();
  196.     if (state != lastState_) {
  197.         if (state == 0)
  198.             sendDcsBiosMessage(msg_, "0");
  199.         if (state == 1)
  200.             sendDcsBiosMessage(msg_, "1");
  201.         if (state == 2)
  202.             sendDcsBiosMessage(msg_, "2");
  203.     }
  204.     lastState_ = state;
  205. }
  206.  
  207.  
  208.  
  209.  
  210.  
  211.  
  212.  
  213.  
  214.  
  215.  
  216.  
  217.  
  218.  
  219.  
  220.  
  221. Potentiometer::Potentiometer(char* msg, char pin) {
  222.     msg_ = msg;
  223.     pin_ = pin;
  224.     pinMode(pin_, INPUT);
  225.     lastState_ = map(analogRead(pin_), 0, 1023, 0, 65535);
  226. }
  227. void Potentiometer::pollInput() {
  228.     unsigned int state = map(analogRead(pin_), 0, 1023, 0, 65535);
  229.     if (state != lastState_) {
  230.         char buf[6];
  231.         utoa(state, buf, 10);
  232.         sendDcsBiosMessage(msg_, buf);
  233.     }
  234.     lastState_ = state;
  235. }
  236.  
  237.  
  238. SwitchMultiPos::SwitchMultiPos(char* msg, const byte* pins, char numberOfPins) {
  239.     msg_ = msg;
  240.     pins_ = pins;
  241.     numberOfPins_ = numberOfPins;
  242.     char i;
  243.     for (i=0; i<numberOfPins; i++) {
  244.         pinMode(pins[i], INPUT_PULLUP);
  245.     }
  246.     lastState_ = readState();
  247. }
  248. char SwitchMultiPos::readState() {
  249.     char i;
  250.     for (i=0; i<numberOfPins_; i++) {
  251.         if (digitalRead(pins_[i]) == LOW) return i;
  252.     }
  253.     return 0;
  254. }
  255. void SwitchMultiPos::pollInput() {
  256.     char state = readState();
  257.     if (state != lastState_) {
  258.         char buf[7];
  259.         utoa(state, buf, 10);
  260.         sendDcsBiosMessage(msg_, buf);
  261.     }
  262.     lastState_ = state;
  263. }
  264.  
  265.  
  266.  
  267.  
  268.  
  269.  
  270. SwitchMultiPosSR::SwitchMultiPosSR(char* msg, const byte* SRpins, char numberOfSRPins) {
  271.     msg_ = msg;
  272.     SRpins_ = SRpins;
  273.     numberOfSRPins_ = numberOfSRPins;
  274.     pinValues_ = pinValues;
  275.     lastState_ = readState();
  276. }
  277. int SwitchMultiPosSR::readState() {
  278.     int i;
  279.     for (i=0; i<numberOfSRPins_; i++) {
  280.         if ((pinValues & (1<< SRpins_[i])) != 0) return i;
  281.     }
  282.     return 0;
  283. }
  284. void SwitchMultiPosSR::pollInput() {
  285.     int state = readState();
  286.     if (state != lastState_) {
  287.         char buf[7];
  288.         utoa(state, buf, 10);
  289.         sendDcsBiosMessage(msg_, buf);
  290.     }
  291.     lastState_ = state;
  292. }
  293.  
  294.  
  295.  
  296.  
  297.  
  298.  
  299.  
  300.  
  301.  
  302.  
  303.  
  304. RotaryEncoder::RotaryEncoder(const char* msg, const char* decArg, const char* incArg, char pinA, char pinB) {
  305.     msg_ = msg;
  306.     decArg_ = decArg;
  307.     incArg_ = incArg;
  308.     pinA_ = pinA;
  309.     pinB_ = pinB;
  310.     pinMode(pinA_, INPUT_PULLUP);
  311.     pinMode(pinB_, INPUT_PULLUP);
  312.     delta_ = 0;
  313.     lastState_ = readState();
  314. }
  315. char RotaryEncoder::readState() {
  316.     return (digitalRead(pinA_) << 1) | digitalRead(pinB_);
  317. }
  318. /*
  319. Rotary Encoder state transitions for one step:
  320. 3 <-> 2 <-> 0 <-> 1 <-> 3
  321. Right: 11 (3) -> 10 (2) -> 00 (0) -> 01 (1) -> 11 (3)
  322. Left:  11 (3) -> 01 (1) -> 00 (0) -> 10 (2) -> 11 (3)    
  323. */
  324. void RotaryEncoder::pollInput() {
  325.     char state = readState();
  326.     switch(lastState_) {
  327.         case 0:
  328.             if (state == 2) delta_--;
  329.             if (state == 1) delta_++;
  330.             break;
  331.         case 1:
  332.             if (state == 0) delta_--;
  333.             if (state == 3) delta_++;
  334.             break;
  335.         case 2:
  336.             if (state == 3) delta_--;
  337.             if (state == 0) delta_++;
  338.             break;
  339.         case 3:
  340.             if (state == 1) delta_--;
  341.             if (state == 2) delta_++;
  342.             break;
  343.     }
  344.     lastState_ = state;
  345.    
  346.     if (delta_ == 4) {
  347.         sendDcsBiosMessage(msg_, incArg_);
  348.         delta_ = 0;
  349.     }
  350.     if (delta_ == -4) {
  351.         sendDcsBiosMessage(msg_, decArg_);
  352.         delta_ = 0;
  353.     }
  354. }
  355.  
  356.  
  357.  
  358.  
  359.  
  360.  
  361.  
  362.  
  363.  
  364.  
  365. /* ******NON-FUNCTIONING********* */
  366.  
  367. RotaryEncoderSR::RotaryEncoderSR(const char* msg, const char* decArg, const char* incArg, char SRpinA, char SRpinB) {
  368.     msg_ = msg;
  369.     decArg_ = decArg;
  370.     incArg_ = incArg;
  371.     SRpinA_ = SRpinA;
  372.     SRpinB_ = SRpinB;
  373.     delta_ = 0;
  374.     lastState_ = readState();
  375.     pinValues_ = pinValues;
  376. }
  377. int RotaryEncoderSR::readState() {
  378.     return ((pinValues & (1<< SRpinA_)) << 1) | pinValues & (1<< SRpinB_);
  379. }
  380.  
  381. void RotaryEncoderSR::pollInput() {
  382.     int state = readState();
  383.     switch(lastState_) {
  384.         case 0:
  385.             if (state == 2) delta_--;
  386.             if (state == 1) delta_++;
  387.             break;
  388.         case 1:
  389.             if (state == 0) delta_--;
  390.             if (state == 3) delta_++;
  391.             break;
  392.         case 2:
  393.             if (state == 3) delta_--;
  394.             if (state == 0) delta_++;
  395.             break;
  396.         case 3:
  397.             if (state == 1) delta_--;
  398.             if (state == 2) delta_++;
  399.             break;
  400.     }
  401.     lastState_ = state;
  402.    
  403.     if (delta_ != 0) {
  404.         sendDcsBiosMessage(msg_, incArg_);
  405.         delta_ = 0;
  406.     }
  407.     if (delta_ != 0 ) {
  408.         sendDcsBiosMessage(msg_, decArg_);
  409.         delta_ = 0;
  410.     }
  411. }
  412.  
  413. /* ******NON-FUNCTIONING********* */
  414.  
  415.  
  416.  
  417.  
  418.  
  419.  
  420.  
  421.  
  422.  
  423.  
  424.  
  425.  
  426.  
  427.  
  428.  
  429.  
  430.  
  431.  
  432.  
  433.  
  434.  
  435.  
  436. LED::LED(unsigned int address, unsigned int mask, char pin) {
  437.     address_ = address;
  438.     mask_ = mask;
  439.     pin_ = pin;
  440.     pinMode(pin_, OUTPUT);
  441.     digitalWrite(pin_, LOW);
  442. }
  443. void LED::onDcsBiosWrite(unsigned int address, unsigned int value) {
  444.     if (address_ == address) {
  445.         if (value & mask_) {
  446.             digitalWrite(pin_, HIGH);
  447.         } else {
  448.             digitalWrite(pin_, LOW);
  449.         }
  450.     }
  451. }
  452.  
  453. ServoOutput::ServoOutput(unsigned int address, char pin, int minPulseWidth, int maxPulseWidth) {
  454.     address_ = address;
  455.     pin_ = pin;
  456.     minPulseWidth_ = minPulseWidth;
  457.     maxPulseWidth_ = maxPulseWidth;
  458. }
  459. void ServoOutput::onDcsBiosWrite(unsigned int address, unsigned int value) {
  460.     if (address_ == address) {
  461.         if (!servo_.attached())
  462.             servo_.attach(pin_, minPulseWidth_, maxPulseWidth_);
  463.         servo_.writeMicroseconds(map(value, 0, 65535, minPulseWidth_, maxPulseWidth_));
  464.     }
  465. }
  466.  
  467. }
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!