atsamv71j21/mcan0/
mcan_rxesc.rs

1#[doc = "Register `MCAN_RXESC` reader"]
2pub struct R(crate::R<MCAN_RXESC_SPEC>);
3impl core::ops::Deref for R {
4    type Target = crate::R<MCAN_RXESC_SPEC>;
5    #[inline(always)]
6    fn deref(&self) -> &Self::Target {
7        &self.0
8    }
9}
10impl From<crate::R<MCAN_RXESC_SPEC>> for R {
11    #[inline(always)]
12    fn from(reader: crate::R<MCAN_RXESC_SPEC>) -> Self {
13        R(reader)
14    }
15}
16#[doc = "Register `MCAN_RXESC` writer"]
17pub struct W(crate::W<MCAN_RXESC_SPEC>);
18impl core::ops::Deref for W {
19    type Target = crate::W<MCAN_RXESC_SPEC>;
20    #[inline(always)]
21    fn deref(&self) -> &Self::Target {
22        &self.0
23    }
24}
25impl core::ops::DerefMut for W {
26    #[inline(always)]
27    fn deref_mut(&mut self) -> &mut Self::Target {
28        &mut self.0
29    }
30}
31impl From<crate::W<MCAN_RXESC_SPEC>> for W {
32    #[inline(always)]
33    fn from(writer: crate::W<MCAN_RXESC_SPEC>) -> Self {
34        W(writer)
35    }
36}
37#[doc = "Receive FIFO 0 Data Field Size\n\nValue on reset: 0"]
38#[derive(Clone, Copy, Debug, PartialEq)]
39#[repr(u8)]
40pub enum F0DS_A {
41    #[doc = "0: 8-byte data field"]
42    _8_BYTE = 0,
43    #[doc = "1: 12-byte data field"]
44    _12_BYTE = 1,
45    #[doc = "2: 16-byte data field"]
46    _16_BYTE = 2,
47    #[doc = "3: 20-byte data field"]
48    _20_BYTE = 3,
49    #[doc = "4: 24-byte data field"]
50    _24_BYTE = 4,
51    #[doc = "5: 32-byte data field"]
52    _32_BYTE = 5,
53    #[doc = "6: 48-byte data field"]
54    _48_BYTE = 6,
55    #[doc = "7: 64-byte data field"]
56    _64_BYTE = 7,
57}
58impl From<F0DS_A> for u8 {
59    #[inline(always)]
60    fn from(variant: F0DS_A) -> Self {
61        variant as _
62    }
63}
64#[doc = "Field `F0DS` reader - Receive FIFO 0 Data Field Size"]
65pub struct F0DS_R(crate::FieldReader<u8, F0DS_A>);
66impl F0DS_R {
67    #[inline(always)]
68    pub(crate) fn new(bits: u8) -> Self {
69        F0DS_R(crate::FieldReader::new(bits))
70    }
71    #[doc = r"Get enumerated values variant"]
72    #[inline(always)]
73    pub fn variant(&self) -> F0DS_A {
74        match self.bits {
75            0 => F0DS_A::_8_BYTE,
76            1 => F0DS_A::_12_BYTE,
77            2 => F0DS_A::_16_BYTE,
78            3 => F0DS_A::_20_BYTE,
79            4 => F0DS_A::_24_BYTE,
80            5 => F0DS_A::_32_BYTE,
81            6 => F0DS_A::_48_BYTE,
82            7 => F0DS_A::_64_BYTE,
83            _ => unreachable!(),
84        }
85    }
86    #[doc = "Checks if the value of the field is `_8_BYTE`"]
87    #[inline(always)]
88    pub fn is_8_byte(&self) -> bool {
89        **self == F0DS_A::_8_BYTE
90    }
91    #[doc = "Checks if the value of the field is `_12_BYTE`"]
92    #[inline(always)]
93    pub fn is_12_byte(&self) -> bool {
94        **self == F0DS_A::_12_BYTE
95    }
96    #[doc = "Checks if the value of the field is `_16_BYTE`"]
97    #[inline(always)]
98    pub fn is_16_byte(&self) -> bool {
99        **self == F0DS_A::_16_BYTE
100    }
101    #[doc = "Checks if the value of the field is `_20_BYTE`"]
102    #[inline(always)]
103    pub fn is_20_byte(&self) -> bool {
104        **self == F0DS_A::_20_BYTE
105    }
106    #[doc = "Checks if the value of the field is `_24_BYTE`"]
107    #[inline(always)]
108    pub fn is_24_byte(&self) -> bool {
109        **self == F0DS_A::_24_BYTE
110    }
111    #[doc = "Checks if the value of the field is `_32_BYTE`"]
112    #[inline(always)]
113    pub fn is_32_byte(&self) -> bool {
114        **self == F0DS_A::_32_BYTE
115    }
116    #[doc = "Checks if the value of the field is `_48_BYTE`"]
117    #[inline(always)]
118    pub fn is_48_byte(&self) -> bool {
119        **self == F0DS_A::_48_BYTE
120    }
121    #[doc = "Checks if the value of the field is `_64_BYTE`"]
122    #[inline(always)]
123    pub fn is_64_byte(&self) -> bool {
124        **self == F0DS_A::_64_BYTE
125    }
126}
127impl core::ops::Deref for F0DS_R {
128    type Target = crate::FieldReader<u8, F0DS_A>;
129    #[inline(always)]
130    fn deref(&self) -> &Self::Target {
131        &self.0
132    }
133}
134#[doc = "Field `F0DS` writer - Receive FIFO 0 Data Field Size"]
135pub struct F0DS_W<'a> {
136    w: &'a mut W,
137}
138impl<'a> F0DS_W<'a> {
139    #[doc = r"Writes `variant` to the field"]
140    #[inline(always)]
141    pub fn variant(self, variant: F0DS_A) -> &'a mut W {
142        self.bits(variant.into())
143    }
144    #[doc = "8-byte data field"]
145    #[inline(always)]
146    pub fn _8_byte(self) -> &'a mut W {
147        self.variant(F0DS_A::_8_BYTE)
148    }
149    #[doc = "12-byte data field"]
150    #[inline(always)]
151    pub fn _12_byte(self) -> &'a mut W {
152        self.variant(F0DS_A::_12_BYTE)
153    }
154    #[doc = "16-byte data field"]
155    #[inline(always)]
156    pub fn _16_byte(self) -> &'a mut W {
157        self.variant(F0DS_A::_16_BYTE)
158    }
159    #[doc = "20-byte data field"]
160    #[inline(always)]
161    pub fn _20_byte(self) -> &'a mut W {
162        self.variant(F0DS_A::_20_BYTE)
163    }
164    #[doc = "24-byte data field"]
165    #[inline(always)]
166    pub fn _24_byte(self) -> &'a mut W {
167        self.variant(F0DS_A::_24_BYTE)
168    }
169    #[doc = "32-byte data field"]
170    #[inline(always)]
171    pub fn _32_byte(self) -> &'a mut W {
172        self.variant(F0DS_A::_32_BYTE)
173    }
174    #[doc = "48-byte data field"]
175    #[inline(always)]
176    pub fn _48_byte(self) -> &'a mut W {
177        self.variant(F0DS_A::_48_BYTE)
178    }
179    #[doc = "64-byte data field"]
180    #[inline(always)]
181    pub fn _64_byte(self) -> &'a mut W {
182        self.variant(F0DS_A::_64_BYTE)
183    }
184    #[doc = r"Writes raw bits to the field"]
185    #[inline(always)]
186    pub fn bits(self, value: u8) -> &'a mut W {
187        self.w.bits = (self.w.bits & !0x07) | (value as u32 & 0x07);
188        self.w
189    }
190}
191#[doc = "Receive FIFO 1 Data Field Size\n\nValue on reset: 0"]
192#[derive(Clone, Copy, Debug, PartialEq)]
193#[repr(u8)]
194pub enum F1DS_A {
195    #[doc = "0: 8-byte data field"]
196    _8_BYTE = 0,
197    #[doc = "1: 12-byte data field"]
198    _12_BYTE = 1,
199    #[doc = "2: 16-byte data field"]
200    _16_BYTE = 2,
201    #[doc = "3: 20-byte data field"]
202    _20_BYTE = 3,
203    #[doc = "4: 24-byte data field"]
204    _24_BYTE = 4,
205    #[doc = "5: 32-byte data field"]
206    _32_BYTE = 5,
207    #[doc = "6: 48-byte data field"]
208    _48_BYTE = 6,
209    #[doc = "7: 64-byte data field"]
210    _64_BYTE = 7,
211}
212impl From<F1DS_A> for u8 {
213    #[inline(always)]
214    fn from(variant: F1DS_A) -> Self {
215        variant as _
216    }
217}
218#[doc = "Field `F1DS` reader - Receive FIFO 1 Data Field Size"]
219pub struct F1DS_R(crate::FieldReader<u8, F1DS_A>);
220impl F1DS_R {
221    #[inline(always)]
222    pub(crate) fn new(bits: u8) -> Self {
223        F1DS_R(crate::FieldReader::new(bits))
224    }
225    #[doc = r"Get enumerated values variant"]
226    #[inline(always)]
227    pub fn variant(&self) -> F1DS_A {
228        match self.bits {
229            0 => F1DS_A::_8_BYTE,
230            1 => F1DS_A::_12_BYTE,
231            2 => F1DS_A::_16_BYTE,
232            3 => F1DS_A::_20_BYTE,
233            4 => F1DS_A::_24_BYTE,
234            5 => F1DS_A::_32_BYTE,
235            6 => F1DS_A::_48_BYTE,
236            7 => F1DS_A::_64_BYTE,
237            _ => unreachable!(),
238        }
239    }
240    #[doc = "Checks if the value of the field is `_8_BYTE`"]
241    #[inline(always)]
242    pub fn is_8_byte(&self) -> bool {
243        **self == F1DS_A::_8_BYTE
244    }
245    #[doc = "Checks if the value of the field is `_12_BYTE`"]
246    #[inline(always)]
247    pub fn is_12_byte(&self) -> bool {
248        **self == F1DS_A::_12_BYTE
249    }
250    #[doc = "Checks if the value of the field is `_16_BYTE`"]
251    #[inline(always)]
252    pub fn is_16_byte(&self) -> bool {
253        **self == F1DS_A::_16_BYTE
254    }
255    #[doc = "Checks if the value of the field is `_20_BYTE`"]
256    #[inline(always)]
257    pub fn is_20_byte(&self) -> bool {
258        **self == F1DS_A::_20_BYTE
259    }
260    #[doc = "Checks if the value of the field is `_24_BYTE`"]
261    #[inline(always)]
262    pub fn is_24_byte(&self) -> bool {
263        **self == F1DS_A::_24_BYTE
264    }
265    #[doc = "Checks if the value of the field is `_32_BYTE`"]
266    #[inline(always)]
267    pub fn is_32_byte(&self) -> bool {
268        **self == F1DS_A::_32_BYTE
269    }
270    #[doc = "Checks if the value of the field is `_48_BYTE`"]
271    #[inline(always)]
272    pub fn is_48_byte(&self) -> bool {
273        **self == F1DS_A::_48_BYTE
274    }
275    #[doc = "Checks if the value of the field is `_64_BYTE`"]
276    #[inline(always)]
277    pub fn is_64_byte(&self) -> bool {
278        **self == F1DS_A::_64_BYTE
279    }
280}
281impl core::ops::Deref for F1DS_R {
282    type Target = crate::FieldReader<u8, F1DS_A>;
283    #[inline(always)]
284    fn deref(&self) -> &Self::Target {
285        &self.0
286    }
287}
288#[doc = "Field `F1DS` writer - Receive FIFO 1 Data Field Size"]
289pub struct F1DS_W<'a> {
290    w: &'a mut W,
291}
292impl<'a> F1DS_W<'a> {
293    #[doc = r"Writes `variant` to the field"]
294    #[inline(always)]
295    pub fn variant(self, variant: F1DS_A) -> &'a mut W {
296        self.bits(variant.into())
297    }
298    #[doc = "8-byte data field"]
299    #[inline(always)]
300    pub fn _8_byte(self) -> &'a mut W {
301        self.variant(F1DS_A::_8_BYTE)
302    }
303    #[doc = "12-byte data field"]
304    #[inline(always)]
305    pub fn _12_byte(self) -> &'a mut W {
306        self.variant(F1DS_A::_12_BYTE)
307    }
308    #[doc = "16-byte data field"]
309    #[inline(always)]
310    pub fn _16_byte(self) -> &'a mut W {
311        self.variant(F1DS_A::_16_BYTE)
312    }
313    #[doc = "20-byte data field"]
314    #[inline(always)]
315    pub fn _20_byte(self) -> &'a mut W {
316        self.variant(F1DS_A::_20_BYTE)
317    }
318    #[doc = "24-byte data field"]
319    #[inline(always)]
320    pub fn _24_byte(self) -> &'a mut W {
321        self.variant(F1DS_A::_24_BYTE)
322    }
323    #[doc = "32-byte data field"]
324    #[inline(always)]
325    pub fn _32_byte(self) -> &'a mut W {
326        self.variant(F1DS_A::_32_BYTE)
327    }
328    #[doc = "48-byte data field"]
329    #[inline(always)]
330    pub fn _48_byte(self) -> &'a mut W {
331        self.variant(F1DS_A::_48_BYTE)
332    }
333    #[doc = "64-byte data field"]
334    #[inline(always)]
335    pub fn _64_byte(self) -> &'a mut W {
336        self.variant(F1DS_A::_64_BYTE)
337    }
338    #[doc = r"Writes raw bits to the field"]
339    #[inline(always)]
340    pub fn bits(self, value: u8) -> &'a mut W {
341        self.w.bits = (self.w.bits & !(0x07 << 4)) | ((value as u32 & 0x07) << 4);
342        self.w
343    }
344}
345#[doc = "Receive Buffer Data Field Size\n\nValue on reset: 0"]
346#[derive(Clone, Copy, Debug, PartialEq)]
347#[repr(u8)]
348pub enum RBDS_A {
349    #[doc = "0: 8-byte data field"]
350    _8_BYTE = 0,
351    #[doc = "1: 12-byte data field"]
352    _12_BYTE = 1,
353    #[doc = "2: 16-byte data field"]
354    _16_BYTE = 2,
355    #[doc = "3: 20-byte data field"]
356    _20_BYTE = 3,
357    #[doc = "4: 24-byte data field"]
358    _24_BYTE = 4,
359    #[doc = "5: 32-byte data field"]
360    _32_BYTE = 5,
361    #[doc = "6: 48-byte data field"]
362    _48_BYTE = 6,
363    #[doc = "7: 64-byte data field"]
364    _64_BYTE = 7,
365}
366impl From<RBDS_A> for u8 {
367    #[inline(always)]
368    fn from(variant: RBDS_A) -> Self {
369        variant as _
370    }
371}
372#[doc = "Field `RBDS` reader - Receive Buffer Data Field Size"]
373pub struct RBDS_R(crate::FieldReader<u8, RBDS_A>);
374impl RBDS_R {
375    #[inline(always)]
376    pub(crate) fn new(bits: u8) -> Self {
377        RBDS_R(crate::FieldReader::new(bits))
378    }
379    #[doc = r"Get enumerated values variant"]
380    #[inline(always)]
381    pub fn variant(&self) -> RBDS_A {
382        match self.bits {
383            0 => RBDS_A::_8_BYTE,
384            1 => RBDS_A::_12_BYTE,
385            2 => RBDS_A::_16_BYTE,
386            3 => RBDS_A::_20_BYTE,
387            4 => RBDS_A::_24_BYTE,
388            5 => RBDS_A::_32_BYTE,
389            6 => RBDS_A::_48_BYTE,
390            7 => RBDS_A::_64_BYTE,
391            _ => unreachable!(),
392        }
393    }
394    #[doc = "Checks if the value of the field is `_8_BYTE`"]
395    #[inline(always)]
396    pub fn is_8_byte(&self) -> bool {
397        **self == RBDS_A::_8_BYTE
398    }
399    #[doc = "Checks if the value of the field is `_12_BYTE`"]
400    #[inline(always)]
401    pub fn is_12_byte(&self) -> bool {
402        **self == RBDS_A::_12_BYTE
403    }
404    #[doc = "Checks if the value of the field is `_16_BYTE`"]
405    #[inline(always)]
406    pub fn is_16_byte(&self) -> bool {
407        **self == RBDS_A::_16_BYTE
408    }
409    #[doc = "Checks if the value of the field is `_20_BYTE`"]
410    #[inline(always)]
411    pub fn is_20_byte(&self) -> bool {
412        **self == RBDS_A::_20_BYTE
413    }
414    #[doc = "Checks if the value of the field is `_24_BYTE`"]
415    #[inline(always)]
416    pub fn is_24_byte(&self) -> bool {
417        **self == RBDS_A::_24_BYTE
418    }
419    #[doc = "Checks if the value of the field is `_32_BYTE`"]
420    #[inline(always)]
421    pub fn is_32_byte(&self) -> bool {
422        **self == RBDS_A::_32_BYTE
423    }
424    #[doc = "Checks if the value of the field is `_48_BYTE`"]
425    #[inline(always)]
426    pub fn is_48_byte(&self) -> bool {
427        **self == RBDS_A::_48_BYTE
428    }
429    #[doc = "Checks if the value of the field is `_64_BYTE`"]
430    #[inline(always)]
431    pub fn is_64_byte(&self) -> bool {
432        **self == RBDS_A::_64_BYTE
433    }
434}
435impl core::ops::Deref for RBDS_R {
436    type Target = crate::FieldReader<u8, RBDS_A>;
437    #[inline(always)]
438    fn deref(&self) -> &Self::Target {
439        &self.0
440    }
441}
442#[doc = "Field `RBDS` writer - Receive Buffer Data Field Size"]
443pub struct RBDS_W<'a> {
444    w: &'a mut W,
445}
446impl<'a> RBDS_W<'a> {
447    #[doc = r"Writes `variant` to the field"]
448    #[inline(always)]
449    pub fn variant(self, variant: RBDS_A) -> &'a mut W {
450        self.bits(variant.into())
451    }
452    #[doc = "8-byte data field"]
453    #[inline(always)]
454    pub fn _8_byte(self) -> &'a mut W {
455        self.variant(RBDS_A::_8_BYTE)
456    }
457    #[doc = "12-byte data field"]
458    #[inline(always)]
459    pub fn _12_byte(self) -> &'a mut W {
460        self.variant(RBDS_A::_12_BYTE)
461    }
462    #[doc = "16-byte data field"]
463    #[inline(always)]
464    pub fn _16_byte(self) -> &'a mut W {
465        self.variant(RBDS_A::_16_BYTE)
466    }
467    #[doc = "20-byte data field"]
468    #[inline(always)]
469    pub fn _20_byte(self) -> &'a mut W {
470        self.variant(RBDS_A::_20_BYTE)
471    }
472    #[doc = "24-byte data field"]
473    #[inline(always)]
474    pub fn _24_byte(self) -> &'a mut W {
475        self.variant(RBDS_A::_24_BYTE)
476    }
477    #[doc = "32-byte data field"]
478    #[inline(always)]
479    pub fn _32_byte(self) -> &'a mut W {
480        self.variant(RBDS_A::_32_BYTE)
481    }
482    #[doc = "48-byte data field"]
483    #[inline(always)]
484    pub fn _48_byte(self) -> &'a mut W {
485        self.variant(RBDS_A::_48_BYTE)
486    }
487    #[doc = "64-byte data field"]
488    #[inline(always)]
489    pub fn _64_byte(self) -> &'a mut W {
490        self.variant(RBDS_A::_64_BYTE)
491    }
492    #[doc = r"Writes raw bits to the field"]
493    #[inline(always)]
494    pub fn bits(self, value: u8) -> &'a mut W {
495        self.w.bits = (self.w.bits & !(0x07 << 8)) | ((value as u32 & 0x07) << 8);
496        self.w
497    }
498}
499impl R {
500    #[doc = "Bits 0:2 - Receive FIFO 0 Data Field Size"]
501    #[inline(always)]
502    pub fn f0ds(&self) -> F0DS_R {
503        F0DS_R::new((self.bits & 0x07) as u8)
504    }
505    #[doc = "Bits 4:6 - Receive FIFO 1 Data Field Size"]
506    #[inline(always)]
507    pub fn f1ds(&self) -> F1DS_R {
508        F1DS_R::new(((self.bits >> 4) & 0x07) as u8)
509    }
510    #[doc = "Bits 8:10 - Receive Buffer Data Field Size"]
511    #[inline(always)]
512    pub fn rbds(&self) -> RBDS_R {
513        RBDS_R::new(((self.bits >> 8) & 0x07) as u8)
514    }
515}
516impl W {
517    #[doc = "Bits 0:2 - Receive FIFO 0 Data Field Size"]
518    #[inline(always)]
519    pub fn f0ds(&mut self) -> F0DS_W {
520        F0DS_W { w: self }
521    }
522    #[doc = "Bits 4:6 - Receive FIFO 1 Data Field Size"]
523    #[inline(always)]
524    pub fn f1ds(&mut self) -> F1DS_W {
525        F1DS_W { w: self }
526    }
527    #[doc = "Bits 8:10 - Receive Buffer Data Field Size"]
528    #[inline(always)]
529    pub fn rbds(&mut self) -> RBDS_W {
530        RBDS_W { w: self }
531    }
532    #[doc = "Writes raw bits to the register."]
533    #[inline(always)]
534    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
535        self.0.bits(bits);
536        self
537    }
538}
539#[doc = "Receive Buffer / FIFO Element Size Configuration Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [mcan_rxesc](index.html) module"]
540pub struct MCAN_RXESC_SPEC;
541impl crate::RegisterSpec for MCAN_RXESC_SPEC {
542    type Ux = u32;
543}
544#[doc = "`read()` method returns [mcan_rxesc::R](R) reader structure"]
545impl crate::Readable for MCAN_RXESC_SPEC {
546    type Reader = R;
547}
548#[doc = "`write(|w| ..)` method takes [mcan_rxesc::W](W) writer structure"]
549impl crate::Writable for MCAN_RXESC_SPEC {
550    type Writer = W;
551}
552#[doc = "`reset()` method sets MCAN_RXESC to value 0"]
553impl crate::Resettable for MCAN_RXESC_SPEC {
554    #[inline(always)]
555    fn reset_value() -> Self::Ux {
556        0
557    }
558}
atsamv71j21/mcan0/mcan_rxesc.rs

atsamv71j21/mcan0/
mcan_rxesc.rs
