1#[doc = "Register `GTSTR` reader"]
2pub struct R(crate::R<GTSTR_SPEC>);
3impl core::ops::Deref for R {
4 type Target = crate::R<GTSTR_SPEC>;
5 #[inline(always)]
6 fn deref(&self) -> &Self::Target {
7 &self.0
8 }
9}
10impl From<crate::R<GTSTR_SPEC>> for R {
11 #[inline(always)]
12 fn from(reader: crate::R<GTSTR_SPEC>) -> Self {
13 R(reader)
14 }
15}
16#[doc = "Register `GTSTR` writer"]
17pub struct W(crate::W<GTSTR_SPEC>);
18impl core::ops::Deref for W {
19 type Target = crate::W<GTSTR_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<GTSTR_SPEC>> for W {
32 #[inline(always)]
33 fn from(writer: crate::W<GTSTR_SPEC>) -> Self {
34 W(writer)
35 }
36}
37#[doc = "Field `CSTRT0` reader - Channel 0 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
38pub type CSTRT0_R = crate::BitReader<CSTRT0_A>;
39#[doc = "Channel 0 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running.\n\nValue on reset: 0"]
40#[derive(Clone, Copy, Debug, PartialEq, Eq)]
41pub enum CSTRT0_A {
42 #[doc = "0: No effect (write) / counter stop (read)"]
43 _0 = 0,
44 #[doc = "1: GPT32EH0.GTCNT counter starts (write) / Counter running (read)"]
45 _1 = 1,
46}
47impl From<CSTRT0_A> for bool {
48 #[inline(always)]
49 fn from(variant: CSTRT0_A) -> Self {
50 variant as u8 != 0
51 }
52}
53impl CSTRT0_R {
54 #[doc = "Get enumerated values variant"]
55 #[inline(always)]
56 pub fn variant(&self) -> CSTRT0_A {
57 match self.bits {
58 false => CSTRT0_A::_0,
59 true => CSTRT0_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 == CSTRT0_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 == CSTRT0_A::_1
71 }
72}
73#[doc = "Field `CSTRT0` writer - Channel 0 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
74pub type CSTRT0_W<'a, const O: u8> = crate::BitWriter<'a, u32, GTSTR_SPEC, CSTRT0_A, O>;
75impl<'a, const O: u8> CSTRT0_W<'a, O> {
76 #[doc = "No effect (write) / counter stop (read)"]
77 #[inline(always)]
78 pub fn _0(self) -> &'a mut W {
79 self.variant(CSTRT0_A::_0)
80 }
81 #[doc = "GPT32EH0.GTCNT counter starts (write) / Counter running (read)"]
82 #[inline(always)]
83 pub fn _1(self) -> &'a mut W {
84 self.variant(CSTRT0_A::_1)
85 }
86}
87#[doc = "Field `CSTRT1` reader - Channel 1 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
88pub type CSTRT1_R = crate::BitReader<CSTRT1_A>;
89#[doc = "Channel 1 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running.\n\nValue on reset: 0"]
90#[derive(Clone, Copy, Debug, PartialEq, Eq)]
91pub enum CSTRT1_A {
92 #[doc = "0: No effect (write) / counter stop (read)"]
93 _0 = 0,
94 #[doc = "1: GPT32EH1.GTCNT counter starts (write) / Counter running (read)"]
95 _1 = 1,
96}
97impl From<CSTRT1_A> for bool {
98 #[inline(always)]
99 fn from(variant: CSTRT1_A) -> Self {
100 variant as u8 != 0
101 }
102}
103impl CSTRT1_R {
104 #[doc = "Get enumerated values variant"]
105 #[inline(always)]
106 pub fn variant(&self) -> CSTRT1_A {
107 match self.bits {
108 false => CSTRT1_A::_0,
109 true => CSTRT1_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 == CSTRT1_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 == CSTRT1_A::_1
121 }
122}
123#[doc = "Field `CSTRT1` writer - Channel 1 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
124pub type CSTRT1_W<'a, const O: u8> = crate::BitWriter<'a, u32, GTSTR_SPEC, CSTRT1_A, O>;
125impl<'a, const O: u8> CSTRT1_W<'a, O> {
126 #[doc = "No effect (write) / counter stop (read)"]
127 #[inline(always)]
128 pub fn _0(self) -> &'a mut W {
129 self.variant(CSTRT1_A::_0)
130 }
131 #[doc = "GPT32EH1.GTCNT counter starts (write) / Counter running (read)"]
132 #[inline(always)]
133 pub fn _1(self) -> &'a mut W {
134 self.variant(CSTRT1_A::_1)
135 }
136}
137#[doc = "Field `CSTRT2` reader - Channel 2 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
138pub type CSTRT2_R = crate::BitReader<CSTRT2_A>;
139#[doc = "Channel 2 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running.\n\nValue on reset: 0"]
140#[derive(Clone, Copy, Debug, PartialEq, Eq)]
141pub enum CSTRT2_A {
142 #[doc = "0: No effect (write) / counter stop (read)"]
143 _0 = 0,
144 #[doc = "1: GPT32EH2.GTCNT counter starts (write) / Counter running (read)"]
145 _1 = 1,
146}
147impl From<CSTRT2_A> for bool {
148 #[inline(always)]
149 fn from(variant: CSTRT2_A) -> Self {
150 variant as u8 != 0
151 }
152}
153impl CSTRT2_R {
154 #[doc = "Get enumerated values variant"]
155 #[inline(always)]
156 pub fn variant(&self) -> CSTRT2_A {
157 match self.bits {
158 false => CSTRT2_A::_0,
159 true => CSTRT2_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 == CSTRT2_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 == CSTRT2_A::_1
171 }
172}
173#[doc = "Field `CSTRT2` writer - Channel 2 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
174pub type CSTRT2_W<'a, const O: u8> = crate::BitWriter<'a, u32, GTSTR_SPEC, CSTRT2_A, O>;
175impl<'a, const O: u8> CSTRT2_W<'a, O> {
176 #[doc = "No effect (write) / counter stop (read)"]
177 #[inline(always)]
178 pub fn _0(self) -> &'a mut W {
179 self.variant(CSTRT2_A::_0)
180 }
181 #[doc = "GPT32EH2.GTCNT counter starts (write) / Counter running (read)"]
182 #[inline(always)]
183 pub fn _1(self) -> &'a mut W {
184 self.variant(CSTRT2_A::_1)
185 }
186}
187#[doc = "Field `CSTRT3` reader - Channel 3 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
188pub type CSTRT3_R = crate::BitReader<CSTRT3_A>;
189#[doc = "Channel 3 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running.\n\nValue on reset: 0"]
190#[derive(Clone, Copy, Debug, PartialEq, Eq)]
191pub enum CSTRT3_A {
192 #[doc = "0: No effect (write) / counter stop (read)"]
193 _0 = 0,
194 #[doc = "1: GPT32EH3.GTCNT counter starts (write) / Counter running (read)"]
195 _1 = 1,
196}
197impl From<CSTRT3_A> for bool {
198 #[inline(always)]
199 fn from(variant: CSTRT3_A) -> Self {
200 variant as u8 != 0
201 }
202}
203impl CSTRT3_R {
204 #[doc = "Get enumerated values variant"]
205 #[inline(always)]
206 pub fn variant(&self) -> CSTRT3_A {
207 match self.bits {
208 false => CSTRT3_A::_0,
209 true => CSTRT3_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 == CSTRT3_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 == CSTRT3_A::_1
221 }
222}
223#[doc = "Field `CSTRT3` writer - Channel 3 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
224pub type CSTRT3_W<'a, const O: u8> = crate::BitWriter<'a, u32, GTSTR_SPEC, CSTRT3_A, O>;
225impl<'a, const O: u8> CSTRT3_W<'a, O> {
226 #[doc = "No effect (write) / counter stop (read)"]
227 #[inline(always)]
228 pub fn _0(self) -> &'a mut W {
229 self.variant(CSTRT3_A::_0)
230 }
231 #[doc = "GPT32EH3.GTCNT counter starts (write) / Counter running (read)"]
232 #[inline(always)]
233 pub fn _1(self) -> &'a mut W {
234 self.variant(CSTRT3_A::_1)
235 }
236}
237#[doc = "Field `CSTRT4` reader - Channel 4 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
238pub type CSTRT4_R = crate::BitReader<CSTRT4_A>;
239#[doc = "Channel 4 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running.\n\nValue on reset: 0"]
240#[derive(Clone, Copy, Debug, PartialEq, Eq)]
241pub enum CSTRT4_A {
242 #[doc = "0: No effect (write) / counter stop (read)"]
243 _0 = 0,
244 #[doc = "1: GPT32E4.GTCNT counter starts (write) / Counter running (read)"]
245 _1 = 1,
246}
247impl From<CSTRT4_A> for bool {
248 #[inline(always)]
249 fn from(variant: CSTRT4_A) -> Self {
250 variant as u8 != 0
251 }
252}
253impl CSTRT4_R {
254 #[doc = "Get enumerated values variant"]
255 #[inline(always)]
256 pub fn variant(&self) -> CSTRT4_A {
257 match self.bits {
258 false => CSTRT4_A::_0,
259 true => CSTRT4_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 == CSTRT4_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 == CSTRT4_A::_1
271 }
272}
273#[doc = "Field `CSTRT4` writer - Channel 4 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
274pub type CSTRT4_W<'a, const O: u8> = crate::BitWriter<'a, u32, GTSTR_SPEC, CSTRT4_A, O>;
275impl<'a, const O: u8> CSTRT4_W<'a, O> {
276 #[doc = "No effect (write) / counter stop (read)"]
277 #[inline(always)]
278 pub fn _0(self) -> &'a mut W {
279 self.variant(CSTRT4_A::_0)
280 }
281 #[doc = "GPT32E4.GTCNT counter starts (write) / Counter running (read)"]
282 #[inline(always)]
283 pub fn _1(self) -> &'a mut W {
284 self.variant(CSTRT4_A::_1)
285 }
286}
287#[doc = "Field `CSTRT5` reader - Channel 5 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
288pub type CSTRT5_R = crate::BitReader<CSTRT5_A>;
289#[doc = "Channel 5 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running.\n\nValue on reset: 0"]
290#[derive(Clone, Copy, Debug, PartialEq, Eq)]
291pub enum CSTRT5_A {
292 #[doc = "0: No effect (write) / counter stop (read)"]
293 _0 = 0,
294 #[doc = "1: GPT32E5.GTCNT counter starts (write) / Counter running (read)"]
295 _1 = 1,
296}
297impl From<CSTRT5_A> for bool {
298 #[inline(always)]
299 fn from(variant: CSTRT5_A) -> Self {
300 variant as u8 != 0
301 }
302}
303impl CSTRT5_R {
304 #[doc = "Get enumerated values variant"]
305 #[inline(always)]
306 pub fn variant(&self) -> CSTRT5_A {
307 match self.bits {
308 false => CSTRT5_A::_0,
309 true => CSTRT5_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 == CSTRT5_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 == CSTRT5_A::_1
321 }
322}
323#[doc = "Field `CSTRT5` writer - Channel 5 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
324pub type CSTRT5_W<'a, const O: u8> = crate::BitWriter<'a, u32, GTSTR_SPEC, CSTRT5_A, O>;
325impl<'a, const O: u8> CSTRT5_W<'a, O> {
326 #[doc = "No effect (write) / counter stop (read)"]
327 #[inline(always)]
328 pub fn _0(self) -> &'a mut W {
329 self.variant(CSTRT5_A::_0)
330 }
331 #[doc = "GPT32E5.GTCNT counter starts (write) / Counter running (read)"]
332 #[inline(always)]
333 pub fn _1(self) -> &'a mut W {
334 self.variant(CSTRT5_A::_1)
335 }
336}
337#[doc = "Field `CSTRT6` reader - Channel 6 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
338pub type CSTRT6_R = crate::BitReader<CSTRT6_A>;
339#[doc = "Channel 6 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running.\n\nValue on reset: 0"]
340#[derive(Clone, Copy, Debug, PartialEq, Eq)]
341pub enum CSTRT6_A {
342 #[doc = "0: No effect (write) / counter stop (read)"]
343 _0 = 0,
344 #[doc = "1: GPT32E6.GTCNT counter starts (write) / Counter running (read)"]
345 _1 = 1,
346}
347impl From<CSTRT6_A> for bool {
348 #[inline(always)]
349 fn from(variant: CSTRT6_A) -> Self {
350 variant as u8 != 0
351 }
352}
353impl CSTRT6_R {
354 #[doc = "Get enumerated values variant"]
355 #[inline(always)]
356 pub fn variant(&self) -> CSTRT6_A {
357 match self.bits {
358 false => CSTRT6_A::_0,
359 true => CSTRT6_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 == CSTRT6_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 == CSTRT6_A::_1
371 }
372}
373#[doc = "Field `CSTRT6` writer - Channel 6 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
374pub type CSTRT6_W<'a, const O: u8> = crate::BitWriter<'a, u32, GTSTR_SPEC, CSTRT6_A, O>;
375impl<'a, const O: u8> CSTRT6_W<'a, O> {
376 #[doc = "No effect (write) / counter stop (read)"]
377 #[inline(always)]
378 pub fn _0(self) -> &'a mut W {
379 self.variant(CSTRT6_A::_0)
380 }
381 #[doc = "GPT32E6.GTCNT counter starts (write) / Counter running (read)"]
382 #[inline(always)]
383 pub fn _1(self) -> &'a mut W {
384 self.variant(CSTRT6_A::_1)
385 }
386}
387#[doc = "Field `CSTRT7` reader - Channel 7 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
388pub type CSTRT7_R = crate::BitReader<CSTRT7_A>;
389#[doc = "Channel 7 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running.\n\nValue on reset: 0"]
390#[derive(Clone, Copy, Debug, PartialEq, Eq)]
391pub enum CSTRT7_A {
392 #[doc = "0: No effect (write) / counter stop (read)"]
393 _0 = 0,
394 #[doc = "1: GPT32E7.GTCNT counter starts (write) / Counter running (read)"]
395 _1 = 1,
396}
397impl From<CSTRT7_A> for bool {
398 #[inline(always)]
399 fn from(variant: CSTRT7_A) -> Self {
400 variant as u8 != 0
401 }
402}
403impl CSTRT7_R {
404 #[doc = "Get enumerated values variant"]
405 #[inline(always)]
406 pub fn variant(&self) -> CSTRT7_A {
407 match self.bits {
408 false => CSTRT7_A::_0,
409 true => CSTRT7_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 == CSTRT7_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 == CSTRT7_A::_1
421 }
422}
423#[doc = "Field `CSTRT7` writer - Channel 7 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
424pub type CSTRT7_W<'a, const O: u8> = crate::BitWriter<'a, u32, GTSTR_SPEC, CSTRT7_A, O>;
425impl<'a, const O: u8> CSTRT7_W<'a, O> {
426 #[doc = "No effect (write) / counter stop (read)"]
427 #[inline(always)]
428 pub fn _0(self) -> &'a mut W {
429 self.variant(CSTRT7_A::_0)
430 }
431 #[doc = "GPT32E7.GTCNT counter starts (write) / Counter running (read)"]
432 #[inline(always)]
433 pub fn _1(self) -> &'a mut W {
434 self.variant(CSTRT7_A::_1)
435 }
436}
437#[doc = "Field `CSTRT8` reader - Channel 8 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
438pub type CSTRT8_R = crate::BitReader<CSTRT8_A>;
439#[doc = "Channel 8 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running.\n\nValue on reset: 0"]
440#[derive(Clone, Copy, Debug, PartialEq, Eq)]
441pub enum CSTRT8_A {
442 #[doc = "0: No effect (write) / counter stop (read)"]
443 _0 = 0,
444 #[doc = "1: GPT328.GTCNT counter starts (write) / Counter running (read)"]
445 _1 = 1,
446}
447impl From<CSTRT8_A> for bool {
448 #[inline(always)]
449 fn from(variant: CSTRT8_A) -> Self {
450 variant as u8 != 0
451 }
452}
453impl CSTRT8_R {
454 #[doc = "Get enumerated values variant"]
455 #[inline(always)]
456 pub fn variant(&self) -> CSTRT8_A {
457 match self.bits {
458 false => CSTRT8_A::_0,
459 true => CSTRT8_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 == CSTRT8_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 == CSTRT8_A::_1
471 }
472}
473#[doc = "Field `CSTRT8` writer - Channel 8 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
474pub type CSTRT8_W<'a, const O: u8> = crate::BitWriter<'a, u32, GTSTR_SPEC, CSTRT8_A, O>;
475impl<'a, const O: u8> CSTRT8_W<'a, O> {
476 #[doc = "No effect (write) / counter stop (read)"]
477 #[inline(always)]
478 pub fn _0(self) -> &'a mut W {
479 self.variant(CSTRT8_A::_0)
480 }
481 #[doc = "GPT328.GTCNT counter starts (write) / Counter running (read)"]
482 #[inline(always)]
483 pub fn _1(self) -> &'a mut W {
484 self.variant(CSTRT8_A::_1)
485 }
486}
487#[doc = "Field `CSTRT9` reader - Channel 9 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
488pub type CSTRT9_R = crate::BitReader<CSTRT9_A>;
489#[doc = "Channel 9 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running.\n\nValue on reset: 0"]
490#[derive(Clone, Copy, Debug, PartialEq, Eq)]
491pub enum CSTRT9_A {
492 #[doc = "0: No effect (write) / counter stop (read)"]
493 _0 = 0,
494 #[doc = "1: GPT329.GTCNT counter starts (write) / Counter running (read)"]
495 _1 = 1,
496}
497impl From<CSTRT9_A> for bool {
498 #[inline(always)]
499 fn from(variant: CSTRT9_A) -> Self {
500 variant as u8 != 0
501 }
502}
503impl CSTRT9_R {
504 #[doc = "Get enumerated values variant"]
505 #[inline(always)]
506 pub fn variant(&self) -> CSTRT9_A {
507 match self.bits {
508 false => CSTRT9_A::_0,
509 true => CSTRT9_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 == CSTRT9_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 == CSTRT9_A::_1
521 }
522}
523#[doc = "Field `CSTRT9` writer - Channel 9 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
524pub type CSTRT9_W<'a, const O: u8> = crate::BitWriter<'a, u32, GTSTR_SPEC, CSTRT9_A, O>;
525impl<'a, const O: u8> CSTRT9_W<'a, O> {
526 #[doc = "No effect (write) / counter stop (read)"]
527 #[inline(always)]
528 pub fn _0(self) -> &'a mut W {
529 self.variant(CSTRT9_A::_0)
530 }
531 #[doc = "GPT329.GTCNT counter starts (write) / Counter running (read)"]
532 #[inline(always)]
533 pub fn _1(self) -> &'a mut W {
534 self.variant(CSTRT9_A::_1)
535 }
536}
537#[doc = "Field `CSTRT10` reader - Channel 10 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
538pub type CSTRT10_R = crate::BitReader<CSTRT10_A>;
539#[doc = "Channel 10 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running.\n\nValue on reset: 0"]
540#[derive(Clone, Copy, Debug, PartialEq, Eq)]
541pub enum CSTRT10_A {
542 #[doc = "0: No effect (write) / counter stop (read)"]
543 _0 = 0,
544 #[doc = "1: GPT3210.GTCNT counter starts (write) / Counter running (read)"]
545 _1 = 1,
546}
547impl From<CSTRT10_A> for bool {
548 #[inline(always)]
549 fn from(variant: CSTRT10_A) -> Self {
550 variant as u8 != 0
551 }
552}
553impl CSTRT10_R {
554 #[doc = "Get enumerated values variant"]
555 #[inline(always)]
556 pub fn variant(&self) -> CSTRT10_A {
557 match self.bits {
558 false => CSTRT10_A::_0,
559 true => CSTRT10_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 == CSTRT10_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 == CSTRT10_A::_1
571 }
572}
573#[doc = "Field `CSTRT10` writer - Channel 10 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
574pub type CSTRT10_W<'a, const O: u8> = crate::BitWriter<'a, u32, GTSTR_SPEC, CSTRT10_A, O>;
575impl<'a, const O: u8> CSTRT10_W<'a, O> {
576 #[doc = "No effect (write) / counter stop (read)"]
577 #[inline(always)]
578 pub fn _0(self) -> &'a mut W {
579 self.variant(CSTRT10_A::_0)
580 }
581 #[doc = "GPT3210.GTCNT counter starts (write) / Counter running (read)"]
582 #[inline(always)]
583 pub fn _1(self) -> &'a mut W {
584 self.variant(CSTRT10_A::_1)
585 }
586}
587#[doc = "Field `CSTRT11` reader - Channel 11 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
588pub type CSTRT11_R = crate::BitReader<CSTRT11_A>;
589#[doc = "Channel 11 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running.\n\nValue on reset: 0"]
590#[derive(Clone, Copy, Debug, PartialEq, Eq)]
591pub enum CSTRT11_A {
592 #[doc = "0: No effect (write) / counter stop (read)"]
593 _0 = 0,
594 #[doc = "1: GPT3211.GTCNT counter starts (write) / Counter running (read)"]
595 _1 = 1,
596}
597impl From<CSTRT11_A> for bool {
598 #[inline(always)]
599 fn from(variant: CSTRT11_A) -> Self {
600 variant as u8 != 0
601 }
602}
603impl CSTRT11_R {
604 #[doc = "Get enumerated values variant"]
605 #[inline(always)]
606 pub fn variant(&self) -> CSTRT11_A {
607 match self.bits {
608 false => CSTRT11_A::_0,
609 true => CSTRT11_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 == CSTRT11_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 == CSTRT11_A::_1
621 }
622}
623#[doc = "Field `CSTRT11` writer - Channel 11 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
624pub type CSTRT11_W<'a, const O: u8> = crate::BitWriter<'a, u32, GTSTR_SPEC, CSTRT11_A, O>;
625impl<'a, const O: u8> CSTRT11_W<'a, O> {
626 #[doc = "No effect (write) / counter stop (read)"]
627 #[inline(always)]
628 pub fn _0(self) -> &'a mut W {
629 self.variant(CSTRT11_A::_0)
630 }
631 #[doc = "GPT3211.GTCNT counter starts (write) / Counter running (read)"]
632 #[inline(always)]
633 pub fn _1(self) -> &'a mut W {
634 self.variant(CSTRT11_A::_1)
635 }
636}
637#[doc = "Field `CSTRT12` reader - Channel 12 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
638pub type CSTRT12_R = crate::BitReader<CSTRT12_A>;
639#[doc = "Channel 12 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running.\n\nValue on reset: 0"]
640#[derive(Clone, Copy, Debug, PartialEq, Eq)]
641pub enum CSTRT12_A {
642 #[doc = "0: No effect (write) / counter stop (read)"]
643 _0 = 0,
644 #[doc = "1: GPT3212.GTCNT counter starts (write) / Counter running (read)"]
645 _1 = 1,
646}
647impl From<CSTRT12_A> for bool {
648 #[inline(always)]
649 fn from(variant: CSTRT12_A) -> Self {
650 variant as u8 != 0
651 }
652}
653impl CSTRT12_R {
654 #[doc = "Get enumerated values variant"]
655 #[inline(always)]
656 pub fn variant(&self) -> CSTRT12_A {
657 match self.bits {
658 false => CSTRT12_A::_0,
659 true => CSTRT12_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 == CSTRT12_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 == CSTRT12_A::_1
671 }
672}
673#[doc = "Field `CSTRT12` writer - Channel 12 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
674pub type CSTRT12_W<'a, const O: u8> = crate::BitWriter<'a, u32, GTSTR_SPEC, CSTRT12_A, O>;
675impl<'a, const O: u8> CSTRT12_W<'a, O> {
676 #[doc = "No effect (write) / counter stop (read)"]
677 #[inline(always)]
678 pub fn _0(self) -> &'a mut W {
679 self.variant(CSTRT12_A::_0)
680 }
681 #[doc = "GPT3212.GTCNT counter starts (write) / Counter running (read)"]
682 #[inline(always)]
683 pub fn _1(self) -> &'a mut W {
684 self.variant(CSTRT12_A::_1)
685 }
686}
687impl R {
688 #[doc = "Bit 0 - Channel 0 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
689 #[inline(always)]
690 pub fn cstrt0(&self) -> CSTRT0_R {
691 CSTRT0_R::new((self.bits & 1) != 0)
692 }
693 #[doc = "Bit 1 - Channel 1 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
694 #[inline(always)]
695 pub fn cstrt1(&self) -> CSTRT1_R {
696 CSTRT1_R::new(((self.bits >> 1) & 1) != 0)
697 }
698 #[doc = "Bit 2 - Channel 2 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
699 #[inline(always)]
700 pub fn cstrt2(&self) -> CSTRT2_R {
701 CSTRT2_R::new(((self.bits >> 2) & 1) != 0)
702 }
703 #[doc = "Bit 3 - Channel 3 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
704 #[inline(always)]
705 pub fn cstrt3(&self) -> CSTRT3_R {
706 CSTRT3_R::new(((self.bits >> 3) & 1) != 0)
707 }
708 #[doc = "Bit 4 - Channel 4 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
709 #[inline(always)]
710 pub fn cstrt4(&self) -> CSTRT4_R {
711 CSTRT4_R::new(((self.bits >> 4) & 1) != 0)
712 }
713 #[doc = "Bit 5 - Channel 5 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
714 #[inline(always)]
715 pub fn cstrt5(&self) -> CSTRT5_R {
716 CSTRT5_R::new(((self.bits >> 5) & 1) != 0)
717 }
718 #[doc = "Bit 6 - Channel 6 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
719 #[inline(always)]
720 pub fn cstrt6(&self) -> CSTRT6_R {
721 CSTRT6_R::new(((self.bits >> 6) & 1) != 0)
722 }
723 #[doc = "Bit 7 - Channel 7 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
724 #[inline(always)]
725 pub fn cstrt7(&self) -> CSTRT7_R {
726 CSTRT7_R::new(((self.bits >> 7) & 1) != 0)
727 }
728 #[doc = "Bit 8 - Channel 8 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
729 #[inline(always)]
730 pub fn cstrt8(&self) -> CSTRT8_R {
731 CSTRT8_R::new(((self.bits >> 8) & 1) != 0)
732 }
733 #[doc = "Bit 9 - Channel 9 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
734 #[inline(always)]
735 pub fn cstrt9(&self) -> CSTRT9_R {
736 CSTRT9_R::new(((self.bits >> 9) & 1) != 0)
737 }
738 #[doc = "Bit 10 - Channel 10 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
739 #[inline(always)]
740 pub fn cstrt10(&self) -> CSTRT10_R {
741 CSTRT10_R::new(((self.bits >> 10) & 1) != 0)
742 }
743 #[doc = "Bit 11 - Channel 11 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
744 #[inline(always)]
745 pub fn cstrt11(&self) -> CSTRT11_R {
746 CSTRT11_R::new(((self.bits >> 11) & 1) != 0)
747 }
748 #[doc = "Bit 12 - Channel 12 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
749 #[inline(always)]
750 pub fn cstrt12(&self) -> CSTRT12_R {
751 CSTRT12_R::new(((self.bits >> 12) & 1) != 0)
752 }
753}
754impl W {
755 #[doc = "Bit 0 - Channel 0 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
756 #[inline(always)]
757 #[must_use]
758 pub fn cstrt0(&mut self) -> CSTRT0_W<0> {
759 CSTRT0_W::new(self)
760 }
761 #[doc = "Bit 1 - Channel 1 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
762 #[inline(always)]
763 #[must_use]
764 pub fn cstrt1(&mut self) -> CSTRT1_W<1> {
765 CSTRT1_W::new(self)
766 }
767 #[doc = "Bit 2 - Channel 2 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
768 #[inline(always)]
769 #[must_use]
770 pub fn cstrt2(&mut self) -> CSTRT2_W<2> {
771 CSTRT2_W::new(self)
772 }
773 #[doc = "Bit 3 - Channel 3 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
774 #[inline(always)]
775 #[must_use]
776 pub fn cstrt3(&mut self) -> CSTRT3_W<3> {
777 CSTRT3_W::new(self)
778 }
779 #[doc = "Bit 4 - Channel 4 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
780 #[inline(always)]
781 #[must_use]
782 pub fn cstrt4(&mut self) -> CSTRT4_W<4> {
783 CSTRT4_W::new(self)
784 }
785 #[doc = "Bit 5 - Channel 5 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
786 #[inline(always)]
787 #[must_use]
788 pub fn cstrt5(&mut self) -> CSTRT5_W<5> {
789 CSTRT5_W::new(self)
790 }
791 #[doc = "Bit 6 - Channel 6 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
792 #[inline(always)]
793 #[must_use]
794 pub fn cstrt6(&mut self) -> CSTRT6_W<6> {
795 CSTRT6_W::new(self)
796 }
797 #[doc = "Bit 7 - Channel 7 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
798 #[inline(always)]
799 #[must_use]
800 pub fn cstrt7(&mut self) -> CSTRT7_W<7> {
801 CSTRT7_W::new(self)
802 }
803 #[doc = "Bit 8 - Channel 8 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
804 #[inline(always)]
805 #[must_use]
806 pub fn cstrt8(&mut self) -> CSTRT8_W<8> {
807 CSTRT8_W::new(self)
808 }
809 #[doc = "Bit 9 - Channel 9 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
810 #[inline(always)]
811 #[must_use]
812 pub fn cstrt9(&mut self) -> CSTRT9_W<9> {
813 CSTRT9_W::new(self)
814 }
815 #[doc = "Bit 10 - Channel 10 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
816 #[inline(always)]
817 #[must_use]
818 pub fn cstrt10(&mut self) -> CSTRT10_W<10> {
819 CSTRT10_W::new(self)
820 }
821 #[doc = "Bit 11 - Channel 11 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
822 #[inline(always)]
823 #[must_use]
824 pub fn cstrt11(&mut self) -> CSTRT11_W<11> {
825 CSTRT11_W::new(self)
826 }
827 #[doc = "Bit 12 - Channel 12 GTCNT Count StartRead data shows each channel's counter status (GTCR.CST bit). 0 means counter stop. 1 means counter running."]
828 #[inline(always)]
829 #[must_use]
830 pub fn cstrt12(&mut self) -> CSTRT12_W<12> {
831 CSTRT12_W::new(self)
832 }
833 #[doc = "Writes raw bits to the register."]
834 #[inline(always)]
835 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
836 self.0.bits(bits);
837 self
838 }
839}
840#[doc = "General PWM Timer Software Start 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 [gtstr](index.html) module"]
841pub struct GTSTR_SPEC;
842impl crate::RegisterSpec for GTSTR_SPEC {
843 type Ux = u32;
844}
845#[doc = "`read()` method returns [gtstr::R](R) reader structure"]
846impl crate::Readable for GTSTR_SPEC {
847 type Reader = R;
848}
849#[doc = "`write(|w| ..)` method takes [gtstr::W](W) writer structure"]
850impl crate::Writable for GTSTR_SPEC {
851 type Writer = W;
852 const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
853 const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
854}
855#[doc = "`reset()` method sets GTSTR to value 0"]
856impl crate::Resettable for GTSTR_SPEC {
857 const RESET_VALUE: Self::Ux = 0;
858}