gallo-mcp 0.1.0

Model Context Protocol server exposing a Pico de Gallo device to AI agents
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

//! PWM tools.

use rmcp::handler::server::wrapper::Parameters;
use rmcp::model::CallToolResult;
use rmcp::{ErrorData, tool, tool_router};

use crate::error::map_pdg_err;
use crate::{GalloMcp, ok_json};

#[derive(Debug, serde::Deserialize, schemars::JsonSchema)]
pub struct PwmChannelParams {
    /// PWM channel.
    pub channel: u8,
}
#[derive(Debug, serde::Deserialize, schemars::JsonSchema)]
pub struct PwmSetDutyParams {
    /// PWM channel.
    pub channel: u8,
    /// Raw compare value.
    pub duty: u16,
}
#[derive(Debug, serde::Deserialize, schemars::JsonSchema)]
pub struct PwmSetConfigParams {
    /// PWM channel.
    pub channel: u8,
    /// Frequency in Hz.
    pub frequency: u32,
    /// Enable phase-correct mode.
    #[serde(default)]
    pub phase_correct: bool,
}

#[tool_router(router = pwm_router, vis = "pub(crate)")]
impl GalloMcp {
    /// Get PWM duty cycle and max.
    #[tool(
        description = "Get PWM duty cycle and max",
        annotations(read_only_hint = true)
    )]
    async fn pwm_get_duty_cycle(
        &self,
        Parameters(p): Parameters<PwmChannelParams>,
    ) -> Result<CallToolResult, ErrorData> {
        let dev = self.connect().await?;
        let d = dev
            .pwm_get_duty_cycle(p.channel)
            .await
            .map_err(map_pdg_err)?;
        ok_json(&format!("{d:?}"))
    }
    /// Get PWM configuration.
    #[tool(
        description = "Get PWM configuration",
        annotations(read_only_hint = true)
    )]
    async fn pwm_get_config(
        &self,
        Parameters(p): Parameters<PwmChannelParams>,
    ) -> Result<CallToolResult, ErrorData> {
        let dev = self.connect().await?;
        let c = dev.pwm_get_config(p.channel).await.map_err(map_pdg_err)?;
        ok_json(&format!("{c:?}"))
    }
    /// Set PWM raw duty cycle.
    #[tool(
        description = "Set PWM raw duty cycle",
        annotations(destructive_hint = true, read_only_hint = false)
    )]
    async fn pwm_set_duty_cycle(
        &self,
        Parameters(p): Parameters<PwmSetDutyParams>,
    ) -> Result<CallToolResult, ErrorData> {
        let dev = self.connect().await?;
        dev.pwm_set_duty_cycle(p.channel, p.duty)
            .await
            .map_err(map_pdg_err)?;
        ok_json(&"ok")
    }
    /// Enable a PWM channel.
    #[tool(
        description = "Enable a PWM channel",
        annotations(destructive_hint = true, read_only_hint = false)
    )]
    async fn pwm_enable(
        &self,
        Parameters(p): Parameters<PwmChannelParams>,
    ) -> Result<CallToolResult, ErrorData> {
        let dev = self.connect().await?;
        dev.pwm_enable(p.channel).await.map_err(map_pdg_err)?;
        ok_json(&"ok")
    }
    /// Disable a PWM channel.
    #[tool(
        description = "Disable a PWM channel",
        annotations(destructive_hint = true, read_only_hint = false)
    )]
    async fn pwm_disable(
        &self,
        Parameters(p): Parameters<PwmChannelParams>,
    ) -> Result<CallToolResult, ErrorData> {
        let dev = self.connect().await?;
        dev.pwm_disable(p.channel).await.map_err(map_pdg_err)?;
        ok_json(&"ok")
    }
    /// Configure PWM frequency and phase-correct.
    #[tool(
        description = "Configure PWM frequency and phase-correct",
        annotations(destructive_hint = true, read_only_hint = false)
    )]
    async fn pwm_set_config(
        &self,
        Parameters(p): Parameters<PwmSetConfigParams>,
    ) -> Result<CallToolResult, ErrorData> {
        let dev = self.connect().await?;
        dev.pwm_set_config(p.channel, p.frequency, p.phase_correct)
            .await
            .map_err(map_pdg_err)?;
        ok_json(&"ok")
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn set_config_params_deserialize() {
        let p: PwmSetConfigParams =
            serde_json::from_str(r#"{"channel":0,"frequency":1000,"phase_correct":false}"#)
                .unwrap();
        assert_eq!(p.channel, 0);
        assert_eq!(p.frequency, 1000);
        assert!(!p.phase_correct);
    }
    #[test]
    fn pwm_tools_registered() {
        let names: Vec<String> = crate::GalloMcp::router_for_test()
            .list_all()
            .iter()
            .map(|t| t.name.to_string())
            .collect();
        for e in [
            "pwm_get_duty_cycle",
            "pwm_get_config",
            "pwm_set_duty_cycle",
            "pwm_enable",
            "pwm_disable",
            "pwm_set_config",
        ] {
            assert!(names.contains(&e.to_string()), "missing {e}");
        }
    }
}