stm32l0x1/dma1/isr/
mod.rs

1#[doc = r" Value read from the register"]
2pub struct R {
3    bits: u32,
4}
5impl super::ISR {
6    #[doc = r" Reads the contents of the register"]
7    #[inline]
8    pub fn read(&self) -> R {
9        R {
10            bits: self.register.get(),
11        }
12    }
13}
14#[doc = r" Value of the field"]
15pub struct TEIF7R {
16    bits: bool,
17}
18impl TEIF7R {
19    #[doc = r" Value of the field as raw bits"]
20    #[inline]
21    pub fn bit(&self) -> bool {
22        self.bits
23    }
24    #[doc = r" Returns `true` if the bit is clear (0)"]
25    #[inline]
26    pub fn bit_is_clear(&self) -> bool {
27        !self.bit()
28    }
29    #[doc = r" Returns `true` if the bit is set (1)"]
30    #[inline]
31    pub fn bit_is_set(&self) -> bool {
32        self.bit()
33    }
34}
35#[doc = r" Value of the field"]
36pub struct HTIF7R {
37    bits: bool,
38}
39impl HTIF7R {
40    #[doc = r" Value of the field as raw bits"]
41    #[inline]
42    pub fn bit(&self) -> bool {
43        self.bits
44    }
45    #[doc = r" Returns `true` if the bit is clear (0)"]
46    #[inline]
47    pub fn bit_is_clear(&self) -> bool {
48        !self.bit()
49    }
50    #[doc = r" Returns `true` if the bit is set (1)"]
51    #[inline]
52    pub fn bit_is_set(&self) -> bool {
53        self.bit()
54    }
55}
56#[doc = r" Value of the field"]
57pub struct TCIF7R {
58    bits: bool,
59}
60impl TCIF7R {
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 GIF7R {
79    bits: bool,
80}
81impl GIF7R {
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 TEIF6R {
100    bits: bool,
101}
102impl TEIF6R {
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 HTIF6R {
121    bits: bool,
122}
123impl HTIF6R {
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 TCIF6R {
142    bits: bool,
143}
144impl TCIF6R {
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 GIF6R {
163    bits: bool,
164}
165impl GIF6R {
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 TEIF5R {
184    bits: bool,
185}
186impl TEIF5R {
187    #[doc = r" Value of the field as raw bits"]
188    #[inline]
189    pub fn bit(&self) -> bool {
190        self.bits
191    }
192    #[doc = r" Returns `true` if the bit is clear (0)"]
193    #[inline]
194    pub fn bit_is_clear(&self) -> bool {
195        !self.bit()
196    }
197    #[doc = r" Returns `true` if the bit is set (1)"]
198    #[inline]
199    pub fn bit_is_set(&self) -> bool {
200        self.bit()
201    }
202}
203#[doc = r" Value of the field"]
204pub struct HTIF5R {
205    bits: bool,
206}
207impl HTIF5R {
208    #[doc = r" Value of the field as raw bits"]
209    #[inline]
210    pub fn bit(&self) -> bool {
211        self.bits
212    }
213    #[doc = r" Returns `true` if the bit is clear (0)"]
214    #[inline]
215    pub fn bit_is_clear(&self) -> bool {
216        !self.bit()
217    }
218    #[doc = r" Returns `true` if the bit is set (1)"]
219    #[inline]
220    pub fn bit_is_set(&self) -> bool {
221        self.bit()
222    }
223}
224#[doc = r" Value of the field"]
225pub struct TCIF5R {
226    bits: bool,
227}
228impl TCIF5R {
229    #[doc = r" Value of the field as raw bits"]
230    #[inline]
231    pub fn bit(&self) -> bool {
232        self.bits
233    }
234    #[doc = r" Returns `true` if the bit is clear (0)"]
235    #[inline]
236    pub fn bit_is_clear(&self) -> bool {
237        !self.bit()
238    }
239    #[doc = r" Returns `true` if the bit is set (1)"]
240    #[inline]
241    pub fn bit_is_set(&self) -> bool {
242        self.bit()
243    }
244}
245#[doc = r" Value of the field"]
246pub struct GIF5R {
247    bits: bool,
248}
249impl GIF5R {
250    #[doc = r" Value of the field as raw bits"]
251    #[inline]
252    pub fn bit(&self) -> bool {
253        self.bits
254    }
255    #[doc = r" Returns `true` if the bit is clear (0)"]
256    #[inline]
257    pub fn bit_is_clear(&self) -> bool {
258        !self.bit()
259    }
260    #[doc = r" Returns `true` if the bit is set (1)"]
261    #[inline]
262    pub fn bit_is_set(&self) -> bool {
263        self.bit()
264    }
265}
266#[doc = r" Value of the field"]
267pub struct TEIF4R {
268    bits: bool,
269}
270impl TEIF4R {
271    #[doc = r" Value of the field as raw bits"]
272    #[inline]
273    pub fn bit(&self) -> bool {
274        self.bits
275    }
276    #[doc = r" Returns `true` if the bit is clear (0)"]
277    #[inline]
278    pub fn bit_is_clear(&self) -> bool {
279        !self.bit()
280    }
281    #[doc = r" Returns `true` if the bit is set (1)"]
282    #[inline]
283    pub fn bit_is_set(&self) -> bool {
284        self.bit()
285    }
286}
287#[doc = r" Value of the field"]
288pub struct HTIF4R {
289    bits: bool,
290}
291impl HTIF4R {
292    #[doc = r" Value of the field as raw bits"]
293    #[inline]
294    pub fn bit(&self) -> bool {
295        self.bits
296    }
297    #[doc = r" Returns `true` if the bit is clear (0)"]
298    #[inline]
299    pub fn bit_is_clear(&self) -> bool {
300        !self.bit()
301    }
302    #[doc = r" Returns `true` if the bit is set (1)"]
303    #[inline]
304    pub fn bit_is_set(&self) -> bool {
305        self.bit()
306    }
307}
308#[doc = r" Value of the field"]
309pub struct TCIF4R {
310    bits: bool,
311}
312impl TCIF4R {
313    #[doc = r" Value of the field as raw bits"]
314    #[inline]
315    pub fn bit(&self) -> bool {
316        self.bits
317    }
318    #[doc = r" Returns `true` if the bit is clear (0)"]
319    #[inline]
320    pub fn bit_is_clear(&self) -> bool {
321        !self.bit()
322    }
323    #[doc = r" Returns `true` if the bit is set (1)"]
324    #[inline]
325    pub fn bit_is_set(&self) -> bool {
326        self.bit()
327    }
328}
329#[doc = r" Value of the field"]
330pub struct GIF4R {
331    bits: bool,
332}
333impl GIF4R {
334    #[doc = r" Value of the field as raw bits"]
335    #[inline]
336    pub fn bit(&self) -> bool {
337        self.bits
338    }
339    #[doc = r" Returns `true` if the bit is clear (0)"]
340    #[inline]
341    pub fn bit_is_clear(&self) -> bool {
342        !self.bit()
343    }
344    #[doc = r" Returns `true` if the bit is set (1)"]
345    #[inline]
346    pub fn bit_is_set(&self) -> bool {
347        self.bit()
348    }
349}
350#[doc = r" Value of the field"]
351pub struct TEIF3R {
352    bits: bool,
353}
354impl TEIF3R {
355    #[doc = r" Value of the field as raw bits"]
356    #[inline]
357    pub fn bit(&self) -> bool {
358        self.bits
359    }
360    #[doc = r" Returns `true` if the bit is clear (0)"]
361    #[inline]
362    pub fn bit_is_clear(&self) -> bool {
363        !self.bit()
364    }
365    #[doc = r" Returns `true` if the bit is set (1)"]
366    #[inline]
367    pub fn bit_is_set(&self) -> bool {
368        self.bit()
369    }
370}
371#[doc = r" Value of the field"]
372pub struct HTIF3R {
373    bits: bool,
374}
375impl HTIF3R {
376    #[doc = r" Value of the field as raw bits"]
377    #[inline]
378    pub fn bit(&self) -> bool {
379        self.bits
380    }
381    #[doc = r" Returns `true` if the bit is clear (0)"]
382    #[inline]
383    pub fn bit_is_clear(&self) -> bool {
384        !self.bit()
385    }
386    #[doc = r" Returns `true` if the bit is set (1)"]
387    #[inline]
388    pub fn bit_is_set(&self) -> bool {
389        self.bit()
390    }
391}
392#[doc = r" Value of the field"]
393pub struct TCIF3R {
394    bits: bool,
395}
396impl TCIF3R {
397    #[doc = r" Value of the field as raw bits"]
398    #[inline]
399    pub fn bit(&self) -> bool {
400        self.bits
401    }
402    #[doc = r" Returns `true` if the bit is clear (0)"]
403    #[inline]
404    pub fn bit_is_clear(&self) -> bool {
405        !self.bit()
406    }
407    #[doc = r" Returns `true` if the bit is set (1)"]
408    #[inline]
409    pub fn bit_is_set(&self) -> bool {
410        self.bit()
411    }
412}
413#[doc = r" Value of the field"]
414pub struct GIF3R {
415    bits: bool,
416}
417impl GIF3R {
418    #[doc = r" Value of the field as raw bits"]
419    #[inline]
420    pub fn bit(&self) -> bool {
421        self.bits
422    }
423    #[doc = r" Returns `true` if the bit is clear (0)"]
424    #[inline]
425    pub fn bit_is_clear(&self) -> bool {
426        !self.bit()
427    }
428    #[doc = r" Returns `true` if the bit is set (1)"]
429    #[inline]
430    pub fn bit_is_set(&self) -> bool {
431        self.bit()
432    }
433}
434#[doc = r" Value of the field"]
435pub struct TEIF2R {
436    bits: bool,
437}
438impl TEIF2R {
439    #[doc = r" Value of the field as raw bits"]
440    #[inline]
441    pub fn bit(&self) -> bool {
442        self.bits
443    }
444    #[doc = r" Returns `true` if the bit is clear (0)"]
445    #[inline]
446    pub fn bit_is_clear(&self) -> bool {
447        !self.bit()
448    }
449    #[doc = r" Returns `true` if the bit is set (1)"]
450    #[inline]
451    pub fn bit_is_set(&self) -> bool {
452        self.bit()
453    }
454}
455#[doc = r" Value of the field"]
456pub struct HTIF2R {
457    bits: bool,
458}
459impl HTIF2R {
460    #[doc = r" Value of the field as raw bits"]
461    #[inline]
462    pub fn bit(&self) -> bool {
463        self.bits
464    }
465    #[doc = r" Returns `true` if the bit is clear (0)"]
466    #[inline]
467    pub fn bit_is_clear(&self) -> bool {
468        !self.bit()
469    }
470    #[doc = r" Returns `true` if the bit is set (1)"]
471    #[inline]
472    pub fn bit_is_set(&self) -> bool {
473        self.bit()
474    }
475}
476#[doc = r" Value of the field"]
477pub struct TCIF2R {
478    bits: bool,
479}
480impl TCIF2R {
481    #[doc = r" Value of the field as raw bits"]
482    #[inline]
483    pub fn bit(&self) -> bool {
484        self.bits
485    }
486    #[doc = r" Returns `true` if the bit is clear (0)"]
487    #[inline]
488    pub fn bit_is_clear(&self) -> bool {
489        !self.bit()
490    }
491    #[doc = r" Returns `true` if the bit is set (1)"]
492    #[inline]
493    pub fn bit_is_set(&self) -> bool {
494        self.bit()
495    }
496}
497#[doc = r" Value of the field"]
498pub struct GIF2R {
499    bits: bool,
500}
501impl GIF2R {
502    #[doc = r" Value of the field as raw bits"]
503    #[inline]
504    pub fn bit(&self) -> bool {
505        self.bits
506    }
507    #[doc = r" Returns `true` if the bit is clear (0)"]
508    #[inline]
509    pub fn bit_is_clear(&self) -> bool {
510        !self.bit()
511    }
512    #[doc = r" Returns `true` if the bit is set (1)"]
513    #[inline]
514    pub fn bit_is_set(&self) -> bool {
515        self.bit()
516    }
517}
518#[doc = r" Value of the field"]
519pub struct TEIF1R {
520    bits: bool,
521}
522impl TEIF1R {
523    #[doc = r" Value of the field as raw bits"]
524    #[inline]
525    pub fn bit(&self) -> bool {
526        self.bits
527    }
528    #[doc = r" Returns `true` if the bit is clear (0)"]
529    #[inline]
530    pub fn bit_is_clear(&self) -> bool {
531        !self.bit()
532    }
533    #[doc = r" Returns `true` if the bit is set (1)"]
534    #[inline]
535    pub fn bit_is_set(&self) -> bool {
536        self.bit()
537    }
538}
539#[doc = r" Value of the field"]
540pub struct HTIF1R {
541    bits: bool,
542}
543impl HTIF1R {
544    #[doc = r" Value of the field as raw bits"]
545    #[inline]
546    pub fn bit(&self) -> bool {
547        self.bits
548    }
549    #[doc = r" Returns `true` if the bit is clear (0)"]
550    #[inline]
551    pub fn bit_is_clear(&self) -> bool {
552        !self.bit()
553    }
554    #[doc = r" Returns `true` if the bit is set (1)"]
555    #[inline]
556    pub fn bit_is_set(&self) -> bool {
557        self.bit()
558    }
559}
560#[doc = r" Value of the field"]
561pub struct TCIF1R {
562    bits: bool,
563}
564impl TCIF1R {
565    #[doc = r" Value of the field as raw bits"]
566    #[inline]
567    pub fn bit(&self) -> bool {
568        self.bits
569    }
570    #[doc = r" Returns `true` if the bit is clear (0)"]
571    #[inline]
572    pub fn bit_is_clear(&self) -> bool {
573        !self.bit()
574    }
575    #[doc = r" Returns `true` if the bit is set (1)"]
576    #[inline]
577    pub fn bit_is_set(&self) -> bool {
578        self.bit()
579    }
580}
581#[doc = r" Value of the field"]
582pub struct GIF1R {
583    bits: bool,
584}
585impl GIF1R {
586    #[doc = r" Value of the field as raw bits"]
587    #[inline]
588    pub fn bit(&self) -> bool {
589        self.bits
590    }
591    #[doc = r" Returns `true` if the bit is clear (0)"]
592    #[inline]
593    pub fn bit_is_clear(&self) -> bool {
594        !self.bit()
595    }
596    #[doc = r" Returns `true` if the bit is set (1)"]
597    #[inline]
598    pub fn bit_is_set(&self) -> bool {
599        self.bit()
600    }
601}
602impl R {
603    #[doc = r" Value of the register as raw bits"]
604    #[inline]
605    pub fn bits(&self) -> u32 {
606        self.bits
607    }
608    #[doc = "Bit 27 - Channel x transfer error flag (x = 1 ..7)"]
609    #[inline]
610    pub fn teif7(&self) -> TEIF7R {
611        let bits = {
612            const MASK: bool = true;
613            const OFFSET: u8 = 27;
614            ((self.bits >> OFFSET) & MASK as u32) != 0
615        };
616        TEIF7R { bits }
617    }
618    #[doc = "Bit 26 - Channel x half transfer flag (x = 1 ..7)"]
619    #[inline]
620    pub fn htif7(&self) -> HTIF7R {
621        let bits = {
622            const MASK: bool = true;
623            const OFFSET: u8 = 26;
624            ((self.bits >> OFFSET) & MASK as u32) != 0
625        };
626        HTIF7R { bits }
627    }
628    #[doc = "Bit 25 - Channel x transfer complete flag (x = 1 ..7)"]
629    #[inline]
630    pub fn tcif7(&self) -> TCIF7R {
631        let bits = {
632            const MASK: bool = true;
633            const OFFSET: u8 = 25;
634            ((self.bits >> OFFSET) & MASK as u32) != 0
635        };
636        TCIF7R { bits }
637    }
638    #[doc = "Bit 24 - Channel x global interrupt flag (x = 1 ..7)"]
639    #[inline]
640    pub fn gif7(&self) -> GIF7R {
641        let bits = {
642            const MASK: bool = true;
643            const OFFSET: u8 = 24;
644            ((self.bits >> OFFSET) & MASK as u32) != 0
645        };
646        GIF7R { bits }
647    }
648    #[doc = "Bit 23 - Channel x transfer error flag (x = 1 ..7)"]
649    #[inline]
650    pub fn teif6(&self) -> TEIF6R {
651        let bits = {
652            const MASK: bool = true;
653            const OFFSET: u8 = 23;
654            ((self.bits >> OFFSET) & MASK as u32) != 0
655        };
656        TEIF6R { bits }
657    }
658    #[doc = "Bit 22 - Channel x half transfer flag (x = 1 ..7)"]
659    #[inline]
660    pub fn htif6(&self) -> HTIF6R {
661        let bits = {
662            const MASK: bool = true;
663            const OFFSET: u8 = 22;
664            ((self.bits >> OFFSET) & MASK as u32) != 0
665        };
666        HTIF6R { bits }
667    }
668    #[doc = "Bit 21 - Channel x transfer complete flag (x = 1 ..7)"]
669    #[inline]
670    pub fn tcif6(&self) -> TCIF6R {
671        let bits = {
672            const MASK: bool = true;
673            const OFFSET: u8 = 21;
674            ((self.bits >> OFFSET) & MASK as u32) != 0
675        };
676        TCIF6R { bits }
677    }
678    #[doc = "Bit 20 - Channel x global interrupt flag (x = 1 ..7)"]
679    #[inline]
680    pub fn gif6(&self) -> GIF6R {
681        let bits = {
682            const MASK: bool = true;
683            const OFFSET: u8 = 20;
684            ((self.bits >> OFFSET) & MASK as u32) != 0
685        };
686        GIF6R { bits }
687    }
688    #[doc = "Bit 19 - Channel x transfer error flag (x = 1 ..7)"]
689    #[inline]
690    pub fn teif5(&self) -> TEIF5R {
691        let bits = {
692            const MASK: bool = true;
693            const OFFSET: u8 = 19;
694            ((self.bits >> OFFSET) & MASK as u32) != 0
695        };
696        TEIF5R { bits }
697    }
698    #[doc = "Bit 18 - Channel x half transfer flag (x = 1 ..7)"]
699    #[inline]
700    pub fn htif5(&self) -> HTIF5R {
701        let bits = {
702            const MASK: bool = true;
703            const OFFSET: u8 = 18;
704            ((self.bits >> OFFSET) & MASK as u32) != 0
705        };
706        HTIF5R { bits }
707    }
708    #[doc = "Bit 17 - Channel x transfer complete flag (x = 1 ..7)"]
709    #[inline]
710    pub fn tcif5(&self) -> TCIF5R {
711        let bits = {
712            const MASK: bool = true;
713            const OFFSET: u8 = 17;
714            ((self.bits >> OFFSET) & MASK as u32) != 0
715        };
716        TCIF5R { bits }
717    }
718    #[doc = "Bit 16 - Channel x global interrupt flag (x = 1 ..7)"]
719    #[inline]
720    pub fn gif5(&self) -> GIF5R {
721        let bits = {
722            const MASK: bool = true;
723            const OFFSET: u8 = 16;
724            ((self.bits >> OFFSET) & MASK as u32) != 0
725        };
726        GIF5R { bits }
727    }
728    #[doc = "Bit 15 - Channel x transfer error flag (x = 1 ..7)"]
729    #[inline]
730    pub fn teif4(&self) -> TEIF4R {
731        let bits = {
732            const MASK: bool = true;
733            const OFFSET: u8 = 15;
734            ((self.bits >> OFFSET) & MASK as u32) != 0
735        };
736        TEIF4R { bits }
737    }
738    #[doc = "Bit 14 - Channel x half transfer flag (x = 1 ..7)"]
739    #[inline]
740    pub fn htif4(&self) -> HTIF4R {
741        let bits = {
742            const MASK: bool = true;
743            const OFFSET: u8 = 14;
744            ((self.bits >> OFFSET) & MASK as u32) != 0
745        };
746        HTIF4R { bits }
747    }
748    #[doc = "Bit 13 - Channel x transfer complete flag (x = 1 ..7)"]
749    #[inline]
750    pub fn tcif4(&self) -> TCIF4R {
751        let bits = {
752            const MASK: bool = true;
753            const OFFSET: u8 = 13;
754            ((self.bits >> OFFSET) & MASK as u32) != 0
755        };
756        TCIF4R { bits }
757    }
758    #[doc = "Bit 12 - Channel x global interrupt flag (x = 1 ..7)"]
759    #[inline]
760    pub fn gif4(&self) -> GIF4R {
761        let bits = {
762            const MASK: bool = true;
763            const OFFSET: u8 = 12;
764            ((self.bits >> OFFSET) & MASK as u32) != 0
765        };
766        GIF4R { bits }
767    }
768    #[doc = "Bit 11 - Channel x transfer error flag (x = 1 ..7)"]
769    #[inline]
770    pub fn teif3(&self) -> TEIF3R {
771        let bits = {
772            const MASK: bool = true;
773            const OFFSET: u8 = 11;
774            ((self.bits >> OFFSET) & MASK as u32) != 0
775        };
776        TEIF3R { bits }
777    }
778    #[doc = "Bit 10 - Channel x half transfer flag (x = 1 ..7)"]
779    #[inline]
780    pub fn htif3(&self) -> HTIF3R {
781        let bits = {
782            const MASK: bool = true;
783            const OFFSET: u8 = 10;
784            ((self.bits >> OFFSET) & MASK as u32) != 0
785        };
786        HTIF3R { bits }
787    }
788    #[doc = "Bit 9 - Channel x transfer complete flag (x = 1 ..7)"]
789    #[inline]
790    pub fn tcif3(&self) -> TCIF3R {
791        let bits = {
792            const MASK: bool = true;
793            const OFFSET: u8 = 9;
794            ((self.bits >> OFFSET) & MASK as u32) != 0
795        };
796        TCIF3R { bits }
797    }
798    #[doc = "Bit 8 - Channel x global interrupt flag (x = 1 ..7)"]
799    #[inline]
800    pub fn gif3(&self) -> GIF3R {
801        let bits = {
802            const MASK: bool = true;
803            const OFFSET: u8 = 8;
804            ((self.bits >> OFFSET) & MASK as u32) != 0
805        };
806        GIF3R { bits }
807    }
808    #[doc = "Bit 7 - Channel x transfer error flag (x = 1 ..7)"]
809    #[inline]
810    pub fn teif2(&self) -> TEIF2R {
811        let bits = {
812            const MASK: bool = true;
813            const OFFSET: u8 = 7;
814            ((self.bits >> OFFSET) & MASK as u32) != 0
815        };
816        TEIF2R { bits }
817    }
818    #[doc = "Bit 6 - Channel x half transfer flag (x = 1 ..7)"]
819    #[inline]
820    pub fn htif2(&self) -> HTIF2R {
821        let bits = {
822            const MASK: bool = true;
823            const OFFSET: u8 = 6;
824            ((self.bits >> OFFSET) & MASK as u32) != 0
825        };
826        HTIF2R { bits }
827    }
828    #[doc = "Bit 5 - Channel x transfer complete flag (x = 1 ..7)"]
829    #[inline]
830    pub fn tcif2(&self) -> TCIF2R {
831        let bits = {
832            const MASK: bool = true;
833            const OFFSET: u8 = 5;
834            ((self.bits >> OFFSET) & MASK as u32) != 0
835        };
836        TCIF2R { bits }
837    }
838    #[doc = "Bit 4 - Channel x global interrupt flag (x = 1 ..7)"]
839    #[inline]
840    pub fn gif2(&self) -> GIF2R {
841        let bits = {
842            const MASK: bool = true;
843            const OFFSET: u8 = 4;
844            ((self.bits >> OFFSET) & MASK as u32) != 0
845        };
846        GIF2R { bits }
847    }
848    #[doc = "Bit 3 - Channel x transfer error flag (x = 1 ..7)"]
849    #[inline]
850    pub fn teif1(&self) -> TEIF1R {
851        let bits = {
852            const MASK: bool = true;
853            const OFFSET: u8 = 3;
854            ((self.bits >> OFFSET) & MASK as u32) != 0
855        };
856        TEIF1R { bits }
857    }
858    #[doc = "Bit 2 - Channel x half transfer flag (x = 1 ..7)"]
859    #[inline]
860    pub fn htif1(&self) -> HTIF1R {
861        let bits = {
862            const MASK: bool = true;
863            const OFFSET: u8 = 2;
864            ((self.bits >> OFFSET) & MASK as u32) != 0
865        };
866        HTIF1R { bits }
867    }
868    #[doc = "Bit 1 - Channel x transfer complete flag (x = 1 ..7)"]
869    #[inline]
870    pub fn tcif1(&self) -> TCIF1R {
871        let bits = {
872            const MASK: bool = true;
873            const OFFSET: u8 = 1;
874            ((self.bits >> OFFSET) & MASK as u32) != 0
875        };
876        TCIF1R { bits }
877    }
878    #[doc = "Bit 0 - Channel x global interrupt flag (x = 1 ..7)"]
879    #[inline]
880    pub fn gif1(&self) -> GIF1R {
881        let bits = {
882            const MASK: bool = true;
883            const OFFSET: u8 = 0;
884            ((self.bits >> OFFSET) & MASK as u32) != 0
885        };
886        GIF1R { bits }
887    }
888}
stm32l0x1/dma1/isr/mod.rs

stm32l0x1/dma1/isr/
mod.rs
