esp32笔记[9]-rust的串口收发及GCODE解析

scand123

已于 2023-11-02 12:26:46 修改

阅读量512

点赞数

文章标签：串口 GCODE esp32

于 2023-10-26 13:11:40 首次发布

摘要

使用rust在no-std环境下实现esp32-c3串口收发及gcode解析.

平台信息

esp32c3
rust

超链接

esp32笔记[7]-使用rust+zig开发入门

使用rust实现串口中断

示例代码:
serial_interrupts.rs

//! This shows some of the interrupts that can be generated by UART/Serial.
//! Use a proper serial terminal to connect to the board (espmonitor and
//! espflash won't work)

#![no_std]
#![no_main]

use core::{cell::RefCell, fmt::Write};

use critical_section::Mutex;
use esp32c3_hal::{
clock::ClockControl,
interrupt,
peripherals::{self, Peripherals, UART0},
prelude:😗,
riscv,
timer::TimerGroup,
uart::config::AtCmdConfig,
Cpu,
Uart,
};
use esp_backtrace as _;
use nb::block;

static SERIAL: Mutex<RefCell<Option<Uart<UART0>>>> = Mutex::new(RefCell::new(None));

#[entry]
fn main() -> ! {
let peripherals = Peripherals::take();
let system = peripherals.SYSTEM.split();
let clocks = ClockControl::boot_defaults(system.clock_control).freeze();

//let mut uart0 = Uart::new(peripherals.UART0, &amp;clocks);
let mut uart0 = Uart::new(peripherals.UART0, &amp;mut system.peripheral_clock_control);
let timer_group0 = TimerGroup::new(peripherals.TIMG0, &amp;clocks);
let mut timer0 = timer_group0.timer0;

uart0.set_at_cmd(AtCmdConfig::new(None, None, None, b'#', None));
uart0.set_rx_fifo_full_threshold(30).unwrap();
uart0.listen_at_cmd();
uart0.listen_rx_fifo_full();

timer0.start(1u64.secs());

critical_section::with(|cs| SERIAL.borrow_ref_mut(cs).replace(uart0));

interrupt::enable(
    peripherals::Interrupt::UART0,
    interrupt::Priority::Priority1,
)
.unwrap();
interrupt::set_kind(
    Cpu::ProCpu,
    interrupt::CpuInterrupt::Interrupt1, // Interrupt 1 handles priority one interrupts
    interrupt::InterruptKind::Edge,
);

unsafe {
    riscv::interrupt::enable();
}

loop {
    critical_section::with(|cs| {
        writeln!(SERIAL.borrow_ref_mut(cs).as_mut().unwrap(), "Hello World! Send a single `#` character or send at least 30 characters and see the interrupts trigger.").ok();
    });

    block!(timer0.wait()).unwrap();
}

}

#[interrupt]
fn UART0() {
critical_section::with(|cs| {
let mut serial = SERIAL.borrow_ref_mut(cs);
let serial = serial.as_mut().unwrap();

    let mut cnt = 0;
    while let nb::Result::Ok(_c) = serial.read() {
        cnt += 1;
    }
    writeln!(serial, "Read {} bytes", cnt,).ok();

    writeln!(
        serial,
        "Interrupt AT-CMD: {} RX-FIFO-FULL: {}",
        serial.at_cmd_interrupt_set(),
        serial.rx_fifo_full_interrupt_set(),
    )
    .ok();

    serial.reset_at_cmd_interrupt();
    serial.reset_rx_fifo_full_interrupt();
});

}

GCODE简介

[https://www.sae.org/standards/content/rs274d/]
[https://bayareacircuits.com/blog/rs274d-vs-rd274x-gerber-file-format/]
GCODE是一种用于控制数控机床和3D打印机等数控设备的编程语言。在GCODE中，RS274D和RS274X是两种常见的格式。

RS274D是GCODE的早期版本，也称为基本GERBER格式。它使用坐标数据和功能码来描述运动和操作。RS274D格式的文件通常需要附带D码文件才能完整描述图形。

RS274X是GCODE的扩展版本，也称为扩展GERBER格式。它在RS274D的基础上增加了一些功能，如处理多边形填充、正负图形组合和自定义D码等。与RS274D不同，RS274X格式的文件内部包含了光圈表的信息，不需要额外的D码文件。

根据搜索结果，RS274X格式相对于RS274D格式更为常见和推荐使用。RS274X格式的文件具有更高的兼容性和便利性，因为它内部包含了光圈表的信息，无需额外的D码文件。

G代码（G-code）是一种用于控制数控机床的标准指令集。它采用文本格式，通过下发给机床控制系统，来控制机床的运动和操作。

在G代码中，以字母G开头的指令表示机床的运动控制，如轴的定位、线性或圆弧插补等。以字母M开头的指令表示机床的辅助功能和操作命令，如开关冷却液、启动或停止主轴等。

G代码的格式通常是由字母、数字和小数点组成，例如：G01、G02、G03、M03、M08等。其中，字母代表具体的功能，数字和小数点用于指定参数和数值。

G代码具有丰富的功能和应用，可以实现复杂的机床运动和工件加工。例如，通过指定不同的G代码和参数，可以实现直线或曲线的插补运动、螺旋插补、孔加工、螺纹加工、刀具补偿等操作。

G命令	M命令

实现

核心代码

src/main.rs

/*
备注:
- 使用no-std,没有常规的main函数
- 串口波特率115200
目标平台:
- esp32c3(riscv32imc)
依赖:
- esp32c3-hal(0.12.0)
- esp-backtrace(0.8.0)
- esp-println(0.6.0)
- critical_section(1.1.1)
编译及烧录命令:
- cargo-offline run
- cargo-offline build --release
*/
#![no_std]
#![no_main]
#![allow(unused_imports)]
#![allow(unused_parens)]
#![allow(unused_variables)]
#![allow(unused_unsafe)]
#![allow(dead_code)]
#![allow(unused_mut)]

/* start 与zig代码通信 /
#[link(name = “main”)]
extern “C” {
fn add(x: i32, y: i32) -> i32;
}
/ end 与zig代码通信 */

/* start 导入库 */
use esp_println::println;//串口打印
use esp_println::print;//串口打印
use core::{
cell::RefCell, //内部可变性类型RefCell
fmt::Write, //文本写入接口
};
use critical_section::Mutex;//no-std库专用的Mutex

use esp32c3_hal::{
clock::ClockControl, //时钟控制
peripherals::{self, Peripherals, TIMG0, TIMG1,UART0},//外设控制器
prelude:😗,
timer::{Timer, Timer0, TimerGroup},//定时器
Rtc,//rtc时钟
Delay,//延时
gpio::{AnyPin,Input, Output, PullDown, PushPull, IO},//gpio相关
systimer::SystemTimer,//系统定时器
interrupt,//中断
riscv,//riscv架构相关
uart::config::AtCmdConfig,//串口解析at命令
Cpu,//cpu相关
Uart,//串口相关
};

use esp_backtrace as _;// 获取调用堆栈信息
use nb::block;//在异步上下文中阻塞执行代码
/* end 导入库 */

/* start 自定义类型 */
// 字符串类型
#[derive(PartialEq, Copy,Clone)]
struct MyString {
chars: [u8; 128], // 字符数组，可以根据实际需求调整大小
length: usize, // 字符串长度
}

impl MyString {
fn new() -> MyString {
MyString {
chars: [0; 128], // 初始化字符数组
length: 0, // 初始长度为 0
}
}

fn push(&amp;mut self, c: u8) {
    if self.length &lt; self.chars.len() {
        self.chars[self.length] = c;
        self.length += 1;
    }
}

fn append(&amp;mut self, s: &amp;str) {
    for c in s.bytes() {
        self.push(c);
    }
}

}

// 字典类型
#[derive(Copy,Clone)]
struct KeyValuePair<'a> {
key: &'a MyString,
value: &'a MyString,
}

struct MyStringDictionary<'a> {
data: [Option<KeyValuePair<'a>>; 128],
length: usize,
}

impl<'a> MyStringDictionary<'a> {
fn new() -> MyStringDictionary<'a> {
MyStringDictionary {
data: [None; 128],
length: 0,
}
}

fn insert(&amp;mut self, key: &amp;'a MyString, value: &amp;'a MyString) {
    if self.length &lt; self.data.len() {
        self.data[self.length] = Some(KeyValuePair { key, value });
        self.length += 1;
    }
}

fn remove(&amp;mut self, key: &amp;MyString) {
    for i in 0..self.length {
        if let Some(pair) = self.data[i] {
            if pair.key == key {
                self.data[i] = None;
                // 后面的元素前移，保持紧凑布局
                for j in i..self.length - 1 {
                    self.data[j] = self.data[j + 1];
                }
                self.length -= 1;
                break;
            }
        }
    }
}

fn get(&amp;self, key: &amp;MyString) -&gt; Option&lt;&amp;MyString&gt; {
    for i in 0..self.length {
        if let Some(pair) = self.data[i] {
            if pair.key == key {
                return Some(pair.value);
            }
        }
    }
    None
}

fn contains_key(&amp;self, key: &amp;MyString) -&gt; bool {
    self.get(key).is_some()
}

}

// 自定义的标准库
#[derive(PartialEq, Copy,Clone)]
struct MySTD;

impl MySTD {
// strstr函数的实现
fn strstr(haystack: &[u8], needle: &[u8]) -> Option<usize> {
for i in 0…=(haystack.len() - needle.len()) {
if haystack[i…].starts_with(needle) {
return Some(i);
}
}
None
}

// strchr函数的实现
fn strchr(haystack: &amp;[u8], needle: u8) -&gt; Option&lt;usize&gt; {
    for (i, &amp;byte) in haystack.iter().enumerate() {
        if byte == needle {
            return Some(i);
        }
    }
    None
}

// strlen函数的实现
fn strlen(s: &amp;[u8]) -&gt; usize {
    let mut len = 0;
    while len &lt; s.len() &amp;&amp; s[len] != b'\0' {
        len += 1;
    }
    len
}

// strcmp函数的实现
fn strcmp(s1: &amp;[u8], s2: &amp;[u8]) -&gt; i32 {
    for i in 0..s1.len().min(s2.len()) {
        if s1[i] != s2[i] {
            return (s1[i] as i32) - (s2[i] as i32);
        }
    }
    (s1.len() as i32) - (s2.len() as i32)
}

// strcpy函数的实现
fn strcpy(dest: &amp;mut [u8], src: &amp;[u8]) {
    let mut i = 0;
    while i &lt; src.len() &amp;&amp; i &lt; dest.len() {
        dest[i] = src[i];
        i += 1;
    }
    if i &lt; dest.len() {
        dest[i] = b'\0';
    }
}

// strncpy函数的实现
fn strncpy(dest: &amp;mut [u8], src: &amp;[u8], count: usize) {
    let mut i = 0;
    while i &lt; count &amp;&amp; i &lt; src.len() &amp;&amp; i &lt; dest.len() {
        dest[i] = src[i];
        i += 1;
    }
    if i &lt; dest.len() {
        dest[i] = 0;
    }
}

// 复制指定区间的字符到目标字符串
fn strnncpy(dest: &amp;mut [u8], src: &amp;[u8], _start: usize, _end: usize) {
    let start = _start.min(src.len());
    let end = _end.min(src.len()).min(start + dest.len());
    let mut i = 0;
    while start + i &lt; end {
        dest[i] = src[start + i];
        i += 1;
    }
    if i &lt; dest.len() {
        dest[i] = 0;
    }
}

// strtok函数的实现
fn strtok(s: *mut u8, s_size: usize, delim: u8) -&gt; Option&lt;&amp;'static mut [u8]&gt; {
    return None;
}

// strprint函数的实现
fn strprint(_input: &amp;[u8]) {
    let len = Self::strlen(_input);
    for i in 0..len {
        print!("{}", _input[i] as char);
    }
    print!("\n");
}

// 字符数组转int32数字
fn atoi(s: &amp;[u8]) -&gt; Option&lt;i32&gt; {
    if(s.len() == 0){
        return None;
    }

    let mut value = 0;
    let mut sign = 1;
    let mut i = 0;

    // 处理符号位
    if s[i] == b'-' {
        sign = -1;
        i += 1;
    } else if s[i] == b'+' {
        i += 1;
    }

    // 处理整数部分
    while i &lt; s.len() {
        let digit = s[i] - b'0';
        if digit &lt; 0 || digit &gt; 9 {
            break;
        }
        value = value * 10 + (digit as i32);
        i += 1;
    }

    if i &gt; 0 {
        Some(value * sign)
    } else {
        None
    }
}

// 字符数组转f32数字
fn atof(s: &amp;[u8]) -&gt; Option&lt;f32&gt; {

    if(s.len() == 0){
        return None;
    }

    let mut value = 0.0;
    let mut sign = 1.0;
    let mut i = 0;

    // 处理符号位
    if s[i] == b'-' {
        sign = -1.0;
        i += 1;
    } else if s[i] == b'+' {
        i += 1;
    }

    // 处理整数部分
    while i &lt; s.len() &amp;&amp; s[i] &gt;= b'0' &amp;&amp; s[i] &lt;= b'9' {
        value = value * 10.0 + ((s[i] - b'0') as f32);
        i += 1;
    }

    // 处理小数部分
    if i &lt; s.len() &amp;&amp; s[i] == b'.' {
        let mut power = 1.0;
        i += 1;
        while i &lt; s.len() &amp;&amp; s[i] &gt;= b'0' &amp;&amp; s[i] &lt;= b'9' {
            value = value + (((s[i] - b'0') as f32) / (10.0 * power));
            power *= 10.0;
            i += 1;
        }
    }

    // 检查是否成功转换了至少一个数字字符
    if i &gt; 0 {
        Some(value * sign)
    } else {
        None
    }
}

// strcat函数的实现
fn strcat(dest: &amp;mut [u8], src: &amp;[u8]) {
    let dest_len = dest.len();
    let src_len = src.len();

    if src_len &gt; dest_len {
        return;
    }

    let mut i = 0;
    while i &lt; dest_len &amp;&amp; dest[i] != 0 {
        i += 1;
    }

    let mut j = 0;
    while j &lt; src_len &amp;&amp; i &lt; dest_len {
        dest[i] = src[j];
        i += 1;
        j += 1;
    }

    if i &lt; dest_len {
        dest[i] = 0;
    }
}

// 转换f32浮点数到{整数.整数}
fn float_to_uint_point_uint(f: Option&lt;f32&gt;) -&gt; (u16, u16) {
    match(f){
        None=&gt;{
            return (0,0);
        }
        Some(f)=&gt;{
            let integer_part = f as u16;
            let decimal_part = ((f - integer_part as f32) * 10000.0) as u16;
            return (integer_part, decimal_part);
        }
    }//end match
}

// 测试:复制内容到字符数组
fn assign_string(str_value: &amp;[u8]) {
    let len = str_value.len().min(UART0_RX_BUFFER_SIZE);
    unsafe {
        UART0_RX_BUFFER[..len].copy_from_slice(&amp;str_value[..len]);
    }
}

// 判断字符数组是否以某个字符开头
fn starts_with_prefix(s: &amp;[u8], prefix: &amp;[u8]) -&gt; bool {
    if s.len() &lt; prefix.len() {
        return false;
    }

    for i in 0..prefix.len() {
        if s[i] != prefix[i] {
            return false;
        }
    }
    true
}

}

// 自定义的GCODE处理类
#[derive(PartialEq, Copy,Clone)]
struct MyGCODE {
main_command: u8,
sub_command: [u8; 7],
sub_command_num: Option<f32>,
command_args: [Option<f32>; 4],
command_has_args: [bool; 4],
}

impl MyGCODE {
// 去除gcode的注释
fn copy_valid_command(source: &[u8], destination: &mut [u8]) {
// 查找注释字符’;’
match MySTD::strchr(source, b’;‘) {
Some(index)=>{
// 复制源字符数组b’;‘之前的内容到目标字符数组
MySTD::strnncpy(destination, source, 0, index);
}
None => {
// 没有注释字符’;'，复制整个源字符数组到目标字符数组
MySTD::strcpy(destination, source);
}
}
}//end copy_valid_command

// 解析主命令
fn parse_main_command(_input: &amp;[u8]) -&gt; Option&lt;MyGCODE&gt; {
    let mut gcode = MyGCODE {
        main_command: 0,
        sub_command: [0; 7],
        sub_command_num: None,
        command_args: [None; 4],
        command_has_args: [false; 4],
    };
    
    match _input.get(0) {
        Some(&amp;b'G') =&gt; {
            gcode.main_command = b'G';
    
            if let space_0_pos = MySTD::strchr(&amp;_input[1..], b' ') {
                match(space_0_pos){
                    None =&gt;{
                        //没有找到空格,命令没有参数
                        let null_pos = MySTD::strlen(&amp;_input) - 1;
                        let sub_command = &amp;_input[1..(null_pos + 1)];
                        gcode.sub_command_num = MySTD::atof(sub_command);
                        gcode.parse_command_args(&amp;_input[1..(null_pos + 1)]);
                        gcode.exe_command();
                    }
                    Some(space_0_pos) =&gt;{
                        let sub_command = &amp;_input[1..(space_0_pos + 1)];
                        gcode.sub_command_num = MySTD::atof(sub_command);
                        gcode.parse_command_args(&amp;_input[1..(space_0_pos + 1)]);
                        gcode.exe_command();
                    }
                
                }//end match
            } 
            else if let null_pos = MySTD::strchr(&amp;_input[1..], b'\0') {
                match(null_pos){
                    None =&gt;{
                        //pass
                    }
                    Some(null_pos)=&gt;{
                        let sub_command = &amp;_input[1..(null_pos + 1)];
                        gcode.sub_command_num = MySTD::atof(sub_command);
                        gcode.parse_command_args(&amp;_input[1..(null_pos + 1)]);
                        gcode.exe_command();
                    }
                }//end match
                
            }
        },
        Some(&amp;b'M') =&gt; {
            gcode.main_command = b'M';
            if let space_0_pos = MySTD::strchr(&amp;_input[1..], b' ') {
                match(space_0_pos){
                    None=&gt;{
                        //没有空格,没有参数
                        let null_pos = MySTD::strlen(&amp;_input) - 1;
                        let sub_command = &amp;_input[1..(null_pos + 1)];
                        gcode.sub_command_num = MySTD::atof(sub_command);
                        gcode.parse_command_args(&amp;_input[1..(null_pos + 1)]);
                        gcode.exe_command();
                    }
                    Some(space_0_pos)=&gt;{
                        let sub_command = &amp;_input[1..(space_0_pos + 1)];
                        gcode.sub_command_num = MySTD::atof(sub_command);
                        gcode.parse_command_args(&amp;_input[1..(space_0_pos + 1)]);
                        gcode.exe_command();
                    }
                }//end match 
                
            } else if let null_pos = MySTD::strchr(&amp;_input[1..], b'\0') {
                match(null_pos){
                    None=&gt;{
                        //pass
                    }
                    Some(null_pos)=&gt;{
                        let sub_command = &amp;_input[1..(null_pos + 1)];
                        gcode.sub_command_num = MySTD::atof(sub_command);
                        gcode.parse_command_args(&amp;_input[1..(null_pos + 1)]);
                        gcode.exe_command();
                    }
                }//end match
            
            }//end null_pos
        },
        _ =&gt; {
            return None;
        }
    }//end match
    return Some(gcode);
}//end parse_main_command

// 解析命令参数
fn parse_command_args(&amp;mut self, _input: &amp;[u8]) {
    for (index, &amp;c) in _input.iter().enumerate() {
        match c {
            b'X' =&gt; {
                //println!("找到X");
                // 判断数组索引是否越界
                if(index == (MySTD::strlen(&amp;_input) - 1)){
                    return;
                }

                if let x_end = MySTD::strchr(&amp;_input[(index + 1)..], b' ') {
                    match(x_end){
                        None=&gt;{
                            let null_pos = MySTD::strlen(&amp;_input) - 1;
                            let x_value = &amp;_input[(index + 1)..(null_pos+1)];
                            self.command_args[0] = MySTD::atof(x_value);
                            //self.command_has_args[0] = true;
                        }
                        Some(x_end)=&gt;{
                            let x_value = &amp;_input[(index + 1)..(index + 1 + x_end)];
                            self.command_args[0] = MySTD::atof(x_value);
                            //self.command_has_args[0] = true;
                        }
                    }//end match
                 
                }
            },
            b'Y' =&gt; {
                // 判断数组索引是否越界
                if(index == (MySTD::strlen(&amp;_input) - 1)){
                    return;
                }

                if let y_end = MySTD::strchr(&amp;_input[(index + 1)..], b' ') {
                    match(y_end){
                        None=&gt;{
                            let null_pos = MySTD::strlen(&amp;_input) - 1;
                            let y_value = &amp;_input[(index + 1)..(null_pos+1)];
                            self.command_args[1] = MySTD::atof(y_value);
                            //self.command_has_args[1] = true;
                        }
                        Some(y_end)=&gt;{
                            let y_value = &amp;_input[(index + 1)..(index + 1 + y_end)];
                            self.command_args[1] = MySTD::atof(y_value);
                            //self.command_has_args[1] = true;
                        }
                    }//end match
                } 
            },
            b'Z' =&gt; {
                //println!("找到Z");
                // 判断数组索引是否越界
                if(index == (MySTD::strlen(&amp;_input) - 1)){
                    return;
                }

                if let z_end = MySTD::strchr(&amp;_input[(index + 1)..], b' ') {
                    match(z_end){
                        None=&gt;{
                            let null_pos = MySTD::strlen(&amp;_input) - 1;
                            let z_value = &amp;_input[(index + 1)..(null_pos+1)];
                            self.command_args[2] = MySTD::atof(z_value);
                            //self.command_has_args[2] = true;
                        }
                        Some(z_end)=&gt;{
                            let z_value = &amp;_input[(index + 1)..(index + 1 + z_end)];
                            self.command_args[2] = MySTD::atof(z_value);
                            //self.command_has_args[2] = true;
                        }
                    
                    }//end match
                   
                } //end if
            },
            b'F' =&gt; {
                //println!("找到F");

                // 判断数组索引是否越界
                if(index == (MySTD::strlen(&amp;_input) - 1)){
                    return;
                }

                if let f_end = MySTD::strchr(&amp;_input[(index + 1)..], b' ') {
                    match(f_end){
                        None=&gt;{
                            let null_pos = MySTD::strlen(&amp;_input) - 1;
                            let f_value = &amp;_input[(index + 1)..(null_pos+1)];
                            self.command_args[3] = MySTD::atof(f_value);
                            //self.command_has_args[3] = true;
                        }
                        Some(f_end)=&gt;{
                            let f_value = &amp;_input[(index + 1)..(index + 1 + f_end)];
                            self.command_args[3] = MySTD::atof(f_value);
                            //self.command_has_args[3] = true;
                        }
                    }//end match
                   
                }//end if
            },
            _ =&gt; {
                //println!("无效参数类型");
            }
        }//end match
    }//end for
}//end parse_command_args

// 根据子命令判断参数并调用对应的执行函数
fn exe_command(&amp;self) {
    match self.main_command {
        b'M' =&gt; {
            match(self.sub_command_num){
                None=&gt;{
                    //pass
                }

                Some(sub_command_num)=&gt;{
                    // 分割整数和小数
                    let (_subcommand_integer_part,_subcommand_decimal_part) = MySTD::float_to_uint_point_uint(Some(sub_command_num));

                    if(DEBUG_LEVEL_0 == true){
                        println!("-&gt;M:{}.{}", _subcommand_integer_part,_subcommand_decimal_part);
                    }

            // 根据子命令判断
            match(_subcommand_decimal_part){
                /*
                * M0:强制停止程序,Mandatory Program Stop:
                */
                0=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("M:{}子命令",_subcommand_integer_part);
                    }
                }// end M0

                /*
                * M1:可选停止程序,Optional Program Stop
                */
                1=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("M:{}子命令",_subcommand_integer_part);
                    }
                }// end M1

                /*
                * M2:程序结束,Program End
                */
                2=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("M:{}子命令",_subcommand_integer_part);
                    }
                }// end M2

                /*
                * M3:主轴向前/顺时针,Spindle Forward/Clockwise
                */
                3=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("M:{}子命令",_subcommand_integer_part);
                    }
                }// end M3

                /*
                * M4:主轴反向/逆时针,Spindle Reverse/Counterclockwise
                */
                4=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("M:{}子命令",_subcommand_integer_part);
                    }
                }// end M4

                /*
                * M5:主轴停止,Spindle Stop
                */
                5=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("M:{}子命令",_subcommand_integer_part);
                    }
                }// end M5

                /*
                * M6:切换工具,Tool Change
                */
                6=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("M:{}子命令",_subcommand_integer_part);
                    }
                }// end M6

                /*
                * M7:喷雾冷却剂开启,Mist Coolant On
                */
                7=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("M:{}子命令",_subcommand_integer_part);
                    }
                }// end M7

                /*
                * M8:打开冷却液,Flood Coolant On
                */
                8=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("M:{}子命令",_subcommand_integer_part);
                    }
                }// end M8

                /*
                * M9:喷雾冷却剂关闭,All Coolant Off
                */
                9=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("M:{}子命令",_subcommand_integer_part);
                    }
                }// end M9

                /*
                * M19:主轴定向,Spindle Orient
                */
                19=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("M:{}子命令",_subcommand_integer_part);
                    }
                }// end M19

                /*
                * M30:结束程序重头开始,Program End and Rewind
                */
                30=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("M:{}子命令",_subcommand_integer_part);
                    }
                }// end M30

                /*
                * M40:变速到0,Gear Change to 0
                */
                40=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("M:{}子命令",_subcommand_integer_part);
                    }
                }// end M40

                /*
                * M41:变速到1,Gear Change to 1
                */
                41=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("M:{}子命令",_subcommand_integer_part);
                    }
                }// end M41

                /*
                * M42:变速到2,Gear Change to 2
                */
                42=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("M:{}子命令",_subcommand_integer_part);
                    }
                }// end M42

                /*
                * M43:变速到3,Gear Change to 3
                */
                43=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("M:{}子命令",_subcommand_integer_part);
                    }
                }// end M43

                /*
                * M44:变速到4,Gear Change to 4
                */
                44=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("M:{}子命令",_subcommand_integer_part);
                    }
                }// end M44

                /*
                * M45:变速到5,Gear Change to 5
                */
                45=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("M:{}子命令",_subcommand_integer_part);
                    }
                }// end M45

                /*
                * M47:从第一行开始重复程序,Repeat Program from First Line
                */
                47=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("M:{}子命令",_subcommand_integer_part);
                    }
                }// end M47

                /*
                * M48:启用进给速度/主轴速度覆盖,Enable Feed rate/Spindle Speed Overrides
                */
                48=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("M:{}子命令",_subcommand_integer_part);
                    }
                }// end M48

                /*
                * M49:禁用进给速度/主轴速度覆盖,Disable Feed rate/Spindle Speed Overrides
                */
                49=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("M:{}子命令",_subcommand_integer_part);
                    }
                }// end M49

                /*
                * M98:调用子程序,Subprogram Call
                */
                98=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("M:{}子命令",_subcommand_integer_part);
                    }
                }// end M98

                /*
                * M99:回到主程序,Return to main program
                */
                99=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("M:{}子命令",_subcommand_integer_part);
                    }
                }// end M99

                /*
                * M228:Macro for Go To Positions
                * It takes a P(1-14) parameter for which position it goes to,
                * follow in the order that the positions are listed in the screen configuration dialog.
                */
                228=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("M:{}子命令",_subcommand_integer_part);
                    }
                }// end M228

                /*
                * 其他情况
                * M200 – M221: Macros to turn outputs on/off
                */
                _=&gt;{
                    println!("M:undefine:{}子命令",_subcommand_integer_part); 
                }
            }//end match

        }//end Some
    }//end match
        },
        b'G' =&gt; {
            match(self.sub_command_num){
                None=&gt;{
                    //pass
                }
                Some(sub_command_num)=&gt;{

            
            // 分割整数和小数
            let (_subcommand_integer_part,_subcommand_decimal_part) = MySTD::float_to_uint_point_uint(Some(sub_command_num));

            if(DEBUG_LEVEL_0 == true){
                println!("-&gt;G:{}.{}", _subcommand_integer_part,_subcommand_decimal_part);
            }

            // 根据子命令判断参数并调用对应的执行函数
            match(_subcommand_decimal_part){
                /*
                * G0:快速移动,Rapid Move
                * 参数:X,Y,Z,F
                * 备注:G90绝对坐标,G91相对坐标
                */
                0=&gt;{
                    println!("G:{}子命令",_subcommand_integer_part);

                    match(self.command_args[0]){
                        None=&gt;{
                            //没有X参数
                        }
                        Some(_x)=&gt;{
                            let (_x_integer_part,_x_decimal_part) = MySTD::float_to_uint_point_uint(Some(_x));
                            println!("X:{}.{}",_x_integer_part,_x_decimal_part);
                        }
                    }//end match X

                    match(self.command_args[1]){
                        None=&gt;{
                            //没有Y参数
                        }
                        Some(_y)=&gt;{
                            let (_y_integer_part,_y_decimal_part) = MySTD::float_to_uint_point_uint(Some(_y));
                            println!("Y:{}.{}",_y_integer_part,_y_decimal_part);
                        }
                    }//end match Y

                    match(self.command_args[2]){
                        None=&gt;{
                            //没有Z参数
                        }
                        Some(_z)=&gt;{
                            let (_z_integer_part,_z_decimal_part) = MySTD::float_to_uint_point_uint(Some(_z));
                            println!("Z:{}.{}",_z_integer_part,_z_decimal_part);
                        }
                    }//end match Z

                    match(self.command_args[3]){
                        None=&gt;{
                            //没有F参数
                        }
                        Some(_f)=&gt;{
                            let (_f_integer_part,_f_decimal_part) = MySTD::float_to_uint_point_uint(Some(_f));
                            println!("F:{}.{}",_f_integer_part,_f_decimal_part);
                        }
                    }//end match F
                }//end G0

                /*
                * G1:线性进给移动,Linear Feed Move
                * 参数:X,Y,Z,F
                * 备注:G90绝对坐标,G91相对坐标
                */
                1=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("G:{}子命令",_subcommand_integer_part);
                    }

                    match(self.command_args[0]){
                        None=&gt;{
                            //没有X参数
                        }
                        Some(_x)=&gt;{
                            let (_x_integer_part,_x_decimal_part) = MySTD::float_to_uint_point_uint(Some(_x));
                            println!("X:{}.{}",_x_integer_part,_x_decimal_part);
                        }
                    }//end match X

                    match(self.command_args[1]){
                        None=&gt;{
                            //没有Y参数
                        }
                        Some(_y)=&gt;{
                            let (_y_integer_part,_y_decimal_part) = MySTD::float_to_uint_point_uint(Some(_y));
                            println!("Y:{}.{}",_y_integer_part,_y_decimal_part);
                        }
                    }//end match Y

                    match(self.command_args[2]){
                        None=&gt;{
                            //没有Z参数
                        }
                        Some(_z)=&gt;{
                            let (_z_integer_part,_z_decimal_part) = MySTD::float_to_uint_point_uint(Some(_z));
                            println!("Z:{}.{}",_z_integer_part,_z_decimal_part);
                        }
                    }//end match Z

                    match(self.command_args[3]){
                        None=&gt;{
                            //没有F参数
                        }
                        Some(_f)=&gt;{
                            let (_f_integer_part,_f_decimal_part) = MySTD::float_to_uint_point_uint(Some(_f));
                            println!("F:{}.{}",_f_integer_part,_f_decimal_part);
                        }
                    }//end match F
                   
                }//end G1

                /*
                * G02:顺时针圆弧进给移动,Clockwise Arc Feed Move
                * 参数:X,Y,Z,F
                * 备注:G90绝对坐标,G91相对坐标
                */
                2=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("G:{}子命令",_subcommand_integer_part);
                    }
                }//end G2

                3=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("G:{}子命令",_subcommand_integer_part);
                    }
                }//end G3

                4=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("G:{}子命令",_subcommand_integer_part);
                    }
                }//end G4

                5=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("G:{}子命令",_subcommand_integer_part);
                    }
                }//end G5

                6=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("G:{}子命令",_subcommand_integer_part);
                    }
                }//end G6

                7=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("G:{}子命令",_subcommand_integer_part);
                    }
                }//end G7

                8=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("G:{}子命令",_subcommand_integer_part);
                    }
                }//end G8

                9=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("G:{}子命令",_subcommand_integer_part);
                    }
                }//end G9

                10=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("G:{}子命令",_subcommand_integer_part);
                    }
                }//end G10

                11=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("G:{}子命令",_subcommand_integer_part);
                    }
                }//end G11

                12=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("G:{}子命令",_subcommand_integer_part);
                    }
                }//end G12

                13=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("G:{}子命令",_subcommand_integer_part);
                    }
                }//end G13

                14=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("G:{}子命令",_subcommand_integer_part);
                    }
                }//end G14

                15=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("G:{}子命令",_subcommand_integer_part);
                    }
                }//end G15

                16=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("G:{}子命令",_subcommand_integer_part);
                    }
                }//end G16

                17=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("G:{}子命令",_subcommand_integer_part);
                    }
                }//end G17

                18=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("G:{}子命令",_subcommand_integer_part);
                    }
                }//end G18

                19=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("G:{}子命令",_subcommand_integer_part);
                    }
                }//end G19

                20=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("G:{}子命令",_subcommand_integer_part);
                    }
                }//end G20

                21=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("G:{}子命令",_subcommand_integer_part);
                    }
                }//end G21

                22 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G22
                23 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G23
                24 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G24
                25 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G25
                26 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G26
                27 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G27
                28 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G28
                29 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G29
                30 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G30

                31 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G31

                32 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G32

                33 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G33

                34 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G34

                35 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G35

                36 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G36

                37 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G37

                38 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G38

                39 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G39

                40 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G40

                41 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G41

                42 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G42

                43 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G43

                44 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G44

                45 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G45

                46 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G46

                47 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G47

                48 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G48

                49 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G49

                50 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G50
                
                51 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G51

                52 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G52

                53 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G53

                54 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G54

                55 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G55

                56 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G56

                57 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G57

                58 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G58

                59 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G59

                60 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G60

                61 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G61

                62 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G62

                63 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G63

                64 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G64

                65 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G65

                66 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G66

                67 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G67

                68 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G68

                69 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G69

                70 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G70

                71 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G71

                72 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G72

                73 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G73

                74 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G74

                75 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G75

                76 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G76

                77 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G77

                78 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G78

                79 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G79

                80 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G80

                81 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G81

                82 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G82

                83 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G83

                84 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G84

                85 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G85

                86 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G86

                87 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G87

                88 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G88

                89 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G89

                90 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G90

                91 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G91

                92 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G92

                93 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G93

                94 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G94

                95 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G95

                96 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G96

                97 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G97

                98 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G98

                99 =&gt; {
                    if DEBUG_LEVEL_0 {
                        println!("G:{}子命令", _subcommand_integer_part);
                    }
                } // end G99

                /*
                * 其他子命令
                */
                _=&gt;{
                    if(DEBUG_LEVEL_0==true){
                        println!("G:undefined:{}子命令",_subcommand_integer_part);
                    }
                }
            }//end match

        }//end Some
    }//end match
    
        }//end 'G'
        
        _ =&gt; {
            println!("无效的GCODE命令")
        }
    }//end match
}//end exe_command

}//end MyGCODE

/* end 自定义类型 */

/* start 全局变量 /
static TIMER0: Mutex<RefCell<Option<Timer<Timer0<TIMG0>>>>> = Mutex::new(RefCell::new(None));
static TIMER1: Mutex<RefCell<Option<Timer<Timer0<TIMG1>>>>> = Mutex::new(RefCell::new(None));
static mut LED_D4: Option<esp32c3_hal::gpio::Gpio12<Output<PushPull>>> = None;
static mut LED_D5: Option<esp32c3_hal::gpio::Gpio13<Output<PushPull>>> = None;
static SERIAL0: Mutex<RefCell<Option<Uart<UART0>>>> = Mutex::new(RefCell::new(None));
// 创建一个静态数组作为字符缓冲区
const UART0_RX_BUFFER_SIZE: usize = 32;
static mut UART0_RX_BUFFER: [u8; UART0_RX_BUFFER_SIZE] = [0; UART0_RX_BUFFER_SIZE];
static mut UART0_RX_BUF_INDEX: usize = 0; // 缓冲区当前索引
//调试参数
const DEBUG_LEVEL_0:bool = true;
const DEBUG_LEVEL_1:bool = true;
/ end 全局变量 */

/* start 程序入口点 */
#[entry]
fn main() -> ! {
// 实例化对象和定义变量
let peripherals = Peripherals::take();
let mut system = peripherals.SYSTEM.split();
let clocks = ClockControl::boot_defaults(system.clock_control).freeze();
let mut uart0 = Uart::new(peripherals.UART0, &mut system.peripheral_clock_control);

// TIMG0和TIMG1各自包含一个通用定时器和一个看门狗定时器
let mut rtc = Rtc::new(peripherals.RTC_CNTL);
let timer_group0 = TimerGroup::new(peripherals.TIMG0, &amp;clocks,&amp;mut system.peripheral_clock_control);
let mut wdt0 = timer_group0.wdt;
let mut timer0 = timer_group0.timer0;
let timer_group1 = TimerGroup::new(peripherals.TIMG1, &amp;clocks,&amp;mut system.peripheral_clock_control);
let mut wdt1 = timer_group1.wdt;
let mut timer1 = timer_group1.timer0;

// 延时函数初始化
let mut delay = Delay::new(&amp;clocks);

// 配置gpio口
let io = IO::new(peripherals.GPIO, peripherals.IO_MUX);

// 配置uart0串口
uart0.set_rx_fifo_full_threshold(1).unwrap();
uart0.listen_rx_fifo_full();

// 初始化串口中断
critical_section::with(|cs| SERIAL0.borrow_ref_mut(cs).replace(uart0));
interrupt::enable(
    peripherals::Interrupt::UART0,
    interrupt::Priority::Priority1,//1级中断优先级
)
.unwrap();
interrupt::set_kind(
    Cpu::ProCpu,
    interrupt::CpuInterrupt::Interrupt1, 
    interrupt::InterruptKind::Edge,
);

// 配置引脚功能
unsafe {
    LED_D4.replace(io.pins.gpio12.into_push_pull_output());
    LED_D5.replace(io.pins.gpio13.into_push_pull_output());
}

// 初始化定时器0中断
interrupt::enable(
    peripherals::Interrupt::TG0_T0_LEVEL,
    interrupt::Priority::Priority2,
)
.unwrap();
timer0.start(500u64.millis());
timer0.listen();

// 初始化定时器1中断
interrupt::enable(
    peripherals::Interrupt::TG1_T0_LEVEL,
    interrupt::Priority::Priority2,
)
.unwrap();
timer1.start(1u64.secs());
timer1.listen();

// 打开定时器引用锁Mutex,使得定时器中断handler安全跳转
critical_section::with(|cs| {
    TIMER0.borrow_ref_mut(cs).replace(timer0);
    TIMER1.borrow_ref_mut(cs).replace(timer1);
});//end critical_section

// 允许中断
unsafe {
    riscv::interrupt::enable();
}

unsafe{
    //测试
    if(DEBUG_LEVEL_1 == true){
        let mut mystr = MyString::new();
        mystr.append("G00");
        let mut mydict = MyStringDictionary::new();
        let mut key1 = MyString::new();
        key1.append("G00");
        let mut value1 = MyString::new();
        value1.append("Rapid Move");
        mydict.insert(&amp;key1, &amp;value1);

        match mydict.get(&amp;mystr) {
            Some(val) =&gt; {
                let mut result = MyString::new();
                for i in 0..val.length {
                    result.push(val.chars[i]);
                }
                print_my_string(&amp;result);
            },
            None =&gt; println!("Not found!"),
        }

        fn print_my_string(s: &amp;MyString) {
            for i in 0..s.length {
                print!("{}", s.chars[i] as char);
            }
            println!();
        }
    }
}//end unsafe

unsafe{
    print!("Compute(ziglang):");
    unsafe {
        println!("{}", add(4,5));
    }
}

// 开始循环
loop {
    //println!("Compute(ziglang):");
    test_uart();// 分析串口命令
    //delay.delay_ms(2000u32);//延时2000ms
}

}
/* end 程序入口点 */

/* start 中断处理函数 */
// 定时器0中断处理函数
#[interrupt]
fn TG0_T0_LEVEL() {
critical_section::with(|cs| {
//esp_println::println!(“Interrupt 1”);

    //翻转led_d5电平
    unsafe {
        if let Some(led) = &amp;mut LED_D5 {
            led.toggle();
        } else {
            esp_println::println!("Toggle LED_D5 failed!");
        }
    }

    let mut timer0 = TIMER0.borrow_ref_mut(cs);
    let timer0 = timer0.as_mut().unwrap();

    timer0.clear_interrupt();
    timer0.start(500u64.millis());
});//end critical_section

}

// 定时器1中断处理函数
#[interrupt]
fn TG1_T0_LEVEL() {
critical_section::with(|cs| {
//esp_println::println!(“Interrupt 11”);

    //翻转led_d4电平
    unsafe {
        if let Some(led) = &amp;mut LED_D4 {
            led.toggle();
        } else {
            esp_println::println!("Toggle LED_D4 failed!");
        }
    }

    let mut timer1 = TIMER1.borrow_ref_mut(cs);
    let timer1 = timer1.as_mut().unwrap();

    timer1.clear_interrupt();
    timer1.start(1u64.secs());
});//end critical_section

}

// 串口0中断处理函数
#[interrupt]
fn UART0() {
critical_section::with(|cs| {
let mut serial = SERIAL0.borrow_ref_mut(cs);
let serial = serial.as_mut().unwrap();

    let mut cnt = 0; //串口接收计数
    while let nb::Result::Ok(_c) = serial.read() {
        cnt += 1;//计数自增

        // 将接收到的字符加入到字符缓冲区
        unsafe {
            if UART0_RX_BUF_INDEX &lt; UART0_RX_BUFFER_SIZE {
                UART0_RX_BUFFER[UART0_RX_BUF_INDEX] = _c;
                UART0_RX_BUF_INDEX += 1;
            }
        }
    }//end while

    if(DEBUG_LEVEL_0 == true){
        writeln!(serial, "Read {} bytes", cnt,).ok();
    }
    
    // 重置串口中断标志
    serial.reset_rx_fifo_full_interrupt();

});//end critical_section

}
/* end 中断处理函数 */

/* start 自定义函数 */
// 测试专用:按位赋值数组
fn assign_string(str_value: &[u8]) {
unsafe {
UART0_RX_BUFFER.copy_from_slice(&str_value[…UART0_RX_BUFFER_SIZE]);
}
}

// 测试串口
fn test_uart(){
// 判断串口缓冲区中是否有字符
unsafe{
if(UART0_RX_BUFFER[0] == 0){
return;
}
}

// 复制字符串
let mut uart0_char_buf:[u8;48]=[0;48];
unsafe{
    let len = MySTD::strlen(&amp;UART0_RX_BUFFER);
    MySTD::strnncpy(&amp;mut uart0_char_buf,&amp;UART0_RX_BUFFER,0,len);
}

// 打印字符缓冲区中的字符
unsafe {
    // 复制字符串
    if(DEBUG_LEVEL_0 == true){
        print!("Rec:");
        MySTD::strprint(&amp;uart0_char_buf);
    }
}// end unsafe

 // 清空缓存区
 unsafe{
    UART0_RX_BUF_INDEX = 0; // 清空缓冲区索引
    UART0_RX_BUFFER[0]=0;
}

// 分析字符串
unsafe{
    let my_gcode_command = MyGCODE::parse_main_command(&amp;uart0_char_buf);
    match(my_gcode_command){
        None=&gt;{
            if(DEBUG_LEVEL_0 == true){
                println!("no valid GCODE");
            }
        }
        Some(mut _gcode_command)=&gt;{
            //解析命令参数
            _gcode_command.parse_command_args(&amp;uart0_char_buf);
            if(DEBUG_LEVEL_0 == true){
                println!("/* start GCODE */");
                print!("main_command:{}\n",_gcode_command.main_command as char);
                //print!("子命令:{}\n",_gcode_command.sub_command_num as f32);
                // 分割整数和小数
                let (_subcommand_integer_part,_subcommand_decimal_part) = MySTD::float_to_uint_point_uint(_gcode_command.sub_command_num);
                println!("-&gt;sub_command:{}.{}", _subcommand_integer_part,_subcommand_decimal_part);
                match(_gcode_command.command_args[0]){
                    None=&gt;{
                        //没有X参数
                    }
                    Some(_x)=&gt;{
                        let (_x_integer_part,_x_decimal_part) = MySTD::float_to_uint_point_uint(Some(_x));
                        println!("X:{}.{}",_x_integer_part,_x_decimal_part);
                    }
                }//end match X

                match(_gcode_command.command_args[1]){
                    None=&gt;{
                        //没有Y参数
                    }
                    Some(_y)=&gt;{
                        let (_y_integer_part,_y_decimal_part) = MySTD::float_to_uint_point_uint(Some(_y));
                        println!("Y:{}.{}",_y_integer_part,_y_decimal_part);
                    }
                }//end match Y

                match(_gcode_command.command_args[2]){
                    None=&gt;{
                        //没有Z参数
                    }
                    Some(_z)=&gt;{
                        let (_z_integer_part,_z_decimal_part) = MySTD::float_to_uint_point_uint(Some(_z));
                        println!("Z:{}.{}",_z_integer_part,_z_decimal_part);
                    }
                }//end match Z

                match(_gcode_command.command_args[3]){
                    None=&gt;{
                        //没有F参数
                    }
                    Some(_f)=&gt;{
                        let (_f_integer_part,_f_decimal_part) = MySTD::float_to_uint_point_uint(Some(_f));
                        println!("F:{}.{}",_f_integer_part,_f_decimal_part);
                    }
                }//end match F
                
                println!("/* end GCODE */")
            }//end DEBUG_LEVEL_0

        }//end Some
    }//end match

}//end unsafe

}
/* end 自定义函数 */

效果

esp32笔记[9]-rust的串口收发及GCODE解析

scand123

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
esp32笔记[9]-rust的串口收发及GCODE解析

使用rust在no-std环境下实现esp32-c3串口收发及gcode解析.GCODE是一种用于控制数控机床和3D打印机等数控设备的编程语言。在GCODE中，RS274D和RS274X是两种常见的格式。RS274D是GCODE的早期版本，也称为基本GERBER格式。它使用坐标数据和功能码来描述运动和操作。RS274D格式的文件通常需要附带D码文件才能完整描述图形。RS274X是GCODE的扩展版本，也称为扩展GERBER格式。
复制链接

扫一扫