.. _program_listing_file_src_tap_communication_serial_remote.hpp:

Program Listing for File remote.hpp
===================================

|exhale_lsh| :ref:`Return to documentation for file <file_src_tap_communication_serial_remote.hpp>` (``src/tap/communication/serial/remote.hpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   /*
    * Copyright (c) 2020-2022 Advanced Robotics at the University of Washington <robomstr@uw.edu>
    *
    * This file is part of Taproot.
    *
    * Taproot is free software: you can redistribute it and/or modify
    * it under the terms of the GNU General Public License as published by
    * the Free Software Foundation, either version 3 of the License, or
    * (at your option) any later version.
    *
    * Taproot is distributed in the hope that it will be useful,
    * but WITHOUT ANY WARRANTY; without even the implied warranty of
    * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    * GNU General Public License for more details.
    *
    * You should have received a copy of the GNU General Public License
    * along with Taproot.  If not, see <https://www.gnu.org/licenses/>.
    */
   
   #ifndef TAPROOT_REMOTE_HPP_
   #define TAPROOT_REMOTE_HPP_
   
   #include <cstdint>
   
   #ifndef PLATFORM_HOSTED
   #include "modm/platform.hpp"
   #endif
   
   #include "tap/util_macros.hpp"
   
   namespace tap
   {
   class Drivers;
   }
   
   namespace tap::communication::serial
   {
   class Remote
   {
   public:
       Remote(Drivers *drivers) : drivers(drivers) {}
       DISALLOW_COPY_AND_ASSIGN(Remote)
       mockable ~Remote() = default;
   
       enum class Channel
       {
           RIGHT_HORIZONTAL,
           RIGHT_VERTICAL,
           LEFT_HORIZONTAL,
           LEFT_VERTICAL,
           WHEEL
       };
   
       enum class Switch
       {
           LEFT_SWITCH,
           RIGHT_SWITCH
       };
   
       enum class SwitchState
       {
           UNKNOWN = 0,
           UP = 1,
           DOWN = 2,
           MID = 3,
       };
   
       enum class Key
       {
           W = 0,
           S,
           A,
           D,
           SHIFT,
           CTRL,
           Q,
           E,
           R,
           F,
           G,
           Z,
           X,
           C,
           V,
           B
       };
   
       mockable void initialize();
   
       mockable void read();
   
       mockable bool isConnected() const;
   
       mockable float getChannel(Channel ch) const;
   
       mockable SwitchState getSwitch(Switch sw) const;
   
       mockable inline int16_t getMouseX() const { return remote.mouse.x; }
   
       mockable inline int16_t getMouseY() const { return remote.mouse.y; }
   
       mockable inline int16_t getMouseZ() const { return remote.mouse.z; }
   
       mockable inline bool getMouseL() const { return remote.mouse.l; }
   
       mockable inline bool getMouseR() const { return remote.mouse.r; }
   
       mockable inline bool keyPressed(Key key) const
       {
           return (remote.key & (1 << static_cast<uint8_t>(key))) != 0;
       }
   
       mockable uint32_t getUpdateCounter() const;
   
   private:
       static const int REMOTE_BUF_LEN = 18;              
       static const int REMOTE_READ_TIMEOUT = 6;          
       static const int REMOTE_DISCONNECT_TIMEOUT = 100;  
       static const int REMOTE_INT_PRI = 12;              
       static constexpr float ANALOG_MAX_VALUE = 660.0f;  
   
       struct RemoteInfo
       {
           uint32_t updateCounter = 0;
           int16_t rightHorizontal = 0;
           int16_t rightVertical = 0;
           int16_t leftHorizontal = 0;
           int16_t leftVertical = 0;
           SwitchState leftSwitch = SwitchState::UNKNOWN;
           SwitchState rightSwitch = SwitchState::UNKNOWN;
           struct
           {
               int16_t x = 0;
               int16_t y = 0;
               int16_t z = 0;
               bool l = false;
               bool r = false;
           } mouse;
           uint16_t key = 0;   
           int16_t wheel = 0;  
       };
   
       Drivers *drivers;
   
       RemoteInfo remote;
   
       bool connected = false;
   
       uint8_t rxBuffer[REMOTE_BUF_LEN]{0};
   
       uint32_t lastRead = 0;
   
       uint8_t currentBufferIndex = 0;
   
       void parseBuffer();
   
       void clearRxBuffer();
   
       void reset();
   };  // class Remote
   
   }  // namespace tap::communication::serial
   
   #endif  // TAPROOT_REMOTE_HPP_