stm32l4x2_pac/lcd/
ram_com0.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::RAM_COM0 {
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 S30R {
47    bits: bool,
48}
49impl S30R {
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 S29R {
68    bits: bool,
69}
70impl S29R {
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 S28R {
89    bits: bool,
90}
91impl S28R {
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 S27R {
110    bits: bool,
111}
112impl S27R {
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 S26R {
131    bits: bool,
132}
133impl S26R {
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 S25R {
152    bits: bool,
153}
154impl S25R {
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 S24R {
173    bits: bool,
174}
175impl S24R {
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 S23R {
194    bits: bool,
195}
196impl S23R {
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 S22R {
215    bits: bool,
216}
217impl S22R {
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 S21R {
236    bits: bool,
237}
238impl S21R {
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 S20R {
257    bits: bool,
258}
259impl S20R {
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 S19R {
278    bits: bool,
279}
280impl S19R {
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 S18R {
299    bits: bool,
300}
301impl S18R {
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 S17R {
320    bits: bool,
321}
322impl S17R {
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 S16R {
341    bits: bool,
342}
343impl S16R {
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 S15R {
362    bits: bool,
363}
364impl S15R {
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 S14R {
383    bits: bool,
384}
385impl S14R {
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 S13R {
404    bits: bool,
405}
406impl S13R {
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 S12R {
425    bits: bool,
426}
427impl S12R {
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 S11R {
446    bits: bool,
447}
448impl S11R {
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 S10R {
467    bits: bool,
468}
469impl S10R {
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 S09R {
488    bits: bool,
489}
490impl S09R {
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 S08R {
509    bits: bool,
510}
511impl S08R {
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 S07R {
530    bits: bool,
531}
532impl S07R {
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 S06R {
551    bits: bool,
552}
553impl S06R {
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 S05R {
572    bits: bool,
573}
574impl S05R {
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 S04R {
593    bits: bool,
594}
595impl S04R {
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 S03R {
614    bits: bool,
615}
616impl S03R {
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 S02R {
635    bits: bool,
636}
637impl S02R {
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 S01R {
656    bits: bool,
657}
658impl S01R {
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 S00R {
677    bits: bool,
678}
679impl S00R {
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" Proxy"]
697pub struct _S30W<'a> {
698    w: &'a mut W,
699}
700impl<'a> _S30W<'a> {
701    #[doc = r" Sets the field bit"]
702    pub fn set_bit(self) -> &'a mut W {
703        self.bit(true)
704    }
705    #[doc = r" Clears the field bit"]
706    pub fn clear_bit(self) -> &'a mut W {
707        self.bit(false)
708    }
709    #[doc = r" Writes raw bits to the field"]
710    #[inline]
711    pub fn bit(self, value: bool) -> &'a mut W {
712        const MASK: bool = true;
713        const OFFSET: u8 = 30;
714        self.w.bits &= !((MASK as u32) << OFFSET);
715        self.w.bits |= ((value & MASK) as u32) << OFFSET;
716        self.w
717    }
718}
719#[doc = r" Proxy"]
720pub struct _S29W<'a> {
721    w: &'a mut W,
722}
723impl<'a> _S29W<'a> {
724    #[doc = r" Sets the field bit"]
725    pub fn set_bit(self) -> &'a mut W {
726        self.bit(true)
727    }
728    #[doc = r" Clears the field bit"]
729    pub fn clear_bit(self) -> &'a mut W {
730        self.bit(false)
731    }
732    #[doc = r" Writes raw bits to the field"]
733    #[inline]
734    pub fn bit(self, value: bool) -> &'a mut W {
735        const MASK: bool = true;
736        const OFFSET: u8 = 29;
737        self.w.bits &= !((MASK as u32) << OFFSET);
738        self.w.bits |= ((value & MASK) as u32) << OFFSET;
739        self.w
740    }
741}
742#[doc = r" Proxy"]
743pub struct _S28W<'a> {
744    w: &'a mut W,
745}
746impl<'a> _S28W<'a> {
747    #[doc = r" Sets the field bit"]
748    pub fn set_bit(self) -> &'a mut W {
749        self.bit(true)
750    }
751    #[doc = r" Clears the field bit"]
752    pub fn clear_bit(self) -> &'a mut W {
753        self.bit(false)
754    }
755    #[doc = r" Writes raw bits to the field"]
756    #[inline]
757    pub fn bit(self, value: bool) -> &'a mut W {
758        const MASK: bool = true;
759        const OFFSET: u8 = 28;
760        self.w.bits &= !((MASK as u32) << OFFSET);
761        self.w.bits |= ((value & MASK) as u32) << OFFSET;
762        self.w
763    }
764}
765#[doc = r" Proxy"]
766pub struct _S27W<'a> {
767    w: &'a mut W,
768}
769impl<'a> _S27W<'a> {
770    #[doc = r" Sets the field bit"]
771    pub fn set_bit(self) -> &'a mut W {
772        self.bit(true)
773    }
774    #[doc = r" Clears the field bit"]
775    pub fn clear_bit(self) -> &'a mut W {
776        self.bit(false)
777    }
778    #[doc = r" Writes raw bits to the field"]
779    #[inline]
780    pub fn bit(self, value: bool) -> &'a mut W {
781        const MASK: bool = true;
782        const OFFSET: u8 = 27;
783        self.w.bits &= !((MASK as u32) << OFFSET);
784        self.w.bits |= ((value & MASK) as u32) << OFFSET;
785        self.w
786    }
787}
788#[doc = r" Proxy"]
789pub struct _S26W<'a> {
790    w: &'a mut W,
791}
792impl<'a> _S26W<'a> {
793    #[doc = r" Sets the field bit"]
794    pub fn set_bit(self) -> &'a mut W {
795        self.bit(true)
796    }
797    #[doc = r" Clears the field bit"]
798    pub fn clear_bit(self) -> &'a mut W {
799        self.bit(false)
800    }
801    #[doc = r" Writes raw bits to the field"]
802    #[inline]
803    pub fn bit(self, value: bool) -> &'a mut W {
804        const MASK: bool = true;
805        const OFFSET: u8 = 26;
806        self.w.bits &= !((MASK as u32) << OFFSET);
807        self.w.bits |= ((value & MASK) as u32) << OFFSET;
808        self.w
809    }
810}
811#[doc = r" Proxy"]
812pub struct _S25W<'a> {
813    w: &'a mut W,
814}
815impl<'a> _S25W<'a> {
816    #[doc = r" Sets the field bit"]
817    pub fn set_bit(self) -> &'a mut W {
818        self.bit(true)
819    }
820    #[doc = r" Clears the field bit"]
821    pub fn clear_bit(self) -> &'a mut W {
822        self.bit(false)
823    }
824    #[doc = r" Writes raw bits to the field"]
825    #[inline]
826    pub fn bit(self, value: bool) -> &'a mut W {
827        const MASK: bool = true;
828        const OFFSET: u8 = 25;
829        self.w.bits &= !((MASK as u32) << OFFSET);
830        self.w.bits |= ((value & MASK) as u32) << OFFSET;
831        self.w
832    }
833}
834#[doc = r" Proxy"]
835pub struct _S24W<'a> {
836    w: &'a mut W,
837}
838impl<'a> _S24W<'a> {
839    #[doc = r" Sets the field bit"]
840    pub fn set_bit(self) -> &'a mut W {
841        self.bit(true)
842    }
843    #[doc = r" Clears the field bit"]
844    pub fn clear_bit(self) -> &'a mut W {
845        self.bit(false)
846    }
847    #[doc = r" Writes raw bits to the field"]
848    #[inline]
849    pub fn bit(self, value: bool) -> &'a mut W {
850        const MASK: bool = true;
851        const OFFSET: u8 = 24;
852        self.w.bits &= !((MASK as u32) << OFFSET);
853        self.w.bits |= ((value & MASK) as u32) << OFFSET;
854        self.w
855    }
856}
857#[doc = r" Proxy"]
858pub struct _S23W<'a> {
859    w: &'a mut W,
860}
861impl<'a> _S23W<'a> {
862    #[doc = r" Sets the field bit"]
863    pub fn set_bit(self) -> &'a mut W {
864        self.bit(true)
865    }
866    #[doc = r" Clears the field bit"]
867    pub fn clear_bit(self) -> &'a mut W {
868        self.bit(false)
869    }
870    #[doc = r" Writes raw bits to the field"]
871    #[inline]
872    pub fn bit(self, value: bool) -> &'a mut W {
873        const MASK: bool = true;
874        const OFFSET: u8 = 23;
875        self.w.bits &= !((MASK as u32) << OFFSET);
876        self.w.bits |= ((value & MASK) as u32) << OFFSET;
877        self.w
878    }
879}
880#[doc = r" Proxy"]
881pub struct _S22W<'a> {
882    w: &'a mut W,
883}
884impl<'a> _S22W<'a> {
885    #[doc = r" Sets the field bit"]
886    pub fn set_bit(self) -> &'a mut W {
887        self.bit(true)
888    }
889    #[doc = r" Clears the field bit"]
890    pub fn clear_bit(self) -> &'a mut W {
891        self.bit(false)
892    }
893    #[doc = r" Writes raw bits to the field"]
894    #[inline]
895    pub fn bit(self, value: bool) -> &'a mut W {
896        const MASK: bool = true;
897        const OFFSET: u8 = 22;
898        self.w.bits &= !((MASK as u32) << OFFSET);
899        self.w.bits |= ((value & MASK) as u32) << OFFSET;
900        self.w
901    }
902}
903#[doc = r" Proxy"]
904pub struct _S21W<'a> {
905    w: &'a mut W,
906}
907impl<'a> _S21W<'a> {
908    #[doc = r" Sets the field bit"]
909    pub fn set_bit(self) -> &'a mut W {
910        self.bit(true)
911    }
912    #[doc = r" Clears the field bit"]
913    pub fn clear_bit(self) -> &'a mut W {
914        self.bit(false)
915    }
916    #[doc = r" Writes raw bits to the field"]
917    #[inline]
918    pub fn bit(self, value: bool) -> &'a mut W {
919        const MASK: bool = true;
920        const OFFSET: u8 = 21;
921        self.w.bits &= !((MASK as u32) << OFFSET);
922        self.w.bits |= ((value & MASK) as u32) << OFFSET;
923        self.w
924    }
925}
926#[doc = r" Proxy"]
927pub struct _S20W<'a> {
928    w: &'a mut W,
929}
930impl<'a> _S20W<'a> {
931    #[doc = r" Sets the field bit"]
932    pub fn set_bit(self) -> &'a mut W {
933        self.bit(true)
934    }
935    #[doc = r" Clears the field bit"]
936    pub fn clear_bit(self) -> &'a mut W {
937        self.bit(false)
938    }
939    #[doc = r" Writes raw bits to the field"]
940    #[inline]
941    pub fn bit(self, value: bool) -> &'a mut W {
942        const MASK: bool = true;
943        const OFFSET: u8 = 20;
944        self.w.bits &= !((MASK as u32) << OFFSET);
945        self.w.bits |= ((value & MASK) as u32) << OFFSET;
946        self.w
947    }
948}
949#[doc = r" Proxy"]
950pub struct _S19W<'a> {
951    w: &'a mut W,
952}
953impl<'a> _S19W<'a> {
954    #[doc = r" Sets the field bit"]
955    pub fn set_bit(self) -> &'a mut W {
956        self.bit(true)
957    }
958    #[doc = r" Clears the field bit"]
959    pub fn clear_bit(self) -> &'a mut W {
960        self.bit(false)
961    }
962    #[doc = r" Writes raw bits to the field"]
963    #[inline]
964    pub fn bit(self, value: bool) -> &'a mut W {
965        const MASK: bool = true;
966        const OFFSET: u8 = 19;
967        self.w.bits &= !((MASK as u32) << OFFSET);
968        self.w.bits |= ((value & MASK) as u32) << OFFSET;
969        self.w
970    }
971}
972#[doc = r" Proxy"]
973pub struct _S18W<'a> {
974    w: &'a mut W,
975}
976impl<'a> _S18W<'a> {
977    #[doc = r" Sets the field bit"]
978    pub fn set_bit(self) -> &'a mut W {
979        self.bit(true)
980    }
981    #[doc = r" Clears the field bit"]
982    pub fn clear_bit(self) -> &'a mut W {
983        self.bit(false)
984    }
985    #[doc = r" Writes raw bits to the field"]
986    #[inline]
987    pub fn bit(self, value: bool) -> &'a mut W {
988        const MASK: bool = true;
989        const OFFSET: u8 = 18;
990        self.w.bits &= !((MASK as u32) << OFFSET);
991        self.w.bits |= ((value & MASK) as u32) << OFFSET;
992        self.w
993    }
994}
995#[doc = r" Proxy"]
996pub struct _S17W<'a> {
997    w: &'a mut W,
998}
999impl<'a> _S17W<'a> {
1000    #[doc = r" Sets the field bit"]
1001    pub fn set_bit(self) -> &'a mut W {
1002        self.bit(true)
1003    }
1004    #[doc = r" Clears the field bit"]
1005    pub fn clear_bit(self) -> &'a mut W {
1006        self.bit(false)
1007    }
1008    #[doc = r" Writes raw bits to the field"]
1009    #[inline]
1010    pub fn bit(self, value: bool) -> &'a mut W {
1011        const MASK: bool = true;
1012        const OFFSET: u8 = 17;
1013        self.w.bits &= !((MASK as u32) << OFFSET);
1014        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1015        self.w
1016    }
1017}
1018#[doc = r" Proxy"]
1019pub struct _S16W<'a> {
1020    w: &'a mut W,
1021}
1022impl<'a> _S16W<'a> {
1023    #[doc = r" Sets the field bit"]
1024    pub fn set_bit(self) -> &'a mut W {
1025        self.bit(true)
1026    }
1027    #[doc = r" Clears the field bit"]
1028    pub fn clear_bit(self) -> &'a mut W {
1029        self.bit(false)
1030    }
1031    #[doc = r" Writes raw bits to the field"]
1032    #[inline]
1033    pub fn bit(self, value: bool) -> &'a mut W {
1034        const MASK: bool = true;
1035        const OFFSET: u8 = 16;
1036        self.w.bits &= !((MASK as u32) << OFFSET);
1037        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1038        self.w
1039    }
1040}
1041#[doc = r" Proxy"]
1042pub struct _S15W<'a> {
1043    w: &'a mut W,
1044}
1045impl<'a> _S15W<'a> {
1046    #[doc = r" Sets the field bit"]
1047    pub fn set_bit(self) -> &'a mut W {
1048        self.bit(true)
1049    }
1050    #[doc = r" Clears the field bit"]
1051    pub fn clear_bit(self) -> &'a mut W {
1052        self.bit(false)
1053    }
1054    #[doc = r" Writes raw bits to the field"]
1055    #[inline]
1056    pub fn bit(self, value: bool) -> &'a mut W {
1057        const MASK: bool = true;
1058        const OFFSET: u8 = 15;
1059        self.w.bits &= !((MASK as u32) << OFFSET);
1060        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1061        self.w
1062    }
1063}
1064#[doc = r" Proxy"]
1065pub struct _S14W<'a> {
1066    w: &'a mut W,
1067}
1068impl<'a> _S14W<'a> {
1069    #[doc = r" Sets the field bit"]
1070    pub fn set_bit(self) -> &'a mut W {
1071        self.bit(true)
1072    }
1073    #[doc = r" Clears the field bit"]
1074    pub fn clear_bit(self) -> &'a mut W {
1075        self.bit(false)
1076    }
1077    #[doc = r" Writes raw bits to the field"]
1078    #[inline]
1079    pub fn bit(self, value: bool) -> &'a mut W {
1080        const MASK: bool = true;
1081        const OFFSET: u8 = 14;
1082        self.w.bits &= !((MASK as u32) << OFFSET);
1083        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1084        self.w
1085    }
1086}
1087#[doc = r" Proxy"]
1088pub struct _S13W<'a> {
1089    w: &'a mut W,
1090}
1091impl<'a> _S13W<'a> {
1092    #[doc = r" Sets the field bit"]
1093    pub fn set_bit(self) -> &'a mut W {
1094        self.bit(true)
1095    }
1096    #[doc = r" Clears the field bit"]
1097    pub fn clear_bit(self) -> &'a mut W {
1098        self.bit(false)
1099    }
1100    #[doc = r" Writes raw bits to the field"]
1101    #[inline]
1102    pub fn bit(self, value: bool) -> &'a mut W {
1103        const MASK: bool = true;
1104        const OFFSET: u8 = 13;
1105        self.w.bits &= !((MASK as u32) << OFFSET);
1106        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1107        self.w
1108    }
1109}
1110#[doc = r" Proxy"]
1111pub struct _S12W<'a> {
1112    w: &'a mut W,
1113}
1114impl<'a> _S12W<'a> {
1115    #[doc = r" Sets the field bit"]
1116    pub fn set_bit(self) -> &'a mut W {
1117        self.bit(true)
1118    }
1119    #[doc = r" Clears the field bit"]
1120    pub fn clear_bit(self) -> &'a mut W {
1121        self.bit(false)
1122    }
1123    #[doc = r" Writes raw bits to the field"]
1124    #[inline]
1125    pub fn bit(self, value: bool) -> &'a mut W {
1126        const MASK: bool = true;
1127        const OFFSET: u8 = 12;
1128        self.w.bits &= !((MASK as u32) << OFFSET);
1129        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1130        self.w
1131    }
1132}
1133#[doc = r" Proxy"]
1134pub struct _S11W<'a> {
1135    w: &'a mut W,
1136}
1137impl<'a> _S11W<'a> {
1138    #[doc = r" Sets the field bit"]
1139    pub fn set_bit(self) -> &'a mut W {
1140        self.bit(true)
1141    }
1142    #[doc = r" Clears the field bit"]
1143    pub fn clear_bit(self) -> &'a mut W {
1144        self.bit(false)
1145    }
1146    #[doc = r" Writes raw bits to the field"]
1147    #[inline]
1148    pub fn bit(self, value: bool) -> &'a mut W {
1149        const MASK: bool = true;
1150        const OFFSET: u8 = 11;
1151        self.w.bits &= !((MASK as u32) << OFFSET);
1152        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1153        self.w
1154    }
1155}
1156#[doc = r" Proxy"]
1157pub struct _S10W<'a> {
1158    w: &'a mut W,
1159}
1160impl<'a> _S10W<'a> {
1161    #[doc = r" Sets the field bit"]
1162    pub fn set_bit(self) -> &'a mut W {
1163        self.bit(true)
1164    }
1165    #[doc = r" Clears the field bit"]
1166    pub fn clear_bit(self) -> &'a mut W {
1167        self.bit(false)
1168    }
1169    #[doc = r" Writes raw bits to the field"]
1170    #[inline]
1171    pub fn bit(self, value: bool) -> &'a mut W {
1172        const MASK: bool = true;
1173        const OFFSET: u8 = 10;
1174        self.w.bits &= !((MASK as u32) << OFFSET);
1175        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1176        self.w
1177    }
1178}
1179#[doc = r" Proxy"]
1180pub struct _S09W<'a> {
1181    w: &'a mut W,
1182}
1183impl<'a> _S09W<'a> {
1184    #[doc = r" Sets the field bit"]
1185    pub fn set_bit(self) -> &'a mut W {
1186        self.bit(true)
1187    }
1188    #[doc = r" Clears the field bit"]
1189    pub fn clear_bit(self) -> &'a mut W {
1190        self.bit(false)
1191    }
1192    #[doc = r" Writes raw bits to the field"]
1193    #[inline]
1194    pub fn bit(self, value: bool) -> &'a mut W {
1195        const MASK: bool = true;
1196        const OFFSET: u8 = 9;
1197        self.w.bits &= !((MASK as u32) << OFFSET);
1198        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1199        self.w
1200    }
1201}
1202#[doc = r" Proxy"]
1203pub struct _S08W<'a> {
1204    w: &'a mut W,
1205}
1206impl<'a> _S08W<'a> {
1207    #[doc = r" Sets the field bit"]
1208    pub fn set_bit(self) -> &'a mut W {
1209        self.bit(true)
1210    }
1211    #[doc = r" Clears the field bit"]
1212    pub fn clear_bit(self) -> &'a mut W {
1213        self.bit(false)
1214    }
1215    #[doc = r" Writes raw bits to the field"]
1216    #[inline]
1217    pub fn bit(self, value: bool) -> &'a mut W {
1218        const MASK: bool = true;
1219        const OFFSET: u8 = 8;
1220        self.w.bits &= !((MASK as u32) << OFFSET);
1221        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1222        self.w
1223    }
1224}
1225#[doc = r" Proxy"]
1226pub struct _S07W<'a> {
1227    w: &'a mut W,
1228}
1229impl<'a> _S07W<'a> {
1230    #[doc = r" Sets the field bit"]
1231    pub fn set_bit(self) -> &'a mut W {
1232        self.bit(true)
1233    }
1234    #[doc = r" Clears the field bit"]
1235    pub fn clear_bit(self) -> &'a mut W {
1236        self.bit(false)
1237    }
1238    #[doc = r" Writes raw bits to the field"]
1239    #[inline]
1240    pub fn bit(self, value: bool) -> &'a mut W {
1241        const MASK: bool = true;
1242        const OFFSET: u8 = 7;
1243        self.w.bits &= !((MASK as u32) << OFFSET);
1244        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1245        self.w
1246    }
1247}
1248#[doc = r" Proxy"]
1249pub struct _S06W<'a> {
1250    w: &'a mut W,
1251}
1252impl<'a> _S06W<'a> {
1253    #[doc = r" Sets the field bit"]
1254    pub fn set_bit(self) -> &'a mut W {
1255        self.bit(true)
1256    }
1257    #[doc = r" Clears the field bit"]
1258    pub fn clear_bit(self) -> &'a mut W {
1259        self.bit(false)
1260    }
1261    #[doc = r" Writes raw bits to the field"]
1262    #[inline]
1263    pub fn bit(self, value: bool) -> &'a mut W {
1264        const MASK: bool = true;
1265        const OFFSET: u8 = 6;
1266        self.w.bits &= !((MASK as u32) << OFFSET);
1267        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1268        self.w
1269    }
1270}
1271#[doc = r" Proxy"]
1272pub struct _S05W<'a> {
1273    w: &'a mut W,
1274}
1275impl<'a> _S05W<'a> {
1276    #[doc = r" Sets the field bit"]
1277    pub fn set_bit(self) -> &'a mut W {
1278        self.bit(true)
1279    }
1280    #[doc = r" Clears the field bit"]
1281    pub fn clear_bit(self) -> &'a mut W {
1282        self.bit(false)
1283    }
1284    #[doc = r" Writes raw bits to the field"]
1285    #[inline]
1286    pub fn bit(self, value: bool) -> &'a mut W {
1287        const MASK: bool = true;
1288        const OFFSET: u8 = 5;
1289        self.w.bits &= !((MASK as u32) << OFFSET);
1290        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1291        self.w
1292    }
1293}
1294#[doc = r" Proxy"]
1295pub struct _S04W<'a> {
1296    w: &'a mut W,
1297}
1298impl<'a> _S04W<'a> {
1299    #[doc = r" Sets the field bit"]
1300    pub fn set_bit(self) -> &'a mut W {
1301        self.bit(true)
1302    }
1303    #[doc = r" Clears the field bit"]
1304    pub fn clear_bit(self) -> &'a mut W {
1305        self.bit(false)
1306    }
1307    #[doc = r" Writes raw bits to the field"]
1308    #[inline]
1309    pub fn bit(self, value: bool) -> &'a mut W {
1310        const MASK: bool = true;
1311        const OFFSET: u8 = 4;
1312        self.w.bits &= !((MASK as u32) << OFFSET);
1313        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1314        self.w
1315    }
1316}
1317#[doc = r" Proxy"]
1318pub struct _S03W<'a> {
1319    w: &'a mut W,
1320}
1321impl<'a> _S03W<'a> {
1322    #[doc = r" Sets the field bit"]
1323    pub fn set_bit(self) -> &'a mut W {
1324        self.bit(true)
1325    }
1326    #[doc = r" Clears the field bit"]
1327    pub fn clear_bit(self) -> &'a mut W {
1328        self.bit(false)
1329    }
1330    #[doc = r" Writes raw bits to the field"]
1331    #[inline]
1332    pub fn bit(self, value: bool) -> &'a mut W {
1333        const MASK: bool = true;
1334        const OFFSET: u8 = 3;
1335        self.w.bits &= !((MASK as u32) << OFFSET);
1336        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1337        self.w
1338    }
1339}
1340#[doc = r" Proxy"]
1341pub struct _S02W<'a> {
1342    w: &'a mut W,
1343}
1344impl<'a> _S02W<'a> {
1345    #[doc = r" Sets the field bit"]
1346    pub fn set_bit(self) -> &'a mut W {
1347        self.bit(true)
1348    }
1349    #[doc = r" Clears the field bit"]
1350    pub fn clear_bit(self) -> &'a mut W {
1351        self.bit(false)
1352    }
1353    #[doc = r" Writes raw bits to the field"]
1354    #[inline]
1355    pub fn bit(self, value: bool) -> &'a mut W {
1356        const MASK: bool = true;
1357        const OFFSET: u8 = 2;
1358        self.w.bits &= !((MASK as u32) << OFFSET);
1359        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1360        self.w
1361    }
1362}
1363#[doc = r" Proxy"]
1364pub struct _S01W<'a> {
1365    w: &'a mut W,
1366}
1367impl<'a> _S01W<'a> {
1368    #[doc = r" Sets the field bit"]
1369    pub fn set_bit(self) -> &'a mut W {
1370        self.bit(true)
1371    }
1372    #[doc = r" Clears the field bit"]
1373    pub fn clear_bit(self) -> &'a mut W {
1374        self.bit(false)
1375    }
1376    #[doc = r" Writes raw bits to the field"]
1377    #[inline]
1378    pub fn bit(self, value: bool) -> &'a mut W {
1379        const MASK: bool = true;
1380        const OFFSET: u8 = 1;
1381        self.w.bits &= !((MASK as u32) << OFFSET);
1382        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1383        self.w
1384    }
1385}
1386#[doc = r" Proxy"]
1387pub struct _S00W<'a> {
1388    w: &'a mut W,
1389}
1390impl<'a> _S00W<'a> {
1391    #[doc = r" Sets the field bit"]
1392    pub fn set_bit(self) -> &'a mut W {
1393        self.bit(true)
1394    }
1395    #[doc = r" Clears the field bit"]
1396    pub fn clear_bit(self) -> &'a mut W {
1397        self.bit(false)
1398    }
1399    #[doc = r" Writes raw bits to the field"]
1400    #[inline]
1401    pub fn bit(self, value: bool) -> &'a mut W {
1402        const MASK: bool = true;
1403        const OFFSET: u8 = 0;
1404        self.w.bits &= !((MASK as u32) << OFFSET);
1405        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1406        self.w
1407    }
1408}
1409impl R {
1410    #[doc = r" Value of the register as raw bits"]
1411    #[inline]
1412    pub fn bits(&self) -> u32 {
1413        self.bits
1414    }
1415    #[doc = "Bit 30 - S30"]
1416    #[inline]
1417    pub fn s30(&self) -> S30R {
1418        let bits = {
1419            const MASK: bool = true;
1420            const OFFSET: u8 = 30;
1421            ((self.bits >> OFFSET) & MASK as u32) != 0
1422        };
1423        S30R { bits }
1424    }
1425    #[doc = "Bit 29 - S29"]
1426    #[inline]
1427    pub fn s29(&self) -> S29R {
1428        let bits = {
1429            const MASK: bool = true;
1430            const OFFSET: u8 = 29;
1431            ((self.bits >> OFFSET) & MASK as u32) != 0
1432        };
1433        S29R { bits }
1434    }
1435    #[doc = "Bit 28 - S28"]
1436    #[inline]
1437    pub fn s28(&self) -> S28R {
1438        let bits = {
1439            const MASK: bool = true;
1440            const OFFSET: u8 = 28;
1441            ((self.bits >> OFFSET) & MASK as u32) != 0
1442        };
1443        S28R { bits }
1444    }
1445    #[doc = "Bit 27 - S27"]
1446    #[inline]
1447    pub fn s27(&self) -> S27R {
1448        let bits = {
1449            const MASK: bool = true;
1450            const OFFSET: u8 = 27;
1451            ((self.bits >> OFFSET) & MASK as u32) != 0
1452        };
1453        S27R { bits }
1454    }
1455    #[doc = "Bit 26 - S26"]
1456    #[inline]
1457    pub fn s26(&self) -> S26R {
1458        let bits = {
1459            const MASK: bool = true;
1460            const OFFSET: u8 = 26;
1461            ((self.bits >> OFFSET) & MASK as u32) != 0
1462        };
1463        S26R { bits }
1464    }
1465    #[doc = "Bit 25 - S25"]
1466    #[inline]
1467    pub fn s25(&self) -> S25R {
1468        let bits = {
1469            const MASK: bool = true;
1470            const OFFSET: u8 = 25;
1471            ((self.bits >> OFFSET) & MASK as u32) != 0
1472        };
1473        S25R { bits }
1474    }
1475    #[doc = "Bit 24 - S24"]
1476    #[inline]
1477    pub fn s24(&self) -> S24R {
1478        let bits = {
1479            const MASK: bool = true;
1480            const OFFSET: u8 = 24;
1481            ((self.bits >> OFFSET) & MASK as u32) != 0
1482        };
1483        S24R { bits }
1484    }
1485    #[doc = "Bit 23 - S23"]
1486    #[inline]
1487    pub fn s23(&self) -> S23R {
1488        let bits = {
1489            const MASK: bool = true;
1490            const OFFSET: u8 = 23;
1491            ((self.bits >> OFFSET) & MASK as u32) != 0
1492        };
1493        S23R { bits }
1494    }
1495    #[doc = "Bit 22 - S22"]
1496    #[inline]
1497    pub fn s22(&self) -> S22R {
1498        let bits = {
1499            const MASK: bool = true;
1500            const OFFSET: u8 = 22;
1501            ((self.bits >> OFFSET) & MASK as u32) != 0
1502        };
1503        S22R { bits }
1504    }
1505    #[doc = "Bit 21 - S21"]
1506    #[inline]
1507    pub fn s21(&self) -> S21R {
1508        let bits = {
1509            const MASK: bool = true;
1510            const OFFSET: u8 = 21;
1511            ((self.bits >> OFFSET) & MASK as u32) != 0
1512        };
1513        S21R { bits }
1514    }
1515    #[doc = "Bit 20 - S20"]
1516    #[inline]
1517    pub fn s20(&self) -> S20R {
1518        let bits = {
1519            const MASK: bool = true;
1520            const OFFSET: u8 = 20;
1521            ((self.bits >> OFFSET) & MASK as u32) != 0
1522        };
1523        S20R { bits }
1524    }
1525    #[doc = "Bit 19 - S19"]
1526    #[inline]
1527    pub fn s19(&self) -> S19R {
1528        let bits = {
1529            const MASK: bool = true;
1530            const OFFSET: u8 = 19;
1531            ((self.bits >> OFFSET) & MASK as u32) != 0
1532        };
1533        S19R { bits }
1534    }
1535    #[doc = "Bit 18 - S18"]
1536    #[inline]
1537    pub fn s18(&self) -> S18R {
1538        let bits = {
1539            const MASK: bool = true;
1540            const OFFSET: u8 = 18;
1541            ((self.bits >> OFFSET) & MASK as u32) != 0
1542        };
1543        S18R { bits }
1544    }
1545    #[doc = "Bit 17 - S17"]
1546    #[inline]
1547    pub fn s17(&self) -> S17R {
1548        let bits = {
1549            const MASK: bool = true;
1550            const OFFSET: u8 = 17;
1551            ((self.bits >> OFFSET) & MASK as u32) != 0
1552        };
1553        S17R { bits }
1554    }
1555    #[doc = "Bit 16 - S16"]
1556    #[inline]
1557    pub fn s16(&self) -> S16R {
1558        let bits = {
1559            const MASK: bool = true;
1560            const OFFSET: u8 = 16;
1561            ((self.bits >> OFFSET) & MASK as u32) != 0
1562        };
1563        S16R { bits }
1564    }
1565    #[doc = "Bit 15 - S15"]
1566    #[inline]
1567    pub fn s15(&self) -> S15R {
1568        let bits = {
1569            const MASK: bool = true;
1570            const OFFSET: u8 = 15;
1571            ((self.bits >> OFFSET) & MASK as u32) != 0
1572        };
1573        S15R { bits }
1574    }
1575    #[doc = "Bit 14 - S14"]
1576    #[inline]
1577    pub fn s14(&self) -> S14R {
1578        let bits = {
1579            const MASK: bool = true;
1580            const OFFSET: u8 = 14;
1581            ((self.bits >> OFFSET) & MASK as u32) != 0
1582        };
1583        S14R { bits }
1584    }
1585    #[doc = "Bit 13 - S13"]
1586    #[inline]
1587    pub fn s13(&self) -> S13R {
1588        let bits = {
1589            const MASK: bool = true;
1590            const OFFSET: u8 = 13;
1591            ((self.bits >> OFFSET) & MASK as u32) != 0
1592        };
1593        S13R { bits }
1594    }
1595    #[doc = "Bit 12 - S12"]
1596    #[inline]
1597    pub fn s12(&self) -> S12R {
1598        let bits = {
1599            const MASK: bool = true;
1600            const OFFSET: u8 = 12;
1601            ((self.bits >> OFFSET) & MASK as u32) != 0
1602        };
1603        S12R { bits }
1604    }
1605    #[doc = "Bit 11 - S11"]
1606    #[inline]
1607    pub fn s11(&self) -> S11R {
1608        let bits = {
1609            const MASK: bool = true;
1610            const OFFSET: u8 = 11;
1611            ((self.bits >> OFFSET) & MASK as u32) != 0
1612        };
1613        S11R { bits }
1614    }
1615    #[doc = "Bit 10 - S10"]
1616    #[inline]
1617    pub fn s10(&self) -> S10R {
1618        let bits = {
1619            const MASK: bool = true;
1620            const OFFSET: u8 = 10;
1621            ((self.bits >> OFFSET) & MASK as u32) != 0
1622        };
1623        S10R { bits }
1624    }
1625    #[doc = "Bit 9 - S09"]
1626    #[inline]
1627    pub fn s09(&self) -> S09R {
1628        let bits = {
1629            const MASK: bool = true;
1630            const OFFSET: u8 = 9;
1631            ((self.bits >> OFFSET) & MASK as u32) != 0
1632        };
1633        S09R { bits }
1634    }
1635    #[doc = "Bit 8 - S08"]
1636    #[inline]
1637    pub fn s08(&self) -> S08R {
1638        let bits = {
1639            const MASK: bool = true;
1640            const OFFSET: u8 = 8;
1641            ((self.bits >> OFFSET) & MASK as u32) != 0
1642        };
1643        S08R { bits }
1644    }
1645    #[doc = "Bit 7 - S07"]
1646    #[inline]
1647    pub fn s07(&self) -> S07R {
1648        let bits = {
1649            const MASK: bool = true;
1650            const OFFSET: u8 = 7;
1651            ((self.bits >> OFFSET) & MASK as u32) != 0
1652        };
1653        S07R { bits }
1654    }
1655    #[doc = "Bit 6 - S06"]
1656    #[inline]
1657    pub fn s06(&self) -> S06R {
1658        let bits = {
1659            const MASK: bool = true;
1660            const OFFSET: u8 = 6;
1661            ((self.bits >> OFFSET) & MASK as u32) != 0
1662        };
1663        S06R { bits }
1664    }
1665    #[doc = "Bit 5 - S05"]
1666    #[inline]
1667    pub fn s05(&self) -> S05R {
1668        let bits = {
1669            const MASK: bool = true;
1670            const OFFSET: u8 = 5;
1671            ((self.bits >> OFFSET) & MASK as u32) != 0
1672        };
1673        S05R { bits }
1674    }
1675    #[doc = "Bit 4 - S04"]
1676    #[inline]
1677    pub fn s04(&self) -> S04R {
1678        let bits = {
1679            const MASK: bool = true;
1680            const OFFSET: u8 = 4;
1681            ((self.bits >> OFFSET) & MASK as u32) != 0
1682        };
1683        S04R { bits }
1684    }
1685    #[doc = "Bit 3 - S03"]
1686    #[inline]
1687    pub fn s03(&self) -> S03R {
1688        let bits = {
1689            const MASK: bool = true;
1690            const OFFSET: u8 = 3;
1691            ((self.bits >> OFFSET) & MASK as u32) != 0
1692        };
1693        S03R { bits }
1694    }
1695    #[doc = "Bit 2 - S02"]
1696    #[inline]
1697    pub fn s02(&self) -> S02R {
1698        let bits = {
1699            const MASK: bool = true;
1700            const OFFSET: u8 = 2;
1701            ((self.bits >> OFFSET) & MASK as u32) != 0
1702        };
1703        S02R { bits }
1704    }
1705    #[doc = "Bit 1 - S01"]
1706    #[inline]
1707    pub fn s01(&self) -> S01R {
1708        let bits = {
1709            const MASK: bool = true;
1710            const OFFSET: u8 = 1;
1711            ((self.bits >> OFFSET) & MASK as u32) != 0
1712        };
1713        S01R { bits }
1714    }
1715    #[doc = "Bit 0 - S00"]
1716    #[inline]
1717    pub fn s00(&self) -> S00R {
1718        let bits = {
1719            const MASK: bool = true;
1720            const OFFSET: u8 = 0;
1721            ((self.bits >> OFFSET) & MASK as u32) != 0
1722        };
1723        S00R { bits }
1724    }
1725}
1726impl W {
1727    #[doc = r" Reset value of the register"]
1728    #[inline]
1729    pub fn reset_value() -> W {
1730        W { bits: 0 }
1731    }
1732    #[doc = r" Writes raw bits to the register"]
1733    #[inline]
1734    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1735        self.bits = bits;
1736        self
1737    }
1738    #[doc = "Bit 30 - S30"]
1739    #[inline]
1740    pub fn s30(&mut self) -> _S30W {
1741        _S30W { w: self }
1742    }
1743    #[doc = "Bit 29 - S29"]
1744    #[inline]
1745    pub fn s29(&mut self) -> _S29W {
1746        _S29W { w: self }
1747    }
1748    #[doc = "Bit 28 - S28"]
1749    #[inline]
1750    pub fn s28(&mut self) -> _S28W {
1751        _S28W { w: self }
1752    }
1753    #[doc = "Bit 27 - S27"]
1754    #[inline]
1755    pub fn s27(&mut self) -> _S27W {
1756        _S27W { w: self }
1757    }
1758    #[doc = "Bit 26 - S26"]
1759    #[inline]
1760    pub fn s26(&mut self) -> _S26W {
1761        _S26W { w: self }
1762    }
1763    #[doc = "Bit 25 - S25"]
1764    #[inline]
1765    pub fn s25(&mut self) -> _S25W {
1766        _S25W { w: self }
1767    }
1768    #[doc = "Bit 24 - S24"]
1769    #[inline]
1770    pub fn s24(&mut self) -> _S24W {
1771        _S24W { w: self }
1772    }
1773    #[doc = "Bit 23 - S23"]
1774    #[inline]
1775    pub fn s23(&mut self) -> _S23W {
1776        _S23W { w: self }
1777    }
1778    #[doc = "Bit 22 - S22"]
1779    #[inline]
1780    pub fn s22(&mut self) -> _S22W {
1781        _S22W { w: self }
1782    }
1783    #[doc = "Bit 21 - S21"]
1784    #[inline]
1785    pub fn s21(&mut self) -> _S21W {
1786        _S21W { w: self }
1787    }
1788    #[doc = "Bit 20 - S20"]
1789    #[inline]
1790    pub fn s20(&mut self) -> _S20W {
1791        _S20W { w: self }
1792    }
1793    #[doc = "Bit 19 - S19"]
1794    #[inline]
1795    pub fn s19(&mut self) -> _S19W {
1796        _S19W { w: self }
1797    }
1798    #[doc = "Bit 18 - S18"]
1799    #[inline]
1800    pub fn s18(&mut self) -> _S18W {
1801        _S18W { w: self }
1802    }
1803    #[doc = "Bit 17 - S17"]
1804    #[inline]
1805    pub fn s17(&mut self) -> _S17W {
1806        _S17W { w: self }
1807    }
1808    #[doc = "Bit 16 - S16"]
1809    #[inline]
1810    pub fn s16(&mut self) -> _S16W {
1811        _S16W { w: self }
1812    }
1813    #[doc = "Bit 15 - S15"]
1814    #[inline]
1815    pub fn s15(&mut self) -> _S15W {
1816        _S15W { w: self }
1817    }
1818    #[doc = "Bit 14 - S14"]
1819    #[inline]
1820    pub fn s14(&mut self) -> _S14W {
1821        _S14W { w: self }
1822    }
1823    #[doc = "Bit 13 - S13"]
1824    #[inline]
1825    pub fn s13(&mut self) -> _S13W {
1826        _S13W { w: self }
1827    }
1828    #[doc = "Bit 12 - S12"]
1829    #[inline]
1830    pub fn s12(&mut self) -> _S12W {
1831        _S12W { w: self }
1832    }
1833    #[doc = "Bit 11 - S11"]
1834    #[inline]
1835    pub fn s11(&mut self) -> _S11W {
1836        _S11W { w: self }
1837    }
1838    #[doc = "Bit 10 - S10"]
1839    #[inline]
1840    pub fn s10(&mut self) -> _S10W {
1841        _S10W { w: self }
1842    }
1843    #[doc = "Bit 9 - S09"]
1844    #[inline]
1845    pub fn s09(&mut self) -> _S09W {
1846        _S09W { w: self }
1847    }
1848    #[doc = "Bit 8 - S08"]
1849    #[inline]
1850    pub fn s08(&mut self) -> _S08W {
1851        _S08W { w: self }
1852    }
1853    #[doc = "Bit 7 - S07"]
1854    #[inline]
1855    pub fn s07(&mut self) -> _S07W {
1856        _S07W { w: self }
1857    }
1858    #[doc = "Bit 6 - S06"]
1859    #[inline]
1860    pub fn s06(&mut self) -> _S06W {
1861        _S06W { w: self }
1862    }
1863    #[doc = "Bit 5 - S05"]
1864    #[inline]
1865    pub fn s05(&mut self) -> _S05W {
1866        _S05W { w: self }
1867    }
1868    #[doc = "Bit 4 - S04"]
1869    #[inline]
1870    pub fn s04(&mut self) -> _S04W {
1871        _S04W { w: self }
1872    }
1873    #[doc = "Bit 3 - S03"]
1874    #[inline]
1875    pub fn s03(&mut self) -> _S03W {
1876        _S03W { w: self }
1877    }
1878    #[doc = "Bit 2 - S02"]
1879    #[inline]
1880    pub fn s02(&mut self) -> _S02W {
1881        _S02W { w: self }
1882    }
1883    #[doc = "Bit 1 - S01"]
1884    #[inline]
1885    pub fn s01(&mut self) -> _S01W {
1886        _S01W { w: self }
1887    }
1888    #[doc = "Bit 0 - S00"]
1889    #[inline]
1890    pub fn s00(&mut self) -> _S00W {
1891        _S00W { w: self }
1892    }
1893}
stm32l4x2_pac/lcd/ram_com0.rs

stm32l4x2_pac/lcd/
ram_com0.rs
