nrf52840_pac/radio/
shorts.rs

Help
1#[doc = "Register `SHORTS` reader"]
2pub struct R(crate::R<SHORTS_SPEC>);
3impl core::ops::Deref for R {
4    type Target = crate::R<SHORTS_SPEC>;
5    #[inline(always)]
6    fn deref(&self) -> &Self::Target {
7        &self.0
8    }
9}
10impl From<crate::R<SHORTS_SPEC>> for R {
11    #[inline(always)]
12    fn from(reader: crate::R<SHORTS_SPEC>) -> Self {
13        R(reader)
14    }
15}
16#[doc = "Register `SHORTS` writer"]
17pub struct W(crate::W<SHORTS_SPEC>);
18impl core::ops::Deref for W {
19    type Target = crate::W<SHORTS_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<SHORTS_SPEC>> for W {
32    #[inline(always)]
33    fn from(writer: crate::W<SHORTS_SPEC>) -> Self {
34        W(writer)
35    }
36}
37#[doc = "Field `READY_START` reader - Shortcut between READY event and START task"]
38pub type READY_START_R = crate::BitReader<READY_START_A>;
39#[doc = "Shortcut between READY event and START task\n\nValue on reset: 0"]
40#[derive(Clone, Copy, Debug, PartialEq)]
41pub enum READY_START_A {
42    #[doc = "0: Disable shortcut"]
43    DISABLED = 0,
44    #[doc = "1: Enable shortcut"]
45    ENABLED = 1,
46}
47impl From<READY_START_A> for bool {
48    #[inline(always)]
49    fn from(variant: READY_START_A) -> Self {
50        variant as u8 != 0
51    }
52}
53impl READY_START_R {
54    #[doc = "Get enumerated values variant"]
55    #[inline(always)]
56    pub fn variant(&self) -> READY_START_A {
57        match self.bits {
58            false => READY_START_A::DISABLED,
59            true => READY_START_A::ENABLED,
60        }
61    }
62    #[doc = "Checks if the value of the field is `DISABLED`"]
63    #[inline(always)]
64    pub fn is_disabled(&self) -> bool {
65        *self == READY_START_A::DISABLED
66    }
67    #[doc = "Checks if the value of the field is `ENABLED`"]
68    #[inline(always)]
69    pub fn is_enabled(&self) -> bool {
70        *self == READY_START_A::ENABLED
71    }
72}
73#[doc = "Field `READY_START` writer - Shortcut between READY event and START task"]
74pub type READY_START_W<'a, const O: u8> = crate::BitWriter<'a, u32, SHORTS_SPEC, READY_START_A, O>;
75impl<'a, const O: u8> READY_START_W<'a, O> {
76    #[doc = "Disable shortcut"]
77    #[inline(always)]
78    pub fn disabled(self) -> &'a mut W {
79        self.variant(READY_START_A::DISABLED)
80    }
81    #[doc = "Enable shortcut"]
82    #[inline(always)]
83    pub fn enabled(self) -> &'a mut W {
84        self.variant(READY_START_A::ENABLED)
85    }
86}
87#[doc = "Field `END_DISABLE` reader - Shortcut between END event and DISABLE task"]
88pub type END_DISABLE_R = crate::BitReader<END_DISABLE_A>;
89#[doc = "Shortcut between END event and DISABLE task\n\nValue on reset: 0"]
90#[derive(Clone, Copy, Debug, PartialEq)]
91pub enum END_DISABLE_A {
92    #[doc = "0: Disable shortcut"]
93    DISABLED = 0,
94    #[doc = "1: Enable shortcut"]
95    ENABLED = 1,
96}
97impl From<END_DISABLE_A> for bool {
98    #[inline(always)]
99    fn from(variant: END_DISABLE_A) -> Self {
100        variant as u8 != 0
101    }
102}
103impl END_DISABLE_R {
104    #[doc = "Get enumerated values variant"]
105    #[inline(always)]
106    pub fn variant(&self) -> END_DISABLE_A {
107        match self.bits {
108            false => END_DISABLE_A::DISABLED,
109            true => END_DISABLE_A::ENABLED,
110        }
111    }
112    #[doc = "Checks if the value of the field is `DISABLED`"]
113    #[inline(always)]
114    pub fn is_disabled(&self) -> bool {
115        *self == END_DISABLE_A::DISABLED
116    }
117    #[doc = "Checks if the value of the field is `ENABLED`"]
118    #[inline(always)]
119    pub fn is_enabled(&self) -> bool {
120        *self == END_DISABLE_A::ENABLED
121    }
122}
123#[doc = "Field `END_DISABLE` writer - Shortcut between END event and DISABLE task"]
124pub type END_DISABLE_W<'a, const O: u8> = crate::BitWriter<'a, u32, SHORTS_SPEC, END_DISABLE_A, O>;
125impl<'a, const O: u8> END_DISABLE_W<'a, O> {
126    #[doc = "Disable shortcut"]
127    #[inline(always)]
128    pub fn disabled(self) -> &'a mut W {
129        self.variant(END_DISABLE_A::DISABLED)
130    }
131    #[doc = "Enable shortcut"]
132    #[inline(always)]
133    pub fn enabled(self) -> &'a mut W {
134        self.variant(END_DISABLE_A::ENABLED)
135    }
136}
137#[doc = "Field `DISABLED_TXEN` reader - Shortcut between DISABLED event and TXEN task"]
138pub type DISABLED_TXEN_R = crate::BitReader<DISABLED_TXEN_A>;
139#[doc = "Shortcut between DISABLED event and TXEN task\n\nValue on reset: 0"]
140#[derive(Clone, Copy, Debug, PartialEq)]
141pub enum DISABLED_TXEN_A {
142    #[doc = "0: Disable shortcut"]
143    DISABLED = 0,
144    #[doc = "1: Enable shortcut"]
145    ENABLED = 1,
146}
147impl From<DISABLED_TXEN_A> for bool {
148    #[inline(always)]
149    fn from(variant: DISABLED_TXEN_A) -> Self {
150        variant as u8 != 0
151    }
152}
153impl DISABLED_TXEN_R {
154    #[doc = "Get enumerated values variant"]
155    #[inline(always)]
156    pub fn variant(&self) -> DISABLED_TXEN_A {
157        match self.bits {
158            false => DISABLED_TXEN_A::DISABLED,
159            true => DISABLED_TXEN_A::ENABLED,
160        }
161    }
162    #[doc = "Checks if the value of the field is `DISABLED`"]
163    #[inline(always)]
164    pub fn is_disabled(&self) -> bool {
165        *self == DISABLED_TXEN_A::DISABLED
166    }
167    #[doc = "Checks if the value of the field is `ENABLED`"]
168    #[inline(always)]
169    pub fn is_enabled(&self) -> bool {
170        *self == DISABLED_TXEN_A::ENABLED
171    }
172}
173#[doc = "Field `DISABLED_TXEN` writer - Shortcut between DISABLED event and TXEN task"]
174pub type DISABLED_TXEN_W<'a, const O: u8> =
175    crate::BitWriter<'a, u32, SHORTS_SPEC, DISABLED_TXEN_A, O>;
176impl<'a, const O: u8> DISABLED_TXEN_W<'a, O> {
177    #[doc = "Disable shortcut"]
178    #[inline(always)]
179    pub fn disabled(self) -> &'a mut W {
180        self.variant(DISABLED_TXEN_A::DISABLED)
181    }
182    #[doc = "Enable shortcut"]
183    #[inline(always)]
184    pub fn enabled(self) -> &'a mut W {
185        self.variant(DISABLED_TXEN_A::ENABLED)
186    }
187}
188#[doc = "Field `DISABLED_RXEN` reader - Shortcut between DISABLED event and RXEN task"]
189pub type DISABLED_RXEN_R = crate::BitReader<DISABLED_RXEN_A>;
190#[doc = "Shortcut between DISABLED event and RXEN task\n\nValue on reset: 0"]
191#[derive(Clone, Copy, Debug, PartialEq)]
192pub enum DISABLED_RXEN_A {
193    #[doc = "0: Disable shortcut"]
194    DISABLED = 0,
195    #[doc = "1: Enable shortcut"]
196    ENABLED = 1,
197}
198impl From<DISABLED_RXEN_A> for bool {
199    #[inline(always)]
200    fn from(variant: DISABLED_RXEN_A) -> Self {
201        variant as u8 != 0
202    }
203}
204impl DISABLED_RXEN_R {
205    #[doc = "Get enumerated values variant"]
206    #[inline(always)]
207    pub fn variant(&self) -> DISABLED_RXEN_A {
208        match self.bits {
209            false => DISABLED_RXEN_A::DISABLED,
210            true => DISABLED_RXEN_A::ENABLED,
211        }
212    }
213    #[doc = "Checks if the value of the field is `DISABLED`"]
214    #[inline(always)]
215    pub fn is_disabled(&self) -> bool {
216        *self == DISABLED_RXEN_A::DISABLED
217    }
218    #[doc = "Checks if the value of the field is `ENABLED`"]
219    #[inline(always)]
220    pub fn is_enabled(&self) -> bool {
221        *self == DISABLED_RXEN_A::ENABLED
222    }
223}
224#[doc = "Field `DISABLED_RXEN` writer - Shortcut between DISABLED event and RXEN task"]
225pub type DISABLED_RXEN_W<'a, const O: u8> =
226    crate::BitWriter<'a, u32, SHORTS_SPEC, DISABLED_RXEN_A, O>;
227impl<'a, const O: u8> DISABLED_RXEN_W<'a, O> {
228    #[doc = "Disable shortcut"]
229    #[inline(always)]
230    pub fn disabled(self) -> &'a mut W {
231        self.variant(DISABLED_RXEN_A::DISABLED)
232    }
233    #[doc = "Enable shortcut"]
234    #[inline(always)]
235    pub fn enabled(self) -> &'a mut W {
236        self.variant(DISABLED_RXEN_A::ENABLED)
237    }
238}
239#[doc = "Field `ADDRESS_RSSISTART` reader - Shortcut between ADDRESS event and RSSISTART task"]
240pub type ADDRESS_RSSISTART_R = crate::BitReader<ADDRESS_RSSISTART_A>;
241#[doc = "Shortcut between ADDRESS event and RSSISTART task\n\nValue on reset: 0"]
242#[derive(Clone, Copy, Debug, PartialEq)]
243pub enum ADDRESS_RSSISTART_A {
244    #[doc = "0: Disable shortcut"]
245    DISABLED = 0,
246    #[doc = "1: Enable shortcut"]
247    ENABLED = 1,
248}
249impl From<ADDRESS_RSSISTART_A> for bool {
250    #[inline(always)]
251    fn from(variant: ADDRESS_RSSISTART_A) -> Self {
252        variant as u8 != 0
253    }
254}
255impl ADDRESS_RSSISTART_R {
256    #[doc = "Get enumerated values variant"]
257    #[inline(always)]
258    pub fn variant(&self) -> ADDRESS_RSSISTART_A {
259        match self.bits {
260            false => ADDRESS_RSSISTART_A::DISABLED,
261            true => ADDRESS_RSSISTART_A::ENABLED,
262        }
263    }
264    #[doc = "Checks if the value of the field is `DISABLED`"]
265    #[inline(always)]
266    pub fn is_disabled(&self) -> bool {
267        *self == ADDRESS_RSSISTART_A::DISABLED
268    }
269    #[doc = "Checks if the value of the field is `ENABLED`"]
270    #[inline(always)]
271    pub fn is_enabled(&self) -> bool {
272        *self == ADDRESS_RSSISTART_A::ENABLED
273    }
274}
275#[doc = "Field `ADDRESS_RSSISTART` writer - Shortcut between ADDRESS event and RSSISTART task"]
276pub type ADDRESS_RSSISTART_W<'a, const O: u8> =
277    crate::BitWriter<'a, u32, SHORTS_SPEC, ADDRESS_RSSISTART_A, O>;
278impl<'a, const O: u8> ADDRESS_RSSISTART_W<'a, O> {
279    #[doc = "Disable shortcut"]
280    #[inline(always)]
281    pub fn disabled(self) -> &'a mut W {
282        self.variant(ADDRESS_RSSISTART_A::DISABLED)
283    }
284    #[doc = "Enable shortcut"]
285    #[inline(always)]
286    pub fn enabled(self) -> &'a mut W {
287        self.variant(ADDRESS_RSSISTART_A::ENABLED)
288    }
289}
290#[doc = "Field `END_START` reader - Shortcut between END event and START task"]
291pub type END_START_R = crate::BitReader<END_START_A>;
292#[doc = "Shortcut between END event and START task\n\nValue on reset: 0"]
293#[derive(Clone, Copy, Debug, PartialEq)]
294pub enum END_START_A {
295    #[doc = "0: Disable shortcut"]
296    DISABLED = 0,
297    #[doc = "1: Enable shortcut"]
298    ENABLED = 1,
299}
300impl From<END_START_A> for bool {
301    #[inline(always)]
302    fn from(variant: END_START_A) -> Self {
303        variant as u8 != 0
304    }
305}
306impl END_START_R {
307    #[doc = "Get enumerated values variant"]
308    #[inline(always)]
309    pub fn variant(&self) -> END_START_A {
310        match self.bits {
311            false => END_START_A::DISABLED,
312            true => END_START_A::ENABLED,
313        }
314    }
315    #[doc = "Checks if the value of the field is `DISABLED`"]
316    #[inline(always)]
317    pub fn is_disabled(&self) -> bool {
318        *self == END_START_A::DISABLED
319    }
320    #[doc = "Checks if the value of the field is `ENABLED`"]
321    #[inline(always)]
322    pub fn is_enabled(&self) -> bool {
323        *self == END_START_A::ENABLED
324    }
325}
326#[doc = "Field `END_START` writer - Shortcut between END event and START task"]
327pub type END_START_W<'a, const O: u8> = crate::BitWriter<'a, u32, SHORTS_SPEC, END_START_A, O>;
328impl<'a, const O: u8> END_START_W<'a, O> {
329    #[doc = "Disable shortcut"]
330    #[inline(always)]
331    pub fn disabled(self) -> &'a mut W {
332        self.variant(END_START_A::DISABLED)
333    }
334    #[doc = "Enable shortcut"]
335    #[inline(always)]
336    pub fn enabled(self) -> &'a mut W {
337        self.variant(END_START_A::ENABLED)
338    }
339}
340#[doc = "Field `ADDRESS_BCSTART` reader - Shortcut between ADDRESS event and BCSTART task"]
341pub type ADDRESS_BCSTART_R = crate::BitReader<ADDRESS_BCSTART_A>;
342#[doc = "Shortcut between ADDRESS event and BCSTART task\n\nValue on reset: 0"]
343#[derive(Clone, Copy, Debug, PartialEq)]
344pub enum ADDRESS_BCSTART_A {
345    #[doc = "0: Disable shortcut"]
346    DISABLED = 0,
347    #[doc = "1: Enable shortcut"]
348    ENABLED = 1,
349}
350impl From<ADDRESS_BCSTART_A> for bool {
351    #[inline(always)]
352    fn from(variant: ADDRESS_BCSTART_A) -> Self {
353        variant as u8 != 0
354    }
355}
356impl ADDRESS_BCSTART_R {
357    #[doc = "Get enumerated values variant"]
358    #[inline(always)]
359    pub fn variant(&self) -> ADDRESS_BCSTART_A {
360        match self.bits {
361            false => ADDRESS_BCSTART_A::DISABLED,
362            true => ADDRESS_BCSTART_A::ENABLED,
363        }
364    }
365    #[doc = "Checks if the value of the field is `DISABLED`"]
366    #[inline(always)]
367    pub fn is_disabled(&self) -> bool {
368        *self == ADDRESS_BCSTART_A::DISABLED
369    }
370    #[doc = "Checks if the value of the field is `ENABLED`"]
371    #[inline(always)]
372    pub fn is_enabled(&self) -> bool {
373        *self == ADDRESS_BCSTART_A::ENABLED
374    }
375}
376#[doc = "Field `ADDRESS_BCSTART` writer - Shortcut between ADDRESS event and BCSTART task"]
377pub type ADDRESS_BCSTART_W<'a, const O: u8> =
378    crate::BitWriter<'a, u32, SHORTS_SPEC, ADDRESS_BCSTART_A, O>;
379impl<'a, const O: u8> ADDRESS_BCSTART_W<'a, O> {
380    #[doc = "Disable shortcut"]
381    #[inline(always)]
382    pub fn disabled(self) -> &'a mut W {
383        self.variant(ADDRESS_BCSTART_A::DISABLED)
384    }
385    #[doc = "Enable shortcut"]
386    #[inline(always)]
387    pub fn enabled(self) -> &'a mut W {
388        self.variant(ADDRESS_BCSTART_A::ENABLED)
389    }
390}
391#[doc = "Field `DISABLED_RSSISTOP` reader - Shortcut between DISABLED event and RSSISTOP task"]
392pub type DISABLED_RSSISTOP_R = crate::BitReader<DISABLED_RSSISTOP_A>;
393#[doc = "Shortcut between DISABLED event and RSSISTOP task\n\nValue on reset: 0"]
394#[derive(Clone, Copy, Debug, PartialEq)]
395pub enum DISABLED_RSSISTOP_A {
396    #[doc = "0: Disable shortcut"]
397    DISABLED = 0,
398    #[doc = "1: Enable shortcut"]
399    ENABLED = 1,
400}
401impl From<DISABLED_RSSISTOP_A> for bool {
402    #[inline(always)]
403    fn from(variant: DISABLED_RSSISTOP_A) -> Self {
404        variant as u8 != 0
405    }
406}
407impl DISABLED_RSSISTOP_R {
408    #[doc = "Get enumerated values variant"]
409    #[inline(always)]
410    pub fn variant(&self) -> DISABLED_RSSISTOP_A {
411        match self.bits {
412            false => DISABLED_RSSISTOP_A::DISABLED,
413            true => DISABLED_RSSISTOP_A::ENABLED,
414        }
415    }
416    #[doc = "Checks if the value of the field is `DISABLED`"]
417    #[inline(always)]
418    pub fn is_disabled(&self) -> bool {
419        *self == DISABLED_RSSISTOP_A::DISABLED
420    }
421    #[doc = "Checks if the value of the field is `ENABLED`"]
422    #[inline(always)]
423    pub fn is_enabled(&self) -> bool {
424        *self == DISABLED_RSSISTOP_A::ENABLED
425    }
426}
427#[doc = "Field `DISABLED_RSSISTOP` writer - Shortcut between DISABLED event and RSSISTOP task"]
428pub type DISABLED_RSSISTOP_W<'a, const O: u8> =
429    crate::BitWriter<'a, u32, SHORTS_SPEC, DISABLED_RSSISTOP_A, O>;
430impl<'a, const O: u8> DISABLED_RSSISTOP_W<'a, O> {
431    #[doc = "Disable shortcut"]
432    #[inline(always)]
433    pub fn disabled(self) -> &'a mut W {
434        self.variant(DISABLED_RSSISTOP_A::DISABLED)
435    }
436    #[doc = "Enable shortcut"]
437    #[inline(always)]
438    pub fn enabled(self) -> &'a mut W {
439        self.variant(DISABLED_RSSISTOP_A::ENABLED)
440    }
441}
442#[doc = "Field `RXREADY_CCASTART` reader - Shortcut between RXREADY event and CCASTART task"]
443pub type RXREADY_CCASTART_R = crate::BitReader<RXREADY_CCASTART_A>;
444#[doc = "Shortcut between RXREADY event and CCASTART task\n\nValue on reset: 0"]
445#[derive(Clone, Copy, Debug, PartialEq)]
446pub enum RXREADY_CCASTART_A {
447    #[doc = "0: Disable shortcut"]
448    DISABLED = 0,
449    #[doc = "1: Enable shortcut"]
450    ENABLED = 1,
451}
452impl From<RXREADY_CCASTART_A> for bool {
453    #[inline(always)]
454    fn from(variant: RXREADY_CCASTART_A) -> Self {
455        variant as u8 != 0
456    }
457}
458impl RXREADY_CCASTART_R {
459    #[doc = "Get enumerated values variant"]
460    #[inline(always)]
461    pub fn variant(&self) -> RXREADY_CCASTART_A {
462        match self.bits {
463            false => RXREADY_CCASTART_A::DISABLED,
464            true => RXREADY_CCASTART_A::ENABLED,
465        }
466    }
467    #[doc = "Checks if the value of the field is `DISABLED`"]
468    #[inline(always)]
469    pub fn is_disabled(&self) -> bool {
470        *self == RXREADY_CCASTART_A::DISABLED
471    }
472    #[doc = "Checks if the value of the field is `ENABLED`"]
473    #[inline(always)]
474    pub fn is_enabled(&self) -> bool {
475        *self == RXREADY_CCASTART_A::ENABLED
476    }
477}
478#[doc = "Field `RXREADY_CCASTART` writer - Shortcut between RXREADY event and CCASTART task"]
479pub type RXREADY_CCASTART_W<'a, const O: u8> =
480    crate::BitWriter<'a, u32, SHORTS_SPEC, RXREADY_CCASTART_A, O>;
481impl<'a, const O: u8> RXREADY_CCASTART_W<'a, O> {
482    #[doc = "Disable shortcut"]
483    #[inline(always)]
484    pub fn disabled(self) -> &'a mut W {
485        self.variant(RXREADY_CCASTART_A::DISABLED)
486    }
487    #[doc = "Enable shortcut"]
488    #[inline(always)]
489    pub fn enabled(self) -> &'a mut W {
490        self.variant(RXREADY_CCASTART_A::ENABLED)
491    }
492}
493#[doc = "Field `CCAIDLE_TXEN` reader - Shortcut between CCAIDLE event and TXEN task"]
494pub type CCAIDLE_TXEN_R = crate::BitReader<CCAIDLE_TXEN_A>;
495#[doc = "Shortcut between CCAIDLE event and TXEN task\n\nValue on reset: 0"]
496#[derive(Clone, Copy, Debug, PartialEq)]
497pub enum CCAIDLE_TXEN_A {
498    #[doc = "0: Disable shortcut"]
499    DISABLED = 0,
500    #[doc = "1: Enable shortcut"]
501    ENABLED = 1,
502}
503impl From<CCAIDLE_TXEN_A> for bool {
504    #[inline(always)]
505    fn from(variant: CCAIDLE_TXEN_A) -> Self {
506        variant as u8 != 0
507    }
508}
509impl CCAIDLE_TXEN_R {
510    #[doc = "Get enumerated values variant"]
511    #[inline(always)]
512    pub fn variant(&self) -> CCAIDLE_TXEN_A {
513        match self.bits {
514            false => CCAIDLE_TXEN_A::DISABLED,
515            true => CCAIDLE_TXEN_A::ENABLED,
516        }
517    }
518    #[doc = "Checks if the value of the field is `DISABLED`"]
519    #[inline(always)]
520    pub fn is_disabled(&self) -> bool {
521        *self == CCAIDLE_TXEN_A::DISABLED
522    }
523    #[doc = "Checks if the value of the field is `ENABLED`"]
524    #[inline(always)]
525    pub fn is_enabled(&self) -> bool {
526        *self == CCAIDLE_TXEN_A::ENABLED
527    }
528}
529#[doc = "Field `CCAIDLE_TXEN` writer - Shortcut between CCAIDLE event and TXEN task"]
530pub type CCAIDLE_TXEN_W<'a, const O: u8> =
531    crate::BitWriter<'a, u32, SHORTS_SPEC, CCAIDLE_TXEN_A, O>;
532impl<'a, const O: u8> CCAIDLE_TXEN_W<'a, O> {
533    #[doc = "Disable shortcut"]
534    #[inline(always)]
535    pub fn disabled(self) -> &'a mut W {
536        self.variant(CCAIDLE_TXEN_A::DISABLED)
537    }
538    #[doc = "Enable shortcut"]
539    #[inline(always)]
540    pub fn enabled(self) -> &'a mut W {
541        self.variant(CCAIDLE_TXEN_A::ENABLED)
542    }
543}
544#[doc = "Field `CCABUSY_DISABLE` reader - Shortcut between CCABUSY event and DISABLE task"]
545pub type CCABUSY_DISABLE_R = crate::BitReader<CCABUSY_DISABLE_A>;
546#[doc = "Shortcut between CCABUSY event and DISABLE task\n\nValue on reset: 0"]
547#[derive(Clone, Copy, Debug, PartialEq)]
548pub enum CCABUSY_DISABLE_A {
549    #[doc = "0: Disable shortcut"]
550    DISABLED = 0,
551    #[doc = "1: Enable shortcut"]
552    ENABLED = 1,
553}
554impl From<CCABUSY_DISABLE_A> for bool {
555    #[inline(always)]
556    fn from(variant: CCABUSY_DISABLE_A) -> Self {
557        variant as u8 != 0
558    }
559}
560impl CCABUSY_DISABLE_R {
561    #[doc = "Get enumerated values variant"]
562    #[inline(always)]
563    pub fn variant(&self) -> CCABUSY_DISABLE_A {
564        match self.bits {
565            false => CCABUSY_DISABLE_A::DISABLED,
566            true => CCABUSY_DISABLE_A::ENABLED,
567        }
568    }
569    #[doc = "Checks if the value of the field is `DISABLED`"]
570    #[inline(always)]
571    pub fn is_disabled(&self) -> bool {
572        *self == CCABUSY_DISABLE_A::DISABLED
573    }
574    #[doc = "Checks if the value of the field is `ENABLED`"]
575    #[inline(always)]
576    pub fn is_enabled(&self) -> bool {
577        *self == CCABUSY_DISABLE_A::ENABLED
578    }
579}
580#[doc = "Field `CCABUSY_DISABLE` writer - Shortcut between CCABUSY event and DISABLE task"]
581pub type CCABUSY_DISABLE_W<'a, const O: u8> =
582    crate::BitWriter<'a, u32, SHORTS_SPEC, CCABUSY_DISABLE_A, O>;
583impl<'a, const O: u8> CCABUSY_DISABLE_W<'a, O> {
584    #[doc = "Disable shortcut"]
585    #[inline(always)]
586    pub fn disabled(self) -> &'a mut W {
587        self.variant(CCABUSY_DISABLE_A::DISABLED)
588    }
589    #[doc = "Enable shortcut"]
590    #[inline(always)]
591    pub fn enabled(self) -> &'a mut W {
592        self.variant(CCABUSY_DISABLE_A::ENABLED)
593    }
594}
595#[doc = "Field `FRAMESTART_BCSTART` reader - Shortcut between FRAMESTART event and BCSTART task"]
596pub type FRAMESTART_BCSTART_R = crate::BitReader<FRAMESTART_BCSTART_A>;
597#[doc = "Shortcut between FRAMESTART event and BCSTART task\n\nValue on reset: 0"]
598#[derive(Clone, Copy, Debug, PartialEq)]
599pub enum FRAMESTART_BCSTART_A {
600    #[doc = "0: Disable shortcut"]
601    DISABLED = 0,
602    #[doc = "1: Enable shortcut"]
603    ENABLED = 1,
604}
605impl From<FRAMESTART_BCSTART_A> for bool {
606    #[inline(always)]
607    fn from(variant: FRAMESTART_BCSTART_A) -> Self {
608        variant as u8 != 0
609    }
610}
611impl FRAMESTART_BCSTART_R {
612    #[doc = "Get enumerated values variant"]
613    #[inline(always)]
614    pub fn variant(&self) -> FRAMESTART_BCSTART_A {
615        match self.bits {
616            false => FRAMESTART_BCSTART_A::DISABLED,
617            true => FRAMESTART_BCSTART_A::ENABLED,
618        }
619    }
620    #[doc = "Checks if the value of the field is `DISABLED`"]
621    #[inline(always)]
622    pub fn is_disabled(&self) -> bool {
623        *self == FRAMESTART_BCSTART_A::DISABLED
624    }
625    #[doc = "Checks if the value of the field is `ENABLED`"]
626    #[inline(always)]
627    pub fn is_enabled(&self) -> bool {
628        *self == FRAMESTART_BCSTART_A::ENABLED
629    }
630}
631#[doc = "Field `FRAMESTART_BCSTART` writer - Shortcut between FRAMESTART event and BCSTART task"]
632pub type FRAMESTART_BCSTART_W<'a, const O: u8> =
633    crate::BitWriter<'a, u32, SHORTS_SPEC, FRAMESTART_BCSTART_A, O>;
634impl<'a, const O: u8> FRAMESTART_BCSTART_W<'a, O> {
635    #[doc = "Disable shortcut"]
636    #[inline(always)]
637    pub fn disabled(self) -> &'a mut W {
638        self.variant(FRAMESTART_BCSTART_A::DISABLED)
639    }
640    #[doc = "Enable shortcut"]
641    #[inline(always)]
642    pub fn enabled(self) -> &'a mut W {
643        self.variant(FRAMESTART_BCSTART_A::ENABLED)
644    }
645}
646#[doc = "Field `READY_EDSTART` reader - Shortcut between READY event and EDSTART task"]
647pub type READY_EDSTART_R = crate::BitReader<READY_EDSTART_A>;
648#[doc = "Shortcut between READY event and EDSTART task\n\nValue on reset: 0"]
649#[derive(Clone, Copy, Debug, PartialEq)]
650pub enum READY_EDSTART_A {
651    #[doc = "0: Disable shortcut"]
652    DISABLED = 0,
653    #[doc = "1: Enable shortcut"]
654    ENABLED = 1,
655}
656impl From<READY_EDSTART_A> for bool {
657    #[inline(always)]
658    fn from(variant: READY_EDSTART_A) -> Self {
659        variant as u8 != 0
660    }
661}
662impl READY_EDSTART_R {
663    #[doc = "Get enumerated values variant"]
664    #[inline(always)]
665    pub fn variant(&self) -> READY_EDSTART_A {
666        match self.bits {
667            false => READY_EDSTART_A::DISABLED,
668            true => READY_EDSTART_A::ENABLED,
669        }
670    }
671    #[doc = "Checks if the value of the field is `DISABLED`"]
672    #[inline(always)]
673    pub fn is_disabled(&self) -> bool {
674        *self == READY_EDSTART_A::DISABLED
675    }
676    #[doc = "Checks if the value of the field is `ENABLED`"]
677    #[inline(always)]
678    pub fn is_enabled(&self) -> bool {
679        *self == READY_EDSTART_A::ENABLED
680    }
681}
682#[doc = "Field `READY_EDSTART` writer - Shortcut between READY event and EDSTART task"]
683pub type READY_EDSTART_W<'a, const O: u8> =
684    crate::BitWriter<'a, u32, SHORTS_SPEC, READY_EDSTART_A, O>;
685impl<'a, const O: u8> READY_EDSTART_W<'a, O> {
686    #[doc = "Disable shortcut"]
687    #[inline(always)]
688    pub fn disabled(self) -> &'a mut W {
689        self.variant(READY_EDSTART_A::DISABLED)
690    }
691    #[doc = "Enable shortcut"]
692    #[inline(always)]
693    pub fn enabled(self) -> &'a mut W {
694        self.variant(READY_EDSTART_A::ENABLED)
695    }
696}
697#[doc = "Field `EDEND_DISABLE` reader - Shortcut between EDEND event and DISABLE task"]
698pub type EDEND_DISABLE_R = crate::BitReader<EDEND_DISABLE_A>;
699#[doc = "Shortcut between EDEND event and DISABLE task\n\nValue on reset: 0"]
700#[derive(Clone, Copy, Debug, PartialEq)]
701pub enum EDEND_DISABLE_A {
702    #[doc = "0: Disable shortcut"]
703    DISABLED = 0,
704    #[doc = "1: Enable shortcut"]
705    ENABLED = 1,
706}
707impl From<EDEND_DISABLE_A> for bool {
708    #[inline(always)]
709    fn from(variant: EDEND_DISABLE_A) -> Self {
710        variant as u8 != 0
711    }
712}
713impl EDEND_DISABLE_R {
714    #[doc = "Get enumerated values variant"]
715    #[inline(always)]
716    pub fn variant(&self) -> EDEND_DISABLE_A {
717        match self.bits {
718            false => EDEND_DISABLE_A::DISABLED,
719            true => EDEND_DISABLE_A::ENABLED,
720        }
721    }
722    #[doc = "Checks if the value of the field is `DISABLED`"]
723    #[inline(always)]
724    pub fn is_disabled(&self) -> bool {
725        *self == EDEND_DISABLE_A::DISABLED
726    }
727    #[doc = "Checks if the value of the field is `ENABLED`"]
728    #[inline(always)]
729    pub fn is_enabled(&self) -> bool {
730        *self == EDEND_DISABLE_A::ENABLED
731    }
732}
733#[doc = "Field `EDEND_DISABLE` writer - Shortcut between EDEND event and DISABLE task"]
734pub type EDEND_DISABLE_W<'a, const O: u8> =
735    crate::BitWriter<'a, u32, SHORTS_SPEC, EDEND_DISABLE_A, O>;
736impl<'a, const O: u8> EDEND_DISABLE_W<'a, O> {
737    #[doc = "Disable shortcut"]
738    #[inline(always)]
739    pub fn disabled(self) -> &'a mut W {
740        self.variant(EDEND_DISABLE_A::DISABLED)
741    }
742    #[doc = "Enable shortcut"]
743    #[inline(always)]
744    pub fn enabled(self) -> &'a mut W {
745        self.variant(EDEND_DISABLE_A::ENABLED)
746    }
747}
748#[doc = "Field `CCAIDLE_STOP` reader - Shortcut between CCAIDLE event and STOP task"]
749pub type CCAIDLE_STOP_R = crate::BitReader<CCAIDLE_STOP_A>;
750#[doc = "Shortcut between CCAIDLE event and STOP task\n\nValue on reset: 0"]
751#[derive(Clone, Copy, Debug, PartialEq)]
752pub enum CCAIDLE_STOP_A {
753    #[doc = "0: Disable shortcut"]
754    DISABLED = 0,
755    #[doc = "1: Enable shortcut"]
756    ENABLED = 1,
757}
758impl From<CCAIDLE_STOP_A> for bool {
759    #[inline(always)]
760    fn from(variant: CCAIDLE_STOP_A) -> Self {
761        variant as u8 != 0
762    }
763}
764impl CCAIDLE_STOP_R {
765    #[doc = "Get enumerated values variant"]
766    #[inline(always)]
767    pub fn variant(&self) -> CCAIDLE_STOP_A {
768        match self.bits {
769            false => CCAIDLE_STOP_A::DISABLED,
770            true => CCAIDLE_STOP_A::ENABLED,
771        }
772    }
773    #[doc = "Checks if the value of the field is `DISABLED`"]
774    #[inline(always)]
775    pub fn is_disabled(&self) -> bool {
776        *self == CCAIDLE_STOP_A::DISABLED
777    }
778    #[doc = "Checks if the value of the field is `ENABLED`"]
779    #[inline(always)]
780    pub fn is_enabled(&self) -> bool {
781        *self == CCAIDLE_STOP_A::ENABLED
782    }
783}
784#[doc = "Field `CCAIDLE_STOP` writer - Shortcut between CCAIDLE event and STOP task"]
785pub type CCAIDLE_STOP_W<'a, const O: u8> =
786    crate::BitWriter<'a, u32, SHORTS_SPEC, CCAIDLE_STOP_A, O>;
787impl<'a, const O: u8> CCAIDLE_STOP_W<'a, O> {
788    #[doc = "Disable shortcut"]
789    #[inline(always)]
790    pub fn disabled(self) -> &'a mut W {
791        self.variant(CCAIDLE_STOP_A::DISABLED)
792    }
793    #[doc = "Enable shortcut"]
794    #[inline(always)]
795    pub fn enabled(self) -> &'a mut W {
796        self.variant(CCAIDLE_STOP_A::ENABLED)
797    }
798}
799#[doc = "Field `TXREADY_START` reader - Shortcut between TXREADY event and START task"]
800pub type TXREADY_START_R = crate::BitReader<TXREADY_START_A>;
801#[doc = "Shortcut between TXREADY event and START task\n\nValue on reset: 0"]
802#[derive(Clone, Copy, Debug, PartialEq)]
803pub enum TXREADY_START_A {
804    #[doc = "0: Disable shortcut"]
805    DISABLED = 0,
806    #[doc = "1: Enable shortcut"]
807    ENABLED = 1,
808}
809impl From<TXREADY_START_A> for bool {
810    #[inline(always)]
811    fn from(variant: TXREADY_START_A) -> Self {
812        variant as u8 != 0
813    }
814}
815impl TXREADY_START_R {
816    #[doc = "Get enumerated values variant"]
817    #[inline(always)]
818    pub fn variant(&self) -> TXREADY_START_A {
819        match self.bits {
820            false => TXREADY_START_A::DISABLED,
821            true => TXREADY_START_A::ENABLED,
822        }
823    }
824    #[doc = "Checks if the value of the field is `DISABLED`"]
825    #[inline(always)]
826    pub fn is_disabled(&self) -> bool {
827        *self == TXREADY_START_A::DISABLED
828    }
829    #[doc = "Checks if the value of the field is `ENABLED`"]
830    #[inline(always)]
831    pub fn is_enabled(&self) -> bool {
832        *self == TXREADY_START_A::ENABLED
833    }
834}
835#[doc = "Field `TXREADY_START` writer - Shortcut between TXREADY event and START task"]
836pub type TXREADY_START_W<'a, const O: u8> =
837    crate::BitWriter<'a, u32, SHORTS_SPEC, TXREADY_START_A, O>;
838impl<'a, const O: u8> TXREADY_START_W<'a, O> {
839    #[doc = "Disable shortcut"]
840    #[inline(always)]
841    pub fn disabled(self) -> &'a mut W {
842        self.variant(TXREADY_START_A::DISABLED)
843    }
844    #[doc = "Enable shortcut"]
845    #[inline(always)]
846    pub fn enabled(self) -> &'a mut W {
847        self.variant(TXREADY_START_A::ENABLED)
848    }
849}
850#[doc = "Field `RXREADY_START` reader - Shortcut between RXREADY event and START task"]
851pub type RXREADY_START_R = crate::BitReader<RXREADY_START_A>;
852#[doc = "Shortcut between RXREADY event and START task\n\nValue on reset: 0"]
853#[derive(Clone, Copy, Debug, PartialEq)]
854pub enum RXREADY_START_A {
855    #[doc = "0: Disable shortcut"]
856    DISABLED = 0,
857    #[doc = "1: Enable shortcut"]
858    ENABLED = 1,
859}
860impl From<RXREADY_START_A> for bool {
861    #[inline(always)]
862    fn from(variant: RXREADY_START_A) -> Self {
863        variant as u8 != 0
864    }
865}
866impl RXREADY_START_R {
867    #[doc = "Get enumerated values variant"]
868    #[inline(always)]
869    pub fn variant(&self) -> RXREADY_START_A {
870        match self.bits {
871            false => RXREADY_START_A::DISABLED,
872            true => RXREADY_START_A::ENABLED,
873        }
874    }
875    #[doc = "Checks if the value of the field is `DISABLED`"]
876    #[inline(always)]
877    pub fn is_disabled(&self) -> bool {
878        *self == RXREADY_START_A::DISABLED
879    }
880    #[doc = "Checks if the value of the field is `ENABLED`"]
881    #[inline(always)]
882    pub fn is_enabled(&self) -> bool {
883        *self == RXREADY_START_A::ENABLED
884    }
885}
886#[doc = "Field `RXREADY_START` writer - Shortcut between RXREADY event and START task"]
887pub type RXREADY_START_W<'a, const O: u8> =
888    crate::BitWriter<'a, u32, SHORTS_SPEC, RXREADY_START_A, O>;
889impl<'a, const O: u8> RXREADY_START_W<'a, O> {
890    #[doc = "Disable shortcut"]
891    #[inline(always)]
892    pub fn disabled(self) -> &'a mut W {
893        self.variant(RXREADY_START_A::DISABLED)
894    }
895    #[doc = "Enable shortcut"]
896    #[inline(always)]
897    pub fn enabled(self) -> &'a mut W {
898        self.variant(RXREADY_START_A::ENABLED)
899    }
900}
901#[doc = "Field `PHYEND_DISABLE` reader - Shortcut between PHYEND event and DISABLE task"]
902pub type PHYEND_DISABLE_R = crate::BitReader<PHYEND_DISABLE_A>;
903#[doc = "Shortcut between PHYEND event and DISABLE task\n\nValue on reset: 0"]
904#[derive(Clone, Copy, Debug, PartialEq)]
905pub enum PHYEND_DISABLE_A {
906    #[doc = "0: Disable shortcut"]
907    DISABLED = 0,
908    #[doc = "1: Enable shortcut"]
909    ENABLED = 1,
910}
911impl From<PHYEND_DISABLE_A> for bool {
912    #[inline(always)]
913    fn from(variant: PHYEND_DISABLE_A) -> Self {
914        variant as u8 != 0
915    }
916}
917impl PHYEND_DISABLE_R {
918    #[doc = "Get enumerated values variant"]
919    #[inline(always)]
920    pub fn variant(&self) -> PHYEND_DISABLE_A {
921        match self.bits {
922            false => PHYEND_DISABLE_A::DISABLED,
923            true => PHYEND_DISABLE_A::ENABLED,
924        }
925    }
926    #[doc = "Checks if the value of the field is `DISABLED`"]
927    #[inline(always)]
928    pub fn is_disabled(&self) -> bool {
929        *self == PHYEND_DISABLE_A::DISABLED
930    }
931    #[doc = "Checks if the value of the field is `ENABLED`"]
932    #[inline(always)]
933    pub fn is_enabled(&self) -> bool {
934        *self == PHYEND_DISABLE_A::ENABLED
935    }
936}
937#[doc = "Field `PHYEND_DISABLE` writer - Shortcut between PHYEND event and DISABLE task"]
938pub type PHYEND_DISABLE_W<'a, const O: u8> =
939    crate::BitWriter<'a, u32, SHORTS_SPEC, PHYEND_DISABLE_A, O>;
940impl<'a, const O: u8> PHYEND_DISABLE_W<'a, O> {
941    #[doc = "Disable shortcut"]
942    #[inline(always)]
943    pub fn disabled(self) -> &'a mut W {
944        self.variant(PHYEND_DISABLE_A::DISABLED)
945    }
946    #[doc = "Enable shortcut"]
947    #[inline(always)]
948    pub fn enabled(self) -> &'a mut W {
949        self.variant(PHYEND_DISABLE_A::ENABLED)
950    }
951}
952#[doc = "Field `PHYEND_START` reader - Shortcut between PHYEND event and START task"]
953pub type PHYEND_START_R = crate::BitReader<PHYEND_START_A>;
954#[doc = "Shortcut between PHYEND event and START task\n\nValue on reset: 0"]
955#[derive(Clone, Copy, Debug, PartialEq)]
956pub enum PHYEND_START_A {
957    #[doc = "0: Disable shortcut"]
958    DISABLED = 0,
959    #[doc = "1: Enable shortcut"]
960    ENABLED = 1,
961}
962impl From<PHYEND_START_A> for bool {
963    #[inline(always)]
964    fn from(variant: PHYEND_START_A) -> Self {
965        variant as u8 != 0
966    }
967}
968impl PHYEND_START_R {
969    #[doc = "Get enumerated values variant"]
970    #[inline(always)]
971    pub fn variant(&self) -> PHYEND_START_A {
972        match self.bits {
973            false => PHYEND_START_A::DISABLED,
974            true => PHYEND_START_A::ENABLED,
975        }
976    }
977    #[doc = "Checks if the value of the field is `DISABLED`"]
978    #[inline(always)]
979    pub fn is_disabled(&self) -> bool {
980        *self == PHYEND_START_A::DISABLED
981    }
982    #[doc = "Checks if the value of the field is `ENABLED`"]
983    #[inline(always)]
984    pub fn is_enabled(&self) -> bool {
985        *self == PHYEND_START_A::ENABLED
986    }
987}
988#[doc = "Field `PHYEND_START` writer - Shortcut between PHYEND event and START task"]
989pub type PHYEND_START_W<'a, const O: u8> =
990    crate::BitWriter<'a, u32, SHORTS_SPEC, PHYEND_START_A, O>;
991impl<'a, const O: u8> PHYEND_START_W<'a, O> {
992    #[doc = "Disable shortcut"]
993    #[inline(always)]
994    pub fn disabled(self) -> &'a mut W {
995        self.variant(PHYEND_START_A::DISABLED)
996    }
997    #[doc = "Enable shortcut"]
998    #[inline(always)]
999    pub fn enabled(self) -> &'a mut W {
1000        self.variant(PHYEND_START_A::ENABLED)
1001    }
1002}
1003impl R {
1004    #[doc = "Bit 0 - Shortcut between READY event and START task"]
1005    #[inline(always)]
1006    pub fn ready_start(&self) -> READY_START_R {
1007        READY_START_R::new((self.bits & 1) != 0)
1008    }
1009    #[doc = "Bit 1 - Shortcut between END event and DISABLE task"]
1010    #[inline(always)]
1011    pub fn end_disable(&self) -> END_DISABLE_R {
1012        END_DISABLE_R::new(((self.bits >> 1) & 1) != 0)
1013    }
1014    #[doc = "Bit 2 - Shortcut between DISABLED event and TXEN task"]
1015    #[inline(always)]
1016    pub fn disabled_txen(&self) -> DISABLED_TXEN_R {
1017        DISABLED_TXEN_R::new(((self.bits >> 2) & 1) != 0)
1018    }
1019    #[doc = "Bit 3 - Shortcut between DISABLED event and RXEN task"]
1020    #[inline(always)]
1021    pub fn disabled_rxen(&self) -> DISABLED_RXEN_R {
1022        DISABLED_RXEN_R::new(((self.bits >> 3) & 1) != 0)
1023    }
1024    #[doc = "Bit 4 - Shortcut between ADDRESS event and RSSISTART task"]
1025    #[inline(always)]
1026    pub fn address_rssistart(&self) -> ADDRESS_RSSISTART_R {
1027        ADDRESS_RSSISTART_R::new(((self.bits >> 4) & 1) != 0)
1028    }
1029    #[doc = "Bit 5 - Shortcut between END event and START task"]
1030    #[inline(always)]
1031    pub fn end_start(&self) -> END_START_R {
1032        END_START_R::new(((self.bits >> 5) & 1) != 0)
1033    }
1034    #[doc = "Bit 6 - Shortcut between ADDRESS event and BCSTART task"]
1035    #[inline(always)]
1036    pub fn address_bcstart(&self) -> ADDRESS_BCSTART_R {
1037        ADDRESS_BCSTART_R::new(((self.bits >> 6) & 1) != 0)
1038    }
1039    #[doc = "Bit 8 - Shortcut between DISABLED event and RSSISTOP task"]
1040    #[inline(always)]
1041    pub fn disabled_rssistop(&self) -> DISABLED_RSSISTOP_R {
1042        DISABLED_RSSISTOP_R::new(((self.bits >> 8) & 1) != 0)
1043    }
1044    #[doc = "Bit 11 - Shortcut between RXREADY event and CCASTART task"]
1045    #[inline(always)]
1046    pub fn rxready_ccastart(&self) -> RXREADY_CCASTART_R {
1047        RXREADY_CCASTART_R::new(((self.bits >> 11) & 1) != 0)
1048    }
1049    #[doc = "Bit 12 - Shortcut between CCAIDLE event and TXEN task"]
1050    #[inline(always)]
1051    pub fn ccaidle_txen(&self) -> CCAIDLE_TXEN_R {
1052        CCAIDLE_TXEN_R::new(((self.bits >> 12) & 1) != 0)
1053    }
1054    #[doc = "Bit 13 - Shortcut between CCABUSY event and DISABLE task"]
1055    #[inline(always)]
1056    pub fn ccabusy_disable(&self) -> CCABUSY_DISABLE_R {
1057        CCABUSY_DISABLE_R::new(((self.bits >> 13) & 1) != 0)
1058    }
1059    #[doc = "Bit 14 - Shortcut between FRAMESTART event and BCSTART task"]
1060    #[inline(always)]
1061    pub fn framestart_bcstart(&self) -> FRAMESTART_BCSTART_R {
1062        FRAMESTART_BCSTART_R::new(((self.bits >> 14) & 1) != 0)
1063    }
1064    #[doc = "Bit 15 - Shortcut between READY event and EDSTART task"]
1065    #[inline(always)]
1066    pub fn ready_edstart(&self) -> READY_EDSTART_R {
1067        READY_EDSTART_R::new(((self.bits >> 15) & 1) != 0)
1068    }
1069    #[doc = "Bit 16 - Shortcut between EDEND event and DISABLE task"]
1070    #[inline(always)]
1071    pub fn edend_disable(&self) -> EDEND_DISABLE_R {
1072        EDEND_DISABLE_R::new(((self.bits >> 16) & 1) != 0)
1073    }
1074    #[doc = "Bit 17 - Shortcut between CCAIDLE event and STOP task"]
1075    #[inline(always)]
1076    pub fn ccaidle_stop(&self) -> CCAIDLE_STOP_R {
1077        CCAIDLE_STOP_R::new(((self.bits >> 17) & 1) != 0)
1078    }
1079    #[doc = "Bit 18 - Shortcut between TXREADY event and START task"]
1080    #[inline(always)]
1081    pub fn txready_start(&self) -> TXREADY_START_R {
1082        TXREADY_START_R::new(((self.bits >> 18) & 1) != 0)
1083    }
1084    #[doc = "Bit 19 - Shortcut between RXREADY event and START task"]
1085    #[inline(always)]
1086    pub fn rxready_start(&self) -> RXREADY_START_R {
1087        RXREADY_START_R::new(((self.bits >> 19) & 1) != 0)
1088    }
1089    #[doc = "Bit 20 - Shortcut between PHYEND event and DISABLE task"]
1090    #[inline(always)]
1091    pub fn phyend_disable(&self) -> PHYEND_DISABLE_R {
1092        PHYEND_DISABLE_R::new(((self.bits >> 20) & 1) != 0)
1093    }
1094    #[doc = "Bit 21 - Shortcut between PHYEND event and START task"]
1095    #[inline(always)]
1096    pub fn phyend_start(&self) -> PHYEND_START_R {
1097        PHYEND_START_R::new(((self.bits >> 21) & 1) != 0)
1098    }
1099}
1100impl W {
1101    #[doc = "Bit 0 - Shortcut between READY event and START task"]
1102    #[inline(always)]
1103    pub fn ready_start(&mut self) -> READY_START_W<0> {
1104        READY_START_W::new(self)
1105    }
1106    #[doc = "Bit 1 - Shortcut between END event and DISABLE task"]
1107    #[inline(always)]
1108    pub fn end_disable(&mut self) -> END_DISABLE_W<1> {
1109        END_DISABLE_W::new(self)
1110    }
1111    #[doc = "Bit 2 - Shortcut between DISABLED event and TXEN task"]
1112    #[inline(always)]
1113    pub fn disabled_txen(&mut self) -> DISABLED_TXEN_W<2> {
1114        DISABLED_TXEN_W::new(self)
1115    }
1116    #[doc = "Bit 3 - Shortcut between DISABLED event and RXEN task"]
1117    #[inline(always)]
1118    pub fn disabled_rxen(&mut self) -> DISABLED_RXEN_W<3> {
1119        DISABLED_RXEN_W::new(self)
1120    }
1121    #[doc = "Bit 4 - Shortcut between ADDRESS event and RSSISTART task"]
1122    #[inline(always)]
1123    pub fn address_rssistart(&mut self) -> ADDRESS_RSSISTART_W<4> {
1124        ADDRESS_RSSISTART_W::new(self)
1125    }
1126    #[doc = "Bit 5 - Shortcut between END event and START task"]
1127    #[inline(always)]
1128    pub fn end_start(&mut self) -> END_START_W<5> {
1129        END_START_W::new(self)
1130    }
1131    #[doc = "Bit 6 - Shortcut between ADDRESS event and BCSTART task"]
1132    #[inline(always)]
1133    pub fn address_bcstart(&mut self) -> ADDRESS_BCSTART_W<6> {
1134        ADDRESS_BCSTART_W::new(self)
1135    }
1136    #[doc = "Bit 8 - Shortcut between DISABLED event and RSSISTOP task"]
1137    #[inline(always)]
1138    pub fn disabled_rssistop(&mut self) -> DISABLED_RSSISTOP_W<8> {
1139        DISABLED_RSSISTOP_W::new(self)
1140    }
1141    #[doc = "Bit 11 - Shortcut between RXREADY event and CCASTART task"]
1142    #[inline(always)]
1143    pub fn rxready_ccastart(&mut self) -> RXREADY_CCASTART_W<11> {
1144        RXREADY_CCASTART_W::new(self)
1145    }
1146    #[doc = "Bit 12 - Shortcut between CCAIDLE event and TXEN task"]
1147    #[inline(always)]
1148    pub fn ccaidle_txen(&mut self) -> CCAIDLE_TXEN_W<12> {
1149        CCAIDLE_TXEN_W::new(self)
1150    }
1151    #[doc = "Bit 13 - Shortcut between CCABUSY event and DISABLE task"]
1152    #[inline(always)]
1153    pub fn ccabusy_disable(&mut self) -> CCABUSY_DISABLE_W<13> {
1154        CCABUSY_DISABLE_W::new(self)
1155    }
1156    #[doc = "Bit 14 - Shortcut between FRAMESTART event and BCSTART task"]
1157    #[inline(always)]
1158    pub fn framestart_bcstart(&mut self) -> FRAMESTART_BCSTART_W<14> {
1159        FRAMESTART_BCSTART_W::new(self)
1160    }
1161    #[doc = "Bit 15 - Shortcut between READY event and EDSTART task"]
1162    #[inline(always)]
1163    pub fn ready_edstart(&mut self) -> READY_EDSTART_W<15> {
1164        READY_EDSTART_W::new(self)
1165    }
1166    #[doc = "Bit 16 - Shortcut between EDEND event and DISABLE task"]
1167    #[inline(always)]
1168    pub fn edend_disable(&mut self) -> EDEND_DISABLE_W<16> {
1169        EDEND_DISABLE_W::new(self)
1170    }
1171    #[doc = "Bit 17 - Shortcut between CCAIDLE event and STOP task"]
1172    #[inline(always)]
1173    pub fn ccaidle_stop(&mut self) -> CCAIDLE_STOP_W<17> {
1174        CCAIDLE_STOP_W::new(self)
1175    }
1176    #[doc = "Bit 18 - Shortcut between TXREADY event and START task"]
1177    #[inline(always)]
1178    pub fn txready_start(&mut self) -> TXREADY_START_W<18> {
1179        TXREADY_START_W::new(self)
1180    }
1181    #[doc = "Bit 19 - Shortcut between RXREADY event and START task"]
1182    #[inline(always)]
1183    pub fn rxready_start(&mut self) -> RXREADY_START_W<19> {
1184        RXREADY_START_W::new(self)
1185    }
1186    #[doc = "Bit 20 - Shortcut between PHYEND event and DISABLE task"]
1187    #[inline(always)]
1188    pub fn phyend_disable(&mut self) -> PHYEND_DISABLE_W<20> {
1189        PHYEND_DISABLE_W::new(self)
1190    }
1191    #[doc = "Bit 21 - Shortcut between PHYEND event and START task"]
1192    #[inline(always)]
1193    pub fn phyend_start(&mut self) -> PHYEND_START_W<21> {
1194        PHYEND_START_W::new(self)
1195    }
1196    #[doc = "Writes raw bits to the register."]
1197    #[inline(always)]
1198    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1199        self.0.bits(bits);
1200        self
1201    }
1202}
1203#[doc = "Shortcut register\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 [shorts](index.html) module"]
1204pub struct SHORTS_SPEC;
1205impl crate::RegisterSpec for SHORTS_SPEC {
1206    type Ux = u32;
1207}
1208#[doc = "`read()` method returns [shorts::R](R) reader structure"]
1209impl crate::Readable for SHORTS_SPEC {
1210    type Reader = R;
1211}
1212#[doc = "`write(|w| ..)` method takes [shorts::W](W) writer structure"]
1213impl crate::Writable for SHORTS_SPEC {
1214    type Writer = W;
1215}
1216#[doc = "`reset()` method sets SHORTS to value 0"]
1217impl crate::Resettable for SHORTS_SPEC {
1218    #[inline(always)]
1219    fn reset_value() -> Self::Ux {
1220        0
1221    }
1222}
nrf52840_pac/radio/shorts.rs

nrf52840_pac/radio/
shorts.rs
