joystick.hpp

Go to the documentation of this file.

 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  *  _____.___.                 .___                    .__.__      *
  *  \__  |   | ____   ____   __| _/___________    _____|__|  |     *
  *   /   |   |/ ___\ / ___\ / __ |\_  __ \__  \  /  ___/  |  |     *
  *   \____   / /_/  > /_/  > /_/ | |  | \// __ \_\___ \|  |  |__   *
  *   / ______\___  /\___  /\____ | |__|  (____  /____  >__|____/   *
  *   \/     /_____//_____/      \/            \/     \/            *
  *                         - Yggdrasil -                           *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  * This software can be used by students and other personal of the *
  * Bern University of Applied Sciences under the terms of the MIT  *
  * license.                                                        *
  * For other persons this software is under the terms of the GNU   *
  * General Public License version 2.                               *
  *                                                                 *
  * Copyright © 2021, Bern University of Applied Sciences.     *
  * All rights reserved.                                            *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#pragma once
 
#include <cpp/common/attributes.hpp>
#include <cpp/common/types.hpp>
#include <cpp/common/utils.hpp>
 
 
namespace bsp::ygg::prph {
 
    class Joystick {
    public:
        Joystick() = delete;
 
        struct Position {
          i16 x;        
          i16 y;        
        };
 
        struct JoystickData {
          Position pos;     
          u16 mag;          
          bool pressed;     
        };
 
 
        static bool init() {
            return true;
        }
 
        static JoystickData getLeft() {
            JoystickData data = { 0 };
 
            data.pos.x = transformInputData(getADCValue(MUX::SingleEnded_AIN0));    // Get ADC Value
            data.pos.y = transformInputData(getADCValue(MUX::SingleEnded_AIN1));    // Get ADC Value
            data.mag = sqrt(data.pos.x * data.pos.x + data.pos.y * data.pos.y);
            data.pressed = LeftJoyStickButton;                              // Read the button state
 
            if(data.mag < Joystick::s_deadzone) {
                data.pos = { 0, 0 };
            }
 
            return data;
        }
 
        static JoystickData getRight() {
            JoystickData data = { 0 };
 
            data.pos.x = -transformInputData(getADCValue(MUX::SingleEnded_AIN2));       // Get ADC Value
            data.pos.y = -transformInputData(getADCValue(MUX::SingleEnded_AIN3));       // Get ADC Value
            data.mag = sqrt(data.pos.x * data.pos.x + data.pos.y * data.pos.y);
            data.pressed = RightJoyStickButton;                                         // Read the button state
 
            if(data.mag < Joystick::s_deadzone) {
                data.pos = { 0, 0 };
            }
 
            return data;
        }
 
        static void setDeadzone(u8 deadzone) {
            if (deadzone < PositionMax)
                Joystick::s_deadzone = deadzone;
        }
 
        static u8 getDeadzone() {
            return Joystick::s_deadzone;
        }
 
    private:
 
        enum class RegisterID : u8 {
            ConversionRegister      = 0x00,     
            ConfigurationRegister   = 0x01,     
        };
 
        enum class MUX : u8 {
            Differential_AIN0_AIN1  = 0x00,     
            Differential_AIN0_AIN3  = 0x01,     
            Differential_AIN1_AIN3  = 0x02,     
            Differential_AIN2_AIN3  = 0x03,     
            SingleEnded_AIN0        = 0x04,     
            SingleEnded_AIN1        = 0x05,     
            SingleEnded_AIN2        = 0x06,     
            SingleEnded_AIN3        = 0x07,     
        };
 
        enum class PGA : u8 {
            FSR_6p144 = 0x00,   
            FSR_4p096 = 0x01,   
            FSR_2p048 = 0x02,   
            FSR_1p024 = 0x03,   
            FSR_0p512 = 0x04,   
            FSR_0p256 = 0x05,   
        };
 
        enum class MODE : u8 {
            Continious = 0x00,  
            SingleShot = 0x01,  
        };
 
        enum class DR : u8 {
            SPS128  = 0x00,     
            SPS250  = 0x01,     
            SPS490  = 0x02,     
            SPS920  = 0x03,     
            SPS1600 = 0x04,     
            SPS2400 = 0x05,     
            SPS3300 = 0x06,     
        };
 
        struct ConfigurationRegister {
            u16 Reserved    : 5;        
            u16 DR          : 3;        
            u16 MODE        : 1;        
            u16 PGA         : 3;        
            u16 MUX         : 3;        
            u16 OS          : 1;        
        };
 
        static_assert(sizeof(ConfigurationRegister) == sizeof(u16), "Configuration register definition wrong");
 
 
        constexpr static inline u8 DeviceAddress        = 0x90;     
        constexpr static inline u8 ReservedBits         = 0x03;     
        constexpr static inline u16 ConversionDone      = 0x8000;   
 
        constexpr static inline u16 CenterPosition      = 0x34A;
        constexpr static inline u16 MaxADCValue         = 0x56A;
        constexpr static inline u16 MinADCValue         = 0x100;
        constexpr static inline i8 PositionRange        = 200;
        constexpr static inline i8 PositionMin          = -100;
        constexpr static inline i8 PositionMax          = 100;
 
        static inline i8 s_deadzone = 5;
 
 
        static u16 getADCValue(MUX channel) {
            ConfigurationRegister configRegister = {0};
            configRegister.OS       = 1;
            configRegister.MUX      = enumValue(channel);
            configRegister.PGA      = enumValue(PGA::FSR_4p096);
            configRegister.MODE     = enumValue(MODE::SingleShot);
            configRegister.DR       = enumValue(DR::SPS1600);
            configRegister.Reserved = ReservedBits;
 
            bsp::I2CA::write<ByteSwapped<u16>>(DeviceAddress, enumValue(RegisterID::ConfigurationRegister), bit_cast<u16>(configRegister));                 // Start Conversion
 
            while((bsp::I2CA::read<ByteSwapped<u16>>(DeviceAddress, enumValue(RegisterID::ConfigurationRegister)) & ConversionDone) == ConversionDone) {    // Poll results
                core::delay(1);     // Avoid spamming the I2C
            }
 
            auto adcData = bsp::I2CA::read<ByteSwapped<u16>>(DeviceAddress, enumValue(RegisterID::ConversionRegister));     // Read results
 
            return adcData;
        }
 
        static inline i16 transformInputData(u16 adcData) {
            return ((((static_cast<i16>(adcData >> 4) - MinADCValue) / float(MaxADCValue - MinADCValue)) * 2.0F) - 1.0F) * 100.0F;  // Convert the 11 bit tow's complement value to a i8 ranged [-100,100]
        }
 
    };
 
}