vexide 0.8.0

Open-source Rust runtime for VEX robots.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

//! # vexide
//!
//! Open-source Rust runtime for VEX V5 robots. vexide provides a runtime, async executor, hardware
//! APIs, and more for the VEX V5 Brain!
//!
//! ## Getting Started
//!
//! To start using vexide, we recommend going through our [docs](https://vexide.dev/docs/), which
//! contain step-by-step instructions for setting up a development environment using
//! [vexide-template](https://github.com/vexide/vexide-template) and tutorials for many of vexide's
//! common features.
//!
//! # Usage
//!
//! To to get a program running, use the `#[vexide::main]` attribute on your main function.
//!
//! ```
//! use vexide::prelude::*;
//!
//! #[vexide::main]
//! async fn main(_peripherals: Peripherals) {
//!     println!("Hello, world!");
//! }
//! ```
//!
//! Check out our [examples](https://github.com/vexide/vexide/tree/main/examples/) for more examples
//! of different features.

#![cfg_attr(docsrs, feature(doc_cfg))]
#![doc(html_logo_url = "https://vexide.dev/images/logo.svg")]

/// Async runtime and executor.
#[cfg(feature = "async")]
pub mod runtime {
    #[doc(inline)]
    pub use vexide_async::block_on;
}

#[doc(inline)]
#[cfg(feature = "sync")]
pub use vexide_async::sync;
#[doc(inline)]
#[cfg(feature = "async")]
pub use vexide_async::task;

/// Utilities for tracking time.
///
/// This module provides types for measuring time and executing code after a set periods of time.
///
/// - [`Sleep`] is a future that does no work and completes at a specific [`Instant`] in time.
///
/// - [`sleep`] and [`sleep_until`] provide ways to yield control away from a future for or until a
///   specific instant in time.
///
/// [`Instant`]: std::time::Instant
/// [`sleep`]: vexide_async::time::sleep
/// [`sleep_until`]: vexide_async::time::sleep_until
#[cfg(any(feature = "core", feature = "async"))]
pub mod time {
    #[doc(inline)]
    #[cfg(feature = "async")]
    pub use vexide_async::time::*;
    #[doc(inline)]
    #[cfg(feature = "core")]
    pub use vexide_core::time::*;
}

#[doc(inline)]
#[cfg(feature = "backtrace")]
pub use vexide_core::backtrace;
#[doc(inline)]
#[cfg(feature = "core")]
pub use vexide_core::{competition, os, program};
#[doc(inline)]
#[cfg(feature = "devices")]
pub use vexide_devices::{adi, battery, color, controller, display, math, peripherals, smart};
#[doc(inline)]
#[cfg(all(
    feature = "macros",
    feature = "core",
    feature = "async",
    feature = "startup",
    feature = "devices"
))]
pub use vexide_macro::{main, test};
#[cfg(all(
    feature = "macros",
    not(all(
        feature = "core",
        feature = "async",
        feature = "startup",
        feature = "devices"
    ))
))]
pub use vexide_macro::{main_fail as main, test_fail as test};
#[doc(inline)]
#[cfg(feature = "startup")]
pub use vexide_startup as startup;
#[doc(inline)]
#[cfg(feature = "allocator")]
pub use vexide_startup::allocator;

/// Commonly used features of vexide.
///
/// This module is meant to be glob imported.
pub mod prelude {
    #[cfg(feature = "core")]
    pub use crate::competition::{Compete, CompeteExt};
    #[cfg(feature = "devices")]
    pub use crate::{
        adi::{
            AdiDevice,
            accelerometer::{AdiAccelerometer, Sensitivity},
            addrled::AdiAddrLed,
            analog::AdiAnalogIn,
            digital::{AdiDigitalIn, AdiDigitalOut},
            encoder::{AdiEncoder, AdiOpticalEncoder},
            gyroscope::AdiGyroscope,
            light_sensor::AdiLightSensor,
            line_tracker::AdiLineTracker,
            motor::AdiMotor,
            potentiometer::{AdiPotentiometer, PotentiometerType},
            pwm::AdiPwmOut,
            range_finder::AdiRangeFinder,
            servo::AdiServo,
        },
        controller::Controller,
        display::Display,
        math::Direction,
        peripherals::Peripherals,
        smart::{
            SmartDevice,
            ai_vision::AiVisionSensor,
            distance::DistanceSensor,
            electromagnet::Electromagnet,
            expander::AdiExpander,
            gps::GpsSensor,
            imu::InertialSensor,
            link::{LinkType, RadioLink},
            motor::{Gearset, Motor},
            optical::OpticalSensor,
            rotation::RotationSensor,
            serial::SerialPort,
            vision::VisionSensor,
        },
    };
    #[cfg(feature = "async")]
    pub use crate::{
        runtime::block_on,
        task::{spawn, task_local},
        time::{sleep, sleep_until},
    };
}