efm32pg22_pac/efm32pg22c200/iadc0_ns/
trigger.rs

1#[doc = "Register `TRIGGER` reader"]
2pub struct R(crate::R<TRIGGER_SPEC>);
3impl core::ops::Deref for R {
4    type Target = crate::R<TRIGGER_SPEC>;
5    #[inline(always)]
6    fn deref(&self) -> &Self::Target {
7        &self.0
8    }
9}
10impl From<crate::R<TRIGGER_SPEC>> for R {
11    #[inline(always)]
12    fn from(reader: crate::R<TRIGGER_SPEC>) -> Self {
13        R(reader)
14    }
15}
16#[doc = "Register `TRIGGER` writer"]
17pub struct W(crate::W<TRIGGER_SPEC>);
18impl core::ops::Deref for W {
19    type Target = crate::W<TRIGGER_SPEC>;
20    #[inline(always)]
21    fn deref(&self) -> &Self::Target {
22        &self.0
23    }
24}
25impl core::ops::DerefMut for W {
26    #[inline(always)]
27    fn deref_mut(&mut self) -> &mut Self::Target {
28        &mut self.0
29    }
30}
31impl From<crate::W<TRIGGER_SPEC>> for W {
32    #[inline(always)]
33    fn from(writer: crate::W<TRIGGER_SPEC>) -> Self {
34        W(writer)
35    }
36}
37#[doc = "Field `SCANTRIGSEL` reader - Scan Trigger Select"]
38pub type SCANTRIGSEL_R = crate::FieldReader<u8, SCANTRIGSEL_A>;
39#[doc = "Scan Trigger Select\n\nValue on reset: 0"]
40#[derive(Clone, Copy, Debug, PartialEq, Eq)]
41#[repr(u8)]
42pub enum SCANTRIGSEL_A {
43    #[doc = "0: Immediate triggering. The scan queue will be disabled once all conversions in the scan table are complete, unless TRIGGERACTION is set to continuous."]
44    IMMEDIATE = 0,
45    #[doc = "1: Triggers when the local timer count reaches zero."]
46    TIMER = 1,
47    #[doc = "2: Triggers on PRS0 from a timer module that is using the same clock group as the ADC and has been programmed to use the same clock source as the ADC. The prescale may be different between the ADC and the timer module."]
48    PRSCLKGRP = 2,
49    #[doc = "3: Triggers on asynchronous PRS0 positive edge. Requires PRS0 to go low for 3 ADC_CLKs before another positive edge can be detected. Generates an additional delay of 1 to 2 ADC_SRC_CLK cycles for synchronization."]
50    PRSPOS = 3,
51    #[doc = "4: Triggers on asynchronous PRS0 negative edge. Requires PRS0 to go high for 3 ADC_CLKs before another negative edge can be detected. Generates an additional delay of 1 to 2 ADC_SRC_CLK cycles for synchronization. PRSNEG should only be used when the trigger source is from a module that remains powered during EM23. For modules (ie: TIMER) that power down during EM23, PRSPOS should be used for an asynchronous trigger, and PRSCLKGRP should be used for a synchronous trigger."]
52    PRSNEG = 4,
53}
54impl From<SCANTRIGSEL_A> for u8 {
55    #[inline(always)]
56    fn from(variant: SCANTRIGSEL_A) -> Self {
57        variant as _
58    }
59}
60impl SCANTRIGSEL_R {
61    #[doc = "Get enumerated values variant"]
62    #[inline(always)]
63    pub fn variant(&self) -> Option<SCANTRIGSEL_A> {
64        match self.bits {
65            0 => Some(SCANTRIGSEL_A::IMMEDIATE),
66            1 => Some(SCANTRIGSEL_A::TIMER),
67            2 => Some(SCANTRIGSEL_A::PRSCLKGRP),
68            3 => Some(SCANTRIGSEL_A::PRSPOS),
69            4 => Some(SCANTRIGSEL_A::PRSNEG),
70            _ => None,
71        }
72    }
73    #[doc = "Checks if the value of the field is `IMMEDIATE`"]
74    #[inline(always)]
75    pub fn is_immediate(&self) -> bool {
76        *self == SCANTRIGSEL_A::IMMEDIATE
77    }
78    #[doc = "Checks if the value of the field is `TIMER`"]
79    #[inline(always)]
80    pub fn is_timer(&self) -> bool {
81        *self == SCANTRIGSEL_A::TIMER
82    }
83    #[doc = "Checks if the value of the field is `PRSCLKGRP`"]
84    #[inline(always)]
85    pub fn is_prsclkgrp(&self) -> bool {
86        *self == SCANTRIGSEL_A::PRSCLKGRP
87    }
88    #[doc = "Checks if the value of the field is `PRSPOS`"]
89    #[inline(always)]
90    pub fn is_prspos(&self) -> bool {
91        *self == SCANTRIGSEL_A::PRSPOS
92    }
93    #[doc = "Checks if the value of the field is `PRSNEG`"]
94    #[inline(always)]
95    pub fn is_prsneg(&self) -> bool {
96        *self == SCANTRIGSEL_A::PRSNEG
97    }
98}
99#[doc = "Field `SCANTRIGSEL` writer - Scan Trigger Select"]
100pub type SCANTRIGSEL_W<'a, const O: u8> =
101    crate::FieldWriter<'a, u32, TRIGGER_SPEC, u8, SCANTRIGSEL_A, 3, O>;
102impl<'a, const O: u8> SCANTRIGSEL_W<'a, O> {
103    #[doc = "Immediate triggering. The scan queue will be disabled once all conversions in the scan table are complete, unless TRIGGERACTION is set to continuous."]
104    #[inline(always)]
105    pub fn immediate(self) -> &'a mut W {
106        self.variant(SCANTRIGSEL_A::IMMEDIATE)
107    }
108    #[doc = "Triggers when the local timer count reaches zero."]
109    #[inline(always)]
110    pub fn timer(self) -> &'a mut W {
111        self.variant(SCANTRIGSEL_A::TIMER)
112    }
113    #[doc = "Triggers on PRS0 from a timer module that is using the same clock group as the ADC and has been programmed to use the same clock source as the ADC. The prescale may be different between the ADC and the timer module."]
114    #[inline(always)]
115    pub fn prsclkgrp(self) -> &'a mut W {
116        self.variant(SCANTRIGSEL_A::PRSCLKGRP)
117    }
118    #[doc = "Triggers on asynchronous PRS0 positive edge. Requires PRS0 to go low for 3 ADC_CLKs before another positive edge can be detected. Generates an additional delay of 1 to 2 ADC_SRC_CLK cycles for synchronization."]
119    #[inline(always)]
120    pub fn prspos(self) -> &'a mut W {
121        self.variant(SCANTRIGSEL_A::PRSPOS)
122    }
123    #[doc = "Triggers on asynchronous PRS0 negative edge. Requires PRS0 to go high for 3 ADC_CLKs before another negative edge can be detected. Generates an additional delay of 1 to 2 ADC_SRC_CLK cycles for synchronization. PRSNEG should only be used when the trigger source is from a module that remains powered during EM23. For modules (ie: TIMER) that power down during EM23, PRSPOS should be used for an asynchronous trigger, and PRSCLKGRP should be used for a synchronous trigger."]
124    #[inline(always)]
125    pub fn prsneg(self) -> &'a mut W {
126        self.variant(SCANTRIGSEL_A::PRSNEG)
127    }
128}
129#[doc = "Field `SCANTRIGACTION` reader - Scan Trigger Action"]
130pub type SCANTRIGACTION_R = crate::BitReader<SCANTRIGACTION_A>;
131#[doc = "Scan Trigger Action\n\nValue on reset: 0"]
132#[derive(Clone, Copy, Debug, PartialEq, Eq)]
133pub enum SCANTRIGACTION_A {
134    #[doc = "0: For TRIGSEL=IMMEDIATE, goes through the scan table once and disables queue. For TRIGSEL = TIMER, PRSCLKGRP, PRSPOS, PRSNEG, goes through the scan table once per trigger."]
135    ONCE = 0,
136    #[doc = "1: Goes through the scan table, converts each entry with a mask bit set, and puts it back into the scan queue to repeat again continuously. The queues are first come first serve. If both queues are triggered, the single queue will get to convert after each scan table completes. The scan queue will get to convert after each single conversion completes."]
137    CONTINUOUS = 1,
138}
139impl From<SCANTRIGACTION_A> for bool {
140    #[inline(always)]
141    fn from(variant: SCANTRIGACTION_A) -> Self {
142        variant as u8 != 0
143    }
144}
145impl SCANTRIGACTION_R {
146    #[doc = "Get enumerated values variant"]
147    #[inline(always)]
148    pub fn variant(&self) -> SCANTRIGACTION_A {
149        match self.bits {
150            false => SCANTRIGACTION_A::ONCE,
151            true => SCANTRIGACTION_A::CONTINUOUS,
152        }
153    }
154    #[doc = "Checks if the value of the field is `ONCE`"]
155    #[inline(always)]
156    pub fn is_once(&self) -> bool {
157        *self == SCANTRIGACTION_A::ONCE
158    }
159    #[doc = "Checks if the value of the field is `CONTINUOUS`"]
160    #[inline(always)]
161    pub fn is_continuous(&self) -> bool {
162        *self == SCANTRIGACTION_A::CONTINUOUS
163    }
164}
165#[doc = "Field `SCANTRIGACTION` writer - Scan Trigger Action"]
166pub type SCANTRIGACTION_W<'a, const O: u8> =
167    crate::BitWriter<'a, u32, TRIGGER_SPEC, SCANTRIGACTION_A, O>;
168impl<'a, const O: u8> SCANTRIGACTION_W<'a, O> {
169    #[doc = "For TRIGSEL=IMMEDIATE, goes through the scan table once and disables queue. For TRIGSEL = TIMER, PRSCLKGRP, PRSPOS, PRSNEG, goes through the scan table once per trigger."]
170    #[inline(always)]
171    pub fn once(self) -> &'a mut W {
172        self.variant(SCANTRIGACTION_A::ONCE)
173    }
174    #[doc = "Goes through the scan table, converts each entry with a mask bit set, and puts it back into the scan queue to repeat again continuously. The queues are first come first serve. If both queues are triggered, the single queue will get to convert after each scan table completes. The scan queue will get to convert after each single conversion completes."]
175    #[inline(always)]
176    pub fn continuous(self) -> &'a mut W {
177        self.variant(SCANTRIGACTION_A::CONTINUOUS)
178    }
179}
180#[doc = "Field `SINGLETRIGSEL` reader - Single Trigger Select"]
181pub type SINGLETRIGSEL_R = crate::FieldReader<u8, SINGLETRIGSEL_A>;
182#[doc = "Single Trigger Select\n\nValue on reset: 0"]
183#[derive(Clone, Copy, Debug, PartialEq, Eq)]
184#[repr(u8)]
185pub enum SINGLETRIGSEL_A {
186    #[doc = "0: Immediate triggering. The single queue will be disabled once the conversion is complete, unless TRIGGERACTION is set to continuous."]
187    IMMEDIATE = 0,
188    #[doc = "1: Triggers when the local timer count reaches zero."]
189    TIMER = 1,
190    #[doc = "2: Triggers on PRS1 from a timer module that is using the same clock group as the ADC and has been programmed to use the same clock source as the ADC. The prescale may be different between the ADC and the timer module."]
191    PRSCLKGRP = 2,
192    #[doc = "3: Triggers on asynchronous PRS1 positive edge. Requires PRS1 to go low for 3 ADC_CLKs before another positive edge can be detected. Generates an additional delay of 1 to 2 ADC_SRC_CLK cycles for synchronization."]
193    PRSPOS = 3,
194    #[doc = "4: Triggers on asynchronous PRS1 negative edge. Requires PRS1 to go high for 3 ADC_CLKs before another negative edge can be detected. Generates an additional delay of 1 to 2 ADC_SRC_CLK cycles for synchronization. PRSNEG should only be used when the trigger source is from a module that remains powered during EM23. For modules (ie: TIMER) that power down during EM23, PRSPOS should be used for an asynchronous trigger, and PRSCLKGRP should be used for a synchronous trigger."]
195    PRSNEG = 4,
196}
197impl From<SINGLETRIGSEL_A> for u8 {
198    #[inline(always)]
199    fn from(variant: SINGLETRIGSEL_A) -> Self {
200        variant as _
201    }
202}
203impl SINGLETRIGSEL_R {
204    #[doc = "Get enumerated values variant"]
205    #[inline(always)]
206    pub fn variant(&self) -> Option<SINGLETRIGSEL_A> {
207        match self.bits {
208            0 => Some(SINGLETRIGSEL_A::IMMEDIATE),
209            1 => Some(SINGLETRIGSEL_A::TIMER),
210            2 => Some(SINGLETRIGSEL_A::PRSCLKGRP),
211            3 => Some(SINGLETRIGSEL_A::PRSPOS),
212            4 => Some(SINGLETRIGSEL_A::PRSNEG),
213            _ => None,
214        }
215    }
216    #[doc = "Checks if the value of the field is `IMMEDIATE`"]
217    #[inline(always)]
218    pub fn is_immediate(&self) -> bool {
219        *self == SINGLETRIGSEL_A::IMMEDIATE
220    }
221    #[doc = "Checks if the value of the field is `TIMER`"]
222    #[inline(always)]
223    pub fn is_timer(&self) -> bool {
224        *self == SINGLETRIGSEL_A::TIMER
225    }
226    #[doc = "Checks if the value of the field is `PRSCLKGRP`"]
227    #[inline(always)]
228    pub fn is_prsclkgrp(&self) -> bool {
229        *self == SINGLETRIGSEL_A::PRSCLKGRP
230    }
231    #[doc = "Checks if the value of the field is `PRSPOS`"]
232    #[inline(always)]
233    pub fn is_prspos(&self) -> bool {
234        *self == SINGLETRIGSEL_A::PRSPOS
235    }
236    #[doc = "Checks if the value of the field is `PRSNEG`"]
237    #[inline(always)]
238    pub fn is_prsneg(&self) -> bool {
239        *self == SINGLETRIGSEL_A::PRSNEG
240    }
241}
242#[doc = "Field `SINGLETRIGSEL` writer - Single Trigger Select"]
243pub type SINGLETRIGSEL_W<'a, const O: u8> =
244    crate::FieldWriter<'a, u32, TRIGGER_SPEC, u8, SINGLETRIGSEL_A, 3, O>;
245impl<'a, const O: u8> SINGLETRIGSEL_W<'a, O> {
246    #[doc = "Immediate triggering. The single queue will be disabled once the conversion is complete, unless TRIGGERACTION is set to continuous."]
247    #[inline(always)]
248    pub fn immediate(self) -> &'a mut W {
249        self.variant(SINGLETRIGSEL_A::IMMEDIATE)
250    }
251    #[doc = "Triggers when the local timer count reaches zero."]
252    #[inline(always)]
253    pub fn timer(self) -> &'a mut W {
254        self.variant(SINGLETRIGSEL_A::TIMER)
255    }
256    #[doc = "Triggers on PRS1 from a timer module that is using the same clock group as the ADC and has been programmed to use the same clock source as the ADC. The prescale may be different between the ADC and the timer module."]
257    #[inline(always)]
258    pub fn prsclkgrp(self) -> &'a mut W {
259        self.variant(SINGLETRIGSEL_A::PRSCLKGRP)
260    }
261    #[doc = "Triggers on asynchronous PRS1 positive edge. Requires PRS1 to go low for 3 ADC_CLKs before another positive edge can be detected. Generates an additional delay of 1 to 2 ADC_SRC_CLK cycles for synchronization."]
262    #[inline(always)]
263    pub fn prspos(self) -> &'a mut W {
264        self.variant(SINGLETRIGSEL_A::PRSPOS)
265    }
266    #[doc = "Triggers on asynchronous PRS1 negative edge. Requires PRS1 to go high for 3 ADC_CLKs before another negative edge can be detected. Generates an additional delay of 1 to 2 ADC_SRC_CLK cycles for synchronization. PRSNEG should only be used when the trigger source is from a module that remains powered during EM23. For modules (ie: TIMER) that power down during EM23, PRSPOS should be used for an asynchronous trigger, and PRSCLKGRP should be used for a synchronous trigger."]
267    #[inline(always)]
268    pub fn prsneg(self) -> &'a mut W {
269        self.variant(SINGLETRIGSEL_A::PRSNEG)
270    }
271}
272#[doc = "Field `SINGLETRIGACTION` reader - Single Trigger Action"]
273pub type SINGLETRIGACTION_R = crate::BitReader<SINGLETRIGACTION_A>;
274#[doc = "Single Trigger Action\n\nValue on reset: 0"]
275#[derive(Clone, Copy, Debug, PartialEq, Eq)]
276pub enum SINGLETRIGACTION_A {
277    #[doc = "0: For TRIGSEL=IMMEDIATE, converts the single queue once and disables queue. For TRIGSEL = TIMER, PRSCLKGRP, PRSPOS, PRSNEG, converts the single queue once per trigger.ask."]
278    ONCE = 0,
279    #[doc = "1: Converts the single queue, then checks for a pending scan queue before converting the single queue again continuously. The queues are first come first serve. If both queues are continuous, the IADC alternates between them."]
280    CONTINUOUS = 1,
281}
282impl From<SINGLETRIGACTION_A> for bool {
283    #[inline(always)]
284    fn from(variant: SINGLETRIGACTION_A) -> Self {
285        variant as u8 != 0
286    }
287}
288impl SINGLETRIGACTION_R {
289    #[doc = "Get enumerated values variant"]
290    #[inline(always)]
291    pub fn variant(&self) -> SINGLETRIGACTION_A {
292        match self.bits {
293            false => SINGLETRIGACTION_A::ONCE,
294            true => SINGLETRIGACTION_A::CONTINUOUS,
295        }
296    }
297    #[doc = "Checks if the value of the field is `ONCE`"]
298    #[inline(always)]
299    pub fn is_once(&self) -> bool {
300        *self == SINGLETRIGACTION_A::ONCE
301    }
302    #[doc = "Checks if the value of the field is `CONTINUOUS`"]
303    #[inline(always)]
304    pub fn is_continuous(&self) -> bool {
305        *self == SINGLETRIGACTION_A::CONTINUOUS
306    }
307}
308#[doc = "Field `SINGLETRIGACTION` writer - Single Trigger Action"]
309pub type SINGLETRIGACTION_W<'a, const O: u8> =
310    crate::BitWriter<'a, u32, TRIGGER_SPEC, SINGLETRIGACTION_A, O>;
311impl<'a, const O: u8> SINGLETRIGACTION_W<'a, O> {
312    #[doc = "For TRIGSEL=IMMEDIATE, converts the single queue once and disables queue. For TRIGSEL = TIMER, PRSCLKGRP, PRSPOS, PRSNEG, converts the single queue once per trigger.ask."]
313    #[inline(always)]
314    pub fn once(self) -> &'a mut W {
315        self.variant(SINGLETRIGACTION_A::ONCE)
316    }
317    #[doc = "Converts the single queue, then checks for a pending scan queue before converting the single queue again continuously. The queues are first come first serve. If both queues are continuous, the IADC alternates between them."]
318    #[inline(always)]
319    pub fn continuous(self) -> &'a mut W {
320        self.variant(SINGLETRIGACTION_A::CONTINUOUS)
321    }
322}
323#[doc = "Field `SINGLETAILGATE` reader - Single Tailgate Enable"]
324pub type SINGLETAILGATE_R = crate::BitReader<SINGLETAILGATE_A>;
325#[doc = "Single Tailgate Enable\n\nValue on reset: 0"]
326#[derive(Clone, Copy, Debug, PartialEq, Eq)]
327pub enum SINGLETAILGATE_A {
328    #[doc = "0: The single queue is ready to start warming up and converting once the trigger had been detected."]
329    TAILGATEOFF = 0,
330    #[doc = "1: After the single queue's trigger is detected, it must wait until the end of a scan operation before the Single queue can be converted."]
331    TAILGATEON = 1,
332}
333impl From<SINGLETAILGATE_A> for bool {
334    #[inline(always)]
335    fn from(variant: SINGLETAILGATE_A) -> Self {
336        variant as u8 != 0
337    }
338}
339impl SINGLETAILGATE_R {
340    #[doc = "Get enumerated values variant"]
341    #[inline(always)]
342    pub fn variant(&self) -> SINGLETAILGATE_A {
343        match self.bits {
344            false => SINGLETAILGATE_A::TAILGATEOFF,
345            true => SINGLETAILGATE_A::TAILGATEON,
346        }
347    }
348    #[doc = "Checks if the value of the field is `TAILGATEOFF`"]
349    #[inline(always)]
350    pub fn is_tailgateoff(&self) -> bool {
351        *self == SINGLETAILGATE_A::TAILGATEOFF
352    }
353    #[doc = "Checks if the value of the field is `TAILGATEON`"]
354    #[inline(always)]
355    pub fn is_tailgateon(&self) -> bool {
356        *self == SINGLETAILGATE_A::TAILGATEON
357    }
358}
359#[doc = "Field `SINGLETAILGATE` writer - Single Tailgate Enable"]
360pub type SINGLETAILGATE_W<'a, const O: u8> =
361    crate::BitWriter<'a, u32, TRIGGER_SPEC, SINGLETAILGATE_A, O>;
362impl<'a, const O: u8> SINGLETAILGATE_W<'a, O> {
363    #[doc = "The single queue is ready to start warming up and converting once the trigger had been detected."]
364    #[inline(always)]
365    pub fn tailgateoff(self) -> &'a mut W {
366        self.variant(SINGLETAILGATE_A::TAILGATEOFF)
367    }
368    #[doc = "After the single queue's trigger is detected, it must wait until the end of a scan operation before the Single queue can be converted."]
369    #[inline(always)]
370    pub fn tailgateon(self) -> &'a mut W {
371        self.variant(SINGLETAILGATE_A::TAILGATEON)
372    }
373}
374impl R {
375    #[doc = "Bits 0:2 - Scan Trigger Select"]
376    #[inline(always)]
377    pub fn scantrigsel(&self) -> SCANTRIGSEL_R {
378        SCANTRIGSEL_R::new((self.bits & 7) as u8)
379    }
380    #[doc = "Bit 4 - Scan Trigger Action"]
381    #[inline(always)]
382    pub fn scantrigaction(&self) -> SCANTRIGACTION_R {
383        SCANTRIGACTION_R::new(((self.bits >> 4) & 1) != 0)
384    }
385    #[doc = "Bits 8:10 - Single Trigger Select"]
386    #[inline(always)]
387    pub fn singletrigsel(&self) -> SINGLETRIGSEL_R {
388        SINGLETRIGSEL_R::new(((self.bits >> 8) & 7) as u8)
389    }
390    #[doc = "Bit 12 - Single Trigger Action"]
391    #[inline(always)]
392    pub fn singletrigaction(&self) -> SINGLETRIGACTION_R {
393        SINGLETRIGACTION_R::new(((self.bits >> 12) & 1) != 0)
394    }
395    #[doc = "Bit 16 - Single Tailgate Enable"]
396    #[inline(always)]
397    pub fn singletailgate(&self) -> SINGLETAILGATE_R {
398        SINGLETAILGATE_R::new(((self.bits >> 16) & 1) != 0)
399    }
400}
401impl W {
402    #[doc = "Bits 0:2 - Scan Trigger Select"]
403    #[inline(always)]
404    #[must_use]
405    pub fn scantrigsel(&mut self) -> SCANTRIGSEL_W<0> {
406        SCANTRIGSEL_W::new(self)
407    }
408    #[doc = "Bit 4 - Scan Trigger Action"]
409    #[inline(always)]
410    #[must_use]
411    pub fn scantrigaction(&mut self) -> SCANTRIGACTION_W<4> {
412        SCANTRIGACTION_W::new(self)
413    }
414    #[doc = "Bits 8:10 - Single Trigger Select"]
415    #[inline(always)]
416    #[must_use]
417    pub fn singletrigsel(&mut self) -> SINGLETRIGSEL_W<8> {
418        SINGLETRIGSEL_W::new(self)
419    }
420    #[doc = "Bit 12 - Single Trigger Action"]
421    #[inline(always)]
422    #[must_use]
423    pub fn singletrigaction(&mut self) -> SINGLETRIGACTION_W<12> {
424        SINGLETRIGACTION_W::new(self)
425    }
426    #[doc = "Bit 16 - Single Tailgate Enable"]
427    #[inline(always)]
428    #[must_use]
429    pub fn singletailgate(&mut self) -> SINGLETAILGATE_W<16> {
430        SINGLETAILGATE_W::new(self)
431    }
432    #[doc = "Writes raw bits to the register."]
433    #[inline(always)]
434    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
435        self.0.bits(bits);
436        self
437    }
438}
439#[doc = "Trigger\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [trigger](index.html) module"]
440pub struct TRIGGER_SPEC;
441impl crate::RegisterSpec for TRIGGER_SPEC {
442    type Ux = u32;
443}
444#[doc = "`read()` method returns [trigger::R](R) reader structure"]
445impl crate::Readable for TRIGGER_SPEC {
446    type Reader = R;
447}
448#[doc = "`write(|w| ..)` method takes [trigger::W](W) writer structure"]
449impl crate::Writable for TRIGGER_SPEC {
450    type Writer = W;
451    const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
452    const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
453}
454#[doc = "`reset()` method sets TRIGGER to value 0"]
455impl crate::Resettable for TRIGGER_SPEC {
456    const RESET_VALUE: Self::Ux = 0;
457}
efm32pg22_pac/efm32pg22c200/iadc0_ns/trigger.rs

efm32pg22_pac/efm32pg22c200/iadc0_ns/
trigger.rs
