Struct ServoChannel

Source

pub struct ServoChannel {
    pub id: usize,
    pub name: String,
    pub angle: f32,
    pub spec: ServoSpec,
}

Expand description

Represents a single servo channel

Fields§

§id: usize§name: String§angle: f32§spec: ServoSpec

Implementations§

Source §

impl ServoChannel

Source

pub fn new(id: usize, name: &str, spec: ServoSpec) -> Self

Examples found in repository ?

examples/egui_demo_smooth.rs (line 16)

14    fn new() -> Self {
15        Self {
16            servo: ServoChannel::new(0, "servo1", ServoSpec::mg996r()),
17            target_angle: 90.0,
18            speed: 30.0, // deg/sec
19            last_update: std::time::Instant::now(),
20            input_angle: String::new(),
21            input_speed: String::new(),
22        }
23    }

More examples

Hide additional examples

examples/egui_demo.rs (line 11)

9    fn default() -> Self {
10        let mut system = ServoSystem::new();
11        system.add_channel(ServoChannel::new(0, "Base", ServoSpec::mg996r()));
12        system.add_channel(ServoChannel::new(1, "Shoulder", ServoSpec::mg996r()));
13        system.add_channel(ServoChannel::new(2, "Elbow", ServoSpec::mg996r()));
14        system.add_channel(ServoChannel::new(3, "Wrist UD", ServoSpec::mg996r()));
15        system.add_channel(ServoChannel::new(4, "Wrist LR", ServoSpec::mg996r()));
16        system.add_channel(ServoChannel::new(5, "Gripper", ServoSpec::mg996r()));
17        Self { system }
18    }

examples/basic.rs (line 11)

3fn main() {
4        println!("\n");
5        println!("--- Servo Controller Basic Example ---");
6
7        // MG996R spec create
8        let spec = ServoSpec::mg996r();
9
10        // MG996R 6 channels robot arms example
11        let mut servo0 = ServoChannel::new(0, "base", spec.clone());
12        let mut servo1 = ServoChannel::new(1, "shoulder", spec.clone());
13        let mut servo2 = ServoChannel::new(2, "elbow", spec.clone());
14        let mut servo3 = ServoChannel::new(3, "wrist_pitch", spec.clone());
15        let mut servo4 = ServoChannel::new(4, "wrist_roll", spec.clone());
16        let mut servo5 = ServoChannel::new(5, "gripper", spec.clone());
17
18        // angle init
19        servo0.set_angle(90.0);
20        servo1.set_angle(90.0);
21        servo2.set_angle(90.0);
22        servo3.set_angle(90.0);
23        servo4.set_angle(90.0);
24        servo5.set_angle(90.0);
25
26        println!(
27                "{}: angle {:.1}° → pulse {}",
28                servo0.name,
29                servo0.angle,
30                servo0.get_pulse()
31        );
32        println!(
33                "{}: angle {:.1}° → pulse {}",
34                servo1.name,
35                servo1.angle,
36                servo1.get_pulse()
37        );
38        println!(
39                "{}: angle {:.1}° → pulse {}",
40                servo2.name,
41                servo2.angle,
42                servo2.get_pulse()
43        );
44        println!(
45                "{}: angle {:.1}° → pulse {}",
46                servo3.name,
47                servo3.angle,
48                servo3.get_pulse()
49        );
50        println!(
51                "{}: angle {:.1}° → pulse {}",
52                servo4.name,
53                servo4.angle,
54                servo4.get_pulse()
55        );
56        println!(
57                "{}: angle {:.1}° → pulse {}",
58                servo5.name,
59                servo5.angle,
60                servo5.get_pulse()
61        );
62
63        // pulse -> angle convert test
64        servo0.set_pulse(350);
65        println!(
66                "{}: pulse {} → angle {:.1}°",
67                servo0.name,
68                servo0.get_pulse(),
69                servo0.angle
70        );
71        servo1.set_pulse(400);
72        println!(
73                "{}: pulse {} → angle {:.1}°",
74                servo1.name,
75                servo1.get_pulse(),
76                servo1.angle
77        );
78        servo2.set_pulse(450);
79        println!(
80                "{}: pulse {} → angle {:.1}°",
81                servo2.name,
82                servo2.get_pulse(),
83                servo2.angle
84        );
85        servo3.set_pulse(500);
86        println!(
87                "{}: pulse {} → angle {:.1}°",
88                servo3.name,
89                servo3.get_pulse(),
90                servo3.angle
91        );
92        servo4.set_pulse(550);
93        println!(
94                "{}: pulse {} → angle {:.1}°",
95                servo4.name,
96                servo4.get_pulse(),
97                servo4.angle
98        );
99        servo5.set_pulse(600);
100        println!(
101                "{}: pulse {} → angle {:.1}°",
102                servo5.name,
103                servo5.get_pulse(),
104                servo5.angle
105        );
106
107        println!("\n");
108        // increment / decrement
109        servo0.increment(10.0);
110        println!("{} incremented → {:.1}°", servo1.name, servo1.angle);
111
112        servo1.decrement(30.0);
113        println!("{} decremented → {:.1}°", servo1.name, servo1.angle);
114
115        servo2.increment(20.0);
116        println!("{} incremented → {:.1}°", servo2.name, servo2.angle);
117
118        servo3.decrement(40.0);
119        println!("{} decremented → {:.1}°", servo2.name, servo2.angle);
120
121        servo4.increment(20.0);
122        println!("{} incremented → {:.1}°", servo4.name, servo4.angle);
123        
124        servo5.decrement(15.0);
125        println!("{} decremented → {:.1}°", servo5.name, servo5.angle);
126
127        // ServoSystem Add channels
128        let mut system = ServoSystem::new();
129        system.add_channel(servo0);
130        system.add_channel(servo1);
131
132        println!("\n--- ServoSystem status ---");
133        for servo in &system.channels {
134                println!(
135                "Channel {} ({}): angle {:.1}° → pulse {}",
136                servo.id,
137                servo.name,
138                servo.angle,
139                servo.get_pulse()
140                );
141        }
142
143        // get_channel_mut 예제
144        if let Some(shoulder) = system.get_channel_mut(1) {
145                shoulder.set_angle(120.0);
146                println!(
147                "\nafter update {}: angle {:.1}° → pulse {}",
148                shoulder.name,
149                shoulder.angle,
150                shoulder.get_pulse()
151                );
152        }
153}

Source

pub fn set_angle(&mut self, angle: f32)

Examples found in repository ?

examples/egui_demo.rs (line 38)

22    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
23        egui::CentralPanel::default().show(ctx, |ui| {
24            ui.heading("Servo Simulator Demo (egui 0.32.3)");
25
26            for servo in &mut self.system.channels {
27                ui.group(|ui| {
28                    ui.label(format!("Channel {}: {}", servo.id, servo.name));
29
30                    let mut angle = servo.angle;
31                    if ui
32                        .add(egui::Slider::new(
33                            &mut angle,
34                            servo.spec.min_angle..=servo.spec.max_angle,
35                        ))
36                        .changed()
37                    {
38                        servo.set_angle(angle);
39                    }
40
41                    ui.label(format!(
42                        "Angle: {:.1}° → Pulse: {}",
43                        servo.angle,
44                        servo.get_pulse()
45                    ));
46
47                    // === 시각화 ===
48                    let (rect, _) =
49                        ui.allocate_exact_size(egui::vec2(100.0, 100.0), egui::Sense::hover());
50
51                    let center = rect.center();
52                    let radius = 40.0;
53                    let angle_rad = servo.angle.to_radians();
54
55                    let end = egui::pos2(
56                        center.x + radius * angle_rad.cos(),
57                        center.y - radius * angle_rad.sin(),
58                    );
59
60                    let line = egui::Shape::line_segment(
61                        [center, end],
62                        egui::Stroke::new(2.0, egui::Color32::LIGHT_BLUE),
63                    );
64
65                    ui.painter().add(line);
66                    ui.painter()
67                        .circle_stroke(center, radius, egui::Stroke::new(1.0, egui::Color32::GRAY));
68                });
69            }
70        });
71    }

More examples

Hide additional examples

examples/egui_demo_smooth.rs (line 34)

27    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
28        let now = std::time::Instant::now();
29        let delta = now.duration_since(self.last_update).as_secs_f32();
30        self.last_update = now;
31
32        // smmooth move
33        let new_angle = ServoChannel::smooth_move(self.servo.angle, self.target_angle, self.speed, delta);
34        self.servo.set_angle(new_angle);
35
36        egui::CentralPanel::default().show(ctx, |ui| {
37            ui.heading("Servo Smooth Move Demo");
38
39            ui.label(format!("Current Angle: {:.2}°", self.servo.angle));
40            ui.label(format!("Target Angle: {:.2}°", self.target_angle));
41            ui.label(format!("Speed: {:.2} deg/s", self.speed));
42
43            ui.horizontal(|ui| {
44                ui.label("Target Angle (0 ~ 180): ");
45                ui.text_edit_singleline(&mut self.input_angle);
46            });
47
48            ui.horizontal(|ui| {
49                ui.label("Speed (deg/s): ");
50                ui.text_edit_singleline(&mut self.input_speed);
51            });
52
53            if ui.button("Set").clicked() {
54                if let Ok(angle) = self.input_angle.parse::<f32>() {
55                    self.target_angle = angle.clamp(0.0, 180.0);
56                }
57                if let Ok(speed) = self.input_speed.parse::<f32>() {
58                    self.speed = speed.max(1.0); // minimum speed guarantee
59                }
60                self.input_angle.clear();
61                self.input_speed.clear();
62            }
63
64            // Visualization
65            let (rect, _) = ui.allocate_exact_size(egui::vec2(200.0, 200.0), egui::Sense::hover());
66            let center = rect.center();
67            let radius = 80.0;
68
69            let angle_rad = self.servo.angle.to_radians();
70            let x = center.x + radius * angle_rad.cos();
71            let y = center.y - radius * angle_rad.sin();
72
73            let painter = ui.painter();
74            painter.circle_stroke(center, radius, (2.0, egui::Color32::LIGHT_BLUE));
75            painter.line_segment(
76                [center, egui::pos2(x, y)],
77                (3.0, egui::Color32::RED),
78            );
79        });
80
81        ctx.request_repaint();
82    }

examples/basic.rs (line 19)

3fn main() {
4        println!("\n");
5        println!("--- Servo Controller Basic Example ---");
6
7        // MG996R spec create
8        let spec = ServoSpec::mg996r();
9
10        // MG996R 6 channels robot arms example
11        let mut servo0 = ServoChannel::new(0, "base", spec.clone());
12        let mut servo1 = ServoChannel::new(1, "shoulder", spec.clone());
13        let mut servo2 = ServoChannel::new(2, "elbow", spec.clone());
14        let mut servo3 = ServoChannel::new(3, "wrist_pitch", spec.clone());
15        let mut servo4 = ServoChannel::new(4, "wrist_roll", spec.clone());
16        let mut servo5 = ServoChannel::new(5, "gripper", spec.clone());
17
18        // angle init
19        servo0.set_angle(90.0);
20        servo1.set_angle(90.0);
21        servo2.set_angle(90.0);
22        servo3.set_angle(90.0);
23        servo4.set_angle(90.0);
24        servo5.set_angle(90.0);
25
26        println!(
27                "{}: angle {:.1}° → pulse {}",
28                servo0.name,
29                servo0.angle,
30                servo0.get_pulse()
31        );
32        println!(
33                "{}: angle {:.1}° → pulse {}",
34                servo1.name,
35                servo1.angle,
36                servo1.get_pulse()
37        );
38        println!(
39                "{}: angle {:.1}° → pulse {}",
40                servo2.name,
41                servo2.angle,
42                servo2.get_pulse()
43        );
44        println!(
45                "{}: angle {:.1}° → pulse {}",
46                servo3.name,
47                servo3.angle,
48                servo3.get_pulse()
49        );
50        println!(
51                "{}: angle {:.1}° → pulse {}",
52                servo4.name,
53                servo4.angle,
54                servo4.get_pulse()
55        );
56        println!(
57                "{}: angle {:.1}° → pulse {}",
58                servo5.name,
59                servo5.angle,
60                servo5.get_pulse()
61        );
62
63        // pulse -> angle convert test
64        servo0.set_pulse(350);
65        println!(
66                "{}: pulse {} → angle {:.1}°",
67                servo0.name,
68                servo0.get_pulse(),
69                servo0.angle
70        );
71        servo1.set_pulse(400);
72        println!(
73                "{}: pulse {} → angle {:.1}°",
74                servo1.name,
75                servo1.get_pulse(),
76                servo1.angle
77        );
78        servo2.set_pulse(450);
79        println!(
80                "{}: pulse {} → angle {:.1}°",
81                servo2.name,
82                servo2.get_pulse(),
83                servo2.angle
84        );
85        servo3.set_pulse(500);
86        println!(
87                "{}: pulse {} → angle {:.1}°",
88                servo3.name,
89                servo3.get_pulse(),
90                servo3.angle
91        );
92        servo4.set_pulse(550);
93        println!(
94                "{}: pulse {} → angle {:.1}°",
95                servo4.name,
96                servo4.get_pulse(),
97                servo4.angle
98        );
99        servo5.set_pulse(600);
100        println!(
101                "{}: pulse {} → angle {:.1}°",
102                servo5.name,
103                servo5.get_pulse(),
104                servo5.angle
105        );
106
107        println!("\n");
108        // increment / decrement
109        servo0.increment(10.0);
110        println!("{} incremented → {:.1}°", servo1.name, servo1.angle);
111
112        servo1.decrement(30.0);
113        println!("{} decremented → {:.1}°", servo1.name, servo1.angle);
114
115        servo2.increment(20.0);
116        println!("{} incremented → {:.1}°", servo2.name, servo2.angle);
117
118        servo3.decrement(40.0);
119        println!("{} decremented → {:.1}°", servo2.name, servo2.angle);
120
121        servo4.increment(20.0);
122        println!("{} incremented → {:.1}°", servo4.name, servo4.angle);
123        
124        servo5.decrement(15.0);
125        println!("{} decremented → {:.1}°", servo5.name, servo5.angle);
126
127        // ServoSystem Add channels
128        let mut system = ServoSystem::new();
129        system.add_channel(servo0);
130        system.add_channel(servo1);
131
132        println!("\n--- ServoSystem status ---");
133        for servo in &system.channels {
134                println!(
135                "Channel {} ({}): angle {:.1}° → pulse {}",
136                servo.id,
137                servo.name,
138                servo.angle,
139                servo.get_pulse()
140                );
141        }
142
143        // get_channel_mut 예제
144        if let Some(shoulder) = system.get_channel_mut(1) {
145                shoulder.set_angle(120.0);
146                println!(
147                "\nafter update {}: angle {:.1}° → pulse {}",
148                shoulder.name,
149                shoulder.angle,
150                shoulder.get_pulse()
151                );
152        }
153}

Source

pub fn increment(&mut self, delta: f32)

Examples found in repository ?

examples/basic.rs (line 109)

3fn main() {
4        println!("\n");
5        println!("--- Servo Controller Basic Example ---");
6
7        // MG996R spec create
8        let spec = ServoSpec::mg996r();
9
10        // MG996R 6 channels robot arms example
11        let mut servo0 = ServoChannel::new(0, "base", spec.clone());
12        let mut servo1 = ServoChannel::new(1, "shoulder", spec.clone());
13        let mut servo2 = ServoChannel::new(2, "elbow", spec.clone());
14        let mut servo3 = ServoChannel::new(3, "wrist_pitch", spec.clone());
15        let mut servo4 = ServoChannel::new(4, "wrist_roll", spec.clone());
16        let mut servo5 = ServoChannel::new(5, "gripper", spec.clone());
17
18        // angle init
19        servo0.set_angle(90.0);
20        servo1.set_angle(90.0);
21        servo2.set_angle(90.0);
22        servo3.set_angle(90.0);
23        servo4.set_angle(90.0);
24        servo5.set_angle(90.0);
25
26        println!(
27                "{}: angle {:.1}° → pulse {}",
28                servo0.name,
29                servo0.angle,
30                servo0.get_pulse()
31        );
32        println!(
33                "{}: angle {:.1}° → pulse {}",
34                servo1.name,
35                servo1.angle,
36                servo1.get_pulse()
37        );
38        println!(
39                "{}: angle {:.1}° → pulse {}",
40                servo2.name,
41                servo2.angle,
42                servo2.get_pulse()
43        );
44        println!(
45                "{}: angle {:.1}° → pulse {}",
46                servo3.name,
47                servo3.angle,
48                servo3.get_pulse()
49        );
50        println!(
51                "{}: angle {:.1}° → pulse {}",
52                servo4.name,
53                servo4.angle,
54                servo4.get_pulse()
55        );
56        println!(
57                "{}: angle {:.1}° → pulse {}",
58                servo5.name,
59                servo5.angle,
60                servo5.get_pulse()
61        );
62
63        // pulse -> angle convert test
64        servo0.set_pulse(350);
65        println!(
66                "{}: pulse {} → angle {:.1}°",
67                servo0.name,
68                servo0.get_pulse(),
69                servo0.angle
70        );
71        servo1.set_pulse(400);
72        println!(
73                "{}: pulse {} → angle {:.1}°",
74                servo1.name,
75                servo1.get_pulse(),
76                servo1.angle
77        );
78        servo2.set_pulse(450);
79        println!(
80                "{}: pulse {} → angle {:.1}°",
81                servo2.name,
82                servo2.get_pulse(),
83                servo2.angle
84        );
85        servo3.set_pulse(500);
86        println!(
87                "{}: pulse {} → angle {:.1}°",
88                servo3.name,
89                servo3.get_pulse(),
90                servo3.angle
91        );
92        servo4.set_pulse(550);
93        println!(
94                "{}: pulse {} → angle {:.1}°",
95                servo4.name,
96                servo4.get_pulse(),
97                servo4.angle
98        );
99        servo5.set_pulse(600);
100        println!(
101                "{}: pulse {} → angle {:.1}°",
102                servo5.name,
103                servo5.get_pulse(),
104                servo5.angle
105        );
106
107        println!("\n");
108        // increment / decrement
109        servo0.increment(10.0);
110        println!("{} incremented → {:.1}°", servo1.name, servo1.angle);
111
112        servo1.decrement(30.0);
113        println!("{} decremented → {:.1}°", servo1.name, servo1.angle);
114
115        servo2.increment(20.0);
116        println!("{} incremented → {:.1}°", servo2.name, servo2.angle);
117
118        servo3.decrement(40.0);
119        println!("{} decremented → {:.1}°", servo2.name, servo2.angle);
120
121        servo4.increment(20.0);
122        println!("{} incremented → {:.1}°", servo4.name, servo4.angle);
123        
124        servo5.decrement(15.0);
125        println!("{} decremented → {:.1}°", servo5.name, servo5.angle);
126
127        // ServoSystem Add channels
128        let mut system = ServoSystem::new();
129        system.add_channel(servo0);
130        system.add_channel(servo1);
131
132        println!("\n--- ServoSystem status ---");
133        for servo in &system.channels {
134                println!(
135                "Channel {} ({}): angle {:.1}° → pulse {}",
136                servo.id,
137                servo.name,
138                servo.angle,
139                servo.get_pulse()
140                );
141        }
142
143        // get_channel_mut 예제
144        if let Some(shoulder) = system.get_channel_mut(1) {
145                shoulder.set_angle(120.0);
146                println!(
147                "\nafter update {}: angle {:.1}° → pulse {}",
148                shoulder.name,
149                shoulder.angle,
150                shoulder.get_pulse()
151                );
152        }
153}

Source

pub fn decrement(&mut self, delta: f32)

Examples found in repository ?

examples/basic.rs (line 112)

3fn main() {
4        println!("\n");
5        println!("--- Servo Controller Basic Example ---");
6
7        // MG996R spec create
8        let spec = ServoSpec::mg996r();
9
10        // MG996R 6 channels robot arms example
11        let mut servo0 = ServoChannel::new(0, "base", spec.clone());
12        let mut servo1 = ServoChannel::new(1, "shoulder", spec.clone());
13        let mut servo2 = ServoChannel::new(2, "elbow", spec.clone());
14        let mut servo3 = ServoChannel::new(3, "wrist_pitch", spec.clone());
15        let mut servo4 = ServoChannel::new(4, "wrist_roll", spec.clone());
16        let mut servo5 = ServoChannel::new(5, "gripper", spec.clone());
17
18        // angle init
19        servo0.set_angle(90.0);
20        servo1.set_angle(90.0);
21        servo2.set_angle(90.0);
22        servo3.set_angle(90.0);
23        servo4.set_angle(90.0);
24        servo5.set_angle(90.0);
25
26        println!(
27                "{}: angle {:.1}° → pulse {}",
28                servo0.name,
29                servo0.angle,
30                servo0.get_pulse()
31        );
32        println!(
33                "{}: angle {:.1}° → pulse {}",
34                servo1.name,
35                servo1.angle,
36                servo1.get_pulse()
37        );
38        println!(
39                "{}: angle {:.1}° → pulse {}",
40                servo2.name,
41                servo2.angle,
42                servo2.get_pulse()
43        );
44        println!(
45                "{}: angle {:.1}° → pulse {}",
46                servo3.name,
47                servo3.angle,
48                servo3.get_pulse()
49        );
50        println!(
51                "{}: angle {:.1}° → pulse {}",
52                servo4.name,
53                servo4.angle,
54                servo4.get_pulse()
55        );
56        println!(
57                "{}: angle {:.1}° → pulse {}",
58                servo5.name,
59                servo5.angle,
60                servo5.get_pulse()
61        );
62
63        // pulse -> angle convert test
64        servo0.set_pulse(350);
65        println!(
66                "{}: pulse {} → angle {:.1}°",
67                servo0.name,
68                servo0.get_pulse(),
69                servo0.angle
70        );
71        servo1.set_pulse(400);
72        println!(
73                "{}: pulse {} → angle {:.1}°",
74                servo1.name,
75                servo1.get_pulse(),
76                servo1.angle
77        );
78        servo2.set_pulse(450);
79        println!(
80                "{}: pulse {} → angle {:.1}°",
81                servo2.name,
82                servo2.get_pulse(),
83                servo2.angle
84        );
85        servo3.set_pulse(500);
86        println!(
87                "{}: pulse {} → angle {:.1}°",
88                servo3.name,
89                servo3.get_pulse(),
90                servo3.angle
91        );
92        servo4.set_pulse(550);
93        println!(
94                "{}: pulse {} → angle {:.1}°",
95                servo4.name,
96                servo4.get_pulse(),
97                servo4.angle
98        );
99        servo5.set_pulse(600);
100        println!(
101                "{}: pulse {} → angle {:.1}°",
102                servo5.name,
103                servo5.get_pulse(),
104                servo5.angle
105        );
106
107        println!("\n");
108        // increment / decrement
109        servo0.increment(10.0);
110        println!("{} incremented → {:.1}°", servo1.name, servo1.angle);
111
112        servo1.decrement(30.0);
113        println!("{} decremented → {:.1}°", servo1.name, servo1.angle);
114
115        servo2.increment(20.0);
116        println!("{} incremented → {:.1}°", servo2.name, servo2.angle);
117
118        servo3.decrement(40.0);
119        println!("{} decremented → {:.1}°", servo2.name, servo2.angle);
120
121        servo4.increment(20.0);
122        println!("{} incremented → {:.1}°", servo4.name, servo4.angle);
123        
124        servo5.decrement(15.0);
125        println!("{} decremented → {:.1}°", servo5.name, servo5.angle);
126
127        // ServoSystem Add channels
128        let mut system = ServoSystem::new();
129        system.add_channel(servo0);
130        system.add_channel(servo1);
131
132        println!("\n--- ServoSystem status ---");
133        for servo in &system.channels {
134                println!(
135                "Channel {} ({}): angle {:.1}° → pulse {}",
136                servo.id,
137                servo.name,
138                servo.angle,
139                servo.get_pulse()
140                );
141        }
142
143        // get_channel_mut 예제
144        if let Some(shoulder) = system.get_channel_mut(1) {
145                shoulder.set_angle(120.0);
146                println!(
147                "\nafter update {}: angle {:.1}° → pulse {}",
148                shoulder.name,
149                shoulder.angle,
150                shoulder.get_pulse()
151                );
152        }
153}

Source

pub fn get_pulse(&self) -> u32

Examples found in repository ?

examples/egui_demo.rs (line 44)

22    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
23        egui::CentralPanel::default().show(ctx, |ui| {
24            ui.heading("Servo Simulator Demo (egui 0.32.3)");
25
26            for servo in &mut self.system.channels {
27                ui.group(|ui| {
28                    ui.label(format!("Channel {}: {}", servo.id, servo.name));
29
30                    let mut angle = servo.angle;
31                    if ui
32                        .add(egui::Slider::new(
33                            &mut angle,
34                            servo.spec.min_angle..=servo.spec.max_angle,
35                        ))
36                        .changed()
37                    {
38                        servo.set_angle(angle);
39                    }
40
41                    ui.label(format!(
42                        "Angle: {:.1}° → Pulse: {}",
43                        servo.angle,
44                        servo.get_pulse()
45                    ));
46
47                    // === 시각화 ===
48                    let (rect, _) =
49                        ui.allocate_exact_size(egui::vec2(100.0, 100.0), egui::Sense::hover());
50
51                    let center = rect.center();
52                    let radius = 40.0;
53                    let angle_rad = servo.angle.to_radians();
54
55                    let end = egui::pos2(
56                        center.x + radius * angle_rad.cos(),
57                        center.y - radius * angle_rad.sin(),
58                    );
59
60                    let line = egui::Shape::line_segment(
61                        [center, end],
62                        egui::Stroke::new(2.0, egui::Color32::LIGHT_BLUE),
63                    );
64
65                    ui.painter().add(line);
66                    ui.painter()
67                        .circle_stroke(center, radius, egui::Stroke::new(1.0, egui::Color32::GRAY));
68                });
69            }
70        });
71    }

More examples

Hide additional examples

examples/basic.rs (line 30)

3fn main() {
4        println!("\n");
5        println!("--- Servo Controller Basic Example ---");
6
7        // MG996R spec create
8        let spec = ServoSpec::mg996r();
9
10        // MG996R 6 channels robot arms example
11        let mut servo0 = ServoChannel::new(0, "base", spec.clone());
12        let mut servo1 = ServoChannel::new(1, "shoulder", spec.clone());
13        let mut servo2 = ServoChannel::new(2, "elbow", spec.clone());
14        let mut servo3 = ServoChannel::new(3, "wrist_pitch", spec.clone());
15        let mut servo4 = ServoChannel::new(4, "wrist_roll", spec.clone());
16        let mut servo5 = ServoChannel::new(5, "gripper", spec.clone());
17
18        // angle init
19        servo0.set_angle(90.0);
20        servo1.set_angle(90.0);
21        servo2.set_angle(90.0);
22        servo3.set_angle(90.0);
23        servo4.set_angle(90.0);
24        servo5.set_angle(90.0);
25
26        println!(
27                "{}: angle {:.1}° → pulse {}",
28                servo0.name,
29                servo0.angle,
30                servo0.get_pulse()
31        );
32        println!(
33                "{}: angle {:.1}° → pulse {}",
34                servo1.name,
35                servo1.angle,
36                servo1.get_pulse()
37        );
38        println!(
39                "{}: angle {:.1}° → pulse {}",
40                servo2.name,
41                servo2.angle,
42                servo2.get_pulse()
43        );
44        println!(
45                "{}: angle {:.1}° → pulse {}",
46                servo3.name,
47                servo3.angle,
48                servo3.get_pulse()
49        );
50        println!(
51                "{}: angle {:.1}° → pulse {}",
52                servo4.name,
53                servo4.angle,
54                servo4.get_pulse()
55        );
56        println!(
57                "{}: angle {:.1}° → pulse {}",
58                servo5.name,
59                servo5.angle,
60                servo5.get_pulse()
61        );
62
63        // pulse -> angle convert test
64        servo0.set_pulse(350);
65        println!(
66                "{}: pulse {} → angle {:.1}°",
67                servo0.name,
68                servo0.get_pulse(),
69                servo0.angle
70        );
71        servo1.set_pulse(400);
72        println!(
73                "{}: pulse {} → angle {:.1}°",
74                servo1.name,
75                servo1.get_pulse(),
76                servo1.angle
77        );
78        servo2.set_pulse(450);
79        println!(
80                "{}: pulse {} → angle {:.1}°",
81                servo2.name,
82                servo2.get_pulse(),
83                servo2.angle
84        );
85        servo3.set_pulse(500);
86        println!(
87                "{}: pulse {} → angle {:.1}°",
88                servo3.name,
89                servo3.get_pulse(),
90                servo3.angle
91        );
92        servo4.set_pulse(550);
93        println!(
94                "{}: pulse {} → angle {:.1}°",
95                servo4.name,
96                servo4.get_pulse(),
97                servo4.angle
98        );
99        servo5.set_pulse(600);
100        println!(
101                "{}: pulse {} → angle {:.1}°",
102                servo5.name,
103                servo5.get_pulse(),
104                servo5.angle
105        );
106
107        println!("\n");
108        // increment / decrement
109        servo0.increment(10.0);
110        println!("{} incremented → {:.1}°", servo1.name, servo1.angle);
111
112        servo1.decrement(30.0);
113        println!("{} decremented → {:.1}°", servo1.name, servo1.angle);
114
115        servo2.increment(20.0);
116        println!("{} incremented → {:.1}°", servo2.name, servo2.angle);
117
118        servo3.decrement(40.0);
119        println!("{} decremented → {:.1}°", servo2.name, servo2.angle);
120
121        servo4.increment(20.0);
122        println!("{} incremented → {:.1}°", servo4.name, servo4.angle);
123        
124        servo5.decrement(15.0);
125        println!("{} decremented → {:.1}°", servo5.name, servo5.angle);
126
127        // ServoSystem Add channels
128        let mut system = ServoSystem::new();
129        system.add_channel(servo0);
130        system.add_channel(servo1);
131
132        println!("\n--- ServoSystem status ---");
133        for servo in &system.channels {
134                println!(
135                "Channel {} ({}): angle {:.1}° → pulse {}",
136                servo.id,
137                servo.name,
138                servo.angle,
139                servo.get_pulse()
140                );
141        }
142
143        // get_channel_mut 예제
144        if let Some(shoulder) = system.get_channel_mut(1) {
145                shoulder.set_angle(120.0);
146                println!(
147                "\nafter update {}: angle {:.1}° → pulse {}",
148                shoulder.name,
149                shoulder.angle,
150                shoulder.get_pulse()
151                );
152        }
153}

Source

pub fn set_pulse(&mut self, pulse: u32)

Examples found in repository ?

examples/basic.rs (line 64)

3fn main() {
4        println!("\n");
5        println!("--- Servo Controller Basic Example ---");
6
7        // MG996R spec create
8        let spec = ServoSpec::mg996r();
9
10        // MG996R 6 channels robot arms example
11        let mut servo0 = ServoChannel::new(0, "base", spec.clone());
12        let mut servo1 = ServoChannel::new(1, "shoulder", spec.clone());
13        let mut servo2 = ServoChannel::new(2, "elbow", spec.clone());
14        let mut servo3 = ServoChannel::new(3, "wrist_pitch", spec.clone());
15        let mut servo4 = ServoChannel::new(4, "wrist_roll", spec.clone());
16        let mut servo5 = ServoChannel::new(5, "gripper", spec.clone());
17
18        // angle init
19        servo0.set_angle(90.0);
20        servo1.set_angle(90.0);
21        servo2.set_angle(90.0);
22        servo3.set_angle(90.0);
23        servo4.set_angle(90.0);
24        servo5.set_angle(90.0);
25
26        println!(
27                "{}: angle {:.1}° → pulse {}",
28                servo0.name,
29                servo0.angle,
30                servo0.get_pulse()
31        );
32        println!(
33                "{}: angle {:.1}° → pulse {}",
34                servo1.name,
35                servo1.angle,
36                servo1.get_pulse()
37        );
38        println!(
39                "{}: angle {:.1}° → pulse {}",
40                servo2.name,
41                servo2.angle,
42                servo2.get_pulse()
43        );
44        println!(
45                "{}: angle {:.1}° → pulse {}",
46                servo3.name,
47                servo3.angle,
48                servo3.get_pulse()
49        );
50        println!(
51                "{}: angle {:.1}° → pulse {}",
52                servo4.name,
53                servo4.angle,
54                servo4.get_pulse()
55        );
56        println!(
57                "{}: angle {:.1}° → pulse {}",
58                servo5.name,
59                servo5.angle,
60                servo5.get_pulse()
61        );
62
63        // pulse -> angle convert test
64        servo0.set_pulse(350);
65        println!(
66                "{}: pulse {} → angle {:.1}°",
67                servo0.name,
68                servo0.get_pulse(),
69                servo0.angle
70        );
71        servo1.set_pulse(400);
72        println!(
73                "{}: pulse {} → angle {:.1}°",
74                servo1.name,
75                servo1.get_pulse(),
76                servo1.angle
77        );
78        servo2.set_pulse(450);
79        println!(
80                "{}: pulse {} → angle {:.1}°",
81                servo2.name,
82                servo2.get_pulse(),
83                servo2.angle
84        );
85        servo3.set_pulse(500);
86        println!(
87                "{}: pulse {} → angle {:.1}°",
88                servo3.name,
89                servo3.get_pulse(),
90                servo3.angle
91        );
92        servo4.set_pulse(550);
93        println!(
94                "{}: pulse {} → angle {:.1}°",
95                servo4.name,
96                servo4.get_pulse(),
97                servo4.angle
98        );
99        servo5.set_pulse(600);
100        println!(
101                "{}: pulse {} → angle {:.1}°",
102                servo5.name,
103                servo5.get_pulse(),
104                servo5.angle
105        );
106
107        println!("\n");
108        // increment / decrement
109        servo0.increment(10.0);
110        println!("{} incremented → {:.1}°", servo1.name, servo1.angle);
111
112        servo1.decrement(30.0);
113        println!("{} decremented → {:.1}°", servo1.name, servo1.angle);
114
115        servo2.increment(20.0);
116        println!("{} incremented → {:.1}°", servo2.name, servo2.angle);
117
118        servo3.decrement(40.0);
119        println!("{} decremented → {:.1}°", servo2.name, servo2.angle);
120
121        servo4.increment(20.0);
122        println!("{} incremented → {:.1}°", servo4.name, servo4.angle);
123        
124        servo5.decrement(15.0);
125        println!("{} decremented → {:.1}°", servo5.name, servo5.angle);
126
127        // ServoSystem Add channels
128        let mut system = ServoSystem::new();
129        system.add_channel(servo0);
130        system.add_channel(servo1);
131
132        println!("\n--- ServoSystem status ---");
133        for servo in &system.channels {
134                println!(
135                "Channel {} ({}): angle {:.1}° → pulse {}",
136                servo.id,
137                servo.name,
138                servo.angle,
139                servo.get_pulse()
140                );
141        }
142
143        // get_channel_mut 예제
144        if let Some(shoulder) = system.get_channel_mut(1) {
145                shoulder.set_angle(120.0);
146                println!(
147                "\nafter update {}: angle {:.1}° → pulse {}",
148                shoulder.name,
149                shoulder.angle,
150                shoulder.get_pulse()
151                );
152        }
153}

Source

pub fn smooth_move(current: f32, target: f32, speed: f32, delta: f32) -> f32

Examples found in repository ?

examples/egui_demo_smooth.rs (line 33)

27    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
28        let now = std::time::Instant::now();
29        let delta = now.duration_since(self.last_update).as_secs_f32();
30        self.last_update = now;
31
32        // smmooth move
33        let new_angle = ServoChannel::smooth_move(self.servo.angle, self.target_angle, self.speed, delta);
34        self.servo.set_angle(new_angle);
35
36        egui::CentralPanel::default().show(ctx, |ui| {
37            ui.heading("Servo Smooth Move Demo");
38
39            ui.label(format!("Current Angle: {:.2}°", self.servo.angle));
40            ui.label(format!("Target Angle: {:.2}°", self.target_angle));
41            ui.label(format!("Speed: {:.2} deg/s", self.speed));
42
43            ui.horizontal(|ui| {
44                ui.label("Target Angle (0 ~ 180): ");
45                ui.text_edit_singleline(&mut self.input_angle);
46            });
47
48            ui.horizontal(|ui| {
49                ui.label("Speed (deg/s): ");
50                ui.text_edit_singleline(&mut self.input_speed);
51            });
52
53            if ui.button("Set").clicked() {
54                if let Ok(angle) = self.input_angle.parse::<f32>() {
55                    self.target_angle = angle.clamp(0.0, 180.0);
56                }
57                if let Ok(speed) = self.input_speed.parse::<f32>() {
58                    self.speed = speed.max(1.0); // minimum speed guarantee
59                }
60                self.input_angle.clear();
61                self.input_speed.clear();
62            }
63
64            // Visualization
65            let (rect, _) = ui.allocate_exact_size(egui::vec2(200.0, 200.0), egui::Sense::hover());
66            let center = rect.center();
67            let radius = 80.0;
68
69            let angle_rad = self.servo.angle.to_radians();
70            let x = center.x + radius * angle_rad.cos();
71            let y = center.y - radius * angle_rad.sin();
72
73            let painter = ui.painter();
74            painter.circle_stroke(center, radius, (2.0, egui::Color32::LIGHT_BLUE));
75            painter.line_segment(
76                [center, egui::pos2(x, y)],
77                (3.0, egui::Color32::RED),
78            );
79        });
80
81        ctx.request_repaint();
82    }