lpc11xx/c_can/
canif_cmdmsk_w.rs

1#[doc = "Reader of register CANIF%s_CMDMSK_W"]
2pub type R = crate::R<u32, super::CANIF_CMDMSK_W>;
3#[doc = "Writer for register CANIF%s_CMDMSK_W"]
4pub type W = crate::W<u32, super::CANIF_CMDMSK_W>;
5#[doc = "Register CANIF%s_CMDMSK_W `reset()`'s with value 0"]
6impl crate::ResetValue for super::CANIF_CMDMSK_W {
7    type Type = u32;
8    #[inline(always)]
9    fn reset_value() -> Self::Type {
10        0
11    }
12}
13#[doc = "Access data bytes 4-7.\n\nValue on reset: 0"]
14#[derive(Clone, Copy, Debug, PartialEq)]
15pub enum DATA_B_A {
16    #[doc = "0: Data bytes 4-7 unchanged"]
17    DATA_BYTES_4_7_UNCHA,
18    #[doc = "1: Transfer data bytes 4-7 to message object"]
19    TRANSFER_DATA_BYTES_,
20}
21impl From<DATA_B_A> for bool {
22    #[inline(always)]
23    fn from(variant: DATA_B_A) -> Self {
24        match variant {
25            DATA_B_A::DATA_BYTES_4_7_UNCHA => false,
26            DATA_B_A::TRANSFER_DATA_BYTES_ => true,
27        }
28    }
29}
30#[doc = "Reader of field `DATA_B`"]
31pub type DATA_B_R = crate::R<bool, DATA_B_A>;
32impl DATA_B_R {
33    #[doc = r"Get enumerated values variant"]
34    #[inline(always)]
35    pub fn variant(&self) -> DATA_B_A {
36        match self.bits {
37            false => DATA_B_A::DATA_BYTES_4_7_UNCHA,
38            true => DATA_B_A::TRANSFER_DATA_BYTES_,
39        }
40    }
41    #[doc = "Checks if the value of the field is `DATA_BYTES_4_7_UNCHA`"]
42    #[inline(always)]
43    pub fn is_data_bytes_4_7_uncha(&self) -> bool {
44        *self == DATA_B_A::DATA_BYTES_4_7_UNCHA
45    }
46    #[doc = "Checks if the value of the field is `TRANSFER_DATA_BYTES_`"]
47    #[inline(always)]
48    pub fn is_transfer_data_bytes_(&self) -> bool {
49        *self == DATA_B_A::TRANSFER_DATA_BYTES_
50    }
51}
52#[doc = "Write proxy for field `DATA_B`"]
53pub struct DATA_B_W<'a> {
54    w: &'a mut W,
55}
56impl<'a> DATA_B_W<'a> {
57    #[doc = r"Writes `variant` to the field"]
58    #[inline(always)]
59    pub fn variant(self, variant: DATA_B_A) -> &'a mut W {
60        {
61            self.bit(variant.into())
62        }
63    }
64    #[doc = "Data bytes 4-7 unchanged"]
65    #[inline(always)]
66    pub fn data_bytes_4_7_uncha(self) -> &'a mut W {
67        self.variant(DATA_B_A::DATA_BYTES_4_7_UNCHA)
68    }
69    #[doc = "Transfer data bytes 4-7 to message object"]
70    #[inline(always)]
71    pub fn transfer_data_bytes_(self) -> &'a mut W {
72        self.variant(DATA_B_A::TRANSFER_DATA_BYTES_)
73    }
74    #[doc = r"Sets the field bit"]
75    #[inline(always)]
76    pub fn set_bit(self) -> &'a mut W {
77        self.bit(true)
78    }
79    #[doc = r"Clears the field bit"]
80    #[inline(always)]
81    pub fn clear_bit(self) -> &'a mut W {
82        self.bit(false)
83    }
84    #[doc = r"Writes raw bits to the field"]
85    #[inline(always)]
86    pub fn bit(self, value: bool) -> &'a mut W {
87        self.w.bits = (self.w.bits & !0x01) | ((value as u32) & 0x01);
88        self.w
89    }
90}
91#[doc = "Access data bytes 0-3.\n\nValue on reset: 0"]
92#[derive(Clone, Copy, Debug, PartialEq)]
93pub enum DATA_A_A {
94    #[doc = "0: Data bytes 0-3 unchanged"]
95    DATA_BYTES_0_3_UNCHA,
96    #[doc = "1: Transfer data bytes 0-3 to message object"]
97    TRANSFER_DATA_BYTES_,
98}
99impl From<DATA_A_A> for bool {
100    #[inline(always)]
101    fn from(variant: DATA_A_A) -> Self {
102        match variant {
103            DATA_A_A::DATA_BYTES_0_3_UNCHA => false,
104            DATA_A_A::TRANSFER_DATA_BYTES_ => true,
105        }
106    }
107}
108#[doc = "Reader of field `DATA_A`"]
109pub type DATA_A_R = crate::R<bool, DATA_A_A>;
110impl DATA_A_R {
111    #[doc = r"Get enumerated values variant"]
112    #[inline(always)]
113    pub fn variant(&self) -> DATA_A_A {
114        match self.bits {
115            false => DATA_A_A::DATA_BYTES_0_3_UNCHA,
116            true => DATA_A_A::TRANSFER_DATA_BYTES_,
117        }
118    }
119    #[doc = "Checks if the value of the field is `DATA_BYTES_0_3_UNCHA`"]
120    #[inline(always)]
121    pub fn is_data_bytes_0_3_uncha(&self) -> bool {
122        *self == DATA_A_A::DATA_BYTES_0_3_UNCHA
123    }
124    #[doc = "Checks if the value of the field is `TRANSFER_DATA_BYTES_`"]
125    #[inline(always)]
126    pub fn is_transfer_data_bytes_(&self) -> bool {
127        *self == DATA_A_A::TRANSFER_DATA_BYTES_
128    }
129}
130#[doc = "Write proxy for field `DATA_A`"]
131pub struct DATA_A_W<'a> {
132    w: &'a mut W,
133}
134impl<'a> DATA_A_W<'a> {
135    #[doc = r"Writes `variant` to the field"]
136    #[inline(always)]
137    pub fn variant(self, variant: DATA_A_A) -> &'a mut W {
138        {
139            self.bit(variant.into())
140        }
141    }
142    #[doc = "Data bytes 0-3 unchanged"]
143    #[inline(always)]
144    pub fn data_bytes_0_3_uncha(self) -> &'a mut W {
145        self.variant(DATA_A_A::DATA_BYTES_0_3_UNCHA)
146    }
147    #[doc = "Transfer data bytes 0-3 to message object"]
148    #[inline(always)]
149    pub fn transfer_data_bytes_(self) -> &'a mut W {
150        self.variant(DATA_A_A::TRANSFER_DATA_BYTES_)
151    }
152    #[doc = r"Sets the field bit"]
153    #[inline(always)]
154    pub fn set_bit(self) -> &'a mut W {
155        self.bit(true)
156    }
157    #[doc = r"Clears the field bit"]
158    #[inline(always)]
159    pub fn clear_bit(self) -> &'a mut W {
160        self.bit(false)
161    }
162    #[doc = r"Writes raw bits to the field"]
163    #[inline(always)]
164    pub fn bit(self, value: bool) -> &'a mut W {
165        self.w.bits = (self.w.bits & !(0x01 << 1)) | (((value as u32) & 0x01) << 1);
166        self.w
167    }
168}
169#[doc = "Access transmission request bit.\n\nValue on reset: 0"]
170#[derive(Clone, Copy, Debug, PartialEq)]
171pub enum TXRQST_A {
172    #[doc = "0: No transmission request. TXRQSRT bit unchanged in IF1/2_MCTRL. If a transmission is requested by programming this bit, the TXRQST bit in the CANIFn_MCTRL register is ignored"]
173    NO_TRANSMISSION_REQU,
174    #[doc = "1: Request a transmission. Set the TXRQST bit IF1/2_MCTRL"]
175    REQUEST_A_TRANSMISSI,
176}
177impl From<TXRQST_A> for bool {
178    #[inline(always)]
179    fn from(variant: TXRQST_A) -> Self {
180        match variant {
181            TXRQST_A::NO_TRANSMISSION_REQU => false,
182            TXRQST_A::REQUEST_A_TRANSMISSI => true,
183        }
184    }
185}
186#[doc = "Reader of field `TXRQST`"]
187pub type TXRQST_R = crate::R<bool, TXRQST_A>;
188impl TXRQST_R {
189    #[doc = r"Get enumerated values variant"]
190    #[inline(always)]
191    pub fn variant(&self) -> TXRQST_A {
192        match self.bits {
193            false => TXRQST_A::NO_TRANSMISSION_REQU,
194            true => TXRQST_A::REQUEST_A_TRANSMISSI,
195        }
196    }
197    #[doc = "Checks if the value of the field is `NO_TRANSMISSION_REQU`"]
198    #[inline(always)]
199    pub fn is_no_transmission_requ(&self) -> bool {
200        *self == TXRQST_A::NO_TRANSMISSION_REQU
201    }
202    #[doc = "Checks if the value of the field is `REQUEST_A_TRANSMISSI`"]
203    #[inline(always)]
204    pub fn is_request_a_transmissi(&self) -> bool {
205        *self == TXRQST_A::REQUEST_A_TRANSMISSI
206    }
207}
208#[doc = "Write proxy for field `TXRQST`"]
209pub struct TXRQST_W<'a> {
210    w: &'a mut W,
211}
212impl<'a> TXRQST_W<'a> {
213    #[doc = r"Writes `variant` to the field"]
214    #[inline(always)]
215    pub fn variant(self, variant: TXRQST_A) -> &'a mut W {
216        {
217            self.bit(variant.into())
218        }
219    }
220    #[doc = "No transmission request. TXRQSRT bit unchanged in IF1/2_MCTRL. If a transmission is requested by programming this bit, the TXRQST bit in the CANIFn_MCTRL register is ignored"]
221    #[inline(always)]
222    pub fn no_transmission_requ(self) -> &'a mut W {
223        self.variant(TXRQST_A::NO_TRANSMISSION_REQU)
224    }
225    #[doc = "Request a transmission. Set the TXRQST bit IF1/2_MCTRL"]
226    #[inline(always)]
227    pub fn request_a_transmissi(self) -> &'a mut W {
228        self.variant(TXRQST_A::REQUEST_A_TRANSMISSI)
229    }
230    #[doc = r"Sets the field bit"]
231    #[inline(always)]
232    pub fn set_bit(self) -> &'a mut W {
233        self.bit(true)
234    }
235    #[doc = r"Clears the field bit"]
236    #[inline(always)]
237    pub fn clear_bit(self) -> &'a mut W {
238        self.bit(false)
239    }
240    #[doc = r"Writes raw bits to the field"]
241    #[inline(always)]
242    pub fn bit(self, value: bool) -> &'a mut W {
243        self.w.bits = (self.w.bits & !(0x01 << 2)) | (((value as u32) & 0x01) << 2);
244        self.w
245    }
246}
247#[doc = "Reader of field `CLRINTPND`"]
248pub type CLRINTPND_R = crate::R<bool, bool>;
249#[doc = "Write proxy for field `CLRINTPND`"]
250pub struct CLRINTPND_W<'a> {
251    w: &'a mut W,
252}
253impl<'a> CLRINTPND_W<'a> {
254    #[doc = r"Sets the field bit"]
255    #[inline(always)]
256    pub fn set_bit(self) -> &'a mut W {
257        self.bit(true)
258    }
259    #[doc = r"Clears the field bit"]
260    #[inline(always)]
261    pub fn clear_bit(self) -> &'a mut W {
262        self.bit(false)
263    }
264    #[doc = r"Writes raw bits to the field"]
265    #[inline(always)]
266    pub fn bit(self, value: bool) -> &'a mut W {
267        self.w.bits = (self.w.bits & !(0x01 << 3)) | (((value as u32) & 0x01) << 3);
268        self.w
269    }
270}
271#[doc = "Access control bits.\n\nValue on reset: 0"]
272#[derive(Clone, Copy, Debug, PartialEq)]
273pub enum CTRL_A {
274    #[doc = "0: Control bits unchanged"]
275    UNCHANGED,
276    #[doc = "1: Transfer control bits to message object"]
277    TRANSFER_CONTROL_BIT,
278}
279impl From<CTRL_A> for bool {
280    #[inline(always)]
281    fn from(variant: CTRL_A) -> Self {
282        match variant {
283            CTRL_A::UNCHANGED => false,
284            CTRL_A::TRANSFER_CONTROL_BIT => true,
285        }
286    }
287}
288#[doc = "Reader of field `CTRL`"]
289pub type CTRL_R = crate::R<bool, CTRL_A>;
290impl CTRL_R {
291    #[doc = r"Get enumerated values variant"]
292    #[inline(always)]
293    pub fn variant(&self) -> CTRL_A {
294        match self.bits {
295            false => CTRL_A::UNCHANGED,
296            true => CTRL_A::TRANSFER_CONTROL_BIT,
297        }
298    }
299    #[doc = "Checks if the value of the field is `UNCHANGED`"]
300    #[inline(always)]
301    pub fn is_unchanged(&self) -> bool {
302        *self == CTRL_A::UNCHANGED
303    }
304    #[doc = "Checks if the value of the field is `TRANSFER_CONTROL_BIT`"]
305    #[inline(always)]
306    pub fn is_transfer_control_bit(&self) -> bool {
307        *self == CTRL_A::TRANSFER_CONTROL_BIT
308    }
309}
310#[doc = "Write proxy for field `CTRL`"]
311pub struct CTRL_W<'a> {
312    w: &'a mut W,
313}
314impl<'a> CTRL_W<'a> {
315    #[doc = r"Writes `variant` to the field"]
316    #[inline(always)]
317    pub fn variant(self, variant: CTRL_A) -> &'a mut W {
318        {
319            self.bit(variant.into())
320        }
321    }
322    #[doc = "Control bits unchanged"]
323    #[inline(always)]
324    pub fn unchanged(self) -> &'a mut W {
325        self.variant(CTRL_A::UNCHANGED)
326    }
327    #[doc = "Transfer control bits to message object"]
328    #[inline(always)]
329    pub fn transfer_control_bit(self) -> &'a mut W {
330        self.variant(CTRL_A::TRANSFER_CONTROL_BIT)
331    }
332    #[doc = r"Sets the field bit"]
333    #[inline(always)]
334    pub fn set_bit(self) -> &'a mut W {
335        self.bit(true)
336    }
337    #[doc = r"Clears the field bit"]
338    #[inline(always)]
339    pub fn clear_bit(self) -> &'a mut W {
340        self.bit(false)
341    }
342    #[doc = r"Writes raw bits to the field"]
343    #[inline(always)]
344    pub fn bit(self, value: bool) -> &'a mut W {
345        self.w.bits = (self.w.bits & !(0x01 << 4)) | (((value as u32) & 0x01) << 4);
346        self.w
347    }
348}
349#[doc = "Access arbitration bits.\n\nValue on reset: 0"]
350#[derive(Clone, Copy, Debug, PartialEq)]
351pub enum ARB_A {
352    #[doc = "0: Arbitration bits unchanged"]
353    UNCHANGED,
354    #[doc = "1: Transfer Identifier, DIR, XTD, and MSGVAL bits to message object"]
355    TRANSFER_IDENTIFIER,
356}
357impl From<ARB_A> for bool {
358    #[inline(always)]
359    fn from(variant: ARB_A) -> Self {
360        match variant {
361            ARB_A::UNCHANGED => false,
362            ARB_A::TRANSFER_IDENTIFIER => true,
363        }
364    }
365}
366#[doc = "Reader of field `ARB`"]
367pub type ARB_R = crate::R<bool, ARB_A>;
368impl ARB_R {
369    #[doc = r"Get enumerated values variant"]
370    #[inline(always)]
371    pub fn variant(&self) -> ARB_A {
372        match self.bits {
373            false => ARB_A::UNCHANGED,
374            true => ARB_A::TRANSFER_IDENTIFIER,
375        }
376    }
377    #[doc = "Checks if the value of the field is `UNCHANGED`"]
378    #[inline(always)]
379    pub fn is_unchanged(&self) -> bool {
380        *self == ARB_A::UNCHANGED
381    }
382    #[doc = "Checks if the value of the field is `TRANSFER_IDENTIFIER`"]
383    #[inline(always)]
384    pub fn is_transfer_identifier(&self) -> bool {
385        *self == ARB_A::TRANSFER_IDENTIFIER
386    }
387}
388#[doc = "Write proxy for field `ARB`"]
389pub struct ARB_W<'a> {
390    w: &'a mut W,
391}
392impl<'a> ARB_W<'a> {
393    #[doc = r"Writes `variant` to the field"]
394    #[inline(always)]
395    pub fn variant(self, variant: ARB_A) -> &'a mut W {
396        {
397            self.bit(variant.into())
398        }
399    }
400    #[doc = "Arbitration bits unchanged"]
401    #[inline(always)]
402    pub fn unchanged(self) -> &'a mut W {
403        self.variant(ARB_A::UNCHANGED)
404    }
405    #[doc = "Transfer Identifier, DIR, XTD, and MSGVAL bits to message object"]
406    #[inline(always)]
407    pub fn transfer_identifier(self) -> &'a mut W {
408        self.variant(ARB_A::TRANSFER_IDENTIFIER)
409    }
410    #[doc = r"Sets the field bit"]
411    #[inline(always)]
412    pub fn set_bit(self) -> &'a mut W {
413        self.bit(true)
414    }
415    #[doc = r"Clears the field bit"]
416    #[inline(always)]
417    pub fn clear_bit(self) -> &'a mut W {
418        self.bit(false)
419    }
420    #[doc = r"Writes raw bits to the field"]
421    #[inline(always)]
422    pub fn bit(self, value: bool) -> &'a mut W {
423        self.w.bits = (self.w.bits & !(0x01 << 5)) | (((value as u32) & 0x01) << 5);
424        self.w
425    }
426}
427#[doc = "Access mask bits.\n\nValue on reset: 0"]
428#[derive(Clone, Copy, Debug, PartialEq)]
429pub enum MASK_A {
430    #[doc = "0: Mask bits unchanged"]
431    UNCHANGED,
432    #[doc = "1: Transfer Identifier MASK + MDIR + MXTD to message object"]
433    TRANSFER_IDENTIFIER_,
434}
435impl From<MASK_A> for bool {
436    #[inline(always)]
437    fn from(variant: MASK_A) -> Self {
438        match variant {
439            MASK_A::UNCHANGED => false,
440            MASK_A::TRANSFER_IDENTIFIER_ => true,
441        }
442    }
443}
444#[doc = "Reader of field `MASK`"]
445pub type MASK_R = crate::R<bool, MASK_A>;
446impl MASK_R {
447    #[doc = r"Get enumerated values variant"]
448    #[inline(always)]
449    pub fn variant(&self) -> MASK_A {
450        match self.bits {
451            false => MASK_A::UNCHANGED,
452            true => MASK_A::TRANSFER_IDENTIFIER_,
453        }
454    }
455    #[doc = "Checks if the value of the field is `UNCHANGED`"]
456    #[inline(always)]
457    pub fn is_unchanged(&self) -> bool {
458        *self == MASK_A::UNCHANGED
459    }
460    #[doc = "Checks if the value of the field is `TRANSFER_IDENTIFIER_`"]
461    #[inline(always)]
462    pub fn is_transfer_identifier_(&self) -> bool {
463        *self == MASK_A::TRANSFER_IDENTIFIER_
464    }
465}
466#[doc = "Write proxy for field `MASK`"]
467pub struct MASK_W<'a> {
468    w: &'a mut W,
469}
470impl<'a> MASK_W<'a> {
471    #[doc = r"Writes `variant` to the field"]
472    #[inline(always)]
473    pub fn variant(self, variant: MASK_A) -> &'a mut W {
474        {
475            self.bit(variant.into())
476        }
477    }
478    #[doc = "Mask bits unchanged"]
479    #[inline(always)]
480    pub fn unchanged(self) -> &'a mut W {
481        self.variant(MASK_A::UNCHANGED)
482    }
483    #[doc = "Transfer Identifier MASK + MDIR + MXTD to message object"]
484    #[inline(always)]
485    pub fn transfer_identifier_(self) -> &'a mut W {
486        self.variant(MASK_A::TRANSFER_IDENTIFIER_)
487    }
488    #[doc = r"Sets the field bit"]
489    #[inline(always)]
490    pub fn set_bit(self) -> &'a mut W {
491        self.bit(true)
492    }
493    #[doc = r"Clears the field bit"]
494    #[inline(always)]
495    pub fn clear_bit(self) -> &'a mut W {
496        self.bit(false)
497    }
498    #[doc = r"Writes raw bits to the field"]
499    #[inline(always)]
500    pub fn bit(self, value: bool) -> &'a mut W {
501        self.w.bits = (self.w.bits & !(0x01 << 6)) | (((value as u32) & 0x01) << 6);
502        self.w
503    }
504}
505#[doc = "Reader of field `WR_RD`"]
506pub type WR_RD_R = crate::R<bool, bool>;
507#[doc = "Write proxy for field `WR_RD`"]
508pub struct WR_RD_W<'a> {
509    w: &'a mut W,
510}
511impl<'a> WR_RD_W<'a> {
512    #[doc = r"Sets the field bit"]
513    #[inline(always)]
514    pub fn set_bit(self) -> &'a mut W {
515        self.bit(true)
516    }
517    #[doc = r"Clears the field bit"]
518    #[inline(always)]
519    pub fn clear_bit(self) -> &'a mut W {
520        self.bit(false)
521    }
522    #[doc = r"Writes raw bits to the field"]
523    #[inline(always)]
524    pub fn bit(self, value: bool) -> &'a mut W {
525        self.w.bits = (self.w.bits & !(0x01 << 7)) | (((value as u32) & 0x01) << 7);
526        self.w
527    }
528}
529impl R {
530    #[doc = "Bit 0 - Access data bytes 4-7."]
531    #[inline(always)]
532    pub fn data_b(&self) -> DATA_B_R {
533        DATA_B_R::new((self.bits & 0x01) != 0)
534    }
535    #[doc = "Bit 1 - Access data bytes 0-3."]
536    #[inline(always)]
537    pub fn data_a(&self) -> DATA_A_R {
538        DATA_A_R::new(((self.bits >> 1) & 0x01) != 0)
539    }
540    #[doc = "Bit 2 - Access transmission request bit."]
541    #[inline(always)]
542    pub fn txrqst(&self) -> TXRQST_R {
543        TXRQST_R::new(((self.bits >> 2) & 0x01) != 0)
544    }
545    #[doc = "Bit 3 - This bit is ignored in the write direction."]
546    #[inline(always)]
547    pub fn clrintpnd(&self) -> CLRINTPND_R {
548        CLRINTPND_R::new(((self.bits >> 3) & 0x01) != 0)
549    }
550    #[doc = "Bit 4 - Access control bits."]
551    #[inline(always)]
552    pub fn ctrl(&self) -> CTRL_R {
553        CTRL_R::new(((self.bits >> 4) & 0x01) != 0)
554    }
555    #[doc = "Bit 5 - Access arbitration bits."]
556    #[inline(always)]
557    pub fn arb(&self) -> ARB_R {
558        ARB_R::new(((self.bits >> 5) & 0x01) != 0)
559    }
560    #[doc = "Bit 6 - Access mask bits."]
561    #[inline(always)]
562    pub fn mask(&self) -> MASK_R {
563        MASK_R::new(((self.bits >> 6) & 0x01) != 0)
564    }
565    #[doc = "Bit 7 - Write transfer Transfer data from the selected message buffer registers to the message object addressed by the command request register CANIFn_CMDREQ."]
566    #[inline(always)]
567    pub fn wr_rd(&self) -> WR_RD_R {
568        WR_RD_R::new(((self.bits >> 7) & 0x01) != 0)
569    }
570}
571impl W {
572    #[doc = "Bit 0 - Access data bytes 4-7."]
573    #[inline(always)]
574    pub fn data_b(&mut self) -> DATA_B_W {
575        DATA_B_W { w: self }
576    }
577    #[doc = "Bit 1 - Access data bytes 0-3."]
578    #[inline(always)]
579    pub fn data_a(&mut self) -> DATA_A_W {
580        DATA_A_W { w: self }
581    }
582    #[doc = "Bit 2 - Access transmission request bit."]
583    #[inline(always)]
584    pub fn txrqst(&mut self) -> TXRQST_W {
585        TXRQST_W { w: self }
586    }
587    #[doc = "Bit 3 - This bit is ignored in the write direction."]
588    #[inline(always)]
589    pub fn clrintpnd(&mut self) -> CLRINTPND_W {
590        CLRINTPND_W { w: self }
591    }
592    #[doc = "Bit 4 - Access control bits."]
593    #[inline(always)]
594    pub fn ctrl(&mut self) -> CTRL_W {
595        CTRL_W { w: self }
596    }
597    #[doc = "Bit 5 - Access arbitration bits."]
598    #[inline(always)]
599    pub fn arb(&mut self) -> ARB_W {
600        ARB_W { w: self }
601    }
602    #[doc = "Bit 6 - Access mask bits."]
603    #[inline(always)]
604    pub fn mask(&mut self) -> MASK_W {
605        MASK_W { w: self }
606    }
607    #[doc = "Bit 7 - Write transfer Transfer data from the selected message buffer registers to the message object addressed by the command request register CANIFn_CMDREQ."]
608    #[inline(always)]
609    pub fn wr_rd(&mut self) -> WR_RD_W {
610        WR_RD_W { w: self }
611    }
612}
lpc11xx/c_can/canif_cmdmsk_w.rs

lpc11xx/c_can/
canif_cmdmsk_w.rs
