PS4Parser.h

Go to the documentation of this file.

/* Copyright (C) 2014 Kristian Lauszus, TKJ Electronics. 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 Lauszus, TKJ Electronics
 Web      :  http://www.tkjelectronics.com
 e-mail   :  kristianl@tkjelectronics.com
 */
 
#ifndef _ps4parser_h_
#define _ps4parser_h_
 
#include "Usb.h"
#include "controllerEnums.h"
 
const uint8_t PS4_BUTTONS[] PROGMEM = {
        UP, // UP
        RIGHT, // RIGHT
        DOWN, // DOWN
        LEFT, // LEFT
 
        0x0C, // SHARE
        0x0D, // OPTIONS
        0x0E, // L3
        0x0F, // R3
 
        0x0A, // L2
        0x0B, // R2
        0x08, // L1
        0x09, // R1
 
        0x07, // TRIANGLE
        0x06, // CIRCLE
        0x05, // CROSS
        0x04, // SQUARE
 
        0x10, // PS
        0x11, // TOUCHPAD
};
 
union PS4Buttons {
        struct {
                uint8_t dpad : 4;
                uint8_t square : 1;
                uint8_t cross : 1;
                uint8_t circle : 1;
                uint8_t triangle : 1;
 
                uint8_t l1 : 1;
                uint8_t r1 : 1;
                uint8_t l2 : 1;
                uint8_t r2 : 1;
                uint8_t share : 1;
                uint8_t options : 1;
                uint8_t l3 : 1;
                uint8_t r3 : 1;
 
                uint8_t ps : 1;
                uint8_t touchpad : 1;
                uint8_t reportCounter : 6;
        } __attribute__((packed));
        uint32_t val : 24;
} __attribute__((packed));
 
struct touchpadXY {
        uint8_t dummy; // I can not figure out what this data is for, it seems to change randomly, maybe a timestamp?
        struct {
                uint8_t counter : 7; // Increments every time a finger is touching the touchpad
                uint8_t touching : 1; // The top bit is cleared if the finger is touching the touchpad
                uint16_t x : 12;
                uint16_t y : 12;
        } __attribute__((packed)) finger[2]; // 0 = first finger, 1 = second finger
} __attribute__((packed));
 
struct PS4Status {
        uint8_t battery : 4;
        uint8_t usb : 1;
        uint8_t audio : 1;
        uint8_t mic : 1;
        uint8_t unknown : 1; // Extension port?
} __attribute__((packed));
 
struct PS4Data {
        /* Button and joystick values */
        uint8_t hatValue[4];
        PS4Buttons btn;
        uint8_t trigger[2];
 
        /* Gyro and accelerometer values */
        uint8_t dummy[3]; // First two looks random, while the third one might be some kind of status - it increments once in a while
        int16_t gyroY, gyroZ, gyroX;
        int16_t accX, accZ, accY;
 
        uint8_t dummy2[5];
        PS4Status status;
        uint8_t dummy3[3];
 
        /* The rest is data for the touchpad */
        touchpadXY xy[3]; // It looks like it sends out three coordinates each time, this might be because the microcontroller inside the PS4 controller is much faster than the Bluetooth connection.
                          // The last data is read from the last position in the array while the oldest measurement is from the first position.
                          // The first position will also keep it's value after the finger is released, while the other two will set them to zero.
                          // Note that if you read fast enough from the device, then only the first one will contain any data.
 
        // The last three bytes are always: 0x00, 0x80, 0x00
} __attribute__((packed));
 
struct PS4Output {
        uint8_t bigRumble, smallRumble; // Rumble
        uint8_t r, g, b; // RGB
        uint8_t flashOn, flashOff; // Time to flash bright/dark (255 = 2.5 seconds)
        bool reportChanged; // The data is send when data is received from the controller
} __attribute__((packed));
 
class PS4Parser {
public:
        PS4Parser() {
                Reset();
        };
 
        bool getButtonPress(ButtonEnum b);
        bool getButtonClick(ButtonEnum b);
        uint8_t getAnalogButton(ButtonEnum b);
 
        uint8_t getAnalogHat(AnalogHatEnum a);
 
        uint16_t getX(uint8_t finger = 0, uint8_t xyId = 0) {
                return ps4Data.xy[xyId].finger[finger].x;
        };
 
        uint16_t getY(uint8_t finger = 0, uint8_t xyId = 0) {
                return ps4Data.xy[xyId].finger[finger].y;
        };
 
        bool isTouching(uint8_t finger = 0, uint8_t xyId = 0) {
                return !(ps4Data.xy[xyId].finger[finger].touching); // The bit is cleared when a finger is touching the touchpad
        };
 
        uint8_t getTouchCounter(uint8_t finger = 0, uint8_t xyId = 0) {
                return ps4Data.xy[xyId].finger[finger].counter;
        };
 
        float getAngle(AngleEnum a) {
                if (a == Pitch)
                        return (atan2f(ps4Data.accY, ps4Data.accZ) + PI) * RAD_TO_DEG;
                else
                        return (atan2f(ps4Data.accX, ps4Data.accZ) + PI) * RAD_TO_DEG;
        };
 
        int16_t getSensor(SensorEnum s) {
                switch(s) {
                        case gX:
                                return ps4Data.gyroX;
                        case gY:
                                return ps4Data.gyroY;
                        case gZ:
                                return ps4Data.gyroZ;
                        case aX:
                                return ps4Data.accX;
                        case aY:
                                return ps4Data.accY;
                        case aZ:
                                return ps4Data.accZ;
                        default:
                                return 0;
                }
        };
 
        uint8_t getBatteryLevel() {
                return ps4Data.status.battery;
        };
 
        bool getUsbStatus() {
                return ps4Data.status.usb;
        };
 
        bool getAudioStatus() {
                return ps4Data.status.audio;
        };
 
        bool getMicStatus() {
                return ps4Data.status.mic;
        };
 
        void setAllOff() {
                setRumbleOff();
                setLedOff();
        };
 
        void setRumbleOff() {
                setRumbleOn(0, 0);
        };
 
        void setRumbleOn(RumbleEnum mode) {
                if (mode == RumbleLow)
                        setRumbleOn(0x00, 0xFF);
                else
                        setRumbleOn(0xFF, 0x00);
        };
 
        void setRumbleOn(uint8_t bigRumble, uint8_t smallRumble) {
                ps4Output.bigRumble = bigRumble;
                ps4Output.smallRumble = smallRumble;
                ps4Output.reportChanged = true;
        };
 
        void setLedOff() {
                setLed(0, 0, 0);
        };
 
        void setLed(uint8_t r, uint8_t g, uint8_t b) {
                ps4Output.r = r;
                ps4Output.g = g;
                ps4Output.b = b;
                ps4Output.reportChanged = true;
        };
 
        void setLed(ColorsEnum color) {
                setLed((uint8_t)(color >> 16), (uint8_t)(color >> 8), (uint8_t)(color));
        };
 
        void setLedFlash(uint8_t flashOn, uint8_t flashOff) {
                ps4Output.flashOn = flashOn;
                ps4Output.flashOff = flashOff;
                ps4Output.reportChanged = true;
        };
protected:
        void Parse(uint8_t len, uint8_t *buf);
 
        void Reset();
 
        virtual void sendOutputReport(PS4Output *output) = 0;
 
private:
        static int8_t getButtonIndexPS4(ButtonEnum b);
        bool checkDpad(ButtonEnum b); // Used to check PS4 DPAD buttons
 
        PS4Data ps4Data;
        PS4Buttons oldButtonState, buttonClickState;
        PS4Output ps4Output;
        uint8_t oldDpad;
};
#endif