stm32f30x/can/f6r2/
mod.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::F6R2 {
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 FB0R {
47    bits: bool,
48}
49impl FB0R {
50    #[doc = r" Value of the field as raw bits"]
51    #[inline]
52    pub fn bit(&self) -> bool {
53        self.bits
54    }
55    #[doc = r" Returns `true` if the bit is clear (0)"]
56    #[inline]
57    pub fn bit_is_clear(&self) -> bool {
58        !self.bit()
59    }
60    #[doc = r" Returns `true` if the bit is set (1)"]
61    #[inline]
62    pub fn bit_is_set(&self) -> bool {
63        self.bit()
64    }
65}
66#[doc = r" Value of the field"]
67pub struct FB1R {
68    bits: bool,
69}
70impl FB1R {
71    #[doc = r" Value of the field as raw bits"]
72    #[inline]
73    pub fn bit(&self) -> bool {
74        self.bits
75    }
76    #[doc = r" Returns `true` if the bit is clear (0)"]
77    #[inline]
78    pub fn bit_is_clear(&self) -> bool {
79        !self.bit()
80    }
81    #[doc = r" Returns `true` if the bit is set (1)"]
82    #[inline]
83    pub fn bit_is_set(&self) -> bool {
84        self.bit()
85    }
86}
87#[doc = r" Value of the field"]
88pub struct FB2R {
89    bits: bool,
90}
91impl FB2R {
92    #[doc = r" Value of the field as raw bits"]
93    #[inline]
94    pub fn bit(&self) -> bool {
95        self.bits
96    }
97    #[doc = r" Returns `true` if the bit is clear (0)"]
98    #[inline]
99    pub fn bit_is_clear(&self) -> bool {
100        !self.bit()
101    }
102    #[doc = r" Returns `true` if the bit is set (1)"]
103    #[inline]
104    pub fn bit_is_set(&self) -> bool {
105        self.bit()
106    }
107}
108#[doc = r" Value of the field"]
109pub struct FB3R {
110    bits: bool,
111}
112impl FB3R {
113    #[doc = r" Value of the field as raw bits"]
114    #[inline]
115    pub fn bit(&self) -> bool {
116        self.bits
117    }
118    #[doc = r" Returns `true` if the bit is clear (0)"]
119    #[inline]
120    pub fn bit_is_clear(&self) -> bool {
121        !self.bit()
122    }
123    #[doc = r" Returns `true` if the bit is set (1)"]
124    #[inline]
125    pub fn bit_is_set(&self) -> bool {
126        self.bit()
127    }
128}
129#[doc = r" Value of the field"]
130pub struct FB4R {
131    bits: bool,
132}
133impl FB4R {
134    #[doc = r" Value of the field as raw bits"]
135    #[inline]
136    pub fn bit(&self) -> bool {
137        self.bits
138    }
139    #[doc = r" Returns `true` if the bit is clear (0)"]
140    #[inline]
141    pub fn bit_is_clear(&self) -> bool {
142        !self.bit()
143    }
144    #[doc = r" Returns `true` if the bit is set (1)"]
145    #[inline]
146    pub fn bit_is_set(&self) -> bool {
147        self.bit()
148    }
149}
150#[doc = r" Value of the field"]
151pub struct FB5R {
152    bits: bool,
153}
154impl FB5R {
155    #[doc = r" Value of the field as raw bits"]
156    #[inline]
157    pub fn bit(&self) -> bool {
158        self.bits
159    }
160    #[doc = r" Returns `true` if the bit is clear (0)"]
161    #[inline]
162    pub fn bit_is_clear(&self) -> bool {
163        !self.bit()
164    }
165    #[doc = r" Returns `true` if the bit is set (1)"]
166    #[inline]
167    pub fn bit_is_set(&self) -> bool {
168        self.bit()
169    }
170}
171#[doc = r" Value of the field"]
172pub struct FB6R {
173    bits: bool,
174}
175impl FB6R {
176    #[doc = r" Value of the field as raw bits"]
177    #[inline]
178    pub fn bit(&self) -> bool {
179        self.bits
180    }
181    #[doc = r" Returns `true` if the bit is clear (0)"]
182    #[inline]
183    pub fn bit_is_clear(&self) -> bool {
184        !self.bit()
185    }
186    #[doc = r" Returns `true` if the bit is set (1)"]
187    #[inline]
188    pub fn bit_is_set(&self) -> bool {
189        self.bit()
190    }
191}
192#[doc = r" Value of the field"]
193pub struct FB7R {
194    bits: bool,
195}
196impl FB7R {
197    #[doc = r" Value of the field as raw bits"]
198    #[inline]
199    pub fn bit(&self) -> bool {
200        self.bits
201    }
202    #[doc = r" Returns `true` if the bit is clear (0)"]
203    #[inline]
204    pub fn bit_is_clear(&self) -> bool {
205        !self.bit()
206    }
207    #[doc = r" Returns `true` if the bit is set (1)"]
208    #[inline]
209    pub fn bit_is_set(&self) -> bool {
210        self.bit()
211    }
212}
213#[doc = r" Value of the field"]
214pub struct FB8R {
215    bits: bool,
216}
217impl FB8R {
218    #[doc = r" Value of the field as raw bits"]
219    #[inline]
220    pub fn bit(&self) -> bool {
221        self.bits
222    }
223    #[doc = r" Returns `true` if the bit is clear (0)"]
224    #[inline]
225    pub fn bit_is_clear(&self) -> bool {
226        !self.bit()
227    }
228    #[doc = r" Returns `true` if the bit is set (1)"]
229    #[inline]
230    pub fn bit_is_set(&self) -> bool {
231        self.bit()
232    }
233}
234#[doc = r" Value of the field"]
235pub struct FB9R {
236    bits: bool,
237}
238impl FB9R {
239    #[doc = r" Value of the field as raw bits"]
240    #[inline]
241    pub fn bit(&self) -> bool {
242        self.bits
243    }
244    #[doc = r" Returns `true` if the bit is clear (0)"]
245    #[inline]
246    pub fn bit_is_clear(&self) -> bool {
247        !self.bit()
248    }
249    #[doc = r" Returns `true` if the bit is set (1)"]
250    #[inline]
251    pub fn bit_is_set(&self) -> bool {
252        self.bit()
253    }
254}
255#[doc = r" Value of the field"]
256pub struct FB10R {
257    bits: bool,
258}
259impl FB10R {
260    #[doc = r" Value of the field as raw bits"]
261    #[inline]
262    pub fn bit(&self) -> bool {
263        self.bits
264    }
265    #[doc = r" Returns `true` if the bit is clear (0)"]
266    #[inline]
267    pub fn bit_is_clear(&self) -> bool {
268        !self.bit()
269    }
270    #[doc = r" Returns `true` if the bit is set (1)"]
271    #[inline]
272    pub fn bit_is_set(&self) -> bool {
273        self.bit()
274    }
275}
276#[doc = r" Value of the field"]
277pub struct FB11R {
278    bits: bool,
279}
280impl FB11R {
281    #[doc = r" Value of the field as raw bits"]
282    #[inline]
283    pub fn bit(&self) -> bool {
284        self.bits
285    }
286    #[doc = r" Returns `true` if the bit is clear (0)"]
287    #[inline]
288    pub fn bit_is_clear(&self) -> bool {
289        !self.bit()
290    }
291    #[doc = r" Returns `true` if the bit is set (1)"]
292    #[inline]
293    pub fn bit_is_set(&self) -> bool {
294        self.bit()
295    }
296}
297#[doc = r" Value of the field"]
298pub struct FB12R {
299    bits: bool,
300}
301impl FB12R {
302    #[doc = r" Value of the field as raw bits"]
303    #[inline]
304    pub fn bit(&self) -> bool {
305        self.bits
306    }
307    #[doc = r" Returns `true` if the bit is clear (0)"]
308    #[inline]
309    pub fn bit_is_clear(&self) -> bool {
310        !self.bit()
311    }
312    #[doc = r" Returns `true` if the bit is set (1)"]
313    #[inline]
314    pub fn bit_is_set(&self) -> bool {
315        self.bit()
316    }
317}
318#[doc = r" Value of the field"]
319pub struct FB13R {
320    bits: bool,
321}
322impl FB13R {
323    #[doc = r" Value of the field as raw bits"]
324    #[inline]
325    pub fn bit(&self) -> bool {
326        self.bits
327    }
328    #[doc = r" Returns `true` if the bit is clear (0)"]
329    #[inline]
330    pub fn bit_is_clear(&self) -> bool {
331        !self.bit()
332    }
333    #[doc = r" Returns `true` if the bit is set (1)"]
334    #[inline]
335    pub fn bit_is_set(&self) -> bool {
336        self.bit()
337    }
338}
339#[doc = r" Value of the field"]
340pub struct FB14R {
341    bits: bool,
342}
343impl FB14R {
344    #[doc = r" Value of the field as raw bits"]
345    #[inline]
346    pub fn bit(&self) -> bool {
347        self.bits
348    }
349    #[doc = r" Returns `true` if the bit is clear (0)"]
350    #[inline]
351    pub fn bit_is_clear(&self) -> bool {
352        !self.bit()
353    }
354    #[doc = r" Returns `true` if the bit is set (1)"]
355    #[inline]
356    pub fn bit_is_set(&self) -> bool {
357        self.bit()
358    }
359}
360#[doc = r" Value of the field"]
361pub struct FB15R {
362    bits: bool,
363}
364impl FB15R {
365    #[doc = r" Value of the field as raw bits"]
366    #[inline]
367    pub fn bit(&self) -> bool {
368        self.bits
369    }
370    #[doc = r" Returns `true` if the bit is clear (0)"]
371    #[inline]
372    pub fn bit_is_clear(&self) -> bool {
373        !self.bit()
374    }
375    #[doc = r" Returns `true` if the bit is set (1)"]
376    #[inline]
377    pub fn bit_is_set(&self) -> bool {
378        self.bit()
379    }
380}
381#[doc = r" Value of the field"]
382pub struct FB16R {
383    bits: bool,
384}
385impl FB16R {
386    #[doc = r" Value of the field as raw bits"]
387    #[inline]
388    pub fn bit(&self) -> bool {
389        self.bits
390    }
391    #[doc = r" Returns `true` if the bit is clear (0)"]
392    #[inline]
393    pub fn bit_is_clear(&self) -> bool {
394        !self.bit()
395    }
396    #[doc = r" Returns `true` if the bit is set (1)"]
397    #[inline]
398    pub fn bit_is_set(&self) -> bool {
399        self.bit()
400    }
401}
402#[doc = r" Value of the field"]
403pub struct FB17R {
404    bits: bool,
405}
406impl FB17R {
407    #[doc = r" Value of the field as raw bits"]
408    #[inline]
409    pub fn bit(&self) -> bool {
410        self.bits
411    }
412    #[doc = r" Returns `true` if the bit is clear (0)"]
413    #[inline]
414    pub fn bit_is_clear(&self) -> bool {
415        !self.bit()
416    }
417    #[doc = r" Returns `true` if the bit is set (1)"]
418    #[inline]
419    pub fn bit_is_set(&self) -> bool {
420        self.bit()
421    }
422}
423#[doc = r" Value of the field"]
424pub struct FB18R {
425    bits: bool,
426}
427impl FB18R {
428    #[doc = r" Value of the field as raw bits"]
429    #[inline]
430    pub fn bit(&self) -> bool {
431        self.bits
432    }
433    #[doc = r" Returns `true` if the bit is clear (0)"]
434    #[inline]
435    pub fn bit_is_clear(&self) -> bool {
436        !self.bit()
437    }
438    #[doc = r" Returns `true` if the bit is set (1)"]
439    #[inline]
440    pub fn bit_is_set(&self) -> bool {
441        self.bit()
442    }
443}
444#[doc = r" Value of the field"]
445pub struct FB19R {
446    bits: bool,
447}
448impl FB19R {
449    #[doc = r" Value of the field as raw bits"]
450    #[inline]
451    pub fn bit(&self) -> bool {
452        self.bits
453    }
454    #[doc = r" Returns `true` if the bit is clear (0)"]
455    #[inline]
456    pub fn bit_is_clear(&self) -> bool {
457        !self.bit()
458    }
459    #[doc = r" Returns `true` if the bit is set (1)"]
460    #[inline]
461    pub fn bit_is_set(&self) -> bool {
462        self.bit()
463    }
464}
465#[doc = r" Value of the field"]
466pub struct FB20R {
467    bits: bool,
468}
469impl FB20R {
470    #[doc = r" Value of the field as raw bits"]
471    #[inline]
472    pub fn bit(&self) -> bool {
473        self.bits
474    }
475    #[doc = r" Returns `true` if the bit is clear (0)"]
476    #[inline]
477    pub fn bit_is_clear(&self) -> bool {
478        !self.bit()
479    }
480    #[doc = r" Returns `true` if the bit is set (1)"]
481    #[inline]
482    pub fn bit_is_set(&self) -> bool {
483        self.bit()
484    }
485}
486#[doc = r" Value of the field"]
487pub struct FB21R {
488    bits: bool,
489}
490impl FB21R {
491    #[doc = r" Value of the field as raw bits"]
492    #[inline]
493    pub fn bit(&self) -> bool {
494        self.bits
495    }
496    #[doc = r" Returns `true` if the bit is clear (0)"]
497    #[inline]
498    pub fn bit_is_clear(&self) -> bool {
499        !self.bit()
500    }
501    #[doc = r" Returns `true` if the bit is set (1)"]
502    #[inline]
503    pub fn bit_is_set(&self) -> bool {
504        self.bit()
505    }
506}
507#[doc = r" Value of the field"]
508pub struct FB22R {
509    bits: bool,
510}
511impl FB22R {
512    #[doc = r" Value of the field as raw bits"]
513    #[inline]
514    pub fn bit(&self) -> bool {
515        self.bits
516    }
517    #[doc = r" Returns `true` if the bit is clear (0)"]
518    #[inline]
519    pub fn bit_is_clear(&self) -> bool {
520        !self.bit()
521    }
522    #[doc = r" Returns `true` if the bit is set (1)"]
523    #[inline]
524    pub fn bit_is_set(&self) -> bool {
525        self.bit()
526    }
527}
528#[doc = r" Value of the field"]
529pub struct FB23R {
530    bits: bool,
531}
532impl FB23R {
533    #[doc = r" Value of the field as raw bits"]
534    #[inline]
535    pub fn bit(&self) -> bool {
536        self.bits
537    }
538    #[doc = r" Returns `true` if the bit is clear (0)"]
539    #[inline]
540    pub fn bit_is_clear(&self) -> bool {
541        !self.bit()
542    }
543    #[doc = r" Returns `true` if the bit is set (1)"]
544    #[inline]
545    pub fn bit_is_set(&self) -> bool {
546        self.bit()
547    }
548}
549#[doc = r" Value of the field"]
550pub struct FB24R {
551    bits: bool,
552}
553impl FB24R {
554    #[doc = r" Value of the field as raw bits"]
555    #[inline]
556    pub fn bit(&self) -> bool {
557        self.bits
558    }
559    #[doc = r" Returns `true` if the bit is clear (0)"]
560    #[inline]
561    pub fn bit_is_clear(&self) -> bool {
562        !self.bit()
563    }
564    #[doc = r" Returns `true` if the bit is set (1)"]
565    #[inline]
566    pub fn bit_is_set(&self) -> bool {
567        self.bit()
568    }
569}
570#[doc = r" Value of the field"]
571pub struct FB25R {
572    bits: bool,
573}
574impl FB25R {
575    #[doc = r" Value of the field as raw bits"]
576    #[inline]
577    pub fn bit(&self) -> bool {
578        self.bits
579    }
580    #[doc = r" Returns `true` if the bit is clear (0)"]
581    #[inline]
582    pub fn bit_is_clear(&self) -> bool {
583        !self.bit()
584    }
585    #[doc = r" Returns `true` if the bit is set (1)"]
586    #[inline]
587    pub fn bit_is_set(&self) -> bool {
588        self.bit()
589    }
590}
591#[doc = r" Value of the field"]
592pub struct FB26R {
593    bits: bool,
594}
595impl FB26R {
596    #[doc = r" Value of the field as raw bits"]
597    #[inline]
598    pub fn bit(&self) -> bool {
599        self.bits
600    }
601    #[doc = r" Returns `true` if the bit is clear (0)"]
602    #[inline]
603    pub fn bit_is_clear(&self) -> bool {
604        !self.bit()
605    }
606    #[doc = r" Returns `true` if the bit is set (1)"]
607    #[inline]
608    pub fn bit_is_set(&self) -> bool {
609        self.bit()
610    }
611}
612#[doc = r" Value of the field"]
613pub struct FB27R {
614    bits: bool,
615}
616impl FB27R {
617    #[doc = r" Value of the field as raw bits"]
618    #[inline]
619    pub fn bit(&self) -> bool {
620        self.bits
621    }
622    #[doc = r" Returns `true` if the bit is clear (0)"]
623    #[inline]
624    pub fn bit_is_clear(&self) -> bool {
625        !self.bit()
626    }
627    #[doc = r" Returns `true` if the bit is set (1)"]
628    #[inline]
629    pub fn bit_is_set(&self) -> bool {
630        self.bit()
631    }
632}
633#[doc = r" Value of the field"]
634pub struct FB28R {
635    bits: bool,
636}
637impl FB28R {
638    #[doc = r" Value of the field as raw bits"]
639    #[inline]
640    pub fn bit(&self) -> bool {
641        self.bits
642    }
643    #[doc = r" Returns `true` if the bit is clear (0)"]
644    #[inline]
645    pub fn bit_is_clear(&self) -> bool {
646        !self.bit()
647    }
648    #[doc = r" Returns `true` if the bit is set (1)"]
649    #[inline]
650    pub fn bit_is_set(&self) -> bool {
651        self.bit()
652    }
653}
654#[doc = r" Value of the field"]
655pub struct FB29R {
656    bits: bool,
657}
658impl FB29R {
659    #[doc = r" Value of the field as raw bits"]
660    #[inline]
661    pub fn bit(&self) -> bool {
662        self.bits
663    }
664    #[doc = r" Returns `true` if the bit is clear (0)"]
665    #[inline]
666    pub fn bit_is_clear(&self) -> bool {
667        !self.bit()
668    }
669    #[doc = r" Returns `true` if the bit is set (1)"]
670    #[inline]
671    pub fn bit_is_set(&self) -> bool {
672        self.bit()
673    }
674}
675#[doc = r" Value of the field"]
676pub struct FB30R {
677    bits: bool,
678}
679impl FB30R {
680    #[doc = r" Value of the field as raw bits"]
681    #[inline]
682    pub fn bit(&self) -> bool {
683        self.bits
684    }
685    #[doc = r" Returns `true` if the bit is clear (0)"]
686    #[inline]
687    pub fn bit_is_clear(&self) -> bool {
688        !self.bit()
689    }
690    #[doc = r" Returns `true` if the bit is set (1)"]
691    #[inline]
692    pub fn bit_is_set(&self) -> bool {
693        self.bit()
694    }
695}
696#[doc = r" Value of the field"]
697pub struct FB31R {
698    bits: bool,
699}
700impl FB31R {
701    #[doc = r" Value of the field as raw bits"]
702    #[inline]
703    pub fn bit(&self) -> bool {
704        self.bits
705    }
706    #[doc = r" Returns `true` if the bit is clear (0)"]
707    #[inline]
708    pub fn bit_is_clear(&self) -> bool {
709        !self.bit()
710    }
711    #[doc = r" Returns `true` if the bit is set (1)"]
712    #[inline]
713    pub fn bit_is_set(&self) -> bool {
714        self.bit()
715    }
716}
717#[doc = r" Proxy"]
718pub struct _FB0W<'a> {
719    w: &'a mut W,
720}
721impl<'a> _FB0W<'a> {
722    #[doc = r" Sets the field bit"]
723    pub fn set_bit(self) -> &'a mut W {
724        self.bit(true)
725    }
726    #[doc = r" Clears the field bit"]
727    pub fn clear_bit(self) -> &'a mut W {
728        self.bit(false)
729    }
730    #[doc = r" Writes raw bits to the field"]
731    #[inline]
732    pub fn bit(self, value: bool) -> &'a mut W {
733        const MASK: bool = true;
734        const OFFSET: u8 = 0;
735        self.w.bits &= !((MASK as u32) << OFFSET);
736        self.w.bits |= ((value & MASK) as u32) << OFFSET;
737        self.w
738    }
739}
740#[doc = r" Proxy"]
741pub struct _FB1W<'a> {
742    w: &'a mut W,
743}
744impl<'a> _FB1W<'a> {
745    #[doc = r" Sets the field bit"]
746    pub fn set_bit(self) -> &'a mut W {
747        self.bit(true)
748    }
749    #[doc = r" Clears the field bit"]
750    pub fn clear_bit(self) -> &'a mut W {
751        self.bit(false)
752    }
753    #[doc = r" Writes raw bits to the field"]
754    #[inline]
755    pub fn bit(self, value: bool) -> &'a mut W {
756        const MASK: bool = true;
757        const OFFSET: u8 = 1;
758        self.w.bits &= !((MASK as u32) << OFFSET);
759        self.w.bits |= ((value & MASK) as u32) << OFFSET;
760        self.w
761    }
762}
763#[doc = r" Proxy"]
764pub struct _FB2W<'a> {
765    w: &'a mut W,
766}
767impl<'a> _FB2W<'a> {
768    #[doc = r" Sets the field bit"]
769    pub fn set_bit(self) -> &'a mut W {
770        self.bit(true)
771    }
772    #[doc = r" Clears the field bit"]
773    pub fn clear_bit(self) -> &'a mut W {
774        self.bit(false)
775    }
776    #[doc = r" Writes raw bits to the field"]
777    #[inline]
778    pub fn bit(self, value: bool) -> &'a mut W {
779        const MASK: bool = true;
780        const OFFSET: u8 = 2;
781        self.w.bits &= !((MASK as u32) << OFFSET);
782        self.w.bits |= ((value & MASK) as u32) << OFFSET;
783        self.w
784    }
785}
786#[doc = r" Proxy"]
787pub struct _FB3W<'a> {
788    w: &'a mut W,
789}
790impl<'a> _FB3W<'a> {
791    #[doc = r" Sets the field bit"]
792    pub fn set_bit(self) -> &'a mut W {
793        self.bit(true)
794    }
795    #[doc = r" Clears the field bit"]
796    pub fn clear_bit(self) -> &'a mut W {
797        self.bit(false)
798    }
799    #[doc = r" Writes raw bits to the field"]
800    #[inline]
801    pub fn bit(self, value: bool) -> &'a mut W {
802        const MASK: bool = true;
803        const OFFSET: u8 = 3;
804        self.w.bits &= !((MASK as u32) << OFFSET);
805        self.w.bits |= ((value & MASK) as u32) << OFFSET;
806        self.w
807    }
808}
809#[doc = r" Proxy"]
810pub struct _FB4W<'a> {
811    w: &'a mut W,
812}
813impl<'a> _FB4W<'a> {
814    #[doc = r" Sets the field bit"]
815    pub fn set_bit(self) -> &'a mut W {
816        self.bit(true)
817    }
818    #[doc = r" Clears the field bit"]
819    pub fn clear_bit(self) -> &'a mut W {
820        self.bit(false)
821    }
822    #[doc = r" Writes raw bits to the field"]
823    #[inline]
824    pub fn bit(self, value: bool) -> &'a mut W {
825        const MASK: bool = true;
826        const OFFSET: u8 = 4;
827        self.w.bits &= !((MASK as u32) << OFFSET);
828        self.w.bits |= ((value & MASK) as u32) << OFFSET;
829        self.w
830    }
831}
832#[doc = r" Proxy"]
833pub struct _FB5W<'a> {
834    w: &'a mut W,
835}
836impl<'a> _FB5W<'a> {
837    #[doc = r" Sets the field bit"]
838    pub fn set_bit(self) -> &'a mut W {
839        self.bit(true)
840    }
841    #[doc = r" Clears the field bit"]
842    pub fn clear_bit(self) -> &'a mut W {
843        self.bit(false)
844    }
845    #[doc = r" Writes raw bits to the field"]
846    #[inline]
847    pub fn bit(self, value: bool) -> &'a mut W {
848        const MASK: bool = true;
849        const OFFSET: u8 = 5;
850        self.w.bits &= !((MASK as u32) << OFFSET);
851        self.w.bits |= ((value & MASK) as u32) << OFFSET;
852        self.w
853    }
854}
855#[doc = r" Proxy"]
856pub struct _FB6W<'a> {
857    w: &'a mut W,
858}
859impl<'a> _FB6W<'a> {
860    #[doc = r" Sets the field bit"]
861    pub fn set_bit(self) -> &'a mut W {
862        self.bit(true)
863    }
864    #[doc = r" Clears the field bit"]
865    pub fn clear_bit(self) -> &'a mut W {
866        self.bit(false)
867    }
868    #[doc = r" Writes raw bits to the field"]
869    #[inline]
870    pub fn bit(self, value: bool) -> &'a mut W {
871        const MASK: bool = true;
872        const OFFSET: u8 = 6;
873        self.w.bits &= !((MASK as u32) << OFFSET);
874        self.w.bits |= ((value & MASK) as u32) << OFFSET;
875        self.w
876    }
877}
878#[doc = r" Proxy"]
879pub struct _FB7W<'a> {
880    w: &'a mut W,
881}
882impl<'a> _FB7W<'a> {
883    #[doc = r" Sets the field bit"]
884    pub fn set_bit(self) -> &'a mut W {
885        self.bit(true)
886    }
887    #[doc = r" Clears the field bit"]
888    pub fn clear_bit(self) -> &'a mut W {
889        self.bit(false)
890    }
891    #[doc = r" Writes raw bits to the field"]
892    #[inline]
893    pub fn bit(self, value: bool) -> &'a mut W {
894        const MASK: bool = true;
895        const OFFSET: u8 = 7;
896        self.w.bits &= !((MASK as u32) << OFFSET);
897        self.w.bits |= ((value & MASK) as u32) << OFFSET;
898        self.w
899    }
900}
901#[doc = r" Proxy"]
902pub struct _FB8W<'a> {
903    w: &'a mut W,
904}
905impl<'a> _FB8W<'a> {
906    #[doc = r" Sets the field bit"]
907    pub fn set_bit(self) -> &'a mut W {
908        self.bit(true)
909    }
910    #[doc = r" Clears the field bit"]
911    pub fn clear_bit(self) -> &'a mut W {
912        self.bit(false)
913    }
914    #[doc = r" Writes raw bits to the field"]
915    #[inline]
916    pub fn bit(self, value: bool) -> &'a mut W {
917        const MASK: bool = true;
918        const OFFSET: u8 = 8;
919        self.w.bits &= !((MASK as u32) << OFFSET);
920        self.w.bits |= ((value & MASK) as u32) << OFFSET;
921        self.w
922    }
923}
924#[doc = r" Proxy"]
925pub struct _FB9W<'a> {
926    w: &'a mut W,
927}
928impl<'a> _FB9W<'a> {
929    #[doc = r" Sets the field bit"]
930    pub fn set_bit(self) -> &'a mut W {
931        self.bit(true)
932    }
933    #[doc = r" Clears the field bit"]
934    pub fn clear_bit(self) -> &'a mut W {
935        self.bit(false)
936    }
937    #[doc = r" Writes raw bits to the field"]
938    #[inline]
939    pub fn bit(self, value: bool) -> &'a mut W {
940        const MASK: bool = true;
941        const OFFSET: u8 = 9;
942        self.w.bits &= !((MASK as u32) << OFFSET);
943        self.w.bits |= ((value & MASK) as u32) << OFFSET;
944        self.w
945    }
946}
947#[doc = r" Proxy"]
948pub struct _FB10W<'a> {
949    w: &'a mut W,
950}
951impl<'a> _FB10W<'a> {
952    #[doc = r" Sets the field bit"]
953    pub fn set_bit(self) -> &'a mut W {
954        self.bit(true)
955    }
956    #[doc = r" Clears the field bit"]
957    pub fn clear_bit(self) -> &'a mut W {
958        self.bit(false)
959    }
960    #[doc = r" Writes raw bits to the field"]
961    #[inline]
962    pub fn bit(self, value: bool) -> &'a mut W {
963        const MASK: bool = true;
964        const OFFSET: u8 = 10;
965        self.w.bits &= !((MASK as u32) << OFFSET);
966        self.w.bits |= ((value & MASK) as u32) << OFFSET;
967        self.w
968    }
969}
970#[doc = r" Proxy"]
971pub struct _FB11W<'a> {
972    w: &'a mut W,
973}
974impl<'a> _FB11W<'a> {
975    #[doc = r" Sets the field bit"]
976    pub fn set_bit(self) -> &'a mut W {
977        self.bit(true)
978    }
979    #[doc = r" Clears the field bit"]
980    pub fn clear_bit(self) -> &'a mut W {
981        self.bit(false)
982    }
983    #[doc = r" Writes raw bits to the field"]
984    #[inline]
985    pub fn bit(self, value: bool) -> &'a mut W {
986        const MASK: bool = true;
987        const OFFSET: u8 = 11;
988        self.w.bits &= !((MASK as u32) << OFFSET);
989        self.w.bits |= ((value & MASK) as u32) << OFFSET;
990        self.w
991    }
992}
993#[doc = r" Proxy"]
994pub struct _FB12W<'a> {
995    w: &'a mut W,
996}
997impl<'a> _FB12W<'a> {
998    #[doc = r" Sets the field bit"]
999    pub fn set_bit(self) -> &'a mut W {
1000        self.bit(true)
1001    }
1002    #[doc = r" Clears the field bit"]
1003    pub fn clear_bit(self) -> &'a mut W {
1004        self.bit(false)
1005    }
1006    #[doc = r" Writes raw bits to the field"]
1007    #[inline]
1008    pub fn bit(self, value: bool) -> &'a mut W {
1009        const MASK: bool = true;
1010        const OFFSET: u8 = 12;
1011        self.w.bits &= !((MASK as u32) << OFFSET);
1012        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1013        self.w
1014    }
1015}
1016#[doc = r" Proxy"]
1017pub struct _FB13W<'a> {
1018    w: &'a mut W,
1019}
1020impl<'a> _FB13W<'a> {
1021    #[doc = r" Sets the field bit"]
1022    pub fn set_bit(self) -> &'a mut W {
1023        self.bit(true)
1024    }
1025    #[doc = r" Clears the field bit"]
1026    pub fn clear_bit(self) -> &'a mut W {
1027        self.bit(false)
1028    }
1029    #[doc = r" Writes raw bits to the field"]
1030    #[inline]
1031    pub fn bit(self, value: bool) -> &'a mut W {
1032        const MASK: bool = true;
1033        const OFFSET: u8 = 13;
1034        self.w.bits &= !((MASK as u32) << OFFSET);
1035        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1036        self.w
1037    }
1038}
1039#[doc = r" Proxy"]
1040pub struct _FB14W<'a> {
1041    w: &'a mut W,
1042}
1043impl<'a> _FB14W<'a> {
1044    #[doc = r" Sets the field bit"]
1045    pub fn set_bit(self) -> &'a mut W {
1046        self.bit(true)
1047    }
1048    #[doc = r" Clears the field bit"]
1049    pub fn clear_bit(self) -> &'a mut W {
1050        self.bit(false)
1051    }
1052    #[doc = r" Writes raw bits to the field"]
1053    #[inline]
1054    pub fn bit(self, value: bool) -> &'a mut W {
1055        const MASK: bool = true;
1056        const OFFSET: u8 = 14;
1057        self.w.bits &= !((MASK as u32) << OFFSET);
1058        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1059        self.w
1060    }
1061}
1062#[doc = r" Proxy"]
1063pub struct _FB15W<'a> {
1064    w: &'a mut W,
1065}
1066impl<'a> _FB15W<'a> {
1067    #[doc = r" Sets the field bit"]
1068    pub fn set_bit(self) -> &'a mut W {
1069        self.bit(true)
1070    }
1071    #[doc = r" Clears the field bit"]
1072    pub fn clear_bit(self) -> &'a mut W {
1073        self.bit(false)
1074    }
1075    #[doc = r" Writes raw bits to the field"]
1076    #[inline]
1077    pub fn bit(self, value: bool) -> &'a mut W {
1078        const MASK: bool = true;
1079        const OFFSET: u8 = 15;
1080        self.w.bits &= !((MASK as u32) << OFFSET);
1081        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1082        self.w
1083    }
1084}
1085#[doc = r" Proxy"]
1086pub struct _FB16W<'a> {
1087    w: &'a mut W,
1088}
1089impl<'a> _FB16W<'a> {
1090    #[doc = r" Sets the field bit"]
1091    pub fn set_bit(self) -> &'a mut W {
1092        self.bit(true)
1093    }
1094    #[doc = r" Clears the field bit"]
1095    pub fn clear_bit(self) -> &'a mut W {
1096        self.bit(false)
1097    }
1098    #[doc = r" Writes raw bits to the field"]
1099    #[inline]
1100    pub fn bit(self, value: bool) -> &'a mut W {
1101        const MASK: bool = true;
1102        const OFFSET: u8 = 16;
1103        self.w.bits &= !((MASK as u32) << OFFSET);
1104        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1105        self.w
1106    }
1107}
1108#[doc = r" Proxy"]
1109pub struct _FB17W<'a> {
1110    w: &'a mut W,
1111}
1112impl<'a> _FB17W<'a> {
1113    #[doc = r" Sets the field bit"]
1114    pub fn set_bit(self) -> &'a mut W {
1115        self.bit(true)
1116    }
1117    #[doc = r" Clears the field bit"]
1118    pub fn clear_bit(self) -> &'a mut W {
1119        self.bit(false)
1120    }
1121    #[doc = r" Writes raw bits to the field"]
1122    #[inline]
1123    pub fn bit(self, value: bool) -> &'a mut W {
1124        const MASK: bool = true;
1125        const OFFSET: u8 = 17;
1126        self.w.bits &= !((MASK as u32) << OFFSET);
1127        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1128        self.w
1129    }
1130}
1131#[doc = r" Proxy"]
1132pub struct _FB18W<'a> {
1133    w: &'a mut W,
1134}
1135impl<'a> _FB18W<'a> {
1136    #[doc = r" Sets the field bit"]
1137    pub fn set_bit(self) -> &'a mut W {
1138        self.bit(true)
1139    }
1140    #[doc = r" Clears the field bit"]
1141    pub fn clear_bit(self) -> &'a mut W {
1142        self.bit(false)
1143    }
1144    #[doc = r" Writes raw bits to the field"]
1145    #[inline]
1146    pub fn bit(self, value: bool) -> &'a mut W {
1147        const MASK: bool = true;
1148        const OFFSET: u8 = 18;
1149        self.w.bits &= !((MASK as u32) << OFFSET);
1150        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1151        self.w
1152    }
1153}
1154#[doc = r" Proxy"]
1155pub struct _FB19W<'a> {
1156    w: &'a mut W,
1157}
1158impl<'a> _FB19W<'a> {
1159    #[doc = r" Sets the field bit"]
1160    pub fn set_bit(self) -> &'a mut W {
1161        self.bit(true)
1162    }
1163    #[doc = r" Clears the field bit"]
1164    pub fn clear_bit(self) -> &'a mut W {
1165        self.bit(false)
1166    }
1167    #[doc = r" Writes raw bits to the field"]
1168    #[inline]
1169    pub fn bit(self, value: bool) -> &'a mut W {
1170        const MASK: bool = true;
1171        const OFFSET: u8 = 19;
1172        self.w.bits &= !((MASK as u32) << OFFSET);
1173        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1174        self.w
1175    }
1176}
1177#[doc = r" Proxy"]
1178pub struct _FB20W<'a> {
1179    w: &'a mut W,
1180}
1181impl<'a> _FB20W<'a> {
1182    #[doc = r" Sets the field bit"]
1183    pub fn set_bit(self) -> &'a mut W {
1184        self.bit(true)
1185    }
1186    #[doc = r" Clears the field bit"]
1187    pub fn clear_bit(self) -> &'a mut W {
1188        self.bit(false)
1189    }
1190    #[doc = r" Writes raw bits to the field"]
1191    #[inline]
1192    pub fn bit(self, value: bool) -> &'a mut W {
1193        const MASK: bool = true;
1194        const OFFSET: u8 = 20;
1195        self.w.bits &= !((MASK as u32) << OFFSET);
1196        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1197        self.w
1198    }
1199}
1200#[doc = r" Proxy"]
1201pub struct _FB21W<'a> {
1202    w: &'a mut W,
1203}
1204impl<'a> _FB21W<'a> {
1205    #[doc = r" Sets the field bit"]
1206    pub fn set_bit(self) -> &'a mut W {
1207        self.bit(true)
1208    }
1209    #[doc = r" Clears the field bit"]
1210    pub fn clear_bit(self) -> &'a mut W {
1211        self.bit(false)
1212    }
1213    #[doc = r" Writes raw bits to the field"]
1214    #[inline]
1215    pub fn bit(self, value: bool) -> &'a mut W {
1216        const MASK: bool = true;
1217        const OFFSET: u8 = 21;
1218        self.w.bits &= !((MASK as u32) << OFFSET);
1219        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1220        self.w
1221    }
1222}
1223#[doc = r" Proxy"]
1224pub struct _FB22W<'a> {
1225    w: &'a mut W,
1226}
1227impl<'a> _FB22W<'a> {
1228    #[doc = r" Sets the field bit"]
1229    pub fn set_bit(self) -> &'a mut W {
1230        self.bit(true)
1231    }
1232    #[doc = r" Clears the field bit"]
1233    pub fn clear_bit(self) -> &'a mut W {
1234        self.bit(false)
1235    }
1236    #[doc = r" Writes raw bits to the field"]
1237    #[inline]
1238    pub fn bit(self, value: bool) -> &'a mut W {
1239        const MASK: bool = true;
1240        const OFFSET: u8 = 22;
1241        self.w.bits &= !((MASK as u32) << OFFSET);
1242        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1243        self.w
1244    }
1245}
1246#[doc = r" Proxy"]
1247pub struct _FB23W<'a> {
1248    w: &'a mut W,
1249}
1250impl<'a> _FB23W<'a> {
1251    #[doc = r" Sets the field bit"]
1252    pub fn set_bit(self) -> &'a mut W {
1253        self.bit(true)
1254    }
1255    #[doc = r" Clears the field bit"]
1256    pub fn clear_bit(self) -> &'a mut W {
1257        self.bit(false)
1258    }
1259    #[doc = r" Writes raw bits to the field"]
1260    #[inline]
1261    pub fn bit(self, value: bool) -> &'a mut W {
1262        const MASK: bool = true;
1263        const OFFSET: u8 = 23;
1264        self.w.bits &= !((MASK as u32) << OFFSET);
1265        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1266        self.w
1267    }
1268}
1269#[doc = r" Proxy"]
1270pub struct _FB24W<'a> {
1271    w: &'a mut W,
1272}
1273impl<'a> _FB24W<'a> {
1274    #[doc = r" Sets the field bit"]
1275    pub fn set_bit(self) -> &'a mut W {
1276        self.bit(true)
1277    }
1278    #[doc = r" Clears the field bit"]
1279    pub fn clear_bit(self) -> &'a mut W {
1280        self.bit(false)
1281    }
1282    #[doc = r" Writes raw bits to the field"]
1283    #[inline]
1284    pub fn bit(self, value: bool) -> &'a mut W {
1285        const MASK: bool = true;
1286        const OFFSET: u8 = 24;
1287        self.w.bits &= !((MASK as u32) << OFFSET);
1288        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1289        self.w
1290    }
1291}
1292#[doc = r" Proxy"]
1293pub struct _FB25W<'a> {
1294    w: &'a mut W,
1295}
1296impl<'a> _FB25W<'a> {
1297    #[doc = r" Sets the field bit"]
1298    pub fn set_bit(self) -> &'a mut W {
1299        self.bit(true)
1300    }
1301    #[doc = r" Clears the field bit"]
1302    pub fn clear_bit(self) -> &'a mut W {
1303        self.bit(false)
1304    }
1305    #[doc = r" Writes raw bits to the field"]
1306    #[inline]
1307    pub fn bit(self, value: bool) -> &'a mut W {
1308        const MASK: bool = true;
1309        const OFFSET: u8 = 25;
1310        self.w.bits &= !((MASK as u32) << OFFSET);
1311        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1312        self.w
1313    }
1314}
1315#[doc = r" Proxy"]
1316pub struct _FB26W<'a> {
1317    w: &'a mut W,
1318}
1319impl<'a> _FB26W<'a> {
1320    #[doc = r" Sets the field bit"]
1321    pub fn set_bit(self) -> &'a mut W {
1322        self.bit(true)
1323    }
1324    #[doc = r" Clears the field bit"]
1325    pub fn clear_bit(self) -> &'a mut W {
1326        self.bit(false)
1327    }
1328    #[doc = r" Writes raw bits to the field"]
1329    #[inline]
1330    pub fn bit(self, value: bool) -> &'a mut W {
1331        const MASK: bool = true;
1332        const OFFSET: u8 = 26;
1333        self.w.bits &= !((MASK as u32) << OFFSET);
1334        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1335        self.w
1336    }
1337}
1338#[doc = r" Proxy"]
1339pub struct _FB27W<'a> {
1340    w: &'a mut W,
1341}
1342impl<'a> _FB27W<'a> {
1343    #[doc = r" Sets the field bit"]
1344    pub fn set_bit(self) -> &'a mut W {
1345        self.bit(true)
1346    }
1347    #[doc = r" Clears the field bit"]
1348    pub fn clear_bit(self) -> &'a mut W {
1349        self.bit(false)
1350    }
1351    #[doc = r" Writes raw bits to the field"]
1352    #[inline]
1353    pub fn bit(self, value: bool) -> &'a mut W {
1354        const MASK: bool = true;
1355        const OFFSET: u8 = 27;
1356        self.w.bits &= !((MASK as u32) << OFFSET);
1357        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1358        self.w
1359    }
1360}
1361#[doc = r" Proxy"]
1362pub struct _FB28W<'a> {
1363    w: &'a mut W,
1364}
1365impl<'a> _FB28W<'a> {
1366    #[doc = r" Sets the field bit"]
1367    pub fn set_bit(self) -> &'a mut W {
1368        self.bit(true)
1369    }
1370    #[doc = r" Clears the field bit"]
1371    pub fn clear_bit(self) -> &'a mut W {
1372        self.bit(false)
1373    }
1374    #[doc = r" Writes raw bits to the field"]
1375    #[inline]
1376    pub fn bit(self, value: bool) -> &'a mut W {
1377        const MASK: bool = true;
1378        const OFFSET: u8 = 28;
1379        self.w.bits &= !((MASK as u32) << OFFSET);
1380        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1381        self.w
1382    }
1383}
1384#[doc = r" Proxy"]
1385pub struct _FB29W<'a> {
1386    w: &'a mut W,
1387}
1388impl<'a> _FB29W<'a> {
1389    #[doc = r" Sets the field bit"]
1390    pub fn set_bit(self) -> &'a mut W {
1391        self.bit(true)
1392    }
1393    #[doc = r" Clears the field bit"]
1394    pub fn clear_bit(self) -> &'a mut W {
1395        self.bit(false)
1396    }
1397    #[doc = r" Writes raw bits to the field"]
1398    #[inline]
1399    pub fn bit(self, value: bool) -> &'a mut W {
1400        const MASK: bool = true;
1401        const OFFSET: u8 = 29;
1402        self.w.bits &= !((MASK as u32) << OFFSET);
1403        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1404        self.w
1405    }
1406}
1407#[doc = r" Proxy"]
1408pub struct _FB30W<'a> {
1409    w: &'a mut W,
1410}
1411impl<'a> _FB30W<'a> {
1412    #[doc = r" Sets the field bit"]
1413    pub fn set_bit(self) -> &'a mut W {
1414        self.bit(true)
1415    }
1416    #[doc = r" Clears the field bit"]
1417    pub fn clear_bit(self) -> &'a mut W {
1418        self.bit(false)
1419    }
1420    #[doc = r" Writes raw bits to the field"]
1421    #[inline]
1422    pub fn bit(self, value: bool) -> &'a mut W {
1423        const MASK: bool = true;
1424        const OFFSET: u8 = 30;
1425        self.w.bits &= !((MASK as u32) << OFFSET);
1426        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1427        self.w
1428    }
1429}
1430#[doc = r" Proxy"]
1431pub struct _FB31W<'a> {
1432    w: &'a mut W,
1433}
1434impl<'a> _FB31W<'a> {
1435    #[doc = r" Sets the field bit"]
1436    pub fn set_bit(self) -> &'a mut W {
1437        self.bit(true)
1438    }
1439    #[doc = r" Clears the field bit"]
1440    pub fn clear_bit(self) -> &'a mut W {
1441        self.bit(false)
1442    }
1443    #[doc = r" Writes raw bits to the field"]
1444    #[inline]
1445    pub fn bit(self, value: bool) -> &'a mut W {
1446        const MASK: bool = true;
1447        const OFFSET: u8 = 31;
1448        self.w.bits &= !((MASK as u32) << OFFSET);
1449        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1450        self.w
1451    }
1452}
1453impl R {
1454    #[doc = r" Value of the register as raw bits"]
1455    #[inline]
1456    pub fn bits(&self) -> u32 {
1457        self.bits
1458    }
1459    #[doc = "Bit 0 - Filter bits"]
1460    #[inline]
1461    pub fn fb0(&self) -> FB0R {
1462        let bits = {
1463            const MASK: bool = true;
1464            const OFFSET: u8 = 0;
1465            ((self.bits >> OFFSET) & MASK as u32) != 0
1466        };
1467        FB0R { bits }
1468    }
1469    #[doc = "Bit 1 - Filter bits"]
1470    #[inline]
1471    pub fn fb1(&self) -> FB1R {
1472        let bits = {
1473            const MASK: bool = true;
1474            const OFFSET: u8 = 1;
1475            ((self.bits >> OFFSET) & MASK as u32) != 0
1476        };
1477        FB1R { bits }
1478    }
1479    #[doc = "Bit 2 - Filter bits"]
1480    #[inline]
1481    pub fn fb2(&self) -> FB2R {
1482        let bits = {
1483            const MASK: bool = true;
1484            const OFFSET: u8 = 2;
1485            ((self.bits >> OFFSET) & MASK as u32) != 0
1486        };
1487        FB2R { bits }
1488    }
1489    #[doc = "Bit 3 - Filter bits"]
1490    #[inline]
1491    pub fn fb3(&self) -> FB3R {
1492        let bits = {
1493            const MASK: bool = true;
1494            const OFFSET: u8 = 3;
1495            ((self.bits >> OFFSET) & MASK as u32) != 0
1496        };
1497        FB3R { bits }
1498    }
1499    #[doc = "Bit 4 - Filter bits"]
1500    #[inline]
1501    pub fn fb4(&self) -> FB4R {
1502        let bits = {
1503            const MASK: bool = true;
1504            const OFFSET: u8 = 4;
1505            ((self.bits >> OFFSET) & MASK as u32) != 0
1506        };
1507        FB4R { bits }
1508    }
1509    #[doc = "Bit 5 - Filter bits"]
1510    #[inline]
1511    pub fn fb5(&self) -> FB5R {
1512        let bits = {
1513            const MASK: bool = true;
1514            const OFFSET: u8 = 5;
1515            ((self.bits >> OFFSET) & MASK as u32) != 0
1516        };
1517        FB5R { bits }
1518    }
1519    #[doc = "Bit 6 - Filter bits"]
1520    #[inline]
1521    pub fn fb6(&self) -> FB6R {
1522        let bits = {
1523            const MASK: bool = true;
1524            const OFFSET: u8 = 6;
1525            ((self.bits >> OFFSET) & MASK as u32) != 0
1526        };
1527        FB6R { bits }
1528    }
1529    #[doc = "Bit 7 - Filter bits"]
1530    #[inline]
1531    pub fn fb7(&self) -> FB7R {
1532        let bits = {
1533            const MASK: bool = true;
1534            const OFFSET: u8 = 7;
1535            ((self.bits >> OFFSET) & MASK as u32) != 0
1536        };
1537        FB7R { bits }
1538    }
1539    #[doc = "Bit 8 - Filter bits"]
1540    #[inline]
1541    pub fn fb8(&self) -> FB8R {
1542        let bits = {
1543            const MASK: bool = true;
1544            const OFFSET: u8 = 8;
1545            ((self.bits >> OFFSET) & MASK as u32) != 0
1546        };
1547        FB8R { bits }
1548    }
1549    #[doc = "Bit 9 - Filter bits"]
1550    #[inline]
1551    pub fn fb9(&self) -> FB9R {
1552        let bits = {
1553            const MASK: bool = true;
1554            const OFFSET: u8 = 9;
1555            ((self.bits >> OFFSET) & MASK as u32) != 0
1556        };
1557        FB9R { bits }
1558    }
1559    #[doc = "Bit 10 - Filter bits"]
1560    #[inline]
1561    pub fn fb10(&self) -> FB10R {
1562        let bits = {
1563            const MASK: bool = true;
1564            const OFFSET: u8 = 10;
1565            ((self.bits >> OFFSET) & MASK as u32) != 0
1566        };
1567        FB10R { bits }
1568    }
1569    #[doc = "Bit 11 - Filter bits"]
1570    #[inline]
1571    pub fn fb11(&self) -> FB11R {
1572        let bits = {
1573            const MASK: bool = true;
1574            const OFFSET: u8 = 11;
1575            ((self.bits >> OFFSET) & MASK as u32) != 0
1576        };
1577        FB11R { bits }
1578    }
1579    #[doc = "Bit 12 - Filter bits"]
1580    #[inline]
1581    pub fn fb12(&self) -> FB12R {
1582        let bits = {
1583            const MASK: bool = true;
1584            const OFFSET: u8 = 12;
1585            ((self.bits >> OFFSET) & MASK as u32) != 0
1586        };
1587        FB12R { bits }
1588    }
1589    #[doc = "Bit 13 - Filter bits"]
1590    #[inline]
1591    pub fn fb13(&self) -> FB13R {
1592        let bits = {
1593            const MASK: bool = true;
1594            const OFFSET: u8 = 13;
1595            ((self.bits >> OFFSET) & MASK as u32) != 0
1596        };
1597        FB13R { bits }
1598    }
1599    #[doc = "Bit 14 - Filter bits"]
1600    #[inline]
1601    pub fn fb14(&self) -> FB14R {
1602        let bits = {
1603            const MASK: bool = true;
1604            const OFFSET: u8 = 14;
1605            ((self.bits >> OFFSET) & MASK as u32) != 0
1606        };
1607        FB14R { bits }
1608    }
1609    #[doc = "Bit 15 - Filter bits"]
1610    #[inline]
1611    pub fn fb15(&self) -> FB15R {
1612        let bits = {
1613            const MASK: bool = true;
1614            const OFFSET: u8 = 15;
1615            ((self.bits >> OFFSET) & MASK as u32) != 0
1616        };
1617        FB15R { bits }
1618    }
1619    #[doc = "Bit 16 - Filter bits"]
1620    #[inline]
1621    pub fn fb16(&self) -> FB16R {
1622        let bits = {
1623            const MASK: bool = true;
1624            const OFFSET: u8 = 16;
1625            ((self.bits >> OFFSET) & MASK as u32) != 0
1626        };
1627        FB16R { bits }
1628    }
1629    #[doc = "Bit 17 - Filter bits"]
1630    #[inline]
1631    pub fn fb17(&self) -> FB17R {
1632        let bits = {
1633            const MASK: bool = true;
1634            const OFFSET: u8 = 17;
1635            ((self.bits >> OFFSET) & MASK as u32) != 0
1636        };
1637        FB17R { bits }
1638    }
1639    #[doc = "Bit 18 - Filter bits"]
1640    #[inline]
1641    pub fn fb18(&self) -> FB18R {
1642        let bits = {
1643            const MASK: bool = true;
1644            const OFFSET: u8 = 18;
1645            ((self.bits >> OFFSET) & MASK as u32) != 0
1646        };
1647        FB18R { bits }
1648    }
1649    #[doc = "Bit 19 - Filter bits"]
1650    #[inline]
1651    pub fn fb19(&self) -> FB19R {
1652        let bits = {
1653            const MASK: bool = true;
1654            const OFFSET: u8 = 19;
1655            ((self.bits >> OFFSET) & MASK as u32) != 0
1656        };
1657        FB19R { bits }
1658    }
1659    #[doc = "Bit 20 - Filter bits"]
1660    #[inline]
1661    pub fn fb20(&self) -> FB20R {
1662        let bits = {
1663            const MASK: bool = true;
1664            const OFFSET: u8 = 20;
1665            ((self.bits >> OFFSET) & MASK as u32) != 0
1666        };
1667        FB20R { bits }
1668    }
1669    #[doc = "Bit 21 - Filter bits"]
1670    #[inline]
1671    pub fn fb21(&self) -> FB21R {
1672        let bits = {
1673            const MASK: bool = true;
1674            const OFFSET: u8 = 21;
1675            ((self.bits >> OFFSET) & MASK as u32) != 0
1676        };
1677        FB21R { bits }
1678    }
1679    #[doc = "Bit 22 - Filter bits"]
1680    #[inline]
1681    pub fn fb22(&self) -> FB22R {
1682        let bits = {
1683            const MASK: bool = true;
1684            const OFFSET: u8 = 22;
1685            ((self.bits >> OFFSET) & MASK as u32) != 0
1686        };
1687        FB22R { bits }
1688    }
1689    #[doc = "Bit 23 - Filter bits"]
1690    #[inline]
1691    pub fn fb23(&self) -> FB23R {
1692        let bits = {
1693            const MASK: bool = true;
1694            const OFFSET: u8 = 23;
1695            ((self.bits >> OFFSET) & MASK as u32) != 0
1696        };
1697        FB23R { bits }
1698    }
1699    #[doc = "Bit 24 - Filter bits"]
1700    #[inline]
1701    pub fn fb24(&self) -> FB24R {
1702        let bits = {
1703            const MASK: bool = true;
1704            const OFFSET: u8 = 24;
1705            ((self.bits >> OFFSET) & MASK as u32) != 0
1706        };
1707        FB24R { bits }
1708    }
1709    #[doc = "Bit 25 - Filter bits"]
1710    #[inline]
1711    pub fn fb25(&self) -> FB25R {
1712        let bits = {
1713            const MASK: bool = true;
1714            const OFFSET: u8 = 25;
1715            ((self.bits >> OFFSET) & MASK as u32) != 0
1716        };
1717        FB25R { bits }
1718    }
1719    #[doc = "Bit 26 - Filter bits"]
1720    #[inline]
1721    pub fn fb26(&self) -> FB26R {
1722        let bits = {
1723            const MASK: bool = true;
1724            const OFFSET: u8 = 26;
1725            ((self.bits >> OFFSET) & MASK as u32) != 0
1726        };
1727        FB26R { bits }
1728    }
1729    #[doc = "Bit 27 - Filter bits"]
1730    #[inline]
1731    pub fn fb27(&self) -> FB27R {
1732        let bits = {
1733            const MASK: bool = true;
1734            const OFFSET: u8 = 27;
1735            ((self.bits >> OFFSET) & MASK as u32) != 0
1736        };
1737        FB27R { bits }
1738    }
1739    #[doc = "Bit 28 - Filter bits"]
1740    #[inline]
1741    pub fn fb28(&self) -> FB28R {
1742        let bits = {
1743            const MASK: bool = true;
1744            const OFFSET: u8 = 28;
1745            ((self.bits >> OFFSET) & MASK as u32) != 0
1746        };
1747        FB28R { bits }
1748    }
1749    #[doc = "Bit 29 - Filter bits"]
1750    #[inline]
1751    pub fn fb29(&self) -> FB29R {
1752        let bits = {
1753            const MASK: bool = true;
1754            const OFFSET: u8 = 29;
1755            ((self.bits >> OFFSET) & MASK as u32) != 0
1756        };
1757        FB29R { bits }
1758    }
1759    #[doc = "Bit 30 - Filter bits"]
1760    #[inline]
1761    pub fn fb30(&self) -> FB30R {
1762        let bits = {
1763            const MASK: bool = true;
1764            const OFFSET: u8 = 30;
1765            ((self.bits >> OFFSET) & MASK as u32) != 0
1766        };
1767        FB30R { bits }
1768    }
1769    #[doc = "Bit 31 - Filter bits"]
1770    #[inline]
1771    pub fn fb31(&self) -> FB31R {
1772        let bits = {
1773            const MASK: bool = true;
1774            const OFFSET: u8 = 31;
1775            ((self.bits >> OFFSET) & MASK as u32) != 0
1776        };
1777        FB31R { bits }
1778    }
1779}
1780impl W {
1781    #[doc = r" Reset value of the register"]
1782    #[inline]
1783    pub fn reset_value() -> W {
1784        W { bits: 0 }
1785    }
1786    #[doc = r" Writes raw bits to the register"]
1787    #[inline]
1788    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1789        self.bits = bits;
1790        self
1791    }
1792    #[doc = "Bit 0 - Filter bits"]
1793    #[inline]
1794    pub fn fb0(&mut self) -> _FB0W {
1795        _FB0W { w: self }
1796    }
1797    #[doc = "Bit 1 - Filter bits"]
1798    #[inline]
1799    pub fn fb1(&mut self) -> _FB1W {
1800        _FB1W { w: self }
1801    }
1802    #[doc = "Bit 2 - Filter bits"]
1803    #[inline]
1804    pub fn fb2(&mut self) -> _FB2W {
1805        _FB2W { w: self }
1806    }
1807    #[doc = "Bit 3 - Filter bits"]
1808    #[inline]
1809    pub fn fb3(&mut self) -> _FB3W {
1810        _FB3W { w: self }
1811    }
1812    #[doc = "Bit 4 - Filter bits"]
1813    #[inline]
1814    pub fn fb4(&mut self) -> _FB4W {
1815        _FB4W { w: self }
1816    }
1817    #[doc = "Bit 5 - Filter bits"]
1818    #[inline]
1819    pub fn fb5(&mut self) -> _FB5W {
1820        _FB5W { w: self }
1821    }
1822    #[doc = "Bit 6 - Filter bits"]
1823    #[inline]
1824    pub fn fb6(&mut self) -> _FB6W {
1825        _FB6W { w: self }
1826    }
1827    #[doc = "Bit 7 - Filter bits"]
1828    #[inline]
1829    pub fn fb7(&mut self) -> _FB7W {
1830        _FB7W { w: self }
1831    }
1832    #[doc = "Bit 8 - Filter bits"]
1833    #[inline]
1834    pub fn fb8(&mut self) -> _FB8W {
1835        _FB8W { w: self }
1836    }
1837    #[doc = "Bit 9 - Filter bits"]
1838    #[inline]
1839    pub fn fb9(&mut self) -> _FB9W {
1840        _FB9W { w: self }
1841    }
1842    #[doc = "Bit 10 - Filter bits"]
1843    #[inline]
1844    pub fn fb10(&mut self) -> _FB10W {
1845        _FB10W { w: self }
1846    }
1847    #[doc = "Bit 11 - Filter bits"]
1848    #[inline]
1849    pub fn fb11(&mut self) -> _FB11W {
1850        _FB11W { w: self }
1851    }
1852    #[doc = "Bit 12 - Filter bits"]
1853    #[inline]
1854    pub fn fb12(&mut self) -> _FB12W {
1855        _FB12W { w: self }
1856    }
1857    #[doc = "Bit 13 - Filter bits"]
1858    #[inline]
1859    pub fn fb13(&mut self) -> _FB13W {
1860        _FB13W { w: self }
1861    }
1862    #[doc = "Bit 14 - Filter bits"]
1863    #[inline]
1864    pub fn fb14(&mut self) -> _FB14W {
1865        _FB14W { w: self }
1866    }
1867    #[doc = "Bit 15 - Filter bits"]
1868    #[inline]
1869    pub fn fb15(&mut self) -> _FB15W {
1870        _FB15W { w: self }
1871    }
1872    #[doc = "Bit 16 - Filter bits"]
1873    #[inline]
1874    pub fn fb16(&mut self) -> _FB16W {
1875        _FB16W { w: self }
1876    }
1877    #[doc = "Bit 17 - Filter bits"]
1878    #[inline]
1879    pub fn fb17(&mut self) -> _FB17W {
1880        _FB17W { w: self }
1881    }
1882    #[doc = "Bit 18 - Filter bits"]
1883    #[inline]
1884    pub fn fb18(&mut self) -> _FB18W {
1885        _FB18W { w: self }
1886    }
1887    #[doc = "Bit 19 - Filter bits"]
1888    #[inline]
1889    pub fn fb19(&mut self) -> _FB19W {
1890        _FB19W { w: self }
1891    }
1892    #[doc = "Bit 20 - Filter bits"]
1893    #[inline]
1894    pub fn fb20(&mut self) -> _FB20W {
1895        _FB20W { w: self }
1896    }
1897    #[doc = "Bit 21 - Filter bits"]
1898    #[inline]
1899    pub fn fb21(&mut self) -> _FB21W {
1900        _FB21W { w: self }
1901    }
1902    #[doc = "Bit 22 - Filter bits"]
1903    #[inline]
1904    pub fn fb22(&mut self) -> _FB22W {
1905        _FB22W { w: self }
1906    }
1907    #[doc = "Bit 23 - Filter bits"]
1908    #[inline]
1909    pub fn fb23(&mut self) -> _FB23W {
1910        _FB23W { w: self }
1911    }
1912    #[doc = "Bit 24 - Filter bits"]
1913    #[inline]
1914    pub fn fb24(&mut self) -> _FB24W {
1915        _FB24W { w: self }
1916    }
1917    #[doc = "Bit 25 - Filter bits"]
1918    #[inline]
1919    pub fn fb25(&mut self) -> _FB25W {
1920        _FB25W { w: self }
1921    }
1922    #[doc = "Bit 26 - Filter bits"]
1923    #[inline]
1924    pub fn fb26(&mut self) -> _FB26W {
1925        _FB26W { w: self }
1926    }
1927    #[doc = "Bit 27 - Filter bits"]
1928    #[inline]
1929    pub fn fb27(&mut self) -> _FB27W {
1930        _FB27W { w: self }
1931    }
1932    #[doc = "Bit 28 - Filter bits"]
1933    #[inline]
1934    pub fn fb28(&mut self) -> _FB28W {
1935        _FB28W { w: self }
1936    }
1937    #[doc = "Bit 29 - Filter bits"]
1938    #[inline]
1939    pub fn fb29(&mut self) -> _FB29W {
1940        _FB29W { w: self }
1941    }
1942    #[doc = "Bit 30 - Filter bits"]
1943    #[inline]
1944    pub fn fb30(&mut self) -> _FB30W {
1945        _FB30W { w: self }
1946    }
1947    #[doc = "Bit 31 - Filter bits"]
1948    #[inline]
1949    pub fn fb31(&mut self) -> _FB31W {
1950        _FB31W { w: self }
1951    }
1952}
stm32f30x/can/f6r2/mod.rs

stm32f30x/can/f6r2/
mod.rs
