Brick
Loading...
Searching...
No Matches
v5rt.h
Go to the documentation of this file.
1/**
2 * @file v5rt.h
3 * @brief The header for the VEX V5 C SDK.
4 *
5 * This single header provides access to the entire C SDK for the VEX V5 ecosystem. It is the
6 * low-level library which Crust is built upon.
7 */
8
9#pragma once
10
11#include <cstdarg>
12#include <cstdbool>
13#include <cstdint>
14
15#ifdef __cplusplus
16extern "C" {
17#endif
18
19// Program signature
20
21// The first 16 binary bytes hold this signature. Override weak vexCodeSig in .boot_data.
22typedef struct __attribute__((__packed__)) _vcodesig {
23 uint32_t magic;
24 uint32_t type;
25 uint32_t owner;
26 uint32_t options;
27} vcodesig;
28
29#define V5_SIG_MAGIC 0x35585658
30#define IQ_SIG_MAGIC 0x32515658
31#define EX_SIG_MAGIC 0x45585658
32#define V5_SIG_TYPE_USER 0
33#define V5_SIG_OWNER_SYS 0
34#define V5_SIG_OWNER_VEX 1
35#define V5_SIG_OWNER_PARTNER 2
36#define V5_SIG_OPTIONS_NONE 0
37#define V5_SIG_OPTIONS_INDG (1 << 0) // Invert default graphics colors.
38#define V5_SIG_OPTIONS_EXIT (1 << 1) // End threads when main exits.
39#define V5_SIG_OPTIONS_THDG (1 << 2) // Invert graphics to match the theme.
40
41#define V5_CODE_SIG(type, owner, options) \
42 vcodesig vexCodeSig __attribute__((section(".boot_data"))) = {V5_SIG_MAGIC, type, owner, options};
43
44// System and clocks
45
46struct time {
47 uint8_t ti_hour;
48 uint8_t ti_min;
49 uint8_t ti_sec;
50 uint8_t ti_hund; // Hundredths of a second.
51};
52
53struct date {
54 uint16_t da_year; // Years since 1980.
55 uint8_t da_day;
56 uint8_t da_mon; // 1 = January.
57};
58
59void vexDelay(uint32_t timems);
60void vexBackgroundProcessing(void);
61
62uint32_t vexSystemTimeGet(void);
63void vexGettime(struct time* pTime);
64void vexGetdate(struct date* pDate);
65void vexSystemMemoryDump(void);
66void vexSystemDigitalIO(uint32_t pin, uint32_t value);
67uint32_t vexSystemStartupOptions(void);
68void vexSystemExitRequest(void);
69uint64_t vexSystemHighResTimeGet(void);
70uint64_t vexSystemPowerupTimeGet(void);
71uint32_t vexSystemLinkAddrGet(void);
72uint32_t vexSystemUsbStatus(void);
73
74uint32_t vexSystemVersion(void);
75uint32_t vexStdlibVersion(void);
76
77uint32_t vexSdkVersion(void);
78
79uint32_t vexStdlibVersionLinked(void);
80bool vexStdlibVersionVerify(void);
81
82// Console formatting
83
84int32_t vexDebug(char const* fmt, ...);
85int32_t vex_printf(char const* fmt, ...);
86int32_t vex_sprintf(char* out, const char* format, ...);
87int32_t vex_snprintf(char* out, uint32_t max_len, const char* format, ...);
88int32_t vex_vsprintf(char* out, const char* format, va_list args);
89int32_t vex_vsnprintf(char* out, uint32_t max_len, const char* format, va_list args);
90
91// Devices and ports
92
93typedef enum {
94 kDeviceTypeNoSensor = 0,
95 kDeviceTypeMotorSensor = 2,
96 kDeviceTypeLedSensor = 3,
97 kDeviceTypeAbsEncSensor = 4,
98 kDeviceTypeCrMotorSensor = 5,
99 kDeviceTypeImuSensor = 6,
100 kDeviceTypeRangeSensor = 7, // Legacy distance alias.
101 kDeviceTypeDistanceSensor = 7,
102 kDeviceTypeRadioSensor = 8,
103 kDeviceTypeTetherSensor = 9,
104 kDeviceTypeBrainSensor = 10,
105 kDeviceTypeVisionSensor = 11,
106 kDeviceTypeAdiSensor = 12,
107 kDeviceTypeRes1Sensor = 13,
108 kDeviceTypeRes2Sensor = 14,
109 kDeviceTypeRes3Sensor = 15,
110 kDeviceTypeOpticalSensor = 16,
111 kDeviceTypeMagnetSensor = 17,
112 kDeviceTypeGpsSensor = 20,
113 kDeviceTypeAicameraSensor = 26,
114 kDeviceTypeLightTowerSensor = 27,
115 kDeviceTypeArmDevice = 28,
116 kDeviceTypeAiVisionSensor = 29,
117 kDeviceTypePneumaticSensor = 30,
118 kDeviceTypeMC55MotorSensor = 31,
119 kDeviceTypeBumperSensor = 0x40,
120 kDeviceTypeGyroSensor = 0x46,
121 kDeviceTypeSonarSensor = 0x47,
122 kDeviceTypeGenericSensor = 128,
123 kDeviceTypeGenericSerial = 129,
124 kDeviceTypeUndefinedSensor = 255
125} V5_DeviceType;
126
127typedef struct _V5_Device* V5_DeviceT;
128
129// Includes physical and virtual ports.
130#define V5_MAX_DEVICE_PORTS 32
131typedef V5_DeviceType V5_DeviceTypeBuffer[V5_MAX_DEVICE_PORTS];
132
133uint32_t vexDevicesGetNumber(void);
134uint32_t vexDevicesGetNumberByType(V5_DeviceType type);
135V5_DeviceT vexDevicesGet(void);
136V5_DeviceT vexDeviceGetByIndex(uint32_t index);
137int32_t vexDeviceGetStatus(V5_DeviceType* buffer);
138int32_t vexDeviceGetTimestamp(V5_DeviceT device);
139int32_t vexDeviceGetTimestampByIndex(int32_t index);
140uint32_t vexDeviceButtonStateGet(void);
141
142// Resolve a port index to a device handle.
143#define VEX_DEVICE_GET(device, index) V5_DeviceT device = vexDeviceGetByIndex(index)
144
145int32_t vexDeviceGenericValueGet(V5_DeviceT device);
146
147// Competition
148
149#define V5_COMP_BIT_EBL 1 // Robot disabled.
150#define V5_COMP_BIT_MODE 2 // Autonomous mode.
151#define V5_COMP_BIT_COMP 4 // Competition switch or field control connected.
152#define V5_COMP_BIT_GAME 8 // Field control connected.
153#define V5_COMP_BIT_OPT1 16 // Option 1; VEXos 1.1.3+.
154#define V5_COMP_BIT_OPT2 32 // Option 2; VEXos 1.1.3+.
155
156uint32_t vexCompetitionStatus(void);
157void vexCompetitionControl(uint32_t data);
158
159// Battery
160
161int32_t vexBatteryVoltageGet(void);
162int32_t vexBatteryCurrentGet(void);
163double vexBatteryTemperatureGet(void);
164double vexBatteryCapacityGet(void);
165
166// Controller
167
168typedef enum _V5_ControllerIndex {
169 AnaLeftX = 0,
170 AnaLeftY,
171 AnaRightX,
172 AnaRightY,
173 AnaSpare1,
174 AnaSpare2,
175
176 Button5U,
177 Button5D,
178 Button6U,
179 Button6D,
180 Button7U,
181 Button7D,
182 Button7L,
183 Button7R,
184 Button8U,
185 Button8D,
186 Button8L,
187 Button8R,
188
189 ButtonSEL,
190
191 BatteryLevel,
192
193 ButtonAll,
194 Flags,
195 BatteryCapacity,
196
197 // Controller label aliases.
198 Axis1 = AnaRightX,
199 Axis2 = AnaRightY,
200 Axis3 = AnaLeftY,
201 Axis4 = AnaLeftX,
202
203 ButtonL1 = Button5U,
204 ButtonL2 = Button5D,
205 ButtonR1 = Button6U,
206 ButtonR2 = Button6D,
207
208 ButtonUp = Button7U,
209 ButtonDown = Button7D,
210 ButtonLeft = Button7L,
211 ButtonRight = Button7R,
212
213 ButtonX = Button8U,
214 ButtonB = Button8D,
215 ButtonY = Button8L,
216 ButtonA = Button8R
217} V5_ControllerIndex;
218
219typedef enum _V5_ControllerStatus {
220 kV5ControllerOffline = 0,
221 kV5ControllerTethered,
222 kV5ControllerVexnet
223} V5_ControllerStatus;
224
225typedef enum _V5_ControllerId { kControllerMaster = 0, kControllerPartner } V5_ControllerId;
226
227int32_t vexControllerGet(V5_ControllerId id, V5_ControllerIndex index);
228V5_ControllerStatus vexControllerConnectionStatusGet(V5_ControllerId id);
229bool vexControllerTextSet(V5_ControllerId id, uint32_t line, uint32_t col, const char* str);
230
231// Motors
232
233typedef enum {
234 kMotorControlModeOFF = 0, // Coast.
235 kMotorControlModeBRAKE = 1, // Brake.
236 kMotorControlModeHOLD = 2, // Hold the current position.
237 kMotorControlModeSERVO = 3, // Move to a target and hold.
238 kMotorControlModePROFILE = 4, // Move to a target and stop.
239 kMotorControlModeVELOCITY = 5, // Run at a set velocity.
240 kMotorControlModeUNDEFINED = 6
241} V5MotorControlMode;
242
243typedef enum _V5_MotorBrakeMode {
244 kV5MotorBrakeModeCoast = 0,
245 kV5MotorBrakeModeBrake = 1,
246 kV5MotorBrakeModeHold = 2
247} V5MotorBrakeMode;
248
249typedef enum {
250 kMotorEncoderDegrees = 0,
251 kMotorEncoderRotations = 1,
252 kMotorEncoderCounts = 2
253} V5MotorEncoderUnits;
254
255typedef enum _V5MotorGearset {
256 kMotorGearSet_36 = 0, // 36:1 gearing.
257 kMotorGearSet_18 = 1, // 18:1 gearing.
258 kMotorGearSet_06 = 2 // 6:1 gearing.
259} V5MotorGearset;
260
261// Encoder counts per rotation with 36:1 gearing.
262#define V5_MOTOR_COUNTS_PER_ROT 1800.0
263
264// Position and velocity PID settings.
265typedef struct __attribute__((__packed__)) _V5_DeviceMotorPid {
266 uint8_t kf;
267 uint8_t kp;
268 uint8_t ki;
269 uint8_t kd;
270 uint8_t filter;
271 uint8_t pad1;
272 uint16_t limit;
273 uint8_t threshold;
274 uint8_t loopspeed;
275 uint8_t pad2[2];
276} V5_DeviceMotorPid;
277
278void vexDeviceMotorVelocitySet(V5_DeviceT device, int32_t velocity);
279void vexDeviceMotorVelocityUpdate(V5_DeviceT device, int32_t velocity);
280void vexDeviceMotorVoltageSet(V5_DeviceT device, int32_t value);
281int32_t vexDeviceMotorVelocityGet(V5_DeviceT device);
282double vexDeviceMotorActualVelocityGet(V5_DeviceT device);
283int32_t vexDeviceMotorDirectionGet(V5_DeviceT device);
284void vexDeviceMotorModeSet(V5_DeviceT device, V5MotorControlMode mode);
285V5MotorControlMode vexDeviceMotorModeGet(V5_DeviceT device);
286void vexDeviceMotorPwmSet(V5_DeviceT device, int32_t value);
287int32_t vexDeviceMotorPwmGet(V5_DeviceT device);
288void vexDeviceMotorCurrentLimitSet(V5_DeviceT device, int32_t value);
289int32_t vexDeviceMotorCurrentLimitGet(V5_DeviceT device);
290void vexDeviceMotorVoltageLimitSet(V5_DeviceT device, int32_t value);
291int32_t vexDeviceMotorVoltageLimitGet(V5_DeviceT device);
292void vexDeviceMotorPositionPidSet(V5_DeviceT device, V5_DeviceMotorPid* pid);
293void vexDeviceMotorVelocityPidSet(V5_DeviceT device, V5_DeviceMotorPid* pid);
294int32_t vexDeviceMotorCurrentGet(V5_DeviceT device);
295int32_t vexDeviceMotorVoltageGet(V5_DeviceT device);
296double vexDeviceMotorPowerGet(V5_DeviceT device);
297double vexDeviceMotorTorqueGet(V5_DeviceT device);
298double vexDeviceMotorEfficiencyGet(V5_DeviceT device);
299double vexDeviceMotorTemperatureGet(V5_DeviceT device);
300bool vexDeviceMotorOverTempFlagGet(V5_DeviceT device);
301bool vexDeviceMotorCurrentLimitFlagGet(V5_DeviceT device);
302uint32_t vexDeviceMotorFaultsGet(V5_DeviceT device);
303bool vexDeviceMotorZeroVelocityFlagGet(V5_DeviceT device);
304bool vexDeviceMotorZeroPositionFlagGet(V5_DeviceT device);
305uint32_t vexDeviceMotorFlagsGet(V5_DeviceT device);
306void vexDeviceMotorReverseFlagSet(V5_DeviceT device, bool value);
307bool vexDeviceMotorReverseFlagGet(V5_DeviceT device);
308void vexDeviceMotorEncoderUnitsSet(V5_DeviceT device, V5MotorEncoderUnits units);
309V5MotorEncoderUnits vexDeviceMotorEncoderUnitsGet(V5_DeviceT device);
310void vexDeviceMotorBrakeModeSet(V5_DeviceT device, V5MotorBrakeMode mode);
311V5MotorBrakeMode vexDeviceMotorBrakeModeGet(V5_DeviceT device);
312void vexDeviceMotorPositionSet(V5_DeviceT device, double position);
313double vexDeviceMotorPositionGet(V5_DeviceT device);
314int32_t vexDeviceMotorPositionRawGet(V5_DeviceT device, uint32_t* timestamp);
315void vexDeviceMotorPositionReset(V5_DeviceT device);
316double vexDeviceMotorTargetGet(V5_DeviceT device);
317void vexDeviceMotorServoTargetSet(V5_DeviceT device, double position);
318void vexDeviceMotorAbsoluteTargetSet(V5_DeviceT device, double position, int32_t velocity);
319void vexDeviceMotorRelativeTargetSet(V5_DeviceT device, double position, int32_t velocity);
320void vexDeviceMotorGearingSet(V5_DeviceT device, V5MotorGearset value);
321V5MotorGearset vexDeviceMotorGearingGet(V5_DeviceT device);
322void vexDeviceMotorExternalProfileSet(V5_DeviceT device, double position, int32_t velocity);
323int32_t vexDeviceMotorTypeGet(V5_DeviceT device);
324
325// Three-wire I/O (ADI)
326
327typedef enum _V5_AdiPortConfiguration {
328 kAdiPortTypeAnalogIn = 0,
329 kAdiPortTypeAnalogOut,
330 kAdiPortTypeDigitalIn,
331 kAdiPortTypeDigitalOut,
332
333 kAdiPortTypeSmartButton,
334 kAdiPortTypeSmartPot,
335
336 kAdiPortTypeLegacyButton,
337 kAdiPortTypeLegacyPotentiometer,
338 kAdiPortTypeLegacyLineSensor,
339 kAdiPortTypeLegacyLightSensor,
340 kAdiPortTypeLegacyGyro,
341 kAdiPortTypeLegacyAccelerometer,
342
343 kAdiPortTypeLegacyServo,
344 kAdiPortTypeLegacyPwm,
345
346 kAdiPortTypeQuadEncoder,
347 kAdiPortTypeSonar,
348
349 kAdiPortTypeLegacyPwmSlew,
350
351 kAdiPortTypeUndefined = 255
352} V5_AdiPortConfiguration;
353
354#define V5_ADI_PORT_NUM 8
355
356void vexDeviceAdiPortConfigSet(V5_DeviceT device, uint32_t port, V5_AdiPortConfiguration type);
357V5_AdiPortConfiguration vexDeviceAdiPortConfigGet(V5_DeviceT device, uint32_t port);
358void vexDeviceAdiValueSet(V5_DeviceT device, uint32_t port, int32_t value);
359int32_t vexDeviceAdiValueGet(V5_DeviceT device, uint32_t port);
360
361// Bumper switch
362
363typedef enum _V5_DeviceBumperState { kBumperReleased = 0, kBumperPressed = 1 } V5_DeviceBumperState;
364
365V5_DeviceBumperState vexDeviceBumperGet(V5_DeviceT device);
366
367// Rotation sensor
368
369void vexDeviceAbsEncReset(V5_DeviceT device);
370void vexDeviceAbsEncPositionSet(V5_DeviceT device, int32_t position);
371int32_t vexDeviceAbsEncPositionGet(V5_DeviceT device);
372int32_t vexDeviceAbsEncVelocityGet(V5_DeviceT device);
373int32_t vexDeviceAbsEncAngleGet(V5_DeviceT device);
374void vexDeviceAbsEncReverseFlagSet(V5_DeviceT device, bool value);
375bool vexDeviceAbsEncReverseFlagGet(V5_DeviceT device);
376uint32_t vexDeviceAbsEncStatusGet(V5_DeviceT device);
377void vexDeviceAbsEncDataRateSet(V5_DeviceT device, uint32_t rate);
378
379// Inertial sensor
380
381typedef struct __attribute__((__packed__)) _V5_DeviceImuQuaternion {
382 double a;
383 double b;
384 double c;
385 double d;
386} V5_DeviceImuQuaternion;
387
388typedef struct __attribute__((__packed__)) _V5_DeviceImuAttitude {
389 double pitch; // X axis.
390 double roll; // Y axis.
391 double yaw; // Z axis.
392} V5_DeviceImuAttitude;
393
394typedef struct __attribute__((__packed__)) _V5_DeviceImuRaw {
395 double x;
396 double y;
397 double z;
398 double w;
399} V5_DeviceImuRaw;
400
401// Native heading increases clockwise, like the three-wire gyro.
402typedef enum _V5ImuHeadingnMode {
403 kImuHeadingNative = 0x00,
404 kImuHeadingIQ = 0x01
405} _V5ImuHeadingnMode;
406
407typedef enum _V5ImuOrientationMode {
408 kImuOrientationZUp = 0x00,
409 kImuOrientationZDown = 0x10,
410 kImuOrientationXUp = 0x20,
411 kImuOrientationXDown = 0x30,
412 kImuOrientationYUp = 0x40,
413 kImuOrientationYDown = 0x50,
414 kImuOrientationAuto = 0x80
415} V5ImuOrientationMode;
416
417typedef enum _V5ImuQuaternionMode {
418 kImuQuaternionProcessed = 0x000,
419 kImuQuaternionRaw = 0x100
420} V5ImuQuaternionMode;
421
422void vexDeviceImuReset(V5_DeviceT device);
423double vexDeviceImuHeadingGet(V5_DeviceT device);
424double vexDeviceImuDegreesGet(V5_DeviceT device);
425void vexDeviceImuQuaternionGet(V5_DeviceT device, V5_DeviceImuQuaternion* data);
426void vexDeviceImuAttitudeGet(V5_DeviceT device, V5_DeviceImuAttitude* data);
427void vexDeviceImuRawGyroGet(V5_DeviceT device, V5_DeviceImuRaw* data);
428void vexDeviceImuRawAccelGet(V5_DeviceT device, V5_DeviceImuRaw* data);
429uint32_t vexDeviceImuStatusGet(V5_DeviceT device);
430void vexDeviceImuModeSet(V5_DeviceT device, uint32_t mode);
431uint32_t vexDeviceImuModeGet(V5_DeviceT device);
432void vexDeviceImuDataRateSet(V5_DeviceT device, uint32_t rate);
433
434// Distance sensor
435
436uint32_t vexDeviceDistanceDistanceGet(V5_DeviceT device);
437uint32_t vexDeviceDistanceConfidenceGet(V5_DeviceT device);
438int32_t vexDeviceDistanceObjectSizeGet(V5_DeviceT device);
439double vexDeviceDistanceObjectVelocityGet(V5_DeviceT device);
440uint32_t vexDeviceDistanceStatusGet(V5_DeviceT device);
441
442// Optical sensor
443
444// Raw clear, red, green, and blue channels.
445typedef struct _V5_DeviceOpticalRaw {
446 uint16_t clear;
447 uint16_t red;
448 uint16_t green;
449 uint16_t blue;
450} V5_DeviceOpticalRaw;
451
452typedef struct _V5_DeviceOpticalRgb {
453 double red;
454 double green;
455 double blue;
456 double brightness;
457} V5_DeviceOpticalRgb;
458
459typedef struct _V5_DeviceOpticalGesture {
460 uint8_t udata;
461 uint8_t ddata;
462 uint8_t ldata;
463 uint8_t rdata;
464 uint8_t type;
465 uint8_t pad;
466 uint16_t count;
467 uint32_t time;
468} V5_DeviceOpticalGesture;
469
470double vexDeviceOpticalHueGet(V5_DeviceT device);
471double vexDeviceOpticalSatGet(V5_DeviceT device);
472double vexDeviceOpticalBrightnessGet(V5_DeviceT device);
473int32_t vexDeviceOpticalProximityGet(V5_DeviceT device);
474void vexDeviceOpticalRgbGet(V5_DeviceT device, V5_DeviceOpticalRgb* data);
475void vexDeviceOpticalLedPwmSet(V5_DeviceT device, int32_t value);
476int32_t vexDeviceOpticalLedPwmGet(V5_DeviceT device);
477uint32_t vexDeviceOpticalStatusGet(V5_DeviceT device);
478void vexDeviceOpticalRawGet(V5_DeviceT device, V5_DeviceOpticalRaw* data);
479void vexDeviceOpticalModeSet(V5_DeviceT device, uint32_t mode);
480uint32_t vexDeviceOpticalModeGet(V5_DeviceT device);
481uint32_t vexDeviceOpticalGestureGet(V5_DeviceT, V5_DeviceOpticalGesture* pData);
482void vexDeviceOpticalGestureEnable(V5_DeviceT);
483void vexDeviceOpticalGestureDisable(V5_DeviceT);
484int32_t vexDeviceOpticalProximityThreshold(V5_DeviceT device, int32_t value);
485void vexDeviceOpticalIntegrationTimeSet(V5_DeviceT device, double timeMs);
486double vexDeviceOpticalIntegrationTimeGet(V5_DeviceT device);
487
488// Vision sensor
489
490typedef enum {
491 kVisionModeNormal = 0,
492 kVisionModeMixed = 1,
493 kVisionModeLineDetect = 2,
494 kVisionTypeTest = 3
495} V5VisionMode;
496
497typedef enum {
498 kVisionTypeNormal = 0,
499 kVisionTypeColorCode = 1,
500 kVisionTypeLineDetect = 2
501} V5VisionBlockType;
502
503typedef enum { kVisionWBNormal = 0, kVisionWBStart = 1, kVisionWBManual = 2 } V5VisionWBMode;
504
505typedef enum { kVisionLedModeAuto = 0, kVisionLedModeManual = 1 } V5VisionLedMode;
506
507typedef enum { kVisionWifiModeOff = 0, kVisionWifiModeOn = 1 } V5VisionWifiMode;
508
509// Set when the signature has been read back from the sensor.
510#define VISION_SIG_FLAG_STATUS (1 << 0)
511
512// 40-byte sensor signature format.
513typedef struct __attribute__((__packed__)) _V5_DeviceVisionSignature {
514 uint8_t id;
515 uint8_t flags;
516 uint8_t pad[2];
517 float range;
518 int32_t uMin;
519 int32_t uMax;
520 int32_t uMean;
521 int32_t vMin;
522 int32_t vMax;
523 int32_t vMean;
524 uint32_t mRgb;
525 uint32_t mType;
526} V5_DeviceVisionSignature;
527
528typedef struct __attribute__((__packed__)) _V5_DeviceVisionObject {
529 uint16_t signature;
530 V5VisionBlockType type;
531 uint16_t xoffset; // Left edge.
532 uint16_t yoffset; // Top edge.
533 uint16_t width;
534 uint16_t height;
535 uint16_t angle; // Color-code angle in 0.1 degrees.
536} V5_DeviceVisionObject;
537
538// LED and white balance color.
539typedef struct __attribute__((__packed__)) _V5_DeviceVisionRgb {
540 uint8_t red;
541 uint8_t green;
542 uint8_t blue;
543 uint8_t brightness; // Unused.
544} V5_DeviceVisionRgb;
545
546void vexDeviceVisionModeSet(V5_DeviceT device, V5VisionMode mode);
547V5VisionMode vexDeviceVisionModeGet(V5_DeviceT device);
548int32_t vexDeviceVisionObjectCountGet(V5_DeviceT device);
549int32_t vexDeviceVisionObjectGet(
550 V5_DeviceT device, uint32_t indexObj, V5_DeviceVisionObject* pObject
551);
552void vexDeviceVisionSignatureSet(V5_DeviceT device, V5_DeviceVisionSignature* pSignature);
553bool vexDeviceVisionSignatureGet(
554 V5_DeviceT device, uint32_t id, V5_DeviceVisionSignature* pSignature
555);
556void vexDeviceVisionBrightnessSet(V5_DeviceT device, uint8_t percent);
557uint8_t vexDeviceVisionBrightnessGet(V5_DeviceT device);
558void vexDeviceVisionWhiteBalanceModeSet(V5_DeviceT device, V5VisionWBMode mode);
559V5VisionWBMode vexDeviceVisionWhiteBalanceModeGet(V5_DeviceT device);
560void vexDeviceVisionWhiteBalanceSet(V5_DeviceT device, V5_DeviceVisionRgb color);
561V5_DeviceVisionRgb vexDeviceVisionWhiteBalanceGet(V5_DeviceT device);
562void vexDeviceVisionLedModeSet(V5_DeviceT device, V5VisionLedMode mode);
563V5VisionLedMode vexDeviceVisionLedModeGet(V5_DeviceT device);
564void vexDeviceVisionLedBrigntnessSet(V5_DeviceT device, uint8_t percent);
565uint8_t vexDeviceVisionLedBrigntnessGet(V5_DeviceT device);
566void vexDeviceVisionLedColorSet(V5_DeviceT device, V5_DeviceVisionRgb color);
567V5_DeviceVisionRgb vexDeviceVisionLedColorGet(V5_DeviceT device);
568void vexDeviceVisionWifiModeSet(V5_DeviceT device, V5VisionWifiMode mode);
569V5VisionWifiMode vexDeviceVisionWifiModeGet(V5_DeviceT device);
570
571// AI Vision sensor
572
573typedef struct __attribute((packed)) _V5_DeviceAiVisionObject {
574 uint8_t id;
575 uint8_t type;
576 union {
577 struct {
578 uint16_t xoffset; // Left edge.
579 uint16_t yoffset; // Top edge.
580 uint16_t width;
581 uint16_t height;
582 uint16_t angle; // Color-code angle in 0.1 degrees.
583 } color;
584
585 struct {
586 int16_t x0; // AprilTag corner coordinates.
587 int16_t y0;
588 int16_t x1;
589 int16_t y1;
590 int16_t x2;
591 int16_t y2;
592 int16_t x3;
593 int16_t y3;
594 } tag;
595
596 struct {
597 uint16_t xoffset; // Left edge.
598 uint16_t yoffset; // Top edge.
599 uint16_t width;
600 uint16_t height;
601 uint16_t score;
602 } model;
603 } object;
604} V5_DeviceAiVisionObject;
605
606typedef struct __attribute__((__packed__)) _V5_DeviceAiVisionColor {
607 uint8_t id;
608 uint8_t red;
609 uint8_t grn;
610 uint8_t blu;
611 float hangle;
612 float hdsat;
613 uint32_t reserved;
614} V5_DeviceAiVisionColor;
615
616typedef struct __attribute__((__packed__)) _V5_DeviceAiVisionCode {
617 uint8_t id;
618 uint8_t len;
619 int16_t c1;
620 int16_t c2;
621 int16_t c3;
622 int16_t c4;
623 int16_t c5;
624 int16_t c6;
625 int16_t c7;
626} V5_DeviceAiVisionCode;
627
628void vexDeviceAiVisionModeSet(V5_DeviceT device, uint32_t mode);
629uint32_t vexDeviceAiVisionModeGet(V5_DeviceT device);
630int32_t vexDeviceAiVisionObjectCountGet(V5_DeviceT device);
631int32_t vexDeviceAiVisionObjectGet(
632 V5_DeviceT device, uint32_t indexObj, V5_DeviceAiVisionObject* pObject
633);
634void vexDeviceAiVisionColorSet(V5_DeviceT device, V5_DeviceAiVisionColor* pColor);
635bool vexDeviceAiVisionColorGet(V5_DeviceT device, uint32_t id, V5_DeviceAiVisionColor* pColor);
636void vexDeviceAiVisionCodeSet(V5_DeviceT device, V5_DeviceAiVisionCode* pCode);
637bool vexDeviceAiVisionCodeGet(V5_DeviceT device, uint32_t id, V5_DeviceAiVisionCode* pCode);
638uint32_t vexDeviceAiVisionStatusGet(V5_DeviceT device);
639double vexDeviceAiVisionTemperatureGet(V5_DeviceT device);
640int32_t vexDeviceAiVisionClassNameGet(V5_DeviceT device, int32_t id, uint8_t* pName);
641void vexDeviceAiVisionReset(V5_DeviceT device);
642void vexDeviceAiVisionEnableSet(V5_DeviceT device, uint8_t nEnables, uint8_t nMask);
643uint8_t vexDeviceAiVisionEnableGet(V5_DeviceT device);
644
645// GPS sensor
646
647typedef struct __attribute__((__packed__)) _V5_DeviceGpsQuaternion {
648 double a;
649 double b;
650 double c;
651 double d;
652} V5_DeviceGpsQuaternion;
653
654typedef struct __attribute__((__packed__)) _V5_DeviceGpsAttitude {
655 double pitch; // X axis.
656 double roll; // Y axis.
657 double yaw; // Z axis.
658
659 // Field position.
660 double position_x;
661 double position_y;
662 double position_z;
663
664 // Alternate attitude angles.
665 double az;
666 double el;
667 double rot;
668} V5_DeviceGpsAttitude;
669
670typedef struct __attribute__((__packed__)) _V5_DeviceGpsRaw {
671 double x;
672 double y;
673 double z;
674 double w;
675} V5_DeviceGpsRaw;
676
677void vexDeviceGpsReset(V5_DeviceT device);
678double vexDeviceGpsHeadingGet(V5_DeviceT device);
679double vexDeviceGpsDegreesGet(V5_DeviceT device);
680void vexDeviceGpsQuaternionGet(V5_DeviceT device, V5_DeviceGpsQuaternion* data);
681void vexDeviceGpsAttitudeGet(V5_DeviceT device, V5_DeviceGpsAttitude* data, bool bRaw);
682void vexDeviceGpsRawGyroGet(V5_DeviceT device, V5_DeviceGpsRaw* data);
683void vexDeviceGpsRawAccelGet(V5_DeviceT device, V5_DeviceGpsRaw* data);
684uint32_t vexDeviceGpsStatusGet(V5_DeviceT device);
685void vexDeviceGpsModeSet(V5_DeviceT device, uint32_t mode);
686uint32_t vexDeviceGpsModeGet(V5_DeviceT device);
687void vexDeviceGpsDataRateSet(V5_DeviceT device, uint32_t rate);
688void vexDeviceGpsOriginSet(V5_DeviceT device, double ox, double oy);
689void vexDeviceGpsOriginGet(V5_DeviceT device, double* ox, double* oy);
690void vexDeviceGpsRotationSet(V5_DeviceT device, double value);
691double vexDeviceGpsRotationGet(V5_DeviceT device);
692void vexDeviceGpsInitialPositionSet(
693 V5_DeviceT device, double initial_x, double initial_y, double initial_rotation
694);
695double vexDeviceGpsErrorGet(V5_DeviceT device);
696
697// Electromagnet
698
699typedef enum _V5_DeviceMagnetDuration {
700 kMagnetDurationShort,
701 kMagnetDurationMedium,
702 kMagnetDurationLong,
703 kMagnetDurationExtraLong,
704} V5_DeviceMagnetDuration;
705
706void vexDeviceMagnetPowerSet(V5_DeviceT device, int32_t value, int32_t time);
707int32_t vexDeviceMagnetPowerGet(V5_DeviceT device);
708void vexDeviceMagnetPickup(V5_DeviceT device, V5_DeviceMagnetDuration duration);
709void vexDeviceMagnetDrop(V5_DeviceT device, V5_DeviceMagnetDuration duration);
710double vexDeviceMagnetTemperatureGet(V5_DeviceT device);
711double vexDeviceMagnetCurrentGet(V5_DeviceT device);
712uint32_t vexDeviceMagnetStatusGet(V5_DeviceT device);
713
714// Light tower
715
716void vexDeviceLightTowerRgbSet(V5_DeviceT device, uint32_t rgb_value, uint32_t xyw_value);
717void vexDeviceLightTowerColorSet(V5_DeviceT device, uint32_t color_id, uint32_t value);
718uint32_t vexDeviceLightTowerRgbGet(V5_DeviceT device);
719uint32_t vexDeviceLightTowerXywGet(V5_DeviceT device);
720uint32_t vexDeviceLightTowerStatusGet(V5_DeviceT device);
721void vexDeviceLightTowerBlinkSet(
722 V5_DeviceT device, uint8_t select, uint8_t mask, int32_t onTime, int32_t offTime
723);
724
725// Pneumatics
726
727// Low-level control for development use.
728typedef struct _V5_DevicePneumaticCtrl {
729 uint16_t flags;
730 uint8_t m1_pwm;
731 uint8_t m2_pwm;
732 uint8_t m3_pwm;
733 uint8_t m4_pwm;
734 uint8_t m1_time;
735 uint8_t m2_time;
736 uint8_t m3_time;
737 uint8_t m4_time;
738 uint8_t comp_pwm;
739} V5_DevicePneumaticCtrl;
740
741void vexDevicePneumaticCompressorSet(V5_DeviceT device, bool bState);
742void vexDevicePneumaticCylinderSet(V5_DeviceT device, uint32_t id, bool bState);
743void vexDevicePneumaticCtrlSet(V5_DeviceT device, V5_DevicePneumaticCtrl* pCtrl);
744uint32_t vexDevicePneumaticStatusGet(V5_DeviceT device);
745void vexDevicePneumaticPwmSet(V5_DeviceT device, uint8_t pwm);
746uint32_t vexDevicePneumaticPwmGet(V5_DeviceT device);
747void vexDevicePneumaticCylinderPwmSet(V5_DeviceT device, uint32_t id, bool bState, uint8_t pwm);
748uint32_t vexDevicePneumaticActuationStatusGet(
749 V5_DeviceT device, uint16_t* ac1, uint16_t* ac2, uint16_t* ac3, uint16_t* ac4
750);
751
752// AI camera data
753
754// Object format for firmware 1.1.3 and later.
755typedef struct __attribute__((__packed__)) _V5_DeviceAicamObject {
756 uint8_t group_id;
757 uint8_t object_id;
758 uint8_t classID;
759 uint8_t probability;
760 int16_t depth;
761 int16_t mapX;
762 int16_t mapY;
763 int16_t mapZ;
764 int16_t screenWidth;
765 int16_t screenHeight;
766 int16_t screenX;
767 int16_t screenY;
768} V5_DeviceAicamObject;
769
770// CTE arm data
771
772typedef struct _V5_DeviceArmTipPosition {
773 int32_t tip_x;
774 int32_t tip_y;
775 int32_t tip_z;
776 int32_t tip_roll;
777 int32_t tip_pitch;
778 int32_t tip_yaw;
779 int8_t flags;
780 int8_t spare;
781 uint16_t velocity;
782} V5_DeviceArmTipPosition;
783
784// Legacy LED sensor
785
786typedef enum _V5_DeviceLedColor {
787 kLedColorBlack = 0,
788 kLedColorRed = 0xFF0000,
789 kLedColorGreen = 0x00FF00,
790 kLedColorBlue = 0x0000FF,
791 kLedColorYellow = 0xFFFF00,
792 kLedColorCyan = 0x00FFFF,
793 kLedColorMagenta = 0xFF00FF,
794 kLedColorWhite = 0xFFFFFF
795} V5_DeviceLedColor;
796
797void vexDeviceLedSet(V5_DeviceT device, V5_DeviceLedColor value);
798void vexDeviceLedRgbSet(V5_DeviceT device, uint32_t color);
799V5_DeviceLedColor vexDeviceLedGet(V5_DeviceT device);
800uint32_t vexDeviceLedRgbGet(V5_DeviceT device);
801
802// Legacy gyro, sonar, and range sensors
803
804void vexDeviceGyroReset(V5_DeviceT device);
805double vexDeviceGyroHeadingGet(V5_DeviceT device);
806double vexDeviceGyroDegreesGet(V5_DeviceT device);
807
808int32_t vexDeviceSonarValueGet(V5_DeviceT device);
809
810int32_t vexDeviceRangeValueGet(V5_DeviceT device);
811
812// Device serial communication
813
814void vexDeviceGenericSerialEnable(V5_DeviceT device, int32_t options);
815void vexDeviceGenericSerialBaudrate(V5_DeviceT device, int32_t baudrate);
816int32_t vexDeviceGenericSerialWriteChar(V5_DeviceT device, uint8_t c);
817int32_t vexDeviceGenericSerialWriteFree(V5_DeviceT device);
818int32_t vexDeviceGenericSerialTransmit(V5_DeviceT device, uint8_t* buffer, int32_t length);
819int32_t vexDeviceGenericSerialReadChar(V5_DeviceT device);
820int32_t vexDeviceGenericSerialPeekChar(V5_DeviceT device);
821int32_t vexDeviceGenericSerialReceiveAvail(V5_DeviceT device);
822int32_t vexDeviceGenericSerialReceive(V5_DeviceT device, uint8_t* buffer, int32_t length);
823void vexDeviceGenericSerialFlush(V5_DeviceT device);
824
825// VEXnet radio communication
826
827void vexDeviceGenericRadioConnection(
828 V5_DeviceT device, char* pName, bool bMaster, bool bAllowRadioOverride
829);
830int32_t vexDeviceGenericRadioWriteChar(V5_DeviceT device, uint8_t c);
831int32_t vexDeviceGenericRadioWriteFree(V5_DeviceT device);
832int32_t vexDeviceGenericRadioTransmit(V5_DeviceT device, uint8_t* buffer, int32_t length);
833int32_t vexDeviceGenericRadioReadChar(V5_DeviceT device);
834int32_t vexDeviceGenericRadioPeekChar(V5_DeviceT device);
835int32_t vexDeviceGenericRadioReceiveAvail(V5_DeviceT device);
836int32_t vexDeviceGenericRadioReceive(V5_DeviceT device, uint8_t* buffer, int32_t length);
837void vexDeviceGenericRadioFlush(V5_DeviceT device);
838bool vexDeviceGenericRadioLinkStatus(V5_DeviceT device);
839
840// USB serial (CDC)
841
842int32_t vexSerialWriteChar(uint32_t channel, uint8_t c);
843int32_t vexSerialWriteBuffer(uint32_t channel, uint8_t* data, uint32_t data_len);
844int32_t vexSerialReadChar(uint32_t channel);
845int32_t vexSerialPeekChar(uint32_t channel);
846int32_t vexSerialWriteFree(uint32_t channel);
847
848// Display and images
849
850// data must point to a caller provided image buffer.
851typedef struct __attribute__((__packed__)) _v5_image {
852 uint16_t width;
853 uint16_t height;
854 uint32_t* data;
855 uint32_t* p;
856} v5_image;
857
858#define SYSTEM_DISPLAY_WIDTH 480
859#define SYSTEM_DISPLAY_HEIGHT 272
860
861void vexDisplayForegroundColor(uint32_t col);
862void vexDisplayBackgroundColor(uint32_t col);
863uint32_t vexDisplayForegroundColorGet(void);
864uint32_t vexDisplayBackgroundColorGet(void);
865void vexDisplayErase(void);
866void vexDisplayScroll(int32_t nStartLine, int32_t nLines);
867void vexDisplayScrollRect(int32_t x1, int32_t y1, int32_t x2, int32_t y2, int32_t nLines);
868void vexDisplayCopyRect(
869 int32_t x1, int32_t y1, int32_t x2, int32_t y2, uint32_t* pSrc, int32_t srcStride
870);
871void vexDisplayPixelSet(uint32_t x, uint32_t y);
872void vexDisplayPixelClear(uint32_t x, uint32_t y);
873void vexDisplayLineDraw(int32_t x1, int32_t y1, int32_t x2, int32_t y2);
874void vexDisplayLineClear(int32_t x1, int32_t y1, int32_t x2, int32_t y2);
875void vexDisplayRectDraw(int32_t x1, int32_t y1, int32_t x2, int32_t y2);
876void vexDisplayRectClear(int32_t x1, int32_t y1, int32_t x2, int32_t y2);
877void vexDisplayRectFill(int32_t x1, int32_t y1, int32_t x2, int32_t y2);
878void vexDisplayCircleDraw(int32_t xc, int32_t yc, int32_t radius);
879void vexDisplayCircleClear(int32_t xc, int32_t yc, int32_t radius);
880void vexDisplayCircleFill(int32_t xc, int32_t yc, int32_t radius);
881
882// Formatted text.
883void vexDisplayPrintf(int32_t xpos, int32_t ypos, uint32_t bOpaque, const char* format, ...);
884void vexDisplayString(const int32_t nLineNumber, const char* format, ...);
885void vexDisplayStringAt(int32_t xpos, int32_t ypos, const char* format, ...);
886void vexDisplayBigString(const int32_t nLineNumber, const char* format, ...);
887void vexDisplayBigStringAt(int32_t xpos, int32_t ypos, const char* format, ...);
888void vexDisplaySmallStringAt(int32_t xpos, int32_t ypos, const char* format, ...);
889void vexDisplayCenteredString(const int32_t nLineNumber, const char* format, ...);
890void vexDisplayBigCenteredString(const int32_t nLineNumber, const char* format, ...);
891
892// Text formatting with va_list arguments.
893void vexDisplayVPrintf(
894 int32_t xpos, int32_t ypos, uint32_t bOpaque, const char* format, va_list args
895);
896void vexDisplayVString(const int32_t nLineNumber, const char* format, va_list args);
897void vexDisplayVStringAt(int32_t xpos, int32_t ypos, const char* format, va_list args);
898void vexDisplayVBigString(const int32_t nLineNumber, const char* format, va_list args);
899void vexDisplayVBigStringAt(int32_t xpos, int32_t ypos, const char* format, va_list args);
900void vexDisplayVSmallStringAt(int32_t xpos, int32_t ypos, const char* format, va_list args);
901void vexDisplayVCenteredString(const int32_t nLineNumber, const char* format, va_list args);
902void vexDisplayVBigCenteredString(const int32_t nLineNumber, const char* format, va_list args);
903
904// Font settings and text measurements.
905void vexDisplayTextSize(uint32_t n, uint32_t d);
906void vexDisplayFontNamedSet(const char* pFontName);
907int32_t vexDisplayStringWidthGet(const char* pString);
908int32_t vexDisplayStringHeightGet(const char* pString);
909
910// Frame rendering and buffering.
911bool vexDisplayRender(bool bVsyncWait, bool bRunScheduler);
912void vexDisplayDoubleBufferDisable(void);
913
914// Drawing bounds.
915void vexDisplayClipRegionSet(int32_t x1, int32_t y1, int32_t x2, int32_t y2);
916void vexDisplayClipRegionClear();
917
918// Decode images into the supplied buffer.
919uint32_t vexImageBmpRead(const uint8_t* ibuf, v5_image* oBuf, uint32_t maxw, uint32_t maxh);
920uint32_t vexImagePngRead(
921 const uint8_t* ibuf, v5_image* oBuf, uint32_t maxw, uint32_t maxh, uint32_t ibuflen
922);
923
924// Touchscreen
925
926typedef enum _touchEvent {
927 kTouchEventRelease,
928 kTouchEventPress,
929 kTouchEventPressAuto
930} V5_TouchEvent;
931
932typedef struct _V5_TouchStatus {
933 V5_TouchEvent lastEvent;
934 int16_t lastXpos;
935 int16_t lastYpos;
936 int32_t pressCount;
937 int32_t releaseCount;
938} V5_TouchStatus;
939
940void vexTouchUserCallbackSet(void (*callback)(V5_TouchEvent, int32_t, int32_t));
941bool vexTouchDataGet(V5_TouchStatus* status);
942
943// SD card files
944
945// Opaque file handle; accessed through FIL*.
946typedef void FIL;
947
948#define FS_SEEK_SET 0
949#define FS_SEEK_CUR 1
950#define FS_SEEK_END 2
951
952#define FS_FILE_EXIST 1
953#define FS_FILE_DIR 2
954
955typedef enum {
956 FR_OK = 0U,
957 FR_DISK_ERR, // Low-level disk I/O failed.
958 FR_INT_ERR, // Internal assertion failed.
959 FR_NOT_READY,
960 FR_NO_FILE,
961 FR_NO_PATH,
962 FR_INVALID_NAME,
963 FR_DENIED, // Access denied or directory full.
964 FR_EXIST, // Access prohibited.
965 FR_INVALID_OBJECT,
966 FR_WRITE_PROTECTED,
967 FR_INVALID_DRIVE,
968 FR_NOT_ENABLED, // Volume work area missing.
969 FR_NO_FILESYSTEM,
970 FR_MKFS_ABORTED, // Formatting rejected a parameter.
971 FR_TIMEOUT,
972 FR_LOCKED, // Blocked by file sharing rules.
973 FR_NOT_ENOUGH_CORE, // Long filename buffer allocation failed.
974 FR_TOO_MANY_OPEN_FILES,
975 FR_INVALID_PARAMETER
976} FRESULT;
977
978FRESULT vexFileMountSD(void);
979FRESULT vexFileDirectoryGet(const char* path, char* buffer, uint32_t len);
980FIL* vexFileOpen(const char* filename, const char* mode);
981FIL* vexFileOpenWrite(const char* filename);
982FIL* vexFileOpenCreate(const char* filename);
983void vexFileClose(FIL* fdp);
984int32_t vexFileRead(char* buf, uint32_t size, uint32_t nItems, FIL* fdp);
985int32_t vexFileWrite(char* buf, uint32_t size, uint32_t nItems, FIL* fdp);
986int32_t vexFileSize(FIL* fdp);
987FRESULT vexFileSeek(FIL* fdp, uint32_t offset, int32_t whence);
988bool vexFileDriveStatus(uint32_t drive);
989int32_t vexFileTell(FIL* fdp);
990void vexFileSync(FIL* fdp);
991uint32_t vexFileStatus(const char* filename);
992
993// Shared scratch memory
994
995int32_t vexScratchMemoryPtr(void** ptr);
996bool vexScratchMemoryLock(void);
997void vexScratchMemoryUnlock(void);
998
999// RTOS integration
1000
1001void vexSystemTimerStop();
1002void vexSystemTimerClearInterrupt();
1003int32_t vexSystemTimerReinitForRtos(uint32_t priority, void (*handler)(void* data));
1004void vexSystemApplicationIRQHandler(uint32_t ulICCIAR);
1005int32_t vexSystemWatchdogReinitRtos(void);
1006uint32_t vexSystemWatchdogGet(void);
1007
1008// Boot and interrupt handlers
1009
1010void vexSystemBoot(void);
1011void vexSystemUndefinedException(void);
1012void vexSystemFIQInterrupt(void);
1013void vexSystemIRQInterrupt(void);
1014void vexSystemSWInterrupt(void);
1015void vexSystemDataAbortInterrupt(void);
1016void vexSystemPrefetchAbortInterrupt(void);
1017
1018#ifdef __cplusplus
1019}
1020#endif
units
Definition units.h:12
_V5_DeviceArmTipPosition
Definition v5rt.h:772
_V5_DeviceOpticalGesture
Definition v5rt.h:459
_V5_DeviceOpticalRaw
Definition v5rt.h:445
_V5_DeviceOpticalRgb
Definition v5rt.h:452
_V5_DevicePneumaticCtrl
Definition v5rt.h:728
_V5_TouchStatus
Definition v5rt.h:932
date
Definition v5rt.h:53
time
Definition v5rt.h:46