1#[doc = "Register `MSR` reader"]
2pub type R = crate::R<MsrSpec>;
3#[doc = "Register `MSR` writer"]
4pub type W = crate::W<MsrSpec>;
5#[doc = "Transmit Data Flag\n\nValue on reset: 1"]
6#[cfg_attr(feature = "defmt", derive(defmt::Format))]
7#[derive(Clone, Copy, Debug, PartialEq, Eq)]
8pub enum Tdf {
9 #[doc = "0: Transmit data not requested"]
10 Disabled = 0,
11 #[doc = "1: Transmit data requested"]
12 Enabled = 1,
13}
14impl From<Tdf> for bool {
15 #[inline(always)]
16 fn from(variant: Tdf) -> Self {
17 variant as u8 != 0
18 }
19}
20#[doc = "Field `TDF` reader - Transmit Data Flag"]
21pub type TdfR = crate::BitReader<Tdf>;
22impl TdfR {
23 #[doc = "Get enumerated values variant"]
24 #[inline(always)]
25 pub const fn variant(&self) -> Tdf {
26 match self.bits {
27 false => Tdf::Disabled,
28 true => Tdf::Enabled,
29 }
30 }
31 #[doc = "Transmit data not requested"]
32 #[inline(always)]
33 pub fn is_disabled(&self) -> bool {
34 *self == Tdf::Disabled
35 }
36 #[doc = "Transmit data requested"]
37 #[inline(always)]
38 pub fn is_enabled(&self) -> bool {
39 *self == Tdf::Enabled
40 }
41}
42#[doc = "Receive Data Flag\n\nValue on reset: 0"]
43#[cfg_attr(feature = "defmt", derive(defmt::Format))]
44#[derive(Clone, Copy, Debug, PartialEq, Eq)]
45pub enum Rdf {
46 #[doc = "0: Receive data not ready"]
47 Disabled = 0,
48 #[doc = "1: Receive data ready"]
49 Enabled = 1,
50}
51impl From<Rdf> for bool {
52 #[inline(always)]
53 fn from(variant: Rdf) -> Self {
54 variant as u8 != 0
55 }
56}
57#[doc = "Field `RDF` reader - Receive Data Flag"]
58pub type RdfR = crate::BitReader<Rdf>;
59impl RdfR {
60 #[doc = "Get enumerated values variant"]
61 #[inline(always)]
62 pub const fn variant(&self) -> Rdf {
63 match self.bits {
64 false => Rdf::Disabled,
65 true => Rdf::Enabled,
66 }
67 }
68 #[doc = "Receive data not ready"]
69 #[inline(always)]
70 pub fn is_disabled(&self) -> bool {
71 *self == Rdf::Disabled
72 }
73 #[doc = "Receive data ready"]
74 #[inline(always)]
75 pub fn is_enabled(&self) -> bool {
76 *self == Rdf::Enabled
77 }
78}
79#[doc = "End Packet Flag\n\nValue on reset: 0"]
80#[cfg_attr(feature = "defmt", derive(defmt::Format))]
81#[derive(Clone, Copy, Debug, PartialEq, Eq)]
82pub enum Epf {
83 #[doc = "0: No Stop or repeated Start generated"]
84 IntNo = 0,
85 #[doc = "1: Stop or repeated Start generated"]
86 IntYes = 1,
87}
88impl From<Epf> for bool {
89 #[inline(always)]
90 fn from(variant: Epf) -> Self {
91 variant as u8 != 0
92 }
93}
94#[doc = "Field `EPF` reader - End Packet Flag"]
95pub type EpfR = crate::BitReader<Epf>;
96impl EpfR {
97 #[doc = "Get enumerated values variant"]
98 #[inline(always)]
99 pub const fn variant(&self) -> Epf {
100 match self.bits {
101 false => Epf::IntNo,
102 true => Epf::IntYes,
103 }
104 }
105 #[doc = "No Stop or repeated Start generated"]
106 #[inline(always)]
107 pub fn is_int_no(&self) -> bool {
108 *self == Epf::IntNo
109 }
110 #[doc = "Stop or repeated Start generated"]
111 #[inline(always)]
112 pub fn is_int_yes(&self) -> bool {
113 *self == Epf::IntYes
114 }
115}
116#[doc = "Field `EPF` writer - End Packet Flag"]
117pub type EpfW<'a, REG> = crate::BitWriter1C<'a, REG, Epf>;
118impl<'a, REG> EpfW<'a, REG>
119where
120 REG: crate::Writable + crate::RegisterSpec,
121{
122 #[doc = "No Stop or repeated Start generated"]
123 #[inline(always)]
124 pub fn int_no(self) -> &'a mut crate::W<REG> {
125 self.variant(Epf::IntNo)
126 }
127 #[doc = "Stop or repeated Start generated"]
128 #[inline(always)]
129 pub fn int_yes(self) -> &'a mut crate::W<REG> {
130 self.variant(Epf::IntYes)
131 }
132}
133#[doc = "Stop Detect Flag\n\nValue on reset: 0"]
134#[cfg_attr(feature = "defmt", derive(defmt::Format))]
135#[derive(Clone, Copy, Debug, PartialEq, Eq)]
136pub enum Sdf {
137 #[doc = "0: No Stop condition generated"]
138 IntNo = 0,
139 #[doc = "1: Stop condition generated"]
140 IntYes = 1,
141}
142impl From<Sdf> for bool {
143 #[inline(always)]
144 fn from(variant: Sdf) -> Self {
145 variant as u8 != 0
146 }
147}
148#[doc = "Field `SDF` reader - Stop Detect Flag"]
149pub type SdfR = crate::BitReader<Sdf>;
150impl SdfR {
151 #[doc = "Get enumerated values variant"]
152 #[inline(always)]
153 pub const fn variant(&self) -> Sdf {
154 match self.bits {
155 false => Sdf::IntNo,
156 true => Sdf::IntYes,
157 }
158 }
159 #[doc = "No Stop condition generated"]
160 #[inline(always)]
161 pub fn is_int_no(&self) -> bool {
162 *self == Sdf::IntNo
163 }
164 #[doc = "Stop condition generated"]
165 #[inline(always)]
166 pub fn is_int_yes(&self) -> bool {
167 *self == Sdf::IntYes
168 }
169}
170#[doc = "Field `SDF` writer - Stop Detect Flag"]
171pub type SdfW<'a, REG> = crate::BitWriter1C<'a, REG, Sdf>;
172impl<'a, REG> SdfW<'a, REG>
173where
174 REG: crate::Writable + crate::RegisterSpec,
175{
176 #[doc = "No Stop condition generated"]
177 #[inline(always)]
178 pub fn int_no(self) -> &'a mut crate::W<REG> {
179 self.variant(Sdf::IntNo)
180 }
181 #[doc = "Stop condition generated"]
182 #[inline(always)]
183 pub fn int_yes(self) -> &'a mut crate::W<REG> {
184 self.variant(Sdf::IntYes)
185 }
186}
187#[doc = "NACK Detect Flag\n\nValue on reset: 0"]
188#[cfg_attr(feature = "defmt", derive(defmt::Format))]
189#[derive(Clone, Copy, Debug, PartialEq, Eq)]
190pub enum Ndf {
191 #[doc = "0: No unexpected NACK detected"]
192 IntNo = 0,
193 #[doc = "1: Unexpected NACK detected"]
194 IntYes = 1,
195}
196impl From<Ndf> for bool {
197 #[inline(always)]
198 fn from(variant: Ndf) -> Self {
199 variant as u8 != 0
200 }
201}
202#[doc = "Field `NDF` reader - NACK Detect Flag"]
203pub type NdfR = crate::BitReader<Ndf>;
204impl NdfR {
205 #[doc = "Get enumerated values variant"]
206 #[inline(always)]
207 pub const fn variant(&self) -> Ndf {
208 match self.bits {
209 false => Ndf::IntNo,
210 true => Ndf::IntYes,
211 }
212 }
213 #[doc = "No unexpected NACK detected"]
214 #[inline(always)]
215 pub fn is_int_no(&self) -> bool {
216 *self == Ndf::IntNo
217 }
218 #[doc = "Unexpected NACK detected"]
219 #[inline(always)]
220 pub fn is_int_yes(&self) -> bool {
221 *self == Ndf::IntYes
222 }
223}
224#[doc = "Field `NDF` writer - NACK Detect Flag"]
225pub type NdfW<'a, REG> = crate::BitWriter1C<'a, REG, Ndf>;
226impl<'a, REG> NdfW<'a, REG>
227where
228 REG: crate::Writable + crate::RegisterSpec,
229{
230 #[doc = "No unexpected NACK detected"]
231 #[inline(always)]
232 pub fn int_no(self) -> &'a mut crate::W<REG> {
233 self.variant(Ndf::IntNo)
234 }
235 #[doc = "Unexpected NACK detected"]
236 #[inline(always)]
237 pub fn int_yes(self) -> &'a mut crate::W<REG> {
238 self.variant(Ndf::IntYes)
239 }
240}
241#[doc = "Arbitration Lost Flag\n\nValue on reset: 0"]
242#[cfg_attr(feature = "defmt", derive(defmt::Format))]
243#[derive(Clone, Copy, Debug, PartialEq, Eq)]
244pub enum Alf {
245 #[doc = "0: Controller did not lose arbitration"]
246 IntNo = 0,
247 #[doc = "1: Controller lost arbitration"]
248 IntYes = 1,
249}
250impl From<Alf> for bool {
251 #[inline(always)]
252 fn from(variant: Alf) -> Self {
253 variant as u8 != 0
254 }
255}
256#[doc = "Field `ALF` reader - Arbitration Lost Flag"]
257pub type AlfR = crate::BitReader<Alf>;
258impl AlfR {
259 #[doc = "Get enumerated values variant"]
260 #[inline(always)]
261 pub const fn variant(&self) -> Alf {
262 match self.bits {
263 false => Alf::IntNo,
264 true => Alf::IntYes,
265 }
266 }
267 #[doc = "Controller did not lose arbitration"]
268 #[inline(always)]
269 pub fn is_int_no(&self) -> bool {
270 *self == Alf::IntNo
271 }
272 #[doc = "Controller lost arbitration"]
273 #[inline(always)]
274 pub fn is_int_yes(&self) -> bool {
275 *self == Alf::IntYes
276 }
277}
278#[doc = "Field `ALF` writer - Arbitration Lost Flag"]
279pub type AlfW<'a, REG> = crate::BitWriter1C<'a, REG, Alf>;
280impl<'a, REG> AlfW<'a, REG>
281where
282 REG: crate::Writable + crate::RegisterSpec,
283{
284 #[doc = "Controller did not lose arbitration"]
285 #[inline(always)]
286 pub fn int_no(self) -> &'a mut crate::W<REG> {
287 self.variant(Alf::IntNo)
288 }
289 #[doc = "Controller lost arbitration"]
290 #[inline(always)]
291 pub fn int_yes(self) -> &'a mut crate::W<REG> {
292 self.variant(Alf::IntYes)
293 }
294}
295#[doc = "FIFO Error Flag\n\nValue on reset: 0"]
296#[cfg_attr(feature = "defmt", derive(defmt::Format))]
297#[derive(Clone, Copy, Debug, PartialEq, Eq)]
298pub enum Fef {
299 #[doc = "0: No FIFO error"]
300 IntNo = 0,
301 #[doc = "1: FIFO error"]
302 IntYes = 1,
303}
304impl From<Fef> for bool {
305 #[inline(always)]
306 fn from(variant: Fef) -> Self {
307 variant as u8 != 0
308 }
309}
310#[doc = "Field `FEF` reader - FIFO Error Flag"]
311pub type FefR = crate::BitReader<Fef>;
312impl FefR {
313 #[doc = "Get enumerated values variant"]
314 #[inline(always)]
315 pub const fn variant(&self) -> Fef {
316 match self.bits {
317 false => Fef::IntNo,
318 true => Fef::IntYes,
319 }
320 }
321 #[doc = "No FIFO error"]
322 #[inline(always)]
323 pub fn is_int_no(&self) -> bool {
324 *self == Fef::IntNo
325 }
326 #[doc = "FIFO error"]
327 #[inline(always)]
328 pub fn is_int_yes(&self) -> bool {
329 *self == Fef::IntYes
330 }
331}
332#[doc = "Field `FEF` writer - FIFO Error Flag"]
333pub type FefW<'a, REG> = crate::BitWriter1C<'a, REG, Fef>;
334impl<'a, REG> FefW<'a, REG>
335where
336 REG: crate::Writable + crate::RegisterSpec,
337{
338 #[doc = "No FIFO error"]
339 #[inline(always)]
340 pub fn int_no(self) -> &'a mut crate::W<REG> {
341 self.variant(Fef::IntNo)
342 }
343 #[doc = "FIFO error"]
344 #[inline(always)]
345 pub fn int_yes(self) -> &'a mut crate::W<REG> {
346 self.variant(Fef::IntYes)
347 }
348}
349#[doc = "Pin Low Timeout Flag\n\nValue on reset: 0"]
350#[cfg_attr(feature = "defmt", derive(defmt::Format))]
351#[derive(Clone, Copy, Debug, PartialEq, Eq)]
352pub enum Pltf {
353 #[doc = "0: Pin low timeout did not occur"]
354 IntNo = 0,
355 #[doc = "1: Pin low timeout occurred"]
356 IntYes = 1,
357}
358impl From<Pltf> for bool {
359 #[inline(always)]
360 fn from(variant: Pltf) -> Self {
361 variant as u8 != 0
362 }
363}
364#[doc = "Field `PLTF` reader - Pin Low Timeout Flag"]
365pub type PltfR = crate::BitReader<Pltf>;
366impl PltfR {
367 #[doc = "Get enumerated values variant"]
368 #[inline(always)]
369 pub const fn variant(&self) -> Pltf {
370 match self.bits {
371 false => Pltf::IntNo,
372 true => Pltf::IntYes,
373 }
374 }
375 #[doc = "Pin low timeout did not occur"]
376 #[inline(always)]
377 pub fn is_int_no(&self) -> bool {
378 *self == Pltf::IntNo
379 }
380 #[doc = "Pin low timeout occurred"]
381 #[inline(always)]
382 pub fn is_int_yes(&self) -> bool {
383 *self == Pltf::IntYes
384 }
385}
386#[doc = "Field `PLTF` writer - Pin Low Timeout Flag"]
387pub type PltfW<'a, REG> = crate::BitWriter1C<'a, REG, Pltf>;
388impl<'a, REG> PltfW<'a, REG>
389where
390 REG: crate::Writable + crate::RegisterSpec,
391{
392 #[doc = "Pin low timeout did not occur"]
393 #[inline(always)]
394 pub fn int_no(self) -> &'a mut crate::W<REG> {
395 self.variant(Pltf::IntNo)
396 }
397 #[doc = "Pin low timeout occurred"]
398 #[inline(always)]
399 pub fn int_yes(self) -> &'a mut crate::W<REG> {
400 self.variant(Pltf::IntYes)
401 }
402}
403#[doc = "Data Match Flag\n\nValue on reset: 0"]
404#[cfg_attr(feature = "defmt", derive(defmt::Format))]
405#[derive(Clone, Copy, Debug, PartialEq, Eq)]
406pub enum Dmf {
407 #[doc = "0: Matching data not received"]
408 IntNo = 0,
409 #[doc = "1: Matching data received"]
410 IntYes = 1,
411}
412impl From<Dmf> for bool {
413 #[inline(always)]
414 fn from(variant: Dmf) -> Self {
415 variant as u8 != 0
416 }
417}
418#[doc = "Field `DMF` reader - Data Match Flag"]
419pub type DmfR = crate::BitReader<Dmf>;
420impl DmfR {
421 #[doc = "Get enumerated values variant"]
422 #[inline(always)]
423 pub const fn variant(&self) -> Dmf {
424 match self.bits {
425 false => Dmf::IntNo,
426 true => Dmf::IntYes,
427 }
428 }
429 #[doc = "Matching data not received"]
430 #[inline(always)]
431 pub fn is_int_no(&self) -> bool {
432 *self == Dmf::IntNo
433 }
434 #[doc = "Matching data received"]
435 #[inline(always)]
436 pub fn is_int_yes(&self) -> bool {
437 *self == Dmf::IntYes
438 }
439}
440#[doc = "Field `DMF` writer - Data Match Flag"]
441pub type DmfW<'a, REG> = crate::BitWriter1C<'a, REG, Dmf>;
442impl<'a, REG> DmfW<'a, REG>
443where
444 REG: crate::Writable + crate::RegisterSpec,
445{
446 #[doc = "Matching data not received"]
447 #[inline(always)]
448 pub fn int_no(self) -> &'a mut crate::W<REG> {
449 self.variant(Dmf::IntNo)
450 }
451 #[doc = "Matching data received"]
452 #[inline(always)]
453 pub fn int_yes(self) -> &'a mut crate::W<REG> {
454 self.variant(Dmf::IntYes)
455 }
456}
457#[doc = "Start Flag\n\nValue on reset: 0"]
458#[cfg_attr(feature = "defmt", derive(defmt::Format))]
459#[derive(Clone, Copy, Debug, PartialEq, Eq)]
460pub enum Stf {
461 #[doc = "0: Start condition not detected"]
462 IntNo = 0,
463 #[doc = "1: Start condition detected"]
464 IntYes = 1,
465}
466impl From<Stf> for bool {
467 #[inline(always)]
468 fn from(variant: Stf) -> Self {
469 variant as u8 != 0
470 }
471}
472#[doc = "Field `STF` reader - Start Flag"]
473pub type StfR = crate::BitReader<Stf>;
474impl StfR {
475 #[doc = "Get enumerated values variant"]
476 #[inline(always)]
477 pub const fn variant(&self) -> Stf {
478 match self.bits {
479 false => Stf::IntNo,
480 true => Stf::IntYes,
481 }
482 }
483 #[doc = "Start condition not detected"]
484 #[inline(always)]
485 pub fn is_int_no(&self) -> bool {
486 *self == Stf::IntNo
487 }
488 #[doc = "Start condition detected"]
489 #[inline(always)]
490 pub fn is_int_yes(&self) -> bool {
491 *self == Stf::IntYes
492 }
493}
494#[doc = "Field `STF` writer - Start Flag"]
495pub type StfW<'a, REG> = crate::BitWriter1C<'a, REG, Stf>;
496impl<'a, REG> StfW<'a, REG>
497where
498 REG: crate::Writable + crate::RegisterSpec,
499{
500 #[doc = "Start condition not detected"]
501 #[inline(always)]
502 pub fn int_no(self) -> &'a mut crate::W<REG> {
503 self.variant(Stf::IntNo)
504 }
505 #[doc = "Start condition detected"]
506 #[inline(always)]
507 pub fn int_yes(self) -> &'a mut crate::W<REG> {
508 self.variant(Stf::IntYes)
509 }
510}
511#[doc = "Controller Busy Flag\n\nValue on reset: 0"]
512#[cfg_attr(feature = "defmt", derive(defmt::Format))]
513#[derive(Clone, Copy, Debug, PartialEq, Eq)]
514pub enum Mbf {
515 #[doc = "0: Idle"]
516 Idle = 0,
517 #[doc = "1: Busy"]
518 Busy = 1,
519}
520impl From<Mbf> for bool {
521 #[inline(always)]
522 fn from(variant: Mbf) -> Self {
523 variant as u8 != 0
524 }
525}
526#[doc = "Field `MBF` reader - Controller Busy Flag"]
527pub type MbfR = crate::BitReader<Mbf>;
528impl MbfR {
529 #[doc = "Get enumerated values variant"]
530 #[inline(always)]
531 pub const fn variant(&self) -> Mbf {
532 match self.bits {
533 false => Mbf::Idle,
534 true => Mbf::Busy,
535 }
536 }
537 #[doc = "Idle"]
538 #[inline(always)]
539 pub fn is_idle(&self) -> bool {
540 *self == Mbf::Idle
541 }
542 #[doc = "Busy"]
543 #[inline(always)]
544 pub fn is_busy(&self) -> bool {
545 *self == Mbf::Busy
546 }
547}
548#[doc = "Bus Busy Flag\n\nValue on reset: 0"]
549#[cfg_attr(feature = "defmt", derive(defmt::Format))]
550#[derive(Clone, Copy, Debug, PartialEq, Eq)]
551pub enum Bbf {
552 #[doc = "0: Idle"]
553 Idle = 0,
554 #[doc = "1: Busy"]
555 Busy = 1,
556}
557impl From<Bbf> for bool {
558 #[inline(always)]
559 fn from(variant: Bbf) -> Self {
560 variant as u8 != 0
561 }
562}
563#[doc = "Field `BBF` reader - Bus Busy Flag"]
564pub type BbfR = crate::BitReader<Bbf>;
565impl BbfR {
566 #[doc = "Get enumerated values variant"]
567 #[inline(always)]
568 pub const fn variant(&self) -> Bbf {
569 match self.bits {
570 false => Bbf::Idle,
571 true => Bbf::Busy,
572 }
573 }
574 #[doc = "Idle"]
575 #[inline(always)]
576 pub fn is_idle(&self) -> bool {
577 *self == Bbf::Idle
578 }
579 #[doc = "Busy"]
580 #[inline(always)]
581 pub fn is_busy(&self) -> bool {
582 *self == Bbf::Busy
583 }
584}
585impl R {
586 #[doc = "Bit 0 - Transmit Data Flag"]
587 #[inline(always)]
588 pub fn tdf(&self) -> TdfR {
589 TdfR::new((self.bits & 1) != 0)
590 }
591 #[doc = "Bit 1 - Receive Data Flag"]
592 #[inline(always)]
593 pub fn rdf(&self) -> RdfR {
594 RdfR::new(((self.bits >> 1) & 1) != 0)
595 }
596 #[doc = "Bit 8 - End Packet Flag"]
597 #[inline(always)]
598 pub fn epf(&self) -> EpfR {
599 EpfR::new(((self.bits >> 8) & 1) != 0)
600 }
601 #[doc = "Bit 9 - Stop Detect Flag"]
602 #[inline(always)]
603 pub fn sdf(&self) -> SdfR {
604 SdfR::new(((self.bits >> 9) & 1) != 0)
605 }
606 #[doc = "Bit 10 - NACK Detect Flag"]
607 #[inline(always)]
608 pub fn ndf(&self) -> NdfR {
609 NdfR::new(((self.bits >> 10) & 1) != 0)
610 }
611 #[doc = "Bit 11 - Arbitration Lost Flag"]
612 #[inline(always)]
613 pub fn alf(&self) -> AlfR {
614 AlfR::new(((self.bits >> 11) & 1) != 0)
615 }
616 #[doc = "Bit 12 - FIFO Error Flag"]
617 #[inline(always)]
618 pub fn fef(&self) -> FefR {
619 FefR::new(((self.bits >> 12) & 1) != 0)
620 }
621 #[doc = "Bit 13 - Pin Low Timeout Flag"]
622 #[inline(always)]
623 pub fn pltf(&self) -> PltfR {
624 PltfR::new(((self.bits >> 13) & 1) != 0)
625 }
626 #[doc = "Bit 14 - Data Match Flag"]
627 #[inline(always)]
628 pub fn dmf(&self) -> DmfR {
629 DmfR::new(((self.bits >> 14) & 1) != 0)
630 }
631 #[doc = "Bit 15 - Start Flag"]
632 #[inline(always)]
633 pub fn stf(&self) -> StfR {
634 StfR::new(((self.bits >> 15) & 1) != 0)
635 }
636 #[doc = "Bit 24 - Controller Busy Flag"]
637 #[inline(always)]
638 pub fn mbf(&self) -> MbfR {
639 MbfR::new(((self.bits >> 24) & 1) != 0)
640 }
641 #[doc = "Bit 25 - Bus Busy Flag"]
642 #[inline(always)]
643 pub fn bbf(&self) -> BbfR {
644 BbfR::new(((self.bits >> 25) & 1) != 0)
645 }
646}
647#[cfg(feature = "debug")]
648impl core::fmt::Debug for R {
649 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
650 f.debug_struct("MSR")
651 .field("tdf", &self.tdf())
652 .field("rdf", &self.rdf())
653 .field("epf", &self.epf())
654 .field("sdf", &self.sdf())
655 .field("ndf", &self.ndf())
656 .field("alf", &self.alf())
657 .field("fef", &self.fef())
658 .field("pltf", &self.pltf())
659 .field("dmf", &self.dmf())
660 .field("stf", &self.stf())
661 .field("mbf", &self.mbf())
662 .field("bbf", &self.bbf())
663 .finish()
664 }
665}
666impl W {
667 #[doc = "Bit 8 - End Packet Flag"]
668 #[inline(always)]
669 pub fn epf(&mut self) -> EpfW<'_, MsrSpec> {
670 EpfW::new(self, 8)
671 }
672 #[doc = "Bit 9 - Stop Detect Flag"]
673 #[inline(always)]
674 pub fn sdf(&mut self) -> SdfW<'_, MsrSpec> {
675 SdfW::new(self, 9)
676 }
677 #[doc = "Bit 10 - NACK Detect Flag"]
678 #[inline(always)]
679 pub fn ndf(&mut self) -> NdfW<'_, MsrSpec> {
680 NdfW::new(self, 10)
681 }
682 #[doc = "Bit 11 - Arbitration Lost Flag"]
683 #[inline(always)]
684 pub fn alf(&mut self) -> AlfW<'_, MsrSpec> {
685 AlfW::new(self, 11)
686 }
687 #[doc = "Bit 12 - FIFO Error Flag"]
688 #[inline(always)]
689 pub fn fef(&mut self) -> FefW<'_, MsrSpec> {
690 FefW::new(self, 12)
691 }
692 #[doc = "Bit 13 - Pin Low Timeout Flag"]
693 #[inline(always)]
694 pub fn pltf(&mut self) -> PltfW<'_, MsrSpec> {
695 PltfW::new(self, 13)
696 }
697 #[doc = "Bit 14 - Data Match Flag"]
698 #[inline(always)]
699 pub fn dmf(&mut self) -> DmfW<'_, MsrSpec> {
700 DmfW::new(self, 14)
701 }
702 #[doc = "Bit 15 - Start Flag"]
703 #[inline(always)]
704 pub fn stf(&mut self) -> StfW<'_, MsrSpec> {
705 StfW::new(self, 15)
706 }
707}
708#[doc = "Controller Status\n\nYou can [`read`](crate::Reg::read) this register and get [`msr::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`msr::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
709pub struct MsrSpec;
710impl crate::RegisterSpec for MsrSpec {
711 type Ux = u32;
712}
713#[doc = "`read()` method returns [`msr::R`](R) reader structure"]
714impl crate::Readable for MsrSpec {}
715#[doc = "`write(|w| ..)` method takes [`msr::W`](W) writer structure"]
716impl crate::Writable for MsrSpec {
717 type Safety = crate::Unsafe;
718 const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0xff00;
719}
720#[doc = "`reset()` method sets MSR to value 0x01"]
721impl crate::Resettable for MsrSpec {
722 const RESET_VALUE: u32 = 0x01;
723}