cc13x2_cc26x2_pac/gpt2/
mis.rs

1#[doc = r" Value read from the register"]
2pub struct R {
3    bits: u32,
4}
5#[doc = r" Value to write to the register"]
6pub struct W {
7    bits: u32,
8}
9impl super::MIS {
10    #[doc = r" Modifies the contents of the register"]
11    #[inline]
12    pub fn modify<F>(&self, f: F)
13    where
14        for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
15    {
16        let bits = self.register.get();
17        let r = R { bits: bits };
18        let mut w = W { bits: bits };
19        f(&r, &mut w);
20        self.register.set(w.bits);
21    }
22    #[doc = r" Reads the contents of the register"]
23    #[inline]
24    pub fn read(&self) -> R {
25        R {
26            bits: self.register.get(),
27        }
28    }
29    #[doc = r" Writes to the register"]
30    #[inline]
31    pub fn write<F>(&self, f: F)
32    where
33        F: FnOnce(&mut W) -> &mut W,
34    {
35        let mut w = W::reset_value();
36        f(&mut w);
37        self.register.set(w.bits);
38    }
39    #[doc = r" Writes the reset value to the register"]
40    #[inline]
41    pub fn reset(&self) {
42        self.write(|w| w)
43    }
44}
45#[doc = r" Value of the field"]
46pub struct RESERVED14R {
47    bits: u32,
48}
49impl RESERVED14R {
50    #[doc = r" Value of the field as raw bits"]
51    #[inline]
52    pub fn bits(&self) -> u32 {
53        self.bits
54    }
55}
56#[doc = r" Value of the field"]
57pub struct DMABMISR {
58    bits: bool,
59}
60impl DMABMISR {
61    #[doc = r" Value of the field as raw bits"]
62    #[inline]
63    pub fn bit(&self) -> bool {
64        self.bits
65    }
66    #[doc = r" Returns `true` if the bit is clear (0)"]
67    #[inline]
68    pub fn bit_is_clear(&self) -> bool {
69        !self.bit()
70    }
71    #[doc = r" Returns `true` if the bit is set (1)"]
72    #[inline]
73    pub fn bit_is_set(&self) -> bool {
74        self.bit()
75    }
76}
77#[doc = r" Value of the field"]
78pub struct RESERVED12R {
79    bits: bool,
80}
81impl RESERVED12R {
82    #[doc = r" Value of the field as raw bits"]
83    #[inline]
84    pub fn bit(&self) -> bool {
85        self.bits
86    }
87    #[doc = r" Returns `true` if the bit is clear (0)"]
88    #[inline]
89    pub fn bit_is_clear(&self) -> bool {
90        !self.bit()
91    }
92    #[doc = r" Returns `true` if the bit is set (1)"]
93    #[inline]
94    pub fn bit_is_set(&self) -> bool {
95        self.bit()
96    }
97}
98#[doc = r" Value of the field"]
99pub struct TBMMISR {
100    bits: bool,
101}
102impl TBMMISR {
103    #[doc = r" Value of the field as raw bits"]
104    #[inline]
105    pub fn bit(&self) -> bool {
106        self.bits
107    }
108    #[doc = r" Returns `true` if the bit is clear (0)"]
109    #[inline]
110    pub fn bit_is_clear(&self) -> bool {
111        !self.bit()
112    }
113    #[doc = r" Returns `true` if the bit is set (1)"]
114    #[inline]
115    pub fn bit_is_set(&self) -> bool {
116        self.bit()
117    }
118}
119#[doc = r" Value of the field"]
120pub struct CBEMISR {
121    bits: bool,
122}
123impl CBEMISR {
124    #[doc = r" Value of the field as raw bits"]
125    #[inline]
126    pub fn bit(&self) -> bool {
127        self.bits
128    }
129    #[doc = r" Returns `true` if the bit is clear (0)"]
130    #[inline]
131    pub fn bit_is_clear(&self) -> bool {
132        !self.bit()
133    }
134    #[doc = r" Returns `true` if the bit is set (1)"]
135    #[inline]
136    pub fn bit_is_set(&self) -> bool {
137        self.bit()
138    }
139}
140#[doc = r" Value of the field"]
141pub struct CBMMISR {
142    bits: bool,
143}
144impl CBMMISR {
145    #[doc = r" Value of the field as raw bits"]
146    #[inline]
147    pub fn bit(&self) -> bool {
148        self.bits
149    }
150    #[doc = r" Returns `true` if the bit is clear (0)"]
151    #[inline]
152    pub fn bit_is_clear(&self) -> bool {
153        !self.bit()
154    }
155    #[doc = r" Returns `true` if the bit is set (1)"]
156    #[inline]
157    pub fn bit_is_set(&self) -> bool {
158        self.bit()
159    }
160}
161#[doc = r" Value of the field"]
162pub struct TBTOMISR {
163    bits: bool,
164}
165impl TBTOMISR {
166    #[doc = r" Value of the field as raw bits"]
167    #[inline]
168    pub fn bit(&self) -> bool {
169        self.bits
170    }
171    #[doc = r" Returns `true` if the bit is clear (0)"]
172    #[inline]
173    pub fn bit_is_clear(&self) -> bool {
174        !self.bit()
175    }
176    #[doc = r" Returns `true` if the bit is set (1)"]
177    #[inline]
178    pub fn bit_is_set(&self) -> bool {
179        self.bit()
180    }
181}
182#[doc = r" Value of the field"]
183pub struct RESERVED6R {
184    bits: u8,
185}
186impl RESERVED6R {
187    #[doc = r" Value of the field as raw bits"]
188    #[inline]
189    pub fn bits(&self) -> u8 {
190        self.bits
191    }
192}
193#[doc = r" Value of the field"]
194pub struct DMAAMISR {
195    bits: bool,
196}
197impl DMAAMISR {
198    #[doc = r" Value of the field as raw bits"]
199    #[inline]
200    pub fn bit(&self) -> bool {
201        self.bits
202    }
203    #[doc = r" Returns `true` if the bit is clear (0)"]
204    #[inline]
205    pub fn bit_is_clear(&self) -> bool {
206        !self.bit()
207    }
208    #[doc = r" Returns `true` if the bit is set (1)"]
209    #[inline]
210    pub fn bit_is_set(&self) -> bool {
211        self.bit()
212    }
213}
214#[doc = r" Value of the field"]
215pub struct TAMMISR {
216    bits: bool,
217}
218impl TAMMISR {
219    #[doc = r" Value of the field as raw bits"]
220    #[inline]
221    pub fn bit(&self) -> bool {
222        self.bits
223    }
224    #[doc = r" Returns `true` if the bit is clear (0)"]
225    #[inline]
226    pub fn bit_is_clear(&self) -> bool {
227        !self.bit()
228    }
229    #[doc = r" Returns `true` if the bit is set (1)"]
230    #[inline]
231    pub fn bit_is_set(&self) -> bool {
232        self.bit()
233    }
234}
235#[doc = r" Value of the field"]
236pub struct RESERVED3R {
237    bits: bool,
238}
239impl RESERVED3R {
240    #[doc = r" Value of the field as raw bits"]
241    #[inline]
242    pub fn bit(&self) -> bool {
243        self.bits
244    }
245    #[doc = r" Returns `true` if the bit is clear (0)"]
246    #[inline]
247    pub fn bit_is_clear(&self) -> bool {
248        !self.bit()
249    }
250    #[doc = r" Returns `true` if the bit is set (1)"]
251    #[inline]
252    pub fn bit_is_set(&self) -> bool {
253        self.bit()
254    }
255}
256#[doc = r" Value of the field"]
257pub struct CAEMISR {
258    bits: bool,
259}
260impl CAEMISR {
261    #[doc = r" Value of the field as raw bits"]
262    #[inline]
263    pub fn bit(&self) -> bool {
264        self.bits
265    }
266    #[doc = r" Returns `true` if the bit is clear (0)"]
267    #[inline]
268    pub fn bit_is_clear(&self) -> bool {
269        !self.bit()
270    }
271    #[doc = r" Returns `true` if the bit is set (1)"]
272    #[inline]
273    pub fn bit_is_set(&self) -> bool {
274        self.bit()
275    }
276}
277#[doc = r" Value of the field"]
278pub struct CAMMISR {
279    bits: bool,
280}
281impl CAMMISR {
282    #[doc = r" Value of the field as raw bits"]
283    #[inline]
284    pub fn bit(&self) -> bool {
285        self.bits
286    }
287    #[doc = r" Returns `true` if the bit is clear (0)"]
288    #[inline]
289    pub fn bit_is_clear(&self) -> bool {
290        !self.bit()
291    }
292    #[doc = r" Returns `true` if the bit is set (1)"]
293    #[inline]
294    pub fn bit_is_set(&self) -> bool {
295        self.bit()
296    }
297}
298#[doc = r" Value of the field"]
299pub struct TATOMISR {
300    bits: bool,
301}
302impl TATOMISR {
303    #[doc = r" Value of the field as raw bits"]
304    #[inline]
305    pub fn bit(&self) -> bool {
306        self.bits
307    }
308    #[doc = r" Returns `true` if the bit is clear (0)"]
309    #[inline]
310    pub fn bit_is_clear(&self) -> bool {
311        !self.bit()
312    }
313    #[doc = r" Returns `true` if the bit is set (1)"]
314    #[inline]
315    pub fn bit_is_set(&self) -> bool {
316        self.bit()
317    }
318}
319#[doc = r" Proxy"]
320pub struct _RESERVED14W<'a> {
321    w: &'a mut W,
322}
323impl<'a> _RESERVED14W<'a> {
324    #[doc = r" Writes raw bits to the field"]
325    #[inline]
326    pub unsafe fn bits(self, value: u32) -> &'a mut W {
327        const MASK: u32 = 262143;
328        const OFFSET: u8 = 14;
329        self.w.bits &= !((MASK as u32) << OFFSET);
330        self.w.bits |= ((value & MASK) as u32) << OFFSET;
331        self.w
332    }
333}
334#[doc = r" Proxy"]
335pub struct _DMABMISW<'a> {
336    w: &'a mut W,
337}
338impl<'a> _DMABMISW<'a> {
339    #[doc = r" Sets the field bit"]
340    pub fn set_bit(self) -> &'a mut W {
341        self.bit(true)
342    }
343    #[doc = r" Clears the field bit"]
344    pub fn clear_bit(self) -> &'a mut W {
345        self.bit(false)
346    }
347    #[doc = r" Writes raw bits to the field"]
348    #[inline]
349    pub fn bit(self, value: bool) -> &'a mut W {
350        const MASK: bool = true;
351        const OFFSET: u8 = 13;
352        self.w.bits &= !((MASK as u32) << OFFSET);
353        self.w.bits |= ((value & MASK) as u32) << OFFSET;
354        self.w
355    }
356}
357#[doc = r" Proxy"]
358pub struct _RESERVED12W<'a> {
359    w: &'a mut W,
360}
361impl<'a> _RESERVED12W<'a> {
362    #[doc = r" Sets the field bit"]
363    pub fn set_bit(self) -> &'a mut W {
364        self.bit(true)
365    }
366    #[doc = r" Clears the field bit"]
367    pub fn clear_bit(self) -> &'a mut W {
368        self.bit(false)
369    }
370    #[doc = r" Writes raw bits to the field"]
371    #[inline]
372    pub fn bit(self, value: bool) -> &'a mut W {
373        const MASK: bool = true;
374        const OFFSET: u8 = 12;
375        self.w.bits &= !((MASK as u32) << OFFSET);
376        self.w.bits |= ((value & MASK) as u32) << OFFSET;
377        self.w
378    }
379}
380#[doc = r" Proxy"]
381pub struct _TBMMISW<'a> {
382    w: &'a mut W,
383}
384impl<'a> _TBMMISW<'a> {
385    #[doc = r" Sets the field bit"]
386    pub fn set_bit(self) -> &'a mut W {
387        self.bit(true)
388    }
389    #[doc = r" Clears the field bit"]
390    pub fn clear_bit(self) -> &'a mut W {
391        self.bit(false)
392    }
393    #[doc = r" Writes raw bits to the field"]
394    #[inline]
395    pub fn bit(self, value: bool) -> &'a mut W {
396        const MASK: bool = true;
397        const OFFSET: u8 = 11;
398        self.w.bits &= !((MASK as u32) << OFFSET);
399        self.w.bits |= ((value & MASK) as u32) << OFFSET;
400        self.w
401    }
402}
403#[doc = r" Proxy"]
404pub struct _CBEMISW<'a> {
405    w: &'a mut W,
406}
407impl<'a> _CBEMISW<'a> {
408    #[doc = r" Sets the field bit"]
409    pub fn set_bit(self) -> &'a mut W {
410        self.bit(true)
411    }
412    #[doc = r" Clears the field bit"]
413    pub fn clear_bit(self) -> &'a mut W {
414        self.bit(false)
415    }
416    #[doc = r" Writes raw bits to the field"]
417    #[inline]
418    pub fn bit(self, value: bool) -> &'a mut W {
419        const MASK: bool = true;
420        const OFFSET: u8 = 10;
421        self.w.bits &= !((MASK as u32) << OFFSET);
422        self.w.bits |= ((value & MASK) as u32) << OFFSET;
423        self.w
424    }
425}
426#[doc = r" Proxy"]
427pub struct _CBMMISW<'a> {
428    w: &'a mut W,
429}
430impl<'a> _CBMMISW<'a> {
431    #[doc = r" Sets the field bit"]
432    pub fn set_bit(self) -> &'a mut W {
433        self.bit(true)
434    }
435    #[doc = r" Clears the field bit"]
436    pub fn clear_bit(self) -> &'a mut W {
437        self.bit(false)
438    }
439    #[doc = r" Writes raw bits to the field"]
440    #[inline]
441    pub fn bit(self, value: bool) -> &'a mut W {
442        const MASK: bool = true;
443        const OFFSET: u8 = 9;
444        self.w.bits &= !((MASK as u32) << OFFSET);
445        self.w.bits |= ((value & MASK) as u32) << OFFSET;
446        self.w
447    }
448}
449#[doc = r" Proxy"]
450pub struct _TBTOMISW<'a> {
451    w: &'a mut W,
452}
453impl<'a> _TBTOMISW<'a> {
454    #[doc = r" Sets the field bit"]
455    pub fn set_bit(self) -> &'a mut W {
456        self.bit(true)
457    }
458    #[doc = r" Clears the field bit"]
459    pub fn clear_bit(self) -> &'a mut W {
460        self.bit(false)
461    }
462    #[doc = r" Writes raw bits to the field"]
463    #[inline]
464    pub fn bit(self, value: bool) -> &'a mut W {
465        const MASK: bool = true;
466        const OFFSET: u8 = 8;
467        self.w.bits &= !((MASK as u32) << OFFSET);
468        self.w.bits |= ((value & MASK) as u32) << OFFSET;
469        self.w
470    }
471}
472#[doc = r" Proxy"]
473pub struct _RESERVED6W<'a> {
474    w: &'a mut W,
475}
476impl<'a> _RESERVED6W<'a> {
477    #[doc = r" Writes raw bits to the field"]
478    #[inline]
479    pub unsafe fn bits(self, value: u8) -> &'a mut W {
480        const MASK: u8 = 3;
481        const OFFSET: u8 = 6;
482        self.w.bits &= !((MASK as u32) << OFFSET);
483        self.w.bits |= ((value & MASK) as u32) << OFFSET;
484        self.w
485    }
486}
487#[doc = r" Proxy"]
488pub struct _DMAAMISW<'a> {
489    w: &'a mut W,
490}
491impl<'a> _DMAAMISW<'a> {
492    #[doc = r" Sets the field bit"]
493    pub fn set_bit(self) -> &'a mut W {
494        self.bit(true)
495    }
496    #[doc = r" Clears the field bit"]
497    pub fn clear_bit(self) -> &'a mut W {
498        self.bit(false)
499    }
500    #[doc = r" Writes raw bits to the field"]
501    #[inline]
502    pub fn bit(self, value: bool) -> &'a mut W {
503        const MASK: bool = true;
504        const OFFSET: u8 = 5;
505        self.w.bits &= !((MASK as u32) << OFFSET);
506        self.w.bits |= ((value & MASK) as u32) << OFFSET;
507        self.w
508    }
509}
510#[doc = r" Proxy"]
511pub struct _TAMMISW<'a> {
512    w: &'a mut W,
513}
514impl<'a> _TAMMISW<'a> {
515    #[doc = r" Sets the field bit"]
516    pub fn set_bit(self) -> &'a mut W {
517        self.bit(true)
518    }
519    #[doc = r" Clears the field bit"]
520    pub fn clear_bit(self) -> &'a mut W {
521        self.bit(false)
522    }
523    #[doc = r" Writes raw bits to the field"]
524    #[inline]
525    pub fn bit(self, value: bool) -> &'a mut W {
526        const MASK: bool = true;
527        const OFFSET: u8 = 4;
528        self.w.bits &= !((MASK as u32) << OFFSET);
529        self.w.bits |= ((value & MASK) as u32) << OFFSET;
530        self.w
531    }
532}
533#[doc = r" Proxy"]
534pub struct _RESERVED3W<'a> {
535    w: &'a mut W,
536}
537impl<'a> _RESERVED3W<'a> {
538    #[doc = r" Sets the field bit"]
539    pub fn set_bit(self) -> &'a mut W {
540        self.bit(true)
541    }
542    #[doc = r" Clears the field bit"]
543    pub fn clear_bit(self) -> &'a mut W {
544        self.bit(false)
545    }
546    #[doc = r" Writes raw bits to the field"]
547    #[inline]
548    pub fn bit(self, value: bool) -> &'a mut W {
549        const MASK: bool = true;
550        const OFFSET: u8 = 3;
551        self.w.bits &= !((MASK as u32) << OFFSET);
552        self.w.bits |= ((value & MASK) as u32) << OFFSET;
553        self.w
554    }
555}
556#[doc = r" Proxy"]
557pub struct _CAEMISW<'a> {
558    w: &'a mut W,
559}
560impl<'a> _CAEMISW<'a> {
561    #[doc = r" Sets the field bit"]
562    pub fn set_bit(self) -> &'a mut W {
563        self.bit(true)
564    }
565    #[doc = r" Clears the field bit"]
566    pub fn clear_bit(self) -> &'a mut W {
567        self.bit(false)
568    }
569    #[doc = r" Writes raw bits to the field"]
570    #[inline]
571    pub fn bit(self, value: bool) -> &'a mut W {
572        const MASK: bool = true;
573        const OFFSET: u8 = 2;
574        self.w.bits &= !((MASK as u32) << OFFSET);
575        self.w.bits |= ((value & MASK) as u32) << OFFSET;
576        self.w
577    }
578}
579#[doc = r" Proxy"]
580pub struct _CAMMISW<'a> {
581    w: &'a mut W,
582}
583impl<'a> _CAMMISW<'a> {
584    #[doc = r" Sets the field bit"]
585    pub fn set_bit(self) -> &'a mut W {
586        self.bit(true)
587    }
588    #[doc = r" Clears the field bit"]
589    pub fn clear_bit(self) -> &'a mut W {
590        self.bit(false)
591    }
592    #[doc = r" Writes raw bits to the field"]
593    #[inline]
594    pub fn bit(self, value: bool) -> &'a mut W {
595        const MASK: bool = true;
596        const OFFSET: u8 = 1;
597        self.w.bits &= !((MASK as u32) << OFFSET);
598        self.w.bits |= ((value & MASK) as u32) << OFFSET;
599        self.w
600    }
601}
602#[doc = r" Proxy"]
603pub struct _TATOMISW<'a> {
604    w: &'a mut W,
605}
606impl<'a> _TATOMISW<'a> {
607    #[doc = r" Sets the field bit"]
608    pub fn set_bit(self) -> &'a mut W {
609        self.bit(true)
610    }
611    #[doc = r" Clears the field bit"]
612    pub fn clear_bit(self) -> &'a mut W {
613        self.bit(false)
614    }
615    #[doc = r" Writes raw bits to the field"]
616    #[inline]
617    pub fn bit(self, value: bool) -> &'a mut W {
618        const MASK: bool = true;
619        const OFFSET: u8 = 0;
620        self.w.bits &= !((MASK as u32) << OFFSET);
621        self.w.bits |= ((value & MASK) as u32) << OFFSET;
622        self.w
623    }
624}
625impl R {
626    #[doc = r" Value of the register as raw bits"]
627    #[inline]
628    pub fn bits(&self) -> u32 {
629        self.bits
630    }
631    #[doc = "Bits 14:31 - 31:14\\] Software should not rely on the value of a reserved. Writing any other value than the reset value may result in undefined behavior."]
632    #[inline]
633    pub fn reserved14(&self) -> RESERVED14R {
634        let bits = {
635            const MASK: u32 = 262143;
636            const OFFSET: u8 = 14;
637            ((self.bits >> OFFSET) & MASK as u32) as u32
638        };
639        RESERVED14R { bits }
640    }
641    #[doc = "Bit 13 - 13:13\\] 0: No interrupt or interrupt not enabled 1: RIS.DMABRIS = 1 && IMR.DMABIM = 1"]
642    #[inline]
643    pub fn dmabmis(&self) -> DMABMISR {
644        let bits = {
645            const MASK: bool = true;
646            const OFFSET: u8 = 13;
647            ((self.bits >> OFFSET) & MASK as u32) != 0
648        };
649        DMABMISR { bits }
650    }
651    #[doc = "Bit 12 - 12:12\\] Software should not rely on the value of a reserved. Writing any other value than the reset value may result in undefined behavior."]
652    #[inline]
653    pub fn reserved12(&self) -> RESERVED12R {
654        let bits = {
655            const MASK: bool = true;
656            const OFFSET: u8 = 12;
657            ((self.bits >> OFFSET) & MASK as u32) != 0
658        };
659        RESERVED12R { bits }
660    }
661    #[doc = "Bit 11 - 11:11\\] 0: No interrupt or interrupt not enabled 1: RIS.TBMRIS = 1 && IMR.TBMIM = 1"]
662    #[inline]
663    pub fn tbmmis(&self) -> TBMMISR {
664        let bits = {
665            const MASK: bool = true;
666            const OFFSET: u8 = 11;
667            ((self.bits >> OFFSET) & MASK as u32) != 0
668        };
669        TBMMISR { bits }
670    }
671    #[doc = "Bit 10 - 10:10\\] 0: No interrupt or interrupt not enabled 1: RIS.CBERIS = 1 && IMR.CBEIM = 1"]
672    #[inline]
673    pub fn cbemis(&self) -> CBEMISR {
674        let bits = {
675            const MASK: bool = true;
676            const OFFSET: u8 = 10;
677            ((self.bits >> OFFSET) & MASK as u32) != 0
678        };
679        CBEMISR { bits }
680    }
681    #[doc = "Bit 9 - 9:9\\] 0: No interrupt or interrupt not enabled 1: RIS.CBMRIS = 1 && IMR.CBMIM = 1"]
682    #[inline]
683    pub fn cbmmis(&self) -> CBMMISR {
684        let bits = {
685            const MASK: bool = true;
686            const OFFSET: u8 = 9;
687            ((self.bits >> OFFSET) & MASK as u32) != 0
688        };
689        CBMMISR { bits }
690    }
691    #[doc = "Bit 8 - 8:8\\] 0: No interrupt or interrupt not enabled 1: RIS.TBTORIS = 1 && IMR.TBTOIM = 1"]
692    #[inline]
693    pub fn tbtomis(&self) -> TBTOMISR {
694        let bits = {
695            const MASK: bool = true;
696            const OFFSET: u8 = 8;
697            ((self.bits >> OFFSET) & MASK as u32) != 0
698        };
699        TBTOMISR { bits }
700    }
701    #[doc = "Bits 6:7 - 7:6\\] Software should not rely on the value of a reserved. Writing any other value than the reset value may result in undefined behavior."]
702    #[inline]
703    pub fn reserved6(&self) -> RESERVED6R {
704        let bits = {
705            const MASK: u8 = 3;
706            const OFFSET: u8 = 6;
707            ((self.bits >> OFFSET) & MASK as u32) as u8
708        };
709        RESERVED6R { bits }
710    }
711    #[doc = "Bit 5 - 5:5\\] 0: No interrupt or interrupt not enabled 1: RIS.DMAARIS = 1 && IMR.DMAAIM = 1"]
712    #[inline]
713    pub fn dmaamis(&self) -> DMAAMISR {
714        let bits = {
715            const MASK: bool = true;
716            const OFFSET: u8 = 5;
717            ((self.bits >> OFFSET) & MASK as u32) != 0
718        };
719        DMAAMISR { bits }
720    }
721    #[doc = "Bit 4 - 4:4\\] 0: No interrupt or interrupt not enabled 1: RIS.TAMRIS = 1 && IMR.TAMIM = 1"]
722    #[inline]
723    pub fn tammis(&self) -> TAMMISR {
724        let bits = {
725            const MASK: bool = true;
726            const OFFSET: u8 = 4;
727            ((self.bits >> OFFSET) & MASK as u32) != 0
728        };
729        TAMMISR { bits }
730    }
731    #[doc = "Bit 3 - 3:3\\] Software should not rely on the value of a reserved. Writing any other value than the reset value may result in undefined behavior."]
732    #[inline]
733    pub fn reserved3(&self) -> RESERVED3R {
734        let bits = {
735            const MASK: bool = true;
736            const OFFSET: u8 = 3;
737            ((self.bits >> OFFSET) & MASK as u32) != 0
738        };
739        RESERVED3R { bits }
740    }
741    #[doc = "Bit 2 - 2:2\\] 0: No interrupt or interrupt not enabled 1: RIS.CAERIS = 1 && IMR.CAEIM = 1"]
742    #[inline]
743    pub fn caemis(&self) -> CAEMISR {
744        let bits = {
745            const MASK: bool = true;
746            const OFFSET: u8 = 2;
747            ((self.bits >> OFFSET) & MASK as u32) != 0
748        };
749        CAEMISR { bits }
750    }
751    #[doc = "Bit 1 - 1:1\\] 0: No interrupt or interrupt not enabled 1: RIS.CAMRIS = 1 && IMR.CAMIM = 1"]
752    #[inline]
753    pub fn cammis(&self) -> CAMMISR {
754        let bits = {
755            const MASK: bool = true;
756            const OFFSET: u8 = 1;
757            ((self.bits >> OFFSET) & MASK as u32) != 0
758        };
759        CAMMISR { bits }
760    }
761    #[doc = "Bit 0 - 0:0\\] 0: No interrupt or interrupt not enabled 1: RIS.TATORIS = 1 && IMR.TATOIM = 1"]
762    #[inline]
763    pub fn tatomis(&self) -> TATOMISR {
764        let bits = {
765            const MASK: bool = true;
766            const OFFSET: u8 = 0;
767            ((self.bits >> OFFSET) & MASK as u32) != 0
768        };
769        TATOMISR { bits }
770    }
771}
772impl W {
773    #[doc = r" Reset value of the register"]
774    #[inline]
775    pub fn reset_value() -> W {
776        W { bits: 0 }
777    }
778    #[doc = r" Writes raw bits to the register"]
779    #[inline]
780    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
781        self.bits = bits;
782        self
783    }
784    #[doc = "Bits 14:31 - 31:14\\] Software should not rely on the value of a reserved. Writing any other value than the reset value may result in undefined behavior."]
785    #[inline]
786    pub fn reserved14(&mut self) -> _RESERVED14W {
787        _RESERVED14W { w: self }
788    }
789    #[doc = "Bit 13 - 13:13\\] 0: No interrupt or interrupt not enabled 1: RIS.DMABRIS = 1 && IMR.DMABIM = 1"]
790    #[inline]
791    pub fn dmabmis(&mut self) -> _DMABMISW {
792        _DMABMISW { w: self }
793    }
794    #[doc = "Bit 12 - 12:12\\] Software should not rely on the value of a reserved. Writing any other value than the reset value may result in undefined behavior."]
795    #[inline]
796    pub fn reserved12(&mut self) -> _RESERVED12W {
797        _RESERVED12W { w: self }
798    }
799    #[doc = "Bit 11 - 11:11\\] 0: No interrupt or interrupt not enabled 1: RIS.TBMRIS = 1 && IMR.TBMIM = 1"]
800    #[inline]
801    pub fn tbmmis(&mut self) -> _TBMMISW {
802        _TBMMISW { w: self }
803    }
804    #[doc = "Bit 10 - 10:10\\] 0: No interrupt or interrupt not enabled 1: RIS.CBERIS = 1 && IMR.CBEIM = 1"]
805    #[inline]
806    pub fn cbemis(&mut self) -> _CBEMISW {
807        _CBEMISW { w: self }
808    }
809    #[doc = "Bit 9 - 9:9\\] 0: No interrupt or interrupt not enabled 1: RIS.CBMRIS = 1 && IMR.CBMIM = 1"]
810    #[inline]
811    pub fn cbmmis(&mut self) -> _CBMMISW {
812        _CBMMISW { w: self }
813    }
814    #[doc = "Bit 8 - 8:8\\] 0: No interrupt or interrupt not enabled 1: RIS.TBTORIS = 1 && IMR.TBTOIM = 1"]
815    #[inline]
816    pub fn tbtomis(&mut self) -> _TBTOMISW {
817        _TBTOMISW { w: self }
818    }
819    #[doc = "Bits 6:7 - 7:6\\] Software should not rely on the value of a reserved. Writing any other value than the reset value may result in undefined behavior."]
820    #[inline]
821    pub fn reserved6(&mut self) -> _RESERVED6W {
822        _RESERVED6W { w: self }
823    }
824    #[doc = "Bit 5 - 5:5\\] 0: No interrupt or interrupt not enabled 1: RIS.DMAARIS = 1 && IMR.DMAAIM = 1"]
825    #[inline]
826    pub fn dmaamis(&mut self) -> _DMAAMISW {
827        _DMAAMISW { w: self }
828    }
829    #[doc = "Bit 4 - 4:4\\] 0: No interrupt or interrupt not enabled 1: RIS.TAMRIS = 1 && IMR.TAMIM = 1"]
830    #[inline]
831    pub fn tammis(&mut self) -> _TAMMISW {
832        _TAMMISW { w: self }
833    }
834    #[doc = "Bit 3 - 3:3\\] Software should not rely on the value of a reserved. Writing any other value than the reset value may result in undefined behavior."]
835    #[inline]
836    pub fn reserved3(&mut self) -> _RESERVED3W {
837        _RESERVED3W { w: self }
838    }
839    #[doc = "Bit 2 - 2:2\\] 0: No interrupt or interrupt not enabled 1: RIS.CAERIS = 1 && IMR.CAEIM = 1"]
840    #[inline]
841    pub fn caemis(&mut self) -> _CAEMISW {
842        _CAEMISW { w: self }
843    }
844    #[doc = "Bit 1 - 1:1\\] 0: No interrupt or interrupt not enabled 1: RIS.CAMRIS = 1 && IMR.CAMIM = 1"]
845    #[inline]
846    pub fn cammis(&mut self) -> _CAMMISW {
847        _CAMMISW { w: self }
848    }
849    #[doc = "Bit 0 - 0:0\\] 0: No interrupt or interrupt not enabled 1: RIS.TATORIS = 1 && IMR.TATOIM = 1"]
850    #[inline]
851    pub fn tatomis(&mut self) -> _TATOMISW {
852        _TATOMISW { w: self }
853    }
854}
cc13x2_cc26x2_pac/gpt2/mis.rs

cc13x2_cc26x2_pac/gpt2/
mis.rs
