1#[doc = "Register `GTSTP` reader"]
2pub struct R(crate::R<GTSTP_SPEC>);
3impl core::ops::Deref for R {
4 type Target = crate::R<GTSTP_SPEC>;
5 #[inline(always)]
6 fn deref(&self) -> &Self::Target {
7 &self.0
8 }
9}
10impl From<crate::R<GTSTP_SPEC>> for R {
11 #[inline(always)]
12 fn from(reader: crate::R<GTSTP_SPEC>) -> Self {
13 R(reader)
14 }
15}
16#[doc = "Register `GTSTP` writer"]
17pub struct W(crate::W<GTSTP_SPEC>);
18impl core::ops::Deref for W {
19 type Target = crate::W<GTSTP_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<GTSTP_SPEC>> for W {
32 #[inline(always)]
33 fn from(writer: crate::W<GTSTP_SPEC>) -> Self {
34 W(writer)
35 }
36}
37#[doc = "Field `CSTOP0` reader - Channel 0 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
38pub type CSTOP0_R = crate::BitReader<CSTOP0_A>;
39#[doc = "Channel 0 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop.\n\nValue on reset: 1"]
40#[derive(Clone, Copy, Debug, PartialEq, Eq)]
41pub enum CSTOP0_A {
42 #[doc = "0: No effect (write) / counter running (read)"]
43 _0 = 0,
44 #[doc = "1: GPT32EH0.GTCNT counter stops (write) / Counter stop (read)"]
45 _1 = 1,
46}
47impl From<CSTOP0_A> for bool {
48 #[inline(always)]
49 fn from(variant: CSTOP0_A) -> Self {
50 variant as u8 != 0
51 }
52}
53impl CSTOP0_R {
54 #[doc = "Get enumerated values variant"]
55 #[inline(always)]
56 pub fn variant(&self) -> CSTOP0_A {
57 match self.bits {
58 false => CSTOP0_A::_0,
59 true => CSTOP0_A::_1,
60 }
61 }
62 #[doc = "Checks if the value of the field is `_0`"]
63 #[inline(always)]
64 pub fn is_0(&self) -> bool {
65 *self == CSTOP0_A::_0
66 }
67 #[doc = "Checks if the value of the field is `_1`"]
68 #[inline(always)]
69 pub fn is_1(&self) -> bool {
70 *self == CSTOP0_A::_1
71 }
72}
73#[doc = "Field `CSTOP0` writer - Channel 0 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
74pub type CSTOP0_W<'a, const O: u8> = crate::BitWriter<'a, u32, GTSTP_SPEC, CSTOP0_A, O>;
75impl<'a, const O: u8> CSTOP0_W<'a, O> {
76 #[doc = "No effect (write) / counter running (read)"]
77 #[inline(always)]
78 pub fn _0(self) -> &'a mut W {
79 self.variant(CSTOP0_A::_0)
80 }
81 #[doc = "GPT32EH0.GTCNT counter stops (write) / Counter stop (read)"]
82 #[inline(always)]
83 pub fn _1(self) -> &'a mut W {
84 self.variant(CSTOP0_A::_1)
85 }
86}
87#[doc = "Field `CSTOP1` reader - Channel 1 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
88pub type CSTOP1_R = crate::BitReader<CSTOP1_A>;
89#[doc = "Channel 1 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop.\n\nValue on reset: 1"]
90#[derive(Clone, Copy, Debug, PartialEq, Eq)]
91pub enum CSTOP1_A {
92 #[doc = "0: No effect (write) / counter running (read)"]
93 _0 = 0,
94 #[doc = "1: GPT32EH1.GTCNT counter stops (write) / Counter stop (read)"]
95 _1 = 1,
96}
97impl From<CSTOP1_A> for bool {
98 #[inline(always)]
99 fn from(variant: CSTOP1_A) -> Self {
100 variant as u8 != 0
101 }
102}
103impl CSTOP1_R {
104 #[doc = "Get enumerated values variant"]
105 #[inline(always)]
106 pub fn variant(&self) -> CSTOP1_A {
107 match self.bits {
108 false => CSTOP1_A::_0,
109 true => CSTOP1_A::_1,
110 }
111 }
112 #[doc = "Checks if the value of the field is `_0`"]
113 #[inline(always)]
114 pub fn is_0(&self) -> bool {
115 *self == CSTOP1_A::_0
116 }
117 #[doc = "Checks if the value of the field is `_1`"]
118 #[inline(always)]
119 pub fn is_1(&self) -> bool {
120 *self == CSTOP1_A::_1
121 }
122}
123#[doc = "Field `CSTOP1` writer - Channel 1 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
124pub type CSTOP1_W<'a, const O: u8> = crate::BitWriter<'a, u32, GTSTP_SPEC, CSTOP1_A, O>;
125impl<'a, const O: u8> CSTOP1_W<'a, O> {
126 #[doc = "No effect (write) / counter running (read)"]
127 #[inline(always)]
128 pub fn _0(self) -> &'a mut W {
129 self.variant(CSTOP1_A::_0)
130 }
131 #[doc = "GPT32EH1.GTCNT counter stops (write) / Counter stop (read)"]
132 #[inline(always)]
133 pub fn _1(self) -> &'a mut W {
134 self.variant(CSTOP1_A::_1)
135 }
136}
137#[doc = "Field `CSTOP2` reader - Channel 2 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
138pub type CSTOP2_R = crate::BitReader<CSTOP2_A>;
139#[doc = "Channel 2 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop.\n\nValue on reset: 1"]
140#[derive(Clone, Copy, Debug, PartialEq, Eq)]
141pub enum CSTOP2_A {
142 #[doc = "0: No effect (write) / counter running (read)"]
143 _0 = 0,
144 #[doc = "1: GPT32EH2.GTCNT counter stops (write) / Counter stop (read)"]
145 _1 = 1,
146}
147impl From<CSTOP2_A> for bool {
148 #[inline(always)]
149 fn from(variant: CSTOP2_A) -> Self {
150 variant as u8 != 0
151 }
152}
153impl CSTOP2_R {
154 #[doc = "Get enumerated values variant"]
155 #[inline(always)]
156 pub fn variant(&self) -> CSTOP2_A {
157 match self.bits {
158 false => CSTOP2_A::_0,
159 true => CSTOP2_A::_1,
160 }
161 }
162 #[doc = "Checks if the value of the field is `_0`"]
163 #[inline(always)]
164 pub fn is_0(&self) -> bool {
165 *self == CSTOP2_A::_0
166 }
167 #[doc = "Checks if the value of the field is `_1`"]
168 #[inline(always)]
169 pub fn is_1(&self) -> bool {
170 *self == CSTOP2_A::_1
171 }
172}
173#[doc = "Field `CSTOP2` writer - Channel 2 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
174pub type CSTOP2_W<'a, const O: u8> = crate::BitWriter<'a, u32, GTSTP_SPEC, CSTOP2_A, O>;
175impl<'a, const O: u8> CSTOP2_W<'a, O> {
176 #[doc = "No effect (write) / counter running (read)"]
177 #[inline(always)]
178 pub fn _0(self) -> &'a mut W {
179 self.variant(CSTOP2_A::_0)
180 }
181 #[doc = "GPT32EH2.GTCNT counter stops (write) / Counter stop (read)"]
182 #[inline(always)]
183 pub fn _1(self) -> &'a mut W {
184 self.variant(CSTOP2_A::_1)
185 }
186}
187#[doc = "Field `CSTOP3` reader - Channel 3 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
188pub type CSTOP3_R = crate::BitReader<CSTOP3_A>;
189#[doc = "Channel 3 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop.\n\nValue on reset: 1"]
190#[derive(Clone, Copy, Debug, PartialEq, Eq)]
191pub enum CSTOP3_A {
192 #[doc = "0: No effect (write) / counter running (read)"]
193 _0 = 0,
194 #[doc = "1: GPT32EH3.GTCNT counter stops (write) / Counter stop (read)"]
195 _1 = 1,
196}
197impl From<CSTOP3_A> for bool {
198 #[inline(always)]
199 fn from(variant: CSTOP3_A) -> Self {
200 variant as u8 != 0
201 }
202}
203impl CSTOP3_R {
204 #[doc = "Get enumerated values variant"]
205 #[inline(always)]
206 pub fn variant(&self) -> CSTOP3_A {
207 match self.bits {
208 false => CSTOP3_A::_0,
209 true => CSTOP3_A::_1,
210 }
211 }
212 #[doc = "Checks if the value of the field is `_0`"]
213 #[inline(always)]
214 pub fn is_0(&self) -> bool {
215 *self == CSTOP3_A::_0
216 }
217 #[doc = "Checks if the value of the field is `_1`"]
218 #[inline(always)]
219 pub fn is_1(&self) -> bool {
220 *self == CSTOP3_A::_1
221 }
222}
223#[doc = "Field `CSTOP3` writer - Channel 3 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
224pub type CSTOP3_W<'a, const O: u8> = crate::BitWriter<'a, u32, GTSTP_SPEC, CSTOP3_A, O>;
225impl<'a, const O: u8> CSTOP3_W<'a, O> {
226 #[doc = "No effect (write) / counter running (read)"]
227 #[inline(always)]
228 pub fn _0(self) -> &'a mut W {
229 self.variant(CSTOP3_A::_0)
230 }
231 #[doc = "GPT32EH3.GTCNT counter stops (write) / Counter stop (read)"]
232 #[inline(always)]
233 pub fn _1(self) -> &'a mut W {
234 self.variant(CSTOP3_A::_1)
235 }
236}
237#[doc = "Field `CSTOP4` reader - Channel 4 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
238pub type CSTOP4_R = crate::BitReader<CSTOP4_A>;
239#[doc = "Channel 4 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop.\n\nValue on reset: 1"]
240#[derive(Clone, Copy, Debug, PartialEq, Eq)]
241pub enum CSTOP4_A {
242 #[doc = "0: No effect (write) / counter running (read)"]
243 _0 = 0,
244 #[doc = "1: GPT32E4.GTCNT counter stops (write) / Counter stop (read)"]
245 _1 = 1,
246}
247impl From<CSTOP4_A> for bool {
248 #[inline(always)]
249 fn from(variant: CSTOP4_A) -> Self {
250 variant as u8 != 0
251 }
252}
253impl CSTOP4_R {
254 #[doc = "Get enumerated values variant"]
255 #[inline(always)]
256 pub fn variant(&self) -> CSTOP4_A {
257 match self.bits {
258 false => CSTOP4_A::_0,
259 true => CSTOP4_A::_1,
260 }
261 }
262 #[doc = "Checks if the value of the field is `_0`"]
263 #[inline(always)]
264 pub fn is_0(&self) -> bool {
265 *self == CSTOP4_A::_0
266 }
267 #[doc = "Checks if the value of the field is `_1`"]
268 #[inline(always)]
269 pub fn is_1(&self) -> bool {
270 *self == CSTOP4_A::_1
271 }
272}
273#[doc = "Field `CSTOP4` writer - Channel 4 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
274pub type CSTOP4_W<'a, const O: u8> = crate::BitWriter<'a, u32, GTSTP_SPEC, CSTOP4_A, O>;
275impl<'a, const O: u8> CSTOP4_W<'a, O> {
276 #[doc = "No effect (write) / counter running (read)"]
277 #[inline(always)]
278 pub fn _0(self) -> &'a mut W {
279 self.variant(CSTOP4_A::_0)
280 }
281 #[doc = "GPT32E4.GTCNT counter stops (write) / Counter stop (read)"]
282 #[inline(always)]
283 pub fn _1(self) -> &'a mut W {
284 self.variant(CSTOP4_A::_1)
285 }
286}
287#[doc = "Field `CSTOP5` reader - Channel 5 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
288pub type CSTOP5_R = crate::BitReader<CSTOP5_A>;
289#[doc = "Channel 5 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop.\n\nValue on reset: 1"]
290#[derive(Clone, Copy, Debug, PartialEq, Eq)]
291pub enum CSTOP5_A {
292 #[doc = "0: No effect (write) / counter running (read)"]
293 _0 = 0,
294 #[doc = "1: GPT32E5.GTCNT counter stops (write) / Counter stop (read)"]
295 _1 = 1,
296}
297impl From<CSTOP5_A> for bool {
298 #[inline(always)]
299 fn from(variant: CSTOP5_A) -> Self {
300 variant as u8 != 0
301 }
302}
303impl CSTOP5_R {
304 #[doc = "Get enumerated values variant"]
305 #[inline(always)]
306 pub fn variant(&self) -> CSTOP5_A {
307 match self.bits {
308 false => CSTOP5_A::_0,
309 true => CSTOP5_A::_1,
310 }
311 }
312 #[doc = "Checks if the value of the field is `_0`"]
313 #[inline(always)]
314 pub fn is_0(&self) -> bool {
315 *self == CSTOP5_A::_0
316 }
317 #[doc = "Checks if the value of the field is `_1`"]
318 #[inline(always)]
319 pub fn is_1(&self) -> bool {
320 *self == CSTOP5_A::_1
321 }
322}
323#[doc = "Field `CSTOP5` writer - Channel 5 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
324pub type CSTOP5_W<'a, const O: u8> = crate::BitWriter<'a, u32, GTSTP_SPEC, CSTOP5_A, O>;
325impl<'a, const O: u8> CSTOP5_W<'a, O> {
326 #[doc = "No effect (write) / counter running (read)"]
327 #[inline(always)]
328 pub fn _0(self) -> &'a mut W {
329 self.variant(CSTOP5_A::_0)
330 }
331 #[doc = "GPT32E5.GTCNT counter stops (write) / Counter stop (read)"]
332 #[inline(always)]
333 pub fn _1(self) -> &'a mut W {
334 self.variant(CSTOP5_A::_1)
335 }
336}
337#[doc = "Field `CSTOP6` reader - Channel 6 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
338pub type CSTOP6_R = crate::BitReader<CSTOP6_A>;
339#[doc = "Channel 6 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop.\n\nValue on reset: 1"]
340#[derive(Clone, Copy, Debug, PartialEq, Eq)]
341pub enum CSTOP6_A {
342 #[doc = "0: No effect (write) / counter running (read)"]
343 _0 = 0,
344 #[doc = "1: GPT32E6.GTCNT counter stops (write) / Counter stop (read)"]
345 _1 = 1,
346}
347impl From<CSTOP6_A> for bool {
348 #[inline(always)]
349 fn from(variant: CSTOP6_A) -> Self {
350 variant as u8 != 0
351 }
352}
353impl CSTOP6_R {
354 #[doc = "Get enumerated values variant"]
355 #[inline(always)]
356 pub fn variant(&self) -> CSTOP6_A {
357 match self.bits {
358 false => CSTOP6_A::_0,
359 true => CSTOP6_A::_1,
360 }
361 }
362 #[doc = "Checks if the value of the field is `_0`"]
363 #[inline(always)]
364 pub fn is_0(&self) -> bool {
365 *self == CSTOP6_A::_0
366 }
367 #[doc = "Checks if the value of the field is `_1`"]
368 #[inline(always)]
369 pub fn is_1(&self) -> bool {
370 *self == CSTOP6_A::_1
371 }
372}
373#[doc = "Field `CSTOP6` writer - Channel 6 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
374pub type CSTOP6_W<'a, const O: u8> = crate::BitWriter<'a, u32, GTSTP_SPEC, CSTOP6_A, O>;
375impl<'a, const O: u8> CSTOP6_W<'a, O> {
376 #[doc = "No effect (write) / counter running (read)"]
377 #[inline(always)]
378 pub fn _0(self) -> &'a mut W {
379 self.variant(CSTOP6_A::_0)
380 }
381 #[doc = "GPT32E6.GTCNT counter stops (write) / Counter stop (read)"]
382 #[inline(always)]
383 pub fn _1(self) -> &'a mut W {
384 self.variant(CSTOP6_A::_1)
385 }
386}
387#[doc = "Field `CSTOP7` reader - Channel 7 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
388pub type CSTOP7_R = crate::BitReader<CSTOP7_A>;
389#[doc = "Channel 7 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop.\n\nValue on reset: 1"]
390#[derive(Clone, Copy, Debug, PartialEq, Eq)]
391pub enum CSTOP7_A {
392 #[doc = "0: No effect (write) / counter running (read)"]
393 _0 = 0,
394 #[doc = "1: GPT32E7.GTCNT counter stops (write) / Counter stop (read)"]
395 _1 = 1,
396}
397impl From<CSTOP7_A> for bool {
398 #[inline(always)]
399 fn from(variant: CSTOP7_A) -> Self {
400 variant as u8 != 0
401 }
402}
403impl CSTOP7_R {
404 #[doc = "Get enumerated values variant"]
405 #[inline(always)]
406 pub fn variant(&self) -> CSTOP7_A {
407 match self.bits {
408 false => CSTOP7_A::_0,
409 true => CSTOP7_A::_1,
410 }
411 }
412 #[doc = "Checks if the value of the field is `_0`"]
413 #[inline(always)]
414 pub fn is_0(&self) -> bool {
415 *self == CSTOP7_A::_0
416 }
417 #[doc = "Checks if the value of the field is `_1`"]
418 #[inline(always)]
419 pub fn is_1(&self) -> bool {
420 *self == CSTOP7_A::_1
421 }
422}
423#[doc = "Field `CSTOP7` writer - Channel 7 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
424pub type CSTOP7_W<'a, const O: u8> = crate::BitWriter<'a, u32, GTSTP_SPEC, CSTOP7_A, O>;
425impl<'a, const O: u8> CSTOP7_W<'a, O> {
426 #[doc = "No effect (write) / counter running (read)"]
427 #[inline(always)]
428 pub fn _0(self) -> &'a mut W {
429 self.variant(CSTOP7_A::_0)
430 }
431 #[doc = "GPT32E7.GTCNT counter stops (write) / Counter stop (read)"]
432 #[inline(always)]
433 pub fn _1(self) -> &'a mut W {
434 self.variant(CSTOP7_A::_1)
435 }
436}
437#[doc = "Field `CSTOP8` reader - Channel 8 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
438pub type CSTOP8_R = crate::BitReader<CSTOP8_A>;
439#[doc = "Channel 8 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop.\n\nValue on reset: 1"]
440#[derive(Clone, Copy, Debug, PartialEq, Eq)]
441pub enum CSTOP8_A {
442 #[doc = "0: No effect (write) / counter running (read)"]
443 _0 = 0,
444 #[doc = "1: GPT328.GTCNT counter stops (write) / Counter stop (read)"]
445 _1 = 1,
446}
447impl From<CSTOP8_A> for bool {
448 #[inline(always)]
449 fn from(variant: CSTOP8_A) -> Self {
450 variant as u8 != 0
451 }
452}
453impl CSTOP8_R {
454 #[doc = "Get enumerated values variant"]
455 #[inline(always)]
456 pub fn variant(&self) -> CSTOP8_A {
457 match self.bits {
458 false => CSTOP8_A::_0,
459 true => CSTOP8_A::_1,
460 }
461 }
462 #[doc = "Checks if the value of the field is `_0`"]
463 #[inline(always)]
464 pub fn is_0(&self) -> bool {
465 *self == CSTOP8_A::_0
466 }
467 #[doc = "Checks if the value of the field is `_1`"]
468 #[inline(always)]
469 pub fn is_1(&self) -> bool {
470 *self == CSTOP8_A::_1
471 }
472}
473#[doc = "Field `CSTOP8` writer - Channel 8 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
474pub type CSTOP8_W<'a, const O: u8> = crate::BitWriter<'a, u32, GTSTP_SPEC, CSTOP8_A, O>;
475impl<'a, const O: u8> CSTOP8_W<'a, O> {
476 #[doc = "No effect (write) / counter running (read)"]
477 #[inline(always)]
478 pub fn _0(self) -> &'a mut W {
479 self.variant(CSTOP8_A::_0)
480 }
481 #[doc = "GPT328.GTCNT counter stops (write) / Counter stop (read)"]
482 #[inline(always)]
483 pub fn _1(self) -> &'a mut W {
484 self.variant(CSTOP8_A::_1)
485 }
486}
487#[doc = "Field `CSTOP9` reader - Channel 9 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
488pub type CSTOP9_R = crate::BitReader<CSTOP9_A>;
489#[doc = "Channel 9 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop.\n\nValue on reset: 1"]
490#[derive(Clone, Copy, Debug, PartialEq, Eq)]
491pub enum CSTOP9_A {
492 #[doc = "0: No effect (write) / counter running (read)"]
493 _0 = 0,
494 #[doc = "1: GPT329.GTCNT counter stops (write) / Counter stop (read)"]
495 _1 = 1,
496}
497impl From<CSTOP9_A> for bool {
498 #[inline(always)]
499 fn from(variant: CSTOP9_A) -> Self {
500 variant as u8 != 0
501 }
502}
503impl CSTOP9_R {
504 #[doc = "Get enumerated values variant"]
505 #[inline(always)]
506 pub fn variant(&self) -> CSTOP9_A {
507 match self.bits {
508 false => CSTOP9_A::_0,
509 true => CSTOP9_A::_1,
510 }
511 }
512 #[doc = "Checks if the value of the field is `_0`"]
513 #[inline(always)]
514 pub fn is_0(&self) -> bool {
515 *self == CSTOP9_A::_0
516 }
517 #[doc = "Checks if the value of the field is `_1`"]
518 #[inline(always)]
519 pub fn is_1(&self) -> bool {
520 *self == CSTOP9_A::_1
521 }
522}
523#[doc = "Field `CSTOP9` writer - Channel 9 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
524pub type CSTOP9_W<'a, const O: u8> = crate::BitWriter<'a, u32, GTSTP_SPEC, CSTOP9_A, O>;
525impl<'a, const O: u8> CSTOP9_W<'a, O> {
526 #[doc = "No effect (write) / counter running (read)"]
527 #[inline(always)]
528 pub fn _0(self) -> &'a mut W {
529 self.variant(CSTOP9_A::_0)
530 }
531 #[doc = "GPT329.GTCNT counter stops (write) / Counter stop (read)"]
532 #[inline(always)]
533 pub fn _1(self) -> &'a mut W {
534 self.variant(CSTOP9_A::_1)
535 }
536}
537#[doc = "Field `CSTOP10` reader - Channel 10 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
538pub type CSTOP10_R = crate::BitReader<CSTOP10_A>;
539#[doc = "Channel 10 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop.\n\nValue on reset: 1"]
540#[derive(Clone, Copy, Debug, PartialEq, Eq)]
541pub enum CSTOP10_A {
542 #[doc = "0: No effect (write) / counter running (read)"]
543 _0 = 0,
544 #[doc = "1: GPT3210.GTCNT counter stops (write) / Counter stop (read)"]
545 _1 = 1,
546}
547impl From<CSTOP10_A> for bool {
548 #[inline(always)]
549 fn from(variant: CSTOP10_A) -> Self {
550 variant as u8 != 0
551 }
552}
553impl CSTOP10_R {
554 #[doc = "Get enumerated values variant"]
555 #[inline(always)]
556 pub fn variant(&self) -> CSTOP10_A {
557 match self.bits {
558 false => CSTOP10_A::_0,
559 true => CSTOP10_A::_1,
560 }
561 }
562 #[doc = "Checks if the value of the field is `_0`"]
563 #[inline(always)]
564 pub fn is_0(&self) -> bool {
565 *self == CSTOP10_A::_0
566 }
567 #[doc = "Checks if the value of the field is `_1`"]
568 #[inline(always)]
569 pub fn is_1(&self) -> bool {
570 *self == CSTOP10_A::_1
571 }
572}
573#[doc = "Field `CSTOP10` writer - Channel 10 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
574pub type CSTOP10_W<'a, const O: u8> = crate::BitWriter<'a, u32, GTSTP_SPEC, CSTOP10_A, O>;
575impl<'a, const O: u8> CSTOP10_W<'a, O> {
576 #[doc = "No effect (write) / counter running (read)"]
577 #[inline(always)]
578 pub fn _0(self) -> &'a mut W {
579 self.variant(CSTOP10_A::_0)
580 }
581 #[doc = "GPT3210.GTCNT counter stops (write) / Counter stop (read)"]
582 #[inline(always)]
583 pub fn _1(self) -> &'a mut W {
584 self.variant(CSTOP10_A::_1)
585 }
586}
587#[doc = "Field `CSTOP11` reader - Channel 11 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
588pub type CSTOP11_R = crate::BitReader<CSTOP11_A>;
589#[doc = "Channel 11 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop.\n\nValue on reset: 1"]
590#[derive(Clone, Copy, Debug, PartialEq, Eq)]
591pub enum CSTOP11_A {
592 #[doc = "0: No effect (write) / counter running (read)"]
593 _0 = 0,
594 #[doc = "1: GPT3211.GTCNT counter stops (write) / Counter stop (read)"]
595 _1 = 1,
596}
597impl From<CSTOP11_A> for bool {
598 #[inline(always)]
599 fn from(variant: CSTOP11_A) -> Self {
600 variant as u8 != 0
601 }
602}
603impl CSTOP11_R {
604 #[doc = "Get enumerated values variant"]
605 #[inline(always)]
606 pub fn variant(&self) -> CSTOP11_A {
607 match self.bits {
608 false => CSTOP11_A::_0,
609 true => CSTOP11_A::_1,
610 }
611 }
612 #[doc = "Checks if the value of the field is `_0`"]
613 #[inline(always)]
614 pub fn is_0(&self) -> bool {
615 *self == CSTOP11_A::_0
616 }
617 #[doc = "Checks if the value of the field is `_1`"]
618 #[inline(always)]
619 pub fn is_1(&self) -> bool {
620 *self == CSTOP11_A::_1
621 }
622}
623#[doc = "Field `CSTOP11` writer - Channel 11 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
624pub type CSTOP11_W<'a, const O: u8> = crate::BitWriter<'a, u32, GTSTP_SPEC, CSTOP11_A, O>;
625impl<'a, const O: u8> CSTOP11_W<'a, O> {
626 #[doc = "No effect (write) / counter running (read)"]
627 #[inline(always)]
628 pub fn _0(self) -> &'a mut W {
629 self.variant(CSTOP11_A::_0)
630 }
631 #[doc = "GPT3211.GTCNT counter stops (write) / Counter stop (read)"]
632 #[inline(always)]
633 pub fn _1(self) -> &'a mut W {
634 self.variant(CSTOP11_A::_1)
635 }
636}
637#[doc = "Field `CSTOP12` reader - Channel 12 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
638pub type CSTOP12_R = crate::BitReader<CSTOP12_A>;
639#[doc = "Channel 12 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop.\n\nValue on reset: 1"]
640#[derive(Clone, Copy, Debug, PartialEq, Eq)]
641pub enum CSTOP12_A {
642 #[doc = "0: No effect (write) / counter running (read)"]
643 _0 = 0,
644 #[doc = "1: GPT3212.GTCNT counter stops (write) / Counter stop (read)"]
645 _1 = 1,
646}
647impl From<CSTOP12_A> for bool {
648 #[inline(always)]
649 fn from(variant: CSTOP12_A) -> Self {
650 variant as u8 != 0
651 }
652}
653impl CSTOP12_R {
654 #[doc = "Get enumerated values variant"]
655 #[inline(always)]
656 pub fn variant(&self) -> CSTOP12_A {
657 match self.bits {
658 false => CSTOP12_A::_0,
659 true => CSTOP12_A::_1,
660 }
661 }
662 #[doc = "Checks if the value of the field is `_0`"]
663 #[inline(always)]
664 pub fn is_0(&self) -> bool {
665 *self == CSTOP12_A::_0
666 }
667 #[doc = "Checks if the value of the field is `_1`"]
668 #[inline(always)]
669 pub fn is_1(&self) -> bool {
670 *self == CSTOP12_A::_1
671 }
672}
673#[doc = "Field `CSTOP12` writer - Channel 12 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
674pub type CSTOP12_W<'a, const O: u8> = crate::BitWriter<'a, u32, GTSTP_SPEC, CSTOP12_A, O>;
675impl<'a, const O: u8> CSTOP12_W<'a, O> {
676 #[doc = "No effect (write) / counter running (read)"]
677 #[inline(always)]
678 pub fn _0(self) -> &'a mut W {
679 self.variant(CSTOP12_A::_0)
680 }
681 #[doc = "GPT3212.GTCNT counter stops (write) / Counter stop (read)"]
682 #[inline(always)]
683 pub fn _1(self) -> &'a mut W {
684 self.variant(CSTOP12_A::_1)
685 }
686}
687#[doc = "Field `CSTOP13` reader - Channel 13 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
688pub type CSTOP13_R = crate::BitReader<CSTOP13_A>;
689#[doc = "Channel 13 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop.\n\nValue on reset: 1"]
690#[derive(Clone, Copy, Debug, PartialEq, Eq)]
691pub enum CSTOP13_A {
692 #[doc = "0: No effect (write) / counter running (read)"]
693 _0 = 0,
694 #[doc = "1: GPT3213.GTCNT counter stops (write) / Counter stop (read)"]
695 _1 = 1,
696}
697impl From<CSTOP13_A> for bool {
698 #[inline(always)]
699 fn from(variant: CSTOP13_A) -> Self {
700 variant as u8 != 0
701 }
702}
703impl CSTOP13_R {
704 #[doc = "Get enumerated values variant"]
705 #[inline(always)]
706 pub fn variant(&self) -> CSTOP13_A {
707 match self.bits {
708 false => CSTOP13_A::_0,
709 true => CSTOP13_A::_1,
710 }
711 }
712 #[doc = "Checks if the value of the field is `_0`"]
713 #[inline(always)]
714 pub fn is_0(&self) -> bool {
715 *self == CSTOP13_A::_0
716 }
717 #[doc = "Checks if the value of the field is `_1`"]
718 #[inline(always)]
719 pub fn is_1(&self) -> bool {
720 *self == CSTOP13_A::_1
721 }
722}
723#[doc = "Field `CSTOP13` writer - Channel 13 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
724pub type CSTOP13_W<'a, const O: u8> = crate::BitWriter<'a, u32, GTSTP_SPEC, CSTOP13_A, O>;
725impl<'a, const O: u8> CSTOP13_W<'a, O> {
726 #[doc = "No effect (write) / counter running (read)"]
727 #[inline(always)]
728 pub fn _0(self) -> &'a mut W {
729 self.variant(CSTOP13_A::_0)
730 }
731 #[doc = "GPT3213.GTCNT counter stops (write) / Counter stop (read)"]
732 #[inline(always)]
733 pub fn _1(self) -> &'a mut W {
734 self.variant(CSTOP13_A::_1)
735 }
736}
737impl R {
738 #[doc = "Bit 0 - Channel 0 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
739 #[inline(always)]
740 pub fn cstop0(&self) -> CSTOP0_R {
741 CSTOP0_R::new((self.bits & 1) != 0)
742 }
743 #[doc = "Bit 1 - Channel 1 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
744 #[inline(always)]
745 pub fn cstop1(&self) -> CSTOP1_R {
746 CSTOP1_R::new(((self.bits >> 1) & 1) != 0)
747 }
748 #[doc = "Bit 2 - Channel 2 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
749 #[inline(always)]
750 pub fn cstop2(&self) -> CSTOP2_R {
751 CSTOP2_R::new(((self.bits >> 2) & 1) != 0)
752 }
753 #[doc = "Bit 3 - Channel 3 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
754 #[inline(always)]
755 pub fn cstop3(&self) -> CSTOP3_R {
756 CSTOP3_R::new(((self.bits >> 3) & 1) != 0)
757 }
758 #[doc = "Bit 4 - Channel 4 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
759 #[inline(always)]
760 pub fn cstop4(&self) -> CSTOP4_R {
761 CSTOP4_R::new(((self.bits >> 4) & 1) != 0)
762 }
763 #[doc = "Bit 5 - Channel 5 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
764 #[inline(always)]
765 pub fn cstop5(&self) -> CSTOP5_R {
766 CSTOP5_R::new(((self.bits >> 5) & 1) != 0)
767 }
768 #[doc = "Bit 6 - Channel 6 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
769 #[inline(always)]
770 pub fn cstop6(&self) -> CSTOP6_R {
771 CSTOP6_R::new(((self.bits >> 6) & 1) != 0)
772 }
773 #[doc = "Bit 7 - Channel 7 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
774 #[inline(always)]
775 pub fn cstop7(&self) -> CSTOP7_R {
776 CSTOP7_R::new(((self.bits >> 7) & 1) != 0)
777 }
778 #[doc = "Bit 8 - Channel 8 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
779 #[inline(always)]
780 pub fn cstop8(&self) -> CSTOP8_R {
781 CSTOP8_R::new(((self.bits >> 8) & 1) != 0)
782 }
783 #[doc = "Bit 9 - Channel 9 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
784 #[inline(always)]
785 pub fn cstop9(&self) -> CSTOP9_R {
786 CSTOP9_R::new(((self.bits >> 9) & 1) != 0)
787 }
788 #[doc = "Bit 10 - Channel 10 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
789 #[inline(always)]
790 pub fn cstop10(&self) -> CSTOP10_R {
791 CSTOP10_R::new(((self.bits >> 10) & 1) != 0)
792 }
793 #[doc = "Bit 11 - Channel 11 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
794 #[inline(always)]
795 pub fn cstop11(&self) -> CSTOP11_R {
796 CSTOP11_R::new(((self.bits >> 11) & 1) != 0)
797 }
798 #[doc = "Bit 12 - Channel 12 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
799 #[inline(always)]
800 pub fn cstop12(&self) -> CSTOP12_R {
801 CSTOP12_R::new(((self.bits >> 12) & 1) != 0)
802 }
803 #[doc = "Bit 13 - Channel 13 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
804 #[inline(always)]
805 pub fn cstop13(&self) -> CSTOP13_R {
806 CSTOP13_R::new(((self.bits >> 13) & 1) != 0)
807 }
808}
809impl W {
810 #[doc = "Bit 0 - Channel 0 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
811 #[inline(always)]
812 #[must_use]
813 pub fn cstop0(&mut self) -> CSTOP0_W<0> {
814 CSTOP0_W::new(self)
815 }
816 #[doc = "Bit 1 - Channel 1 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
817 #[inline(always)]
818 #[must_use]
819 pub fn cstop1(&mut self) -> CSTOP1_W<1> {
820 CSTOP1_W::new(self)
821 }
822 #[doc = "Bit 2 - Channel 2 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
823 #[inline(always)]
824 #[must_use]
825 pub fn cstop2(&mut self) -> CSTOP2_W<2> {
826 CSTOP2_W::new(self)
827 }
828 #[doc = "Bit 3 - Channel 3 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
829 #[inline(always)]
830 #[must_use]
831 pub fn cstop3(&mut self) -> CSTOP3_W<3> {
832 CSTOP3_W::new(self)
833 }
834 #[doc = "Bit 4 - Channel 4 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
835 #[inline(always)]
836 #[must_use]
837 pub fn cstop4(&mut self) -> CSTOP4_W<4> {
838 CSTOP4_W::new(self)
839 }
840 #[doc = "Bit 5 - Channel 5 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
841 #[inline(always)]
842 #[must_use]
843 pub fn cstop5(&mut self) -> CSTOP5_W<5> {
844 CSTOP5_W::new(self)
845 }
846 #[doc = "Bit 6 - Channel 6 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
847 #[inline(always)]
848 #[must_use]
849 pub fn cstop6(&mut self) -> CSTOP6_W<6> {
850 CSTOP6_W::new(self)
851 }
852 #[doc = "Bit 7 - Channel 7 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
853 #[inline(always)]
854 #[must_use]
855 pub fn cstop7(&mut self) -> CSTOP7_W<7> {
856 CSTOP7_W::new(self)
857 }
858 #[doc = "Bit 8 - Channel 8 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
859 #[inline(always)]
860 #[must_use]
861 pub fn cstop8(&mut self) -> CSTOP8_W<8> {
862 CSTOP8_W::new(self)
863 }
864 #[doc = "Bit 9 - Channel 9 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
865 #[inline(always)]
866 #[must_use]
867 pub fn cstop9(&mut self) -> CSTOP9_W<9> {
868 CSTOP9_W::new(self)
869 }
870 #[doc = "Bit 10 - Channel 10 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
871 #[inline(always)]
872 #[must_use]
873 pub fn cstop10(&mut self) -> CSTOP10_W<10> {
874 CSTOP10_W::new(self)
875 }
876 #[doc = "Bit 11 - Channel 11 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
877 #[inline(always)]
878 #[must_use]
879 pub fn cstop11(&mut self) -> CSTOP11_W<11> {
880 CSTOP11_W::new(self)
881 }
882 #[doc = "Bit 12 - Channel 12 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
883 #[inline(always)]
884 #[must_use]
885 pub fn cstop12(&mut self) -> CSTOP12_W<12> {
886 CSTOP12_W::new(self)
887 }
888 #[doc = "Bit 13 - Channel 13 GTCNT Count StopRead data shows each channel's counter status (GTCR.CST bit). 0 means counter runnning. 1 means counter stop."]
889 #[inline(always)]
890 #[must_use]
891 pub fn cstop13(&mut self) -> CSTOP13_W<13> {
892 CSTOP13_W::new(self)
893 }
894 #[doc = "Writes raw bits to the register."]
895 #[inline(always)]
896 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
897 self.0.bits(bits);
898 self
899 }
900}
901#[doc = "General PWM Timer Software Stop 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 [gtstp](index.html) module"]
902pub struct GTSTP_SPEC;
903impl crate::RegisterSpec for GTSTP_SPEC {
904 type Ux = u32;
905}
906#[doc = "`read()` method returns [gtstp::R](R) reader structure"]
907impl crate::Readable for GTSTP_SPEC {
908 type Reader = R;
909}
910#[doc = "`write(|w| ..)` method takes [gtstp::W](W) writer structure"]
911impl crate::Writable for GTSTP_SPEC {
912 type Writer = W;
913 const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
914 const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
915}
916#[doc = "`reset()` method sets GTSTP to value 0xffff_ffff"]
917impl crate::Resettable for GTSTP_SPEC {
918 const RESET_VALUE: Self::Ux = 0xffff_ffff;
919}