Red Mosquitto: Implemente um sensor de ruído com um cliente MQTT em um ESP32

1
let peripherals = Peripherals::take().expect("Unable to access device peripherals");
2
let led_pin = peripherals.pins.gpio8;

1
let rmt_channel = peripherals.rmt.channel0;

1
cargo add ws2812-esp32-rmt-driver

1
let mut neopixel =
2
    Ws2812Esp32RmtDriver::new(rmt_channel, led_pin).expect("Unable to talk to ws2812");

1
let color_1 = LedPixelColorGrb24::new_with_rgb(255, 255, 0);
2
neopixel
3
    .write_blocking(color_1.as_ref().iter().cloned())
4
    .expect("Error writing to neopixel");

1
let color_2 = LedPixelColorGrb24::new_with_rgb(255, 0, 255);

1
loop {
2
    neopixel
3
        .write_blocking(color_1.as_ref().iter().cloned())
4
        .expect("Error writing to neopixel");
5
    neopixel
6
        .write_blocking(color_2.as_ref().iter().cloned())
7
        .expect("Error writing to neopixel");
8
}

1
neopixel
2
    .write_blocking(color_1.as_ref().iter().cloned())
3
    .expect("Error writing to neopixel");
4
thread::sleep(Duration::from_millis(500));
5
neopixel
6
    .write_blocking(color_2.as_ref().iter().cloned())
7
    .expect("Error writing to neopixel");
8
thread::sleep(Duration::from_millis(500));

1
enum DeviceStatus {
2
    Ok,
3
    WifiError,
4
    MqttError,
5
}

1
impl TryFrom<u8> for DeviceStatus {
2
    type Error = &'static str;
3
4
    fn try_from(value: u8) -> Result<Self, Self::Error> {
5
        match value {
6
            0u8 => Ok(DeviceStatus::Ok),
7
            1u8 => Ok(DeviceStatus::WifiError),
8
            2u8 => Ok(DeviceStatus::MqttError),
9
            _ => Err("Unknown status"),
10
        }
11
    }
12
}

1
#[repr(u8)]
2
enum DeviceStatus {

1
let mut status = DeviceStatus::Ok as u8;

1
struct ColorStep {
2
    red: u8,
3
    green: u8,
4
    blue: u8,
5
    duration: u64,
6
}

1
impl ColorStep {
2
    fn new(red: u8, green: u8, blue: u8, duration: u64) -> Self {
3
        ColorStep {
4
            red,
5
            green,
6
            blue,
7
            duration,
8
        }
9
    }
10
}

1
impl DeviceStatus {
2
    fn light_sequence(&self) -> Vec<ColorStep> {
3
        match self {
4
            DeviceStatus::Ok => vec![ColorStep::new(0, 255, 0, 500), ColorStep::new(0, 0, 0, 500)],
5
            DeviceStatus::WifiError => {
6
                vec![ColorStep::new(255, 0, 0, 200), ColorStep::new(0, 0, 0, 100)]
7
            }
8
            DeviceStatus::MqttError => vec![
9
                ColorStep::new(255, 0, 255, 100),
10
                ColorStep::new(0, 0, 0, 300),
11
            ],
12
        }
13
    }
14
}

1
use esp_idf_svc::hal::{
2
    gpio::OutputPin,
3
    peripheral::Peripheral,
4
    rmt::RmtChannel,
5
};
6
7
fn report_status(
8
    status: &u8,
9
    rmt_channel: impl Peripheral<P = impl RmtChannel>,
10
    led_pin: impl Peripheral<P = impl OutputPin>,
11
) -> ! {
12
    let mut neopixel =
13
        Ws2812Esp32RmtDriver::new(rmt_channel, led_pin).expect("Unable to talk to ws2812");
14
    loop {}
15
}

1
let mut prev_status = DeviceStatus::WifiError; // Anything but Ok
2
let mut sequence: Vec<ColorStep> = vec![];

1
loop {
2
    if let Ok(status) = DeviceStatus::try_from(*status) {
3
        if status != prev_status {
4
            prev_status = status;
5
            sequence = status.light_sequence();
6
        }
7
        for step in sequence.iter() {
8
            let color = LedPixelColorGrb24::new_with_rgb(step.red, step.green, step.blue);
9
            neopixel
10
                .write_blocking(color.as_ref().iter().cloned())
11
                .expect("Error writing to neopixel");
12
            thread::sleep(Duration::from_millis(step.duration));
13
        }
14
    }
15
}

1
#[derive(Clone, Copy, PartialEq)]
2
enum DeviceStatus {

1
fn change_status(status: &mut u8) -> ! {
2
    loop {
3
        thread::sleep(Duration::from_secs(10));
4
        if let Ok(current) = DeviceStatus::try_from(*status) {
5
            match current {
6
                DeviceStatus::Ok => *status = DeviceStatus::WifiError as u8,
7
                DeviceStatus::WifiError => *status = DeviceStatus::MqttError as u8,
8
                DeviceStatus::MqttError => *status = DeviceStatus::Ok as u8,
9
            }
10
        }
11
    }
12
}

1
thread::scope(|scope| {
2
    scope.spawn(|| report_status(&status, rmt_channel, led_pin));
3
    scope.spawn(|| change_status(&mut status));
4
});

1
let status = &AtomicU8::new(0u8);

1
fn report_status(
2
    status: &AtomicU8,
3
    rmt_channel: impl Peripheral<P = impl RmtChannel>,
4
    led_pin: impl Peripheral<P = impl OutputPin>,
5
) -> ! {
6
    let mut neopixel =
7
        Ws2812Esp32RmtDriver::new(rmt_channel, led_pin).expect("Unable to talk to ws2812");
8
    let mut prev_status = DeviceStatus::WifiError; // Anything but Ok
9
    let mut sequence: Vec<ColorStep> = vec![];
10
    loop {
11
        if let Ok(status) = DeviceStatus::try_from(status.load(Relaxed)) {

1
fn change_status(status: &AtomicU8) -> ! {
2
    loop {
3
        thread::sleep(Duration::from_secs(10));
4
        if let Ok(current) = DeviceStatus::try_from(status.load(Relaxed)) {
5
            match current {
6
                DeviceStatus::Ok => status.store(DeviceStatus::WifiError as u8, Relaxed),
7
                DeviceStatus::WifiError => status.store(DeviceStatus::MqttError as u8, Relaxed),
8
                DeviceStatus::MqttError => status.store(DeviceStatus::Ok as u8, Relaxed),
9
            }
10
        }
11
    }
12
}

1
scope.spawn(|| report_status(status, rmt_channel, led_pin));
2
scope.spawn(|| change_status(status));

1
fn read_noise_level() -> ! {
2
}

1
let adc = peripherals.adc1;

1
let adc_pin = peripherals.pins.gpio0;

1
fn read_noise_level<GPIO>(adc1: ADC1, adc1_pin: GPIO) -> !
2
where
3
    GPIO: ADCPin<Adc = ADC1>,

1
let mut adc =
2
    AdcDriver::new(adc1, &adc::config::Config::default()).expect("Unable to initialze ADC1");
3
let mut adc_channel_drv: AdcChannelDriver<{ attenuation::DB_11 }, _> =
4
    AdcChannelDriver::new(adc1_pin).expect("Unable to access ADC1 channel 0");

1
loop {
2
    thread::sleep(Duration::from_millis(10));
3
    println!("ADC value: {:?}", adc.read(&mut adc_channel));
4
}

1
scope.spawn(|| read_noise_level(adc, adc_pin));

1
const LEN: usize = 5;
2
let mut sample_buffer = [0u16; LEN];

1
for i in 0..LEN {
2
}

1
thread::sleep(Duration::from_millis(10));
2
if let Ok(sample) = adc.read(&mut adc_pin) {
3
    sample_buffer[i] = sample;
4
} else {
5
    sample_buffer[i] = 0u16;
6
}

1
let mut sum = 0.0f32;

1
sum += (sample as f32) * (sample as f32);

1
let d_b = 20.0f32 * (sum / LEN as f32).sqrt().log10();
2
println!(
3
    "ADC values: {:?}, sum: {}, and dB: {} ",
4
    sample_buffer, sum, d_b
5
);

1
ADC values: [0, 0, 0, 0, 0], sum: 0, and dB: -inf
2
ADC values: [0, 0, 0, 3, 0], sum: 9, and dB: 2.5527248
3
ADC values: [0, 0, 0, 11, 0], sum: 121, and dB: 13.838154
4
ADC values: [8, 0, 38, 0, 102], sum: 11912, and dB: 33.770145
5
ADC values: [64, 23, 0, 8, 26], sum: 5365, and dB: 30.305998
6
ADC values: [0, 8, 41, 0, 87], sum: 9314, and dB: 32.70166
7
ADC values: [137, 0, 79, 673, 0], sum: 477939, and dB: 49.804024
8
ADC values: [747, 0, 747, 504, 26], sum: 1370710, and dB: 54.379753
9
ADC values: [240, 0, 111, 55, 26], sum: 73622, and dB: 41.680374
10
ADC values: [8, 26, 26, 58, 96], sum: 13996, and dB: 34.470337

1
struct Configuration {
2
    wifi_ssid: &'static str,
3
    wifi_password: &'static str,
4
}

1
cargo add toml-cfg

1
#[toml_cfg::toml_config]
2
struct Configuration {
3
    #[default("NotMyWifi")]
4
    wifi_ssid: &'static str,
5
    #[default("NotMyPassword")]
6
    wifi_password: &'static str,
7
}

1
[mosquitto-bzzz]
2
wifi_ssid = "ThisAintEither"
3
wifi_password = "NorIsThisMyPassword"

1
echo "cfg.toml" >> .gitignore

1
fn connect_to_wifi(ssid: &str, passwd: &str) {}

1
cargo add anyhow

1
fn connect_to_wifi(ssid: &str, passwd: &str) -> Result<()> {
2
    Ok(())
3
}

1
if ssid.is_empty() {
2
    bail!("No SSID defined");
3
}

1
let auth_method = if passwd.is_empty() {
2
    AuthMethod::None
3
} else {
4
    AuthMethod::WPA2Personal
5
};

1
let sys_loop = EspSystemEventLoop::take().context("Unable to access system event loop.")?;

1
let nvs = EspDefaultNvsPartition::take().context("Unable to access default NVS partition")?;

1
fn connect_to_wifi(ssid: &str, passwd: &str,
2
                   modem: impl Peripheral<P = modem::Modem> + 'static,
3
) -> Result<()> {
4
    // Auth checks here and sys_loop ...
5
    let mut esp_wifi = EspWifi::new(modem, sys_loop.clone(), Some(nvs))?;
6
    let mut wifi = BlockingWifi::wrap(&mut esp_wifi, sys_loop)?;

1
wifi.set_configuration(&mut wifi::Configuration::Client(
2
    wifi::ClientConfiguration {
3
        ssid: ssid
4
            .try_into()
5
            .map_err(|_| anyhow::Error::msg("Unable to use SSID"))?,
6
        password: passwd
7
            .try_into()
8
            .map_err(|_| anyhow::Error::msg("Unable to use Password"))?,
9
        auth_method,
10
        ..Default::default()
11
    },
12
))?;

1
wifi.start()?;
2
wifi.connect()?;
3
wifi.wait_netif_up()?;

1
let ip_info = wifi.wifi().sta_netif().get_ip_info()?;
2
log::info!("DHCP info: {:?}", ip_info);

1
) -> Result<Box<EspWifi<'static>>> {

1
Ok(Box::new(wifi_driver))

1
fn read_noise_level<GPIO>(
2
    adc1: ADC1,
3
    adc1_pin: GPIO,
4
    modem: impl Peripheral<P = modem::Modem> + 'static,
5
) -> !

1
let modem = peripherals.modem;

1
scope.spawn(|| read_noise_level(adc, adc_pin, modem));

1
let app_config = CONFIGURATION;

1
let _wifi = match connect_to_wifi(app_config.wifi_ssid, app_config.wifi_password, modem) {
2
    Ok(wifi) => wifi,
3
    Err(err) => {
4
5
    }
6
};

1
log::error!("Connect to WiFi: {}", err);
2
status.store(DeviceStatus::WifiError as u8, Relaxed);

1
fn read_noise_level<GPIO>(
2
    status: &AtomicU8,

1
scope.spawn(|| read_noise_level(status, adc, adc_pin, modem));

1
thread::Builder::new()
2
    .stack_size(6144)
3
    .spawn_scoped(scope, || read_noise_level(status, adc, adc_pin, modem))
4
    .unwrap();

1
sudo apt-get update && sudo apt-get upgrade
2
sudo apt-get install -y {mosquitto,mosquitto-clients,mosquitto-dev}
3
sudo systemctl enable mosquitto.service

1
sudo mosquitto_passwd -c -b /etc/mosquitto/passwd soundsensor "Zap\!Pow\!Bam\!Kapow\!"
2
sudo sh -c 'echo "listener 1883\nallow_anonymous false\npassword_file /etc/mosquitto/passwd" > /etc/mosquitto/conf.d/remote_access.conf'
3
sudo systemctl restart mosquitto

1
mosquitto_sub -t test/topic -u soundsensor -P "Zap\!Pow\!Bam\!Kapow\!"

1
mosquitto_pub -d -t test/topic -m "Hola caracola" -u soundsensor -P "Zap\!Pow\!Bam\!Kapow\!"

1
#[toml_cfg::toml_config]
2
struct Configuration {
3
    #[default("NotMyWifi")]
4
    wifi_ssid: &'static str,
5
    #[default("NotMyPassword")]
6
    wifi_password: &'static str,
7
    #[default("mqttserver")]
8
    mqtt_host: &'static str,
9
    #[default("")]
10
    mqtt_user: &'static str,
11
    #[default("")]
12
    mqtt_password: &'static str,
13
}

1
[mosquitto-bzzz]
2
wifi_ssid = "ThisAintEither"
3
wifi_password = "NorIsThisMyPassword"
4
mqtt_host = "mqttsystem"
5
mqtt_user = "soundsensor"
6
mqtt_password = "Zap!Pow!Bam!Kapow!"

1
let mut mqtt_client =
2
    EspMqttClient::new()
3
    .expect("Unable to initialize MQTT client");

1
let mqtt_url = if app_config.mqtt_user.is_empty() || app_config.mqtt_password.is_empty() {
2
    format!("mqtt://{}/", app_config.mqtt_host)
3
} else {
4
    format!(
5
        "mqtt://{}:{}@{}/",
6
        app_config.mqtt_user, app_config.mqtt_password, app_config.mqtt_host
7
    )
8
};

1
EspMqttClient::new(&mqtt_url, &MqttClientConfiguration::default(), |_| {
2
    log::info!("MQTT client callback")
3
})

1
const TOPIC: &str = "home/noise sensor/01";

1
let mut mqtt_msg: String;

1
mqtt_msg = format!("{}", d_b);

1
if let Ok(msg_id) = mqtt_client.publish(TOPIC, QoS::AtMostOnce, false, mqtt_msg.as_bytes())
2
{
3
    println!(
4
        "MSG ID: {}, ADC values: {:?}, sum: {}, and dB: {} ",
5
        msg_id, sample_buffer, sum, d_b
6
    );
7
} else {
8
    println!("Unable to send MQTT msg");
9
}

1
mosquitto_sub -t "home/noise sensor/01" -u soundsensor -P "Zap\!Pow\!Bam\!Kapow\!"

1
fn get_sensor_id() -> String {
2
}

1
let mut mac_addr = [0u8; 8];
2
unsafe {
3
    match esp_base_mac_addr_get(mac_addr.as_mut_ptr()) {
4
        ESP_OK => {
5
            let sensor_id = mac_addr.iter().fold(String::new(), |mut output, b| {
6
                let _ = write!(output, "{b:02x}");
7
                output
8
            });
9
            log::info!("Id: {:?}", sensor_id);
10
            sensor_id
11
        }
12
        _ => {
13
            log::error!("Unable to get id.");
14
            String::from("BADCAFE00BADBEEF")
15
        }
16
    }
17
}

1
let sensor_id = get_sensor_id();
2
let topic = format!("home/noise sensor/{sensor_id}");

1
if let Ok(msg_id) = mqtt_client.publish(&topic, QoS::AtMostOnce, false, mqtt_msg.as_bytes())

1
mosquitto_sub -t "home/noise sensor/+" -u soundsensor -P "Zap\!Pow\!Bam\!Kapow\!"