ref_serial_data.hpp

Go to the documentation of this file.

/*****************************************************************************/
/********** !!! WARNING: CODE GENERATED BY TAPROOT. DO NOT EDIT !!! **********/
/*****************************************************************************/
 
/*
 * Copyright (c) 2020-2021 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_REF_SERIAL_DATA_HPP_
#define TAPROOT_REF_SERIAL_DATA_HPP_
 
#include <cinttypes>
 
#include <modm/architecture/interface/register.hpp>
 
#include "modm/architecture/utils.hpp"
 
#include "dji_serial.hpp"
 
namespace tap::communication::serial
{
class RefSerialData
{
public:
    enum class RobotId : uint16_t
    {
        INVALID = 0,
 
        RED_HERO = 1,
        RED_ENGINEER = 2,
        RED_SOLDIER_1 = 3,
        RED_SOLDIER_2 = 4,
        RED_SOLDIER_3 = 5,
        RED_DRONE = 6,
        RED_SENTINEL = 7,
        RED_DART = 8,
        RED_RADAR_STATION = 9,
 
        BLUE_HERO = 101,
        BLUE_ENGINEER = 102,
        BLUE_SOLDIER_1 = 103,
        BLUE_SOLDIER_2 = 104,
        BLUE_SOLDIER_3 = 105,
        BLUE_DRONE = 106,
        BLUE_SENTINEL = 107,
        BLUE_DART = 108,
        BLUE_RADAR_STATION = 109
    };
 
    static inline bool isBlueTeam(RobotId id) { return id >= RobotId::BLUE_HERO; }
 
    class RobotToRobotMessageHandler
    {
    public:
        RobotToRobotMessageHandler() {}
        virtual void operator()(const DJISerial::ReceivedSerialMessage &message) = 0;
    };
 
    class Rx
    {
    public:
        enum class GameType : uint8_t
        {
            UNKNOWN = 0,                  
            ROBOMASTER_RMUC = 1,          
            ROBOMASTER_RMUTC = 2,         
            ROBOMASTER_AI_CHALLENGE = 3,  
            ROBOMASTER_RMUL_3V3 = 4,      
            ROBOMASTER_RMUL_1V1 = 5,      
        };
 
        enum class GameStage : uint8_t
        {
            PREMATCH = 0,        
            SETUP = 1,           
            INITIALIZATION = 2,  
            COUNTDOWN = 3,       
            IN_GAME = 4,         
            END_GAME = 5,        
        };
 
        enum class GameWinner : uint8_t
        {
            DRAW = 0,  
            RED = 1,   
            BLUE = 2,  
        };
 
        enum class SiteDartHit : uint8_t
        {
            NONE = 0,               
            OUTPOST = 1,            
            BASE_FIXED = 2,         
            BASE_RANDOM_FIXED = 3,  
            BASE_RANDOM_MOVING = 4  
        };
 
        enum class SupplierOutletStatus : uint8_t
        {
            CLOSED = 0,     
            PREPARING = 1,  
            RELEASING = 2   
        };
 
        enum class DartTarget : uint8_t
        {
            NONE_OR_OUTPOST = 0,  
            BASE_FIXED = 1,       
            BASE_RANDOM = 2       
        };
 
        enum class ArmorId : uint8_t
        {
            FRONT = 0,  
            LEFT = 1,   
            REAR = 2,   
            RIGHT = 3,  
            TOP = 4,    
        };
 
        enum class DamageType : uint8_t
        {
            ARMOR_DAMAGE = 0,           
            MODULE_OFFLINE = 1,         
            BARREL_OVER_SPEED = 2,      
            BARREL_OVERHEAT = 3,        
            CHASSIS_POWER_OVERRUN = 4,  
            COLLISION = 5,              
        };
 
        enum class SiteData : uint32_t
        {
            RESUPPLY_OUTSIDE_EXCHANGE_OCCUPIED = modm::Bit0,
            RESUPPLY_INSIDE_EXCHANGE_OCCUPIED = modm::Bit1,
            SUPPLIER_OCCUPIED = modm::Bit2,
 
            SMALL_POWER_RUNE_ACTIVATED = modm::Bit3,
            LARGER_POWER_RUNE_ACTIVIATED = modm::Bit4,
 
            CENTRAL_ELEVATED_GROUND_OCCUPIED_TEAM = modm::Bit5,
            CENTRAL_ELEVATED_GROUND_OCCUPIED_OPPONENT = modm::Bit6,
 
            TRAPEZOID_OCCUPIED_TEAM = modm::Bit7,
 
            CENTRAL_BUFF_OCCUPIED_TEAM = modm::Bit21,
            CENTRAL_BUFF_OCCUPIED_OPPONENT = modm::Bit22
        };
        MODM_FLAGS32(SiteData);
 
        enum class RobotPower : uint8_t
        {
            GIMBAL_HAS_POWER = modm::Bit0,   
            CHASSIS_HAS_POWER = modm::Bit1,  
            SHOOTER_HAS_POWER = modm::Bit2,  
        };
        MODM_FLAGS8(RobotPower);
 
        enum class RobotEnergyLevel : uint8_t
        {
            ABOVE_50_PERCENT = 0x32,
            ABOVE_30_PERCENT = 0b11110,
            ABOVE_15_PERCENT = 0b11100,
            ABOVE_5_PERCENT = 0b11000,
            ABOVE_1_PERCENT = 0b10000,
            BELOW_1_PERCENT = 0b00000,
        };
 
        enum class RFIDActivationStatus : uint32_t
        {
            BASE_BUFF = modm::Bit0,
            CENTRAL_ELEVATED_GROUND_OWN = modm::Bit1,
            CENTRAL_ELEVATED_GROUND_OPPONENT = modm::Bit2,
            TRAPEZOID_OWN = modm::Bit3,
            TRAPEZOID_OPPONENT = modm::Bit4,
            LAUNCH_RAMP_FRONT_OWN = modm::Bit5,
            LAUNCH_RAMP_BACK_OWN = modm::Bit6,
            LAUNCH_RAMP_FRONT_OPPONENT = modm::Bit7,
            LAUNCH_RAMP_BACK_OPPONENT = modm::Bit8,
            TERRAIN_CROSSING_OFF_CENTRAL_OWN = modm::Bit9,
            TERRAIN_CROSSING_ON_CENTRAL_OWN = modm::Bit10,
            TERRAIN_CROSSING_OFF_CENTRAL_OPPONENT = modm::Bit11,
            TERRAIN_CROSSING_ON_CENTRAL_OPPONENT = modm::Bit12,
            TERRAIN_CROSSING_OFF_ROAD_OWN = modm::Bit13,
            TERRAIN_CROSSING_ON_ROAD_OWN = modm::Bit14,
            TERRAIN_CROSSING_OFF_ROAD_OPPONENT = modm::Bit15,
            TERRAIN_CROSSING_ON_ROAD_OPPONENT = modm::Bit16,
            FORTRESS_BUFF_OWN = modm::Bit17,
            OUTPOST_BUFF_OWN = modm::Bit18,
            RESUPPLY_ZONE_OUTSIDE_EXCHANGE = modm::Bit19,
            RESUPPLY_ZONE_INSIDE_EXCHANGE = modm::Bit20,
            LARGE_RESOURCE_ISLAND_OWN = modm::Bit21,
            LARGE_RESOURCE_ISLAND_OPPONENT = modm::Bit22,
            CENTRAL_BUFF = modm::Bit23
        };
        MODM_FLAGS32(RFIDActivationStatus);
 
        struct DamageEvent
        {
            uint16_t damageAmount;  
            uint32_t timestampMs;   
        };
 
        enum BulletType
        {
            AMMO_17 = 1,  
            AMMO_42 = 2,  
        };
 
        enum MechanismID
        {
            TURRET_17MM_1 = 1,  
            TURRET_17MM_2 = 2,  
            TURRET_42MM = 3,    
        };
 
        static constexpr int MAX_LAUNCH_SPEED_17MM = 25;
 
        static constexpr int MAX_LAUNCH_SPEED_42MM = 16;
 
        struct RobotHpData
        {
            struct RobotHp
            {
                uint16_t hero1;
                uint16_t engineer2;
                uint16_t standard3;
                uint16_t standard4;
                uint16_t sentry7;
                uint16_t outpost;
                uint16_t base;
            };
 
            RobotHp red;
            RobotHp blue;
        };
 
        struct EventData
        {
            SiteData_t siteData;           
            uint8_t timeSinceLastDartHit;  
            SiteDartHit lastDartHit;       
        };
 
        struct SupplierAction
        {
            RobotId reloadingRobot;             
            SupplierOutletStatus outletStatus;  
            uint8_t suppliedProjectiles;        
        };
 
        struct RobotPosition
        {
            float x;  
            float y;  
        };
 
        struct ChassisData
        {
            uint16_t powerBuffer;            
            RobotPosition position;          
            uint16_t powerConsumptionLimit;  
        };
 
        struct TurretData
        {
            BulletType bulletType;          
            MechanismID launchMechanismID;  
            uint8_t firingFreq;             
            uint16_t heat17ID1;             
            uint16_t heat17ID2;             
            uint16_t heat42;                
            uint16_t heatLimit;             
            uint16_t coolingRate;  
            uint16_t bulletsRemaining17;  
            uint16_t bulletsRemaining42;  
            float bulletSpeed;            
            float yaw;                    
            uint32_t lastReceivedLaunchingInfoTimestamp;  
        };
 
        struct RobotBuffStatus
        {
            uint8_t recoveryBuff;  
            uint8_t coolingBuff;   
            uint8_t defenseBuff;   
            uint8_t
                vulnerabilityBuff;  
            uint16_t attackBuff;    
        };
 
        struct RefereeWarningData
        {
            uint8_t level;        
            RobotId foulRobotID;  
            uint8_t count;        
            uint32_t lastReceivedWarningRobotTime = 0;  
 
            static constexpr uint32_t OFFENDING_OPERATOR_BLIND_TIME = 5'000;
            static constexpr uint32_t NONOFFENDING_OPERATOR_BLIND_TIME = 2'000;
        };
 
        struct DartInfo
        {
            uint8_t launchCountdown;    
            SiteDartHit lastHit;        
            uint8_t hits;               
            DartTarget selectedTarget;  
        };
 
        enum AirSupportState : uint8_t
        {
            COOLING = 0,  
            COOLED = 1,   
            IN_AIR = 2    
        };
 
        struct AirSupportData
        {
            AirSupportState state;       
            uint8_t remainingStateTime;  
        };
 
        enum DartStationState : uint8_t
        {
            OPEN = 0,       
            CLOSED = 1,     
            TRANSITION = 2  
        };
 
        struct DartStationInfo
        {
            DartStationState state;      
            uint16_t targetChangedTime;  
            uint16_t lastLaunchedTime;   
        };
 
        struct GroundRobotPositions
        {
            RobotPosition hero;
            RobotPosition engineer;
            RobotPosition standard3;
            RobotPosition standard4;
        };
 
        struct RadarMarkProgress
        {
            uint8_t hero;
            uint8_t engineer;
            uint8_t standard3;
            uint8_t standard4;
            uint8_t sentry;
        };
 
        struct SentryInfo
        {
            uint16_t projectileAllowance;  
            uint8_t
                remoteProjectileExchanges;  
            uint8_t remoteHealthExchanges;  
        };
 
        struct RadarInfo
        {
            uint8_t availableDoubleVulnerablilityEffects;  
            bool activeDoubleVulnerabilityEffect;          
        };
 
        struct GameData
        {
            GameType gameType;    
            GameStage gameStage;  
            uint16_t stageTimeRemaining;     
            uint64_t unixTime;               
            GameWinner gameWinner;           
            EventData eventData;             
            SupplierAction supplier;         
            DartInfo dartInfo;               
            AirSupportData airSupportData;   
            DartStationInfo dartStation;     
            GroundRobotPositions positions;  
            RadarMarkProgress
                radarProgress;  
            SentryInfo sentry;  
            RadarInfo radar;    
        };
 
        struct RobotData
        {
            RobotId robotId;          
            uint8_t robotLevel;       
            uint16_t previousHp;      
            uint16_t currentHp;       
            uint16_t maxHp;           
            RobotPower_t robotPower;  
            ArmorId damagedArmorId;   
            DamageType damageType;    
            float receivedDps;        
            ChassisData chassis;      
            TurretData turret;        
            RobotHpData allRobotHp;   
            uint16_t remainingCoins;  
            RobotBuffStatus robotBuffStatus;        
            RFIDActivationStatus_t rfidStatus;      
            uint32_t robotDataReceivedTimestamp;    
            RefereeWarningData refereeWarningData;  
            RobotEnergyLevel robotEnergyRemaining;  
        };
    };
 
    class Tx
    {
    public:
        enum DeleteGraphicOperation
        {
            DELETE_GRAPHIC_NO_OP = 0,  
            DELETE_GRAPHIC_LAYER = 1,  
            DELETE_ALL = 2,            
        };
 
        enum GraphicOperation
        {
            GRAPHIC_NO_OP = 0,   
            GRAPHIC_ADD = 1,     
            GRAPHIC_MODIFY = 2,  
            GRAPHIC_DELETE = 3,  
        };
 
        enum class GraphicType : uint8_t
        {
            STRAIGHT_LINE = 0,
            RECTANGLE = 1,
            CIRCLE = 2,
            ELLIPSE = 3,
            ARC = 4,
            FLOATING_NUM = 5,
            INTEGER = 6,
            CHARACTER = 7,
        };
 
        enum class GraphicColor : uint8_t
        {
            RED_AND_BLUE = 0,
            YELLOW = 1,
            GREEN = 2,
            ORANGE = 3,
            PURPLISH_RED = 4,
            PINK = 5,
            CYAN = 6,
            BLACK = 7,
            WHITE = 8,
        };
 
        struct InteractiveHeader
        {
            uint16_t dataCmdId;
            uint16_t senderId;
            uint16_t receiverId;
        } modm_packed;
 
        struct GraphicData
        {
            uint8_t name[3];
            uint32_t operation : 3;
            uint32_t type : 3;
            uint32_t layer : 4;
            uint32_t color : 4;
            uint32_t startAngle : 9;
            uint32_t endAngle : 9;
            uint32_t lineWidth : 10;
            uint32_t startX : 11;
            uint32_t startY : 11;
            union
            {
                struct
                {
                    uint32_t radius : 10;
                    uint32_t endX : 11;
                    uint32_t endY : 11;
                } modm_packed;
                int32_t value : 32;
            } modm_packed;
        } modm_packed;
 
        struct DeleteGraphicLayerMessage
        {
            DJISerial::FrameHeader frameHeader;
            uint16_t cmdId;
            InteractiveHeader interactiveHeader;
            uint8_t deleteOperation;
            uint8_t layer;
            uint16_t crc16;
        } modm_packed;
 
        struct Graphic1Message
        {
            DJISerial::FrameHeader frameHeader;
            uint16_t cmdId;
            InteractiveHeader interactiveHeader;
            GraphicData graphicData;
            uint16_t crc16;
        } modm_packed;
 
        struct RobotToRobotMessage
        {
            DJISerial::FrameHeader frameHeader;
            uint16_t cmdId;
            InteractiveHeader interactiveHeader;
            uint8_t dataAndCRC16[115];
        } modm_packed;
 
        struct Graphic2Message
        {
            DJISerial::FrameHeader frameHeader;
            uint16_t cmdId;
            InteractiveHeader interactiveHeader;
            GraphicData graphicData[2];
            uint16_t crc16;
        } modm_packed;
 
        struct Graphic5Message
        {
            DJISerial::FrameHeader frameHeader;
            uint16_t cmdId;
            InteractiveHeader interactiveHeader;
            GraphicData graphicData[5];
            uint16_t crc16;
        } modm_packed;
 
        struct Graphic7Message
        {
            DJISerial::FrameHeader frameHeader;
            uint16_t cmdId;
            InteractiveHeader interactiveHeader;
            GraphicData graphicData[7];
            uint16_t crc16;
        } modm_packed;
 
        struct GraphicCharacterMessage
        {
            DJISerial::FrameHeader frameHeader;
            uint16_t cmdId;
            InteractiveHeader interactiveHeader;
            GraphicData graphicData;
            char msg[30];
            uint16_t crc16;
        } modm_packed;
 
        static constexpr uint32_t MAX_TRANSMIT_SPEED_BYTES_PER_S = 1000;
 
        template <typename T>
        static constexpr uint32_t getWaitTimeAfterGraphicSendMs(T *)
        {
            // Must be a valid graphic message type
            static_assert(
                std::is_same<T, DeleteGraphicLayerMessage>::value ||
                    std::is_same<T, Graphic1Message>::value ||
                    std::is_same<T, RobotToRobotMessage>::value ||
                    std::is_same<T, Graphic2Message>::value ||
                    std::is_same<T, Graphic5Message>::value ||
                    std::is_same<T, Graphic7Message>::value ||
                    std::is_same<T, GraphicCharacterMessage>::value,
                "Invalid type, getWaitTimeAfterGraphicSendMs only takes in ref serial message "
                "types.");
 
            return sizeof(T) * 1'000 / MAX_TRANSMIT_SPEED_BYTES_PER_S;
        }
    };
};
 
inline RefSerialData::RobotId operator+(RefSerialData::RobotId id1, RefSerialData::RobotId id2)
{
    return static_cast<RefSerialData::RobotId>(
        static_cast<uint16_t>(id1) + static_cast<uint16_t>(id2));
}
 
inline RefSerialData::RobotId operator-(RefSerialData::RobotId id1, RefSerialData::RobotId id2)
{
    return static_cast<RefSerialData::RobotId>(
        static_cast<uint16_t>(id1) - static_cast<uint16_t>(id2));
}
}  // namespace tap::communication::serial
 
#endif  // TAPROOT_REF_SERIAL_DATA_HPP_