SwitchProParser.h

Go to the documentation of this file.

/* Copyright (C) 2021 Kristian Sloth Lauszus. All rights reserved.
 
 This software may be distributed and modified under the terms of the GNU
 General Public License version 2 (GPL2) as published by the Free Software
 Foundation and appearing in the file GPL2.TXT included in the packaging of
 this file. Please note that GPL2 Section 2[b] requires that all works based
 on this software must also be made publicly available under the terms of
 the GPL2 ("Copyleft").
 
 Contact information
 -------------------
 
 Kristian Sloth Lauszus
 Web      :  https://lauszus.com
 e-mail   :  lauszus@gmail.com
 */
 
#ifndef _switch_pro_parser_h_
#define _switch_pro_parser_h_
 
#include "Usb.h"
#include "controllerEnums.h"
 
const uint8_t SWITCH_PRO_LEDS[] PROGMEM = {
        0x00, // OFF
        0x01, // LED1
        0x02, // LED2
        0x04, // LED3
        0x08, // LED4
 
        0x09, // LED5
        0x0A, // LED6
        0x0C, // LED7
        0x0D, // LED8
        0x0E, // LED9
        0x0F, // LED10
};
 
const uint8_t SWITCH_PRO_BUTTONS[] PROGMEM = {
        0x11, // UP
        0x12, // RIGHT
        0x10, // DOWN
        0x13, // LEFT
 
        0x0D, // Capture
        0x09, // PLUS
        0x0B, // L3
        0x0A, // R3
 
        0x08, // MINUS
        0x0C, // HOME
        0, 0, // Skip
 
        0x02, // B
        0x03, // A
        0x01, // X
        0x00, // Y
 
        0x16, // L
        0x06, // R
        0x17, // ZL
        0x07, // ZR
};
 
// https://github.com/dekuNukem/Nintendo_Switch_Reverse_Engineering/blob/master/bluetooth_hid_notes.md#standard-input-report-format
union SwitchProButtons {
        struct {
                uint8_t y : 1;
                uint8_t x : 1;
                uint8_t b : 1;
                uint8_t a : 1;
 
                uint8_t dummy1 : 2;
                uint8_t r : 1;
                uint8_t zr : 1;
 
                uint8_t minus : 1;
                uint8_t plus : 1;
                uint8_t r3 : 1;
                uint8_t l3 : 1;
 
                uint8_t home : 1;
                uint8_t capture : 1;
                uint8_t dummy2 : 2;
 
                uint8_t dpad : 4;
 
                uint8_t dummy3 : 2;
                uint8_t l : 1;
                uint8_t zl : 1;
        } __attribute__((packed));
        uint32_t val : 24;
} __attribute__((packed));
 
struct ImuData {
        int16_t accX, accY, accZ;
        int16_t gyroX, gyroY, gyroZ;
} __attribute__((packed));
 
struct SwitchProData {
        struct {
                uint8_t connection_info : 4;
                uint8_t battery_level : 4;
        } __attribute__((packed));
 
        /* Button and joystick values */
        SwitchProButtons btn; // Bytes 3-5
 
        // Bytes 6-11
        uint16_t leftHatX : 12;
        uint16_t leftHatY : 12;
        uint16_t rightHatX : 12;
        uint16_t rightHatY : 12;
 
        uint8_t vibratorInput; // What is this used for?
 
        // Bytes 13-48
        // Three samples of the IMU is sent in one message
        // See: https://github.com/dekuNukem/Nintendo_Switch_Reverse_Engineering/blob/master/imu_sensor_notes.md
        ImuData imu[3];
} __attribute__((packed));
 
struct SwitchProOutput {
        bool leftRumbleOn;
        bool rightRumbleOn;
        uint8_t ledMask; // Higher nibble flashes the LEDs, lower nibble sets them on/off
        bool ledHome;
 
        // Used to send the reports at the same rate as the controller is sending messages
        bool ledReportChanged;
        bool ledHomeReportChanged;
        bool enableFullReportMode;
        int8_t enableImu; // -1 == Do nothing, 0 == disable IMU, 1 == enable IMU
        bool sendHandshake;
        bool disableTimeout;
} __attribute__((packed));
 
class SwitchProParser {
public:
        SwitchProParser() : output_sequence_counter(0) {
                Reset();
        };
 
        bool getButtonPress(ButtonEnum b);
        bool getButtonClick(ButtonEnum b);
        int16_t getAnalogHat(AnalogHatEnum a);
 
        void enableImu(bool enable) {
                // TODO: Should we just always enable it?
                switchProOutput.enableImu = enable ? 1 : 0;
        }
 
        float getAngle(AngleEnum a) {
                if (a == Pitch)
                        return (atan2f(-switchProData.imu[0].accY, -switchProData.imu[0].accZ) + PI) * RAD_TO_DEG;
                else
                        return (atan2f(switchProData.imu[0].accX, -switchProData.imu[0].accZ) + PI) * RAD_TO_DEG;
        };
 
        int16_t getSensor(SensorEnum s) {
                switch(s) {
                        case gX:
                                return switchProData.imu[0].gyroX;
                        case gY:
                                return switchProData.imu[0].gyroY;
                        case gZ:
                                return switchProData.imu[0].gyroZ;
                        case aX:
                                return switchProData.imu[0].accX;
                        case aY:
                                return switchProData.imu[0].accY;
                        case aZ:
                                return switchProData.imu[0].accZ;
                        default:
                                return 0;
                }
        };
 
        void setAllOff() {
                setRumbleOff();
                setLedOff();
                setLedHomeOff();
        };
 
        void setRumbleOff() {
                setRumble(false, false);
        }
 
        void setRumbleToggle() {
                setRumble(!switchProOutput.leftRumbleOn, !switchProOutput.rightRumbleOn);
        }
 
        void setRumble(bool leftRumbleOn, bool rightRumbleOn) {
                switchProOutput.leftRumbleOn = leftRumbleOn;
                switchProOutput.rightRumbleOn = rightRumbleOn;
                switchProOutput.ledReportChanged = true; // Set this, so the rumble effect gets changed immediately
        }
 
        void setRumbleLeft(bool on) {
                switchProOutput.leftRumbleOn = on;
                switchProOutput.ledReportChanged = true; // Set this, so the rumble effect gets changed immediately
        }
 
        void setRumbleRight(bool on) {
                switchProOutput.rightRumbleOn = on;
                switchProOutput.ledReportChanged = true; // Set this, so the rumble effect gets changed immediately
        }
 
        void setLedRaw(uint8_t mask) {
                switchProOutput.ledMask = mask;
                switchProOutput.ledReportChanged = true;
        }
 
        void setLedOff() {
                setLedRaw(0);
        }
 
        void setLedOff(LEDEnum a) {
                switchProOutput.ledMask &= ~((uint8_t)(pgm_read_byte(&SWITCH_PRO_LEDS[(uint8_t)a]) & 0x0f));
                switchProOutput.ledReportChanged = true;
        }
 
        void setLedOn(LEDEnum a) {
                switchProOutput.ledMask |= (uint8_t)(pgm_read_byte(&SWITCH_PRO_LEDS[(uint8_t)a]) & 0x0f);
                switchProOutput.ledReportChanged = true;
        }
 
        void setLedToggle(LEDEnum a) {
                switchProOutput.ledMask ^= (uint8_t)(pgm_read_byte(&SWITCH_PRO_LEDS[(uint8_t)a]) & 0x0f);
                switchProOutput.ledReportChanged = true;
        }
 
        void setLedHomeOff() {
                switchProOutput.ledHome = false;
                switchProOutput.ledHomeReportChanged = true;
        }
 
        void setLedHomeOn() {
                switchProOutput.ledHome = true;
                switchProOutput.ledHomeReportChanged = true;
        }
 
        void setLedHomeToggle() {
                switchProOutput.ledHome = !switchProOutput.ledHome;
                switchProOutput.ledHomeReportChanged = true;
        }
 
        uint16_t getMessageCounter() {
                return message_counter;
        }
 
        uint8_t getBatteryLevel() {
                return switchProData.battery_level >> 1;
        }
 
        bool isCharging() {
                return switchProData.battery_level & 0x01;
        }
 
protected:
        void Parse(uint8_t len, uint8_t *buf);
 
        void Reset();
 
        virtual void sendOutputReport(uint8_t *data, uint8_t len) = 0;
 
        virtual void sendHandshake() {}
 
        virtual void disableTimeout() {}
 
        SwitchProOutput switchProOutput;
 
private:
        static int8_t getButtonIndexSwitchPro(ButtonEnum b);
 
        void sendOutputCmd();
        void sendRumbleOutputReport();
 
        SwitchProData switchProData;
        SwitchProButtons oldButtonState, buttonClickState;
        uint16_t message_counter = 0;
        uint8_t output_sequence_counter : 4;
        uint32_t rumble_on_timer = 0;
};
#endif