prinThor 0.0.3

The highly reliable but not necessarily functional 3D Printer firmware
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

//! This feature is being stablished
// This module provides a task that notifies to the usart the acceptation or the completion of the
// gcodes that aren't processed immediately, so processor can accept more
// Some firmwares resolves this by allocating extra space in the queue, but that case issues because you can get blocked
use crate::hwa;
#[cfg(feature = "with-motion")]
use printhor_hwa_common::{DeferEvent, DeferType};
#[allow(unused)]
#[allow(unreachable_patterns)]
#[embassy_executor::task(pool_size=1)]
pub async fn defer_task(
    mut processor: hwa::GCodeProcessor,
) -> ! {
    hwa::debug!("defer_task started");
    let mut num_homes = 0u8;
    let mut num_linear = 0u8;
    let mut num_rapid = 0u8;
    let mut num_dwell = 0u8;
    #[cfg(feature = "with-hotend")]
    let mut num_hotend = 0u8;
    #[cfg(feature = "with-hotbed")]
    let mut num_hotbed = 0u8;

    loop {
        match processor.motion_planner.defer_channel.receive().await {
            DeferEvent::Homing(DeferType::AwaitRequested) => {
                num_homes += 1;
            }
            DeferEvent::Homing(DeferType::Completed) => {
                if num_homes > 0 {
                    num_homes -= 1;
                    // FIXME: Control when a confirmation is needed from specific channel
                    processor.write("ok; G28 completed (@defer_task)\n").await;
                }
            }
            DeferEvent::Dwell(DeferType::AwaitRequested) => {
                num_dwell += 1;
            }
            DeferEvent::Dwell(DeferType::Completed) => {
                if num_dwell > 0 {
                    num_dwell -= 1;
                    processor.write("ok; G4 completed (@defer_task)\n").await;
                }
            }
            DeferEvent::LinearMove(DeferType::AwaitRequested) => {
                num_linear += 1;
            }
            DeferEvent::LinearMove(DeferType::Completed) => {
                if num_linear > 0 {
                    num_linear -= 1;
                    //processor.write("ok; G1 completed (@defer_task)\n").await;
                }
            }
            DeferEvent::RapidMove(DeferType::AwaitRequested) => {
                num_rapid += 1;
            }
            DeferEvent::RapidMove(DeferType::Completed) => {
                if num_rapid > 0 {
                    num_rapid -= 1;
                    //processor.write("ok; G0 completed (@defer_task)\n").await;
                }
            }
            #[cfg(feature = "with-hotend")]
            DeferEvent::HotendTemperature(DeferType::AwaitRequested) => {
                num_hotend += 1;
            }
            #[cfg(feature = "with-hotend")]
            DeferEvent::HotendTemperature(DeferType::Completed) => {
                if num_hotend > 0 {
                    num_hotend -= 1;
                    processor.write("ok; M109 completed (@defer_task)\n").await;
                }
            }
            #[cfg(feature = "with-hotbed")]
            DeferEvent::HotbedTemperature(DeferType::AwaitRequested) => {
                num_hotbed += 1;
            }
            #[cfg(feature = "with-hotbed")]
            DeferEvent::HotbedTemperature(DeferType::Completed) => {
                if num_hotbed > 0 {
                    num_hotbed -= 1;
                    processor.write("ok; M190 completed (@defer_task)\n").await;
                }
            }
        }
    }
}