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 153 154 155
use super::FlashLayout; use std::time::Duration; /// A structure to manage the flashing procedure progress reporting. /// /// This struct stores a handler closure which will be called everytime an event happens during the flashing process. /// Such an event can be start or finish of the flashing procedure or a progress report, as well as some more events. /// /// ``` /// use probe_rs::flashing::FlashProgress; /// /// // Print events /// let progress = FlashProgress::new(|event| println!("Event: {:#?}", event)); /// ``` pub struct FlashProgress { handler: Box<dyn Fn(ProgressEvent)>, } impl FlashProgress { /// Create a new `FlashProgress` structure with a given `handler` to be called on events. pub fn new(handler: impl Fn(ProgressEvent) + 'static) -> Self { Self { handler: Box::new(handler), } } /// Emit a flashing progress event. fn emit(&self, event: ProgressEvent) { (self.handler)(event); } /// Signalize that the flashing algorithm was set up and is initialized. pub(super) fn initialized(&self, flash_layout: FlashLayout) { self.emit(ProgressEvent::Initialized { flash_layout }); } /// Signalize that the erasing procedure started. pub(super) fn started_erasing(&self) { self.emit(ProgressEvent::StartedErasing); } /// Signalize that the filling procedure started. pub(super) fn started_filling(&self) { self.emit(ProgressEvent::StartedFilling); } /// Signalize that the programing procedure started. pub(super) fn started_programming(&self) { self.emit(ProgressEvent::StartedProgramming); } /// Signalize that the page programming procedure has made progress. pub(super) fn page_programmed(&self, size: u32, time: Duration) { self.emit(ProgressEvent::PageProgrammed { size, time }); } /// Signalize that the sector erasing procedure has made progress. pub(super) fn sector_erased(&self, size: u32, time: Duration) { self.emit(ProgressEvent::SectorErased { size, time }); } /// Signalize that the page filling procedure has made progress. pub(super) fn page_filled(&self, size: u32, time: Duration) { self.emit(ProgressEvent::PageFilled { size, time }); } /// Signalize that the programming procedure failed. pub(super) fn failed_programming(&self) { self.emit(ProgressEvent::FailedProgramming); } /// Signalize that the programming procedure completed successfully. pub(super) fn finished_programming(&self) { self.emit(ProgressEvent::FinishedProgramming); } /// Signalize that the erasing procedure failed. pub(super) fn failed_erasing(&self) { self.emit(ProgressEvent::FailedErasing); } /// Signalize that the erasing procedure completed successfully. pub(super) fn finished_erasing(&self) { self.emit(ProgressEvent::FinishedErasing); } /// Signalize that the filling procedure failed. pub(super) fn failed_filling(&self) { self.emit(ProgressEvent::FailedFilling); } /// Signalize that the filling procedure completed successfully. pub(super) fn finished_filling(&self) { self.emit(ProgressEvent::FinishedFilling); } } /// Possible events during the flashing process. /// /// If flashing works without problems, the events will arrive in the /// following order: /// /// * `Initialized` /// * `StartedFilling` /// * `PageFilled` for every page /// * `FinishedFilling` /// * `StartedErasing` /// * `SectorErased` for every sector /// * `FinishedErasing` /// * `StartedProgramming` /// * `PageProgrammed` for every page /// * `FinishedProgramming` /// /// If an erorr occurs in any stage, one of the `Failed*` event will be returned, /// and no further events will be returned. #[derive(Debug)] pub enum ProgressEvent { Initialized { flash_layout: FlashLayout, }, /// Filling of flash pages has started. StartedFilling, /// A page has been filled successfully. PageFilled { size: u32, time: Duration, }, /// Filling of the pages has failed. FailedFilling, /// Filling of the pages has finished successfully. FinishedFilling, /// Erasing of flash has started. StartedErasing, /// A sector has been erased successfully. SectorErased { size: u32, time: Duration, }, /// Erasing of the flash has failed. FailedErasing, /// Erasing of the flash has finished successfully. FinishedErasing, /// Programming of the flash has started. StartedProgramming, /// A flash page has been programmed successfully. PageProgrammed { size: u32, time: Duration, }, /// Programming of the flash failed. FailedProgramming, /// Programming of the flash has finished successfully. FinishedProgramming, }