【用Rust玩嵌入式】用STM32做一个拇指琴音符指示器

// 串口设备USART3
// 将pb10配置为push_pull输出，这将是tx引脚
let tx = gpiob.pb10.into_alternate_push_pull(&mut gpiob.crh);// 取得pb11控制权
let rx = gpiob.pb11;// 设置usart设备。通过USART寄存器和 tx/rx 引脚获得所有权。其余寄存器用于启用和配置设备。
let serial = Serial::usart3(    device.USART3,    (tx, rx),    &mut afio.mapr,    Config::default().baudrate(115200.bps()),    clocks,    &mut rcc.apb1,);// 将串行结构拆分为接收和发送部分
let (mut tx, mut rx) = serial.split();// 整个字符串用分段传输, 每段以“+”结尾
// received中接收完每段之后将其push到music_str中缓存
let mut received = String::new();let mut music_str = String::new();let mut player = Player::new(chordes, delay).unwrap();// 注意！loop中如果有hprintln、delay等会导致串口接收失败
loop {    // 程序主循环
    //播放时无法接收蓝牙数据，因为play会有延迟
    if !player.ended() {        let _ = player.play();    } else {        if player.get_theme().is_some() {            player.reset();        }    }    // 从串口接收单个字符
    if let Ok(c) = rx.read() {        received.push(c as char);        // 在数据接收的过程中不能写，否则会造成数据丢失。
        if received.ends_with("+") {            // 替换掉多余字符
            let musics = received.replace("+", "");            received = String::new();            // 每段push到music_str中缓存
            music_str.push_str(&musics);        }        // 如果是#结束，开始播放
        if received.ends_with("#") {            let musics = received.replace("#", "");            received = String::new();            music_str.push_str(&musics);            // 现在musics存储的是完整的音乐字符串
            let musics = music_str;            // 开始播放!
            player.set_song(musics);            music_str = String::new();            writeln!(tx, "START").unwrap();        }    }}

/// 音符
#[derive(Debug, Clone)]pub struct Note{    /// 起始节拍(八分之一拍)
    start_beat: u16,    /// 终止节拍(八分之一拍)
    end_beat: u16,    /// 琴键
    key: u8,    // 键名 (为了节省内存,不使用)
    // name: String
}

/// 曲子
#[derive(Debug)]pub struct Song{    /// 总共多少个八分之一拍
    total_beat: u16,    /// 所有音符
    notes: Vec<Note>,    /// 当前正在播放的音符
    cursor: usize
}

/// 音符播放器
pub struct Player{    delay: Delay,    chordes:ChordesIO,    /// 节拍计数器
    current_beat: u16,    /// 每小节几拍
    beat_per_group: u8,    /// 每个八分之一拍多少微妙
    time_per_beat: u32,    ended: bool,    /// 主题
    theme: Option<Song>,    /// 伴奏
    accompanies: Vec<Option<Song>>,}

    pub fn set_song(&mut self, songs:String) -> Option<()>{        //分离歌曲信息、主题和伴奏
        let mut songs = songs.split("_");        //歌曲信息
        let mut info = songs.next()?.split(",");        let beat_per_group = parse::<u8>(info.next()?)?;//每小节几拍
        let beat_per_min = parse::<f32>(info.next()?)?;//每分钟多少拍
        // 计算每拍延迟(1ms=1000000us)
        // 一个u32可存储4294967295纳秒，即4294.9毫秒，足够一个八分之一节拍延时使用
        // 每拍毫秒数
        let time_per_total_beat = 60000.0 / beat_per_min;        //每八分之一拍毫秒数
        let time_per_eighth_beat = time_per_total_beat / 8.0;        //每八分之一拍微妙数
        let time_per_beat = (time_per_eighth_beat*1000.0) as u32;        //至少有主题曲
        let theme_str = songs.next()?;        self.theme = split_notes(theme_str);        //解析所有伴奏曲
        while let Some(data) = songs.next(){            self.accompanies.push(split_notes(data));        }        self.current_beat = 0;        self.beat_per_group = beat_per_group;        self.time_per_beat = time_per_beat;        self.ended = false;        Some(())    }

/// 解析音符
fn split_notes(data: &str) -> Option<Song>{    // 分别解析每小节的音符
    let mut notes:Vec<Note> = Vec::new();    let parts = data.split("|");    //统计总共多少个八分之一拍
    let mut total_beat_count = 0;    for part in parts{        for note in part.split(","){            let mut symbols = note.chars();            let key_name = symbols.next()?;            let key = match key_name{                NOTE_D6 => NOTE_D6_IO,                NOTE_B5 => NOTE_B5_IO,                NOTE_G5 => NOTE_G5_IO,                NOTE_E5 => NOTE_E5_IO,                NOTE_C5 => NOTE_C5_IO,                NOTE_A4 => NOTE_A4_IO,                NOTE_F4 => NOTE_F4_IO,                NOTE_D4 => NOTE_D4_IO,                NOTE_C4 => NOTE_C4_IO,                NOTE_E4 => NOTE_E4_IO,                NOTE_G4 => NOTE_G4_IO,                NOTE_B4 => NOTE_B4_IO,                NOTE_D5 => NOTE_D5_IO,                NOTE_F5 => NOTE_F5_IO,                NOTE_A5 => NOTE_A5_IO,                NOTE_C6 => NOTE_C6_IO,                NOTE_E6 => NOTE_E6_IO,                _ => NOTE_NO_IO  // 默认为255空引脚，即不亮灯。包括增时线(-)、休止符(0)
            };            let mut beat_count = 8; //默认为整拍
            if let Some(n) = symbols.next(){                //读取音符节拍数
                beat_count = parse::<u16>(&n.to_string())?;            }            /*
                假设第一个音符是1拍，第二个和第三个音符都是半拍，第四个音符又是1拍
                那么第一个音符是从0开始，第二个音符是从8开始，第三个音符从12开始，
                第四个音符从16开始
            */            notes.push(Note{                start_beat: total_beat_count,                end_beat: total_beat_count+beat_count-1,                key,                // name: key_name.to_string(),
            });            //每个音符通常是8个八分之一拍，也可能多于8个，但一般不这么用
            total_beat_count += beat_count;        }    }    let song = Song{        notes,        cursor: 0,        total_beat: total_beat_count    };    Some(song)}

/// 播放一个音符
pub fn play(&mut self) -> Option<Note>{    // 播放结束不做任何操作，直接返回
    if self.ended || self.theme.is_none(){        self.ended = true;        return None;    }    // 获取主题曲的引用
    let theme = self.theme.as_mut().unwrap();    // 检查主歌曲是否已结束
    if self.current_beat == theme.total_beat{        self.ended = true;        return None;    }    // 播放主题曲当前的音符
    let theme_note = play_note(self.current_beat, theme, &mut self.chordes);    // 播放所有伴奏曲当前的音符
    let accompanies:&mut Vec<Option<Song>> = self.accompanies.as_mut();    for accompany in accompanies{        if let Some(accompany) = accompany{            let _ = play_note(self.current_beat, accompany, &mut self.chordes);        }    }    // 延时us(即微妙)
    self.delay.delay_us(self.time_per_beat);    // 节拍计数器+1
    self.current_beat += 1;    // 返回正在播放的音符(暂无实际用途)
    theme_note}/// 点亮音符对应的LED，返回开始的弹奏的音符
fn play_note(current_beat: u16, song:&mut Song, chordes: &mut ChordesIO) -> Option<Note>{    let mut current_note = song.notes.get(song.cursor)?;    //如果当前节拍大于当前音符的结束拍，关闭音符对应的LED，并切换音符
    if current_beat > current_note.end_beat{        let _ = chordes.turn_off(current_note.key);        song.cursor += 1;        current_note = song.notes.get(song.cursor)?;    }    //如果当前节拍等于当前音符的起始拍，点亮LED
    if current_beat == current_note.start_beat{        if chordes.turn_on(current_note.key){            return Some(current_note.clone());        }    }    None}