1#[doc = "Register `INTENSET` reader"]
2pub struct R(crate::R<INTENSET_SPEC>);
3impl core::ops::Deref for R {
4 type Target = crate::R<INTENSET_SPEC>;
5 #[inline(always)]
6 fn deref(&self) -> &Self::Target {
7 &self.0
8 }
9}
10impl From<crate::R<INTENSET_SPEC>> for R {
11 #[inline(always)]
12 fn from(reader: crate::R<INTENSET_SPEC>) -> Self {
13 R(reader)
14 }
15}
16#[doc = "Register `INTENSET` writer"]
17pub struct W(crate::W<INTENSET_SPEC>);
18impl core::ops::Deref for W {
19 type Target = crate::W<INTENSET_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<INTENSET_SPEC>> for W {
32 #[inline(always)]
33 fn from(writer: crate::W<INTENSET_SPEC>) -> Self {
34 W(writer)
35 }
36}
37#[doc = "Field `RXRDYEN` reader - When 1, enables an interrupt when there is a received character available to be read from the RXDAT register."]
38pub struct RXRDYEN_R(crate::FieldReader<bool, bool>);
39impl RXRDYEN_R {
40 pub(crate) fn new(bits: bool) -> Self {
41 RXRDYEN_R(crate::FieldReader::new(bits))
42 }
43}
44impl core::ops::Deref for RXRDYEN_R {
45 type Target = crate::FieldReader<bool, bool>;
46 #[inline(always)]
47 fn deref(&self) -> &Self::Target {
48 &self.0
49 }
50}
51#[doc = "Field `RXRDYEN` writer - When 1, enables an interrupt when there is a received character available to be read from the RXDAT register."]
52pub struct RXRDYEN_W<'a> {
53 w: &'a mut W,
54}
55impl<'a> RXRDYEN_W<'a> {
56 #[doc = r"Sets the field bit"]
57 #[inline(always)]
58 pub fn set_bit(self) -> &'a mut W {
59 self.bit(true)
60 }
61 #[doc = r"Clears the field bit"]
62 #[inline(always)]
63 pub fn clear_bit(self) -> &'a mut W {
64 self.bit(false)
65 }
66 #[doc = r"Writes raw bits to the field"]
67 #[inline(always)]
68 pub fn bit(self, value: bool) -> &'a mut W {
69 self.w.bits = (self.w.bits & !0x01) | (value as u32 & 0x01);
70 self.w
71 }
72}
73#[doc = "Field `TXRDYEN` reader - When 1, enables an interrupt when the TXDAT register is available to take another character to transmit."]
74pub struct TXRDYEN_R(crate::FieldReader<bool, bool>);
75impl TXRDYEN_R {
76 pub(crate) fn new(bits: bool) -> Self {
77 TXRDYEN_R(crate::FieldReader::new(bits))
78 }
79}
80impl core::ops::Deref for TXRDYEN_R {
81 type Target = crate::FieldReader<bool, bool>;
82 #[inline(always)]
83 fn deref(&self) -> &Self::Target {
84 &self.0
85 }
86}
87#[doc = "Field `TXRDYEN` writer - When 1, enables an interrupt when the TXDAT register is available to take another character to transmit."]
88pub struct TXRDYEN_W<'a> {
89 w: &'a mut W,
90}
91impl<'a> TXRDYEN_W<'a> {
92 #[doc = r"Sets the field bit"]
93 #[inline(always)]
94 pub fn set_bit(self) -> &'a mut W {
95 self.bit(true)
96 }
97 #[doc = r"Clears the field bit"]
98 #[inline(always)]
99 pub fn clear_bit(self) -> &'a mut W {
100 self.bit(false)
101 }
102 #[doc = r"Writes raw bits to the field"]
103 #[inline(always)]
104 pub fn bit(self, value: bool) -> &'a mut W {
105 self.w.bits = (self.w.bits & !(0x01 << 2)) | ((value as u32 & 0x01) << 2);
106 self.w
107 }
108}
109#[doc = "Field `TXIDLEEN` reader - When 1, enables an interrupt when the transmitter becomes idle (TXIDLE = 1)."]
110pub struct TXIDLEEN_R(crate::FieldReader<bool, bool>);
111impl TXIDLEEN_R {
112 pub(crate) fn new(bits: bool) -> Self {
113 TXIDLEEN_R(crate::FieldReader::new(bits))
114 }
115}
116impl core::ops::Deref for TXIDLEEN_R {
117 type Target = crate::FieldReader<bool, bool>;
118 #[inline(always)]
119 fn deref(&self) -> &Self::Target {
120 &self.0
121 }
122}
123#[doc = "Field `TXIDLEEN` writer - When 1, enables an interrupt when the transmitter becomes idle (TXIDLE = 1)."]
124pub struct TXIDLEEN_W<'a> {
125 w: &'a mut W,
126}
127impl<'a> TXIDLEEN_W<'a> {
128 #[doc = r"Sets the field bit"]
129 #[inline(always)]
130 pub fn set_bit(self) -> &'a mut W {
131 self.bit(true)
132 }
133 #[doc = r"Clears the field bit"]
134 #[inline(always)]
135 pub fn clear_bit(self) -> &'a mut W {
136 self.bit(false)
137 }
138 #[doc = r"Writes raw bits to the field"]
139 #[inline(always)]
140 pub fn bit(self, value: bool) -> &'a mut W {
141 self.w.bits = (self.w.bits & !(0x01 << 3)) | ((value as u32 & 0x01) << 3);
142 self.w
143 }
144}
145#[doc = "Field `DELTACTSEN` reader - When 1, enables an interrupt when there is a change in the state of the CTS input."]
146pub struct DELTACTSEN_R(crate::FieldReader<bool, bool>);
147impl DELTACTSEN_R {
148 pub(crate) fn new(bits: bool) -> Self {
149 DELTACTSEN_R(crate::FieldReader::new(bits))
150 }
151}
152impl core::ops::Deref for DELTACTSEN_R {
153 type Target = crate::FieldReader<bool, bool>;
154 #[inline(always)]
155 fn deref(&self) -> &Self::Target {
156 &self.0
157 }
158}
159#[doc = "Field `DELTACTSEN` writer - When 1, enables an interrupt when there is a change in the state of the CTS input."]
160pub struct DELTACTSEN_W<'a> {
161 w: &'a mut W,
162}
163impl<'a> DELTACTSEN_W<'a> {
164 #[doc = r"Sets the field bit"]
165 #[inline(always)]
166 pub fn set_bit(self) -> &'a mut W {
167 self.bit(true)
168 }
169 #[doc = r"Clears the field bit"]
170 #[inline(always)]
171 pub fn clear_bit(self) -> &'a mut W {
172 self.bit(false)
173 }
174 #[doc = r"Writes raw bits to the field"]
175 #[inline(always)]
176 pub fn bit(self, value: bool) -> &'a mut W {
177 self.w.bits = (self.w.bits & !(0x01 << 5)) | ((value as u32 & 0x01) << 5);
178 self.w
179 }
180}
181#[doc = "Field `TXDISEN` reader - When 1, enables an interrupt when the transmitter is fully disabled as indicated by the TXDISINT flag in STAT. See description of the TXDISINT bit for details."]
182pub struct TXDISEN_R(crate::FieldReader<bool, bool>);
183impl TXDISEN_R {
184 pub(crate) fn new(bits: bool) -> Self {
185 TXDISEN_R(crate::FieldReader::new(bits))
186 }
187}
188impl core::ops::Deref for TXDISEN_R {
189 type Target = crate::FieldReader<bool, bool>;
190 #[inline(always)]
191 fn deref(&self) -> &Self::Target {
192 &self.0
193 }
194}
195#[doc = "Field `TXDISEN` writer - When 1, enables an interrupt when the transmitter is fully disabled as indicated by the TXDISINT flag in STAT. See description of the TXDISINT bit for details."]
196pub struct TXDISEN_W<'a> {
197 w: &'a mut W,
198}
199impl<'a> TXDISEN_W<'a> {
200 #[doc = r"Sets the field bit"]
201 #[inline(always)]
202 pub fn set_bit(self) -> &'a mut W {
203 self.bit(true)
204 }
205 #[doc = r"Clears the field bit"]
206 #[inline(always)]
207 pub fn clear_bit(self) -> &'a mut W {
208 self.bit(false)
209 }
210 #[doc = r"Writes raw bits to the field"]
211 #[inline(always)]
212 pub fn bit(self, value: bool) -> &'a mut W {
213 self.w.bits = (self.w.bits & !(0x01 << 6)) | ((value as u32 & 0x01) << 6);
214 self.w
215 }
216}
217#[doc = "Field `OVERRUNEN` reader - When 1, enables an interrupt when an overrun error occurred."]
218pub struct OVERRUNEN_R(crate::FieldReader<bool, bool>);
219impl OVERRUNEN_R {
220 pub(crate) fn new(bits: bool) -> Self {
221 OVERRUNEN_R(crate::FieldReader::new(bits))
222 }
223}
224impl core::ops::Deref for OVERRUNEN_R {
225 type Target = crate::FieldReader<bool, bool>;
226 #[inline(always)]
227 fn deref(&self) -> &Self::Target {
228 &self.0
229 }
230}
231#[doc = "Field `OVERRUNEN` writer - When 1, enables an interrupt when an overrun error occurred."]
232pub struct OVERRUNEN_W<'a> {
233 w: &'a mut W,
234}
235impl<'a> OVERRUNEN_W<'a> {
236 #[doc = r"Sets the field bit"]
237 #[inline(always)]
238 pub fn set_bit(self) -> &'a mut W {
239 self.bit(true)
240 }
241 #[doc = r"Clears the field bit"]
242 #[inline(always)]
243 pub fn clear_bit(self) -> &'a mut W {
244 self.bit(false)
245 }
246 #[doc = r"Writes raw bits to the field"]
247 #[inline(always)]
248 pub fn bit(self, value: bool) -> &'a mut W {
249 self.w.bits = (self.w.bits & !(0x01 << 8)) | ((value as u32 & 0x01) << 8);
250 self.w
251 }
252}
253#[doc = "Field `DELTARXBRKEN` reader - When 1, enables an interrupt when a change of state has occurred in the detection of a received break condition (break condition asserted or deasserted)."]
254pub struct DELTARXBRKEN_R(crate::FieldReader<bool, bool>);
255impl DELTARXBRKEN_R {
256 pub(crate) fn new(bits: bool) -> Self {
257 DELTARXBRKEN_R(crate::FieldReader::new(bits))
258 }
259}
260impl core::ops::Deref for DELTARXBRKEN_R {
261 type Target = crate::FieldReader<bool, bool>;
262 #[inline(always)]
263 fn deref(&self) -> &Self::Target {
264 &self.0
265 }
266}
267#[doc = "Field `DELTARXBRKEN` writer - When 1, enables an interrupt when a change of state has occurred in the detection of a received break condition (break condition asserted or deasserted)."]
268pub struct DELTARXBRKEN_W<'a> {
269 w: &'a mut W,
270}
271impl<'a> DELTARXBRKEN_W<'a> {
272 #[doc = r"Sets the field bit"]
273 #[inline(always)]
274 pub fn set_bit(self) -> &'a mut W {
275 self.bit(true)
276 }
277 #[doc = r"Clears the field bit"]
278 #[inline(always)]
279 pub fn clear_bit(self) -> &'a mut W {
280 self.bit(false)
281 }
282 #[doc = r"Writes raw bits to the field"]
283 #[inline(always)]
284 pub fn bit(self, value: bool) -> &'a mut W {
285 self.w.bits = (self.w.bits & !(0x01 << 11)) | ((value as u32 & 0x01) << 11);
286 self.w
287 }
288}
289#[doc = "Field `STARTEN` reader - When 1, enables an interrupt when a received start bit has been detected."]
290pub struct STARTEN_R(crate::FieldReader<bool, bool>);
291impl STARTEN_R {
292 pub(crate) fn new(bits: bool) -> Self {
293 STARTEN_R(crate::FieldReader::new(bits))
294 }
295}
296impl core::ops::Deref for STARTEN_R {
297 type Target = crate::FieldReader<bool, bool>;
298 #[inline(always)]
299 fn deref(&self) -> &Self::Target {
300 &self.0
301 }
302}
303#[doc = "Field `STARTEN` writer - When 1, enables an interrupt when a received start bit has been detected."]
304pub struct STARTEN_W<'a> {
305 w: &'a mut W,
306}
307impl<'a> STARTEN_W<'a> {
308 #[doc = r"Sets the field bit"]
309 #[inline(always)]
310 pub fn set_bit(self) -> &'a mut W {
311 self.bit(true)
312 }
313 #[doc = r"Clears the field bit"]
314 #[inline(always)]
315 pub fn clear_bit(self) -> &'a mut W {
316 self.bit(false)
317 }
318 #[doc = r"Writes raw bits to the field"]
319 #[inline(always)]
320 pub fn bit(self, value: bool) -> &'a mut W {
321 self.w.bits = (self.w.bits & !(0x01 << 12)) | ((value as u32 & 0x01) << 12);
322 self.w
323 }
324}
325#[doc = "Field `FRAMERREN` reader - When 1, enables an interrupt when a framing error has been detected."]
326pub struct FRAMERREN_R(crate::FieldReader<bool, bool>);
327impl FRAMERREN_R {
328 pub(crate) fn new(bits: bool) -> Self {
329 FRAMERREN_R(crate::FieldReader::new(bits))
330 }
331}
332impl core::ops::Deref for FRAMERREN_R {
333 type Target = crate::FieldReader<bool, bool>;
334 #[inline(always)]
335 fn deref(&self) -> &Self::Target {
336 &self.0
337 }
338}
339#[doc = "Field `FRAMERREN` writer - When 1, enables an interrupt when a framing error has been detected."]
340pub struct FRAMERREN_W<'a> {
341 w: &'a mut W,
342}
343impl<'a> FRAMERREN_W<'a> {
344 #[doc = r"Sets the field bit"]
345 #[inline(always)]
346 pub fn set_bit(self) -> &'a mut W {
347 self.bit(true)
348 }
349 #[doc = r"Clears the field bit"]
350 #[inline(always)]
351 pub fn clear_bit(self) -> &'a mut W {
352 self.bit(false)
353 }
354 #[doc = r"Writes raw bits to the field"]
355 #[inline(always)]
356 pub fn bit(self, value: bool) -> &'a mut W {
357 self.w.bits = (self.w.bits & !(0x01 << 13)) | ((value as u32 & 0x01) << 13);
358 self.w
359 }
360}
361#[doc = "Field `PARITYERREN` reader - When 1, enables an interrupt when a parity error has been detected."]
362pub struct PARITYERREN_R(crate::FieldReader<bool, bool>);
363impl PARITYERREN_R {
364 pub(crate) fn new(bits: bool) -> Self {
365 PARITYERREN_R(crate::FieldReader::new(bits))
366 }
367}
368impl core::ops::Deref for PARITYERREN_R {
369 type Target = crate::FieldReader<bool, bool>;
370 #[inline(always)]
371 fn deref(&self) -> &Self::Target {
372 &self.0
373 }
374}
375#[doc = "Field `PARITYERREN` writer - When 1, enables an interrupt when a parity error has been detected."]
376pub struct PARITYERREN_W<'a> {
377 w: &'a mut W,
378}
379impl<'a> PARITYERREN_W<'a> {
380 #[doc = r"Sets the field bit"]
381 #[inline(always)]
382 pub fn set_bit(self) -> &'a mut W {
383 self.bit(true)
384 }
385 #[doc = r"Clears the field bit"]
386 #[inline(always)]
387 pub fn clear_bit(self) -> &'a mut W {
388 self.bit(false)
389 }
390 #[doc = r"Writes raw bits to the field"]
391 #[inline(always)]
392 pub fn bit(self, value: bool) -> &'a mut W {
393 self.w.bits = (self.w.bits & !(0x01 << 14)) | ((value as u32 & 0x01) << 14);
394 self.w
395 }
396}
397#[doc = "Field `RXNOISEEN` reader - When 1, enables an interrupt when noise is detected."]
398pub struct RXNOISEEN_R(crate::FieldReader<bool, bool>);
399impl RXNOISEEN_R {
400 pub(crate) fn new(bits: bool) -> Self {
401 RXNOISEEN_R(crate::FieldReader::new(bits))
402 }
403}
404impl core::ops::Deref for RXNOISEEN_R {
405 type Target = crate::FieldReader<bool, bool>;
406 #[inline(always)]
407 fn deref(&self) -> &Self::Target {
408 &self.0
409 }
410}
411#[doc = "Field `RXNOISEEN` writer - When 1, enables an interrupt when noise is detected."]
412pub struct RXNOISEEN_W<'a> {
413 w: &'a mut W,
414}
415impl<'a> RXNOISEEN_W<'a> {
416 #[doc = r"Sets the field bit"]
417 #[inline(always)]
418 pub fn set_bit(self) -> &'a mut W {
419 self.bit(true)
420 }
421 #[doc = r"Clears the field bit"]
422 #[inline(always)]
423 pub fn clear_bit(self) -> &'a mut W {
424 self.bit(false)
425 }
426 #[doc = r"Writes raw bits to the field"]
427 #[inline(always)]
428 pub fn bit(self, value: bool) -> &'a mut W {
429 self.w.bits = (self.w.bits & !(0x01 << 15)) | ((value as u32 & 0x01) << 15);
430 self.w
431 }
432}
433#[doc = "Field `ABERREN` reader - When 1, enables an interrupt when an autobaud error occurs."]
434pub struct ABERREN_R(crate::FieldReader<bool, bool>);
435impl ABERREN_R {
436 pub(crate) fn new(bits: bool) -> Self {
437 ABERREN_R(crate::FieldReader::new(bits))
438 }
439}
440impl core::ops::Deref for ABERREN_R {
441 type Target = crate::FieldReader<bool, bool>;
442 #[inline(always)]
443 fn deref(&self) -> &Self::Target {
444 &self.0
445 }
446}
447#[doc = "Field `ABERREN` writer - When 1, enables an interrupt when an autobaud error occurs."]
448pub struct ABERREN_W<'a> {
449 w: &'a mut W,
450}
451impl<'a> ABERREN_W<'a> {
452 #[doc = r"Sets the field bit"]
453 #[inline(always)]
454 pub fn set_bit(self) -> &'a mut W {
455 self.bit(true)
456 }
457 #[doc = r"Clears the field bit"]
458 #[inline(always)]
459 pub fn clear_bit(self) -> &'a mut W {
460 self.bit(false)
461 }
462 #[doc = r"Writes raw bits to the field"]
463 #[inline(always)]
464 pub fn bit(self, value: bool) -> &'a mut W {
465 self.w.bits = (self.w.bits & !(0x01 << 16)) | ((value as u32 & 0x01) << 16);
466 self.w
467 }
468}
469impl R {
470 #[doc = "Bit 0 - When 1, enables an interrupt when there is a received character available to be read from the RXDAT register."]
471 #[inline(always)]
472 pub fn rxrdyen(&self) -> RXRDYEN_R {
473 RXRDYEN_R::new((self.bits & 0x01) != 0)
474 }
475 #[doc = "Bit 2 - When 1, enables an interrupt when the TXDAT register is available to take another character to transmit."]
476 #[inline(always)]
477 pub fn txrdyen(&self) -> TXRDYEN_R {
478 TXRDYEN_R::new(((self.bits >> 2) & 0x01) != 0)
479 }
480 #[doc = "Bit 3 - When 1, enables an interrupt when the transmitter becomes idle (TXIDLE = 1)."]
481 #[inline(always)]
482 pub fn txidleen(&self) -> TXIDLEEN_R {
483 TXIDLEEN_R::new(((self.bits >> 3) & 0x01) != 0)
484 }
485 #[doc = "Bit 5 - When 1, enables an interrupt when there is a change in the state of the CTS input."]
486 #[inline(always)]
487 pub fn deltactsen(&self) -> DELTACTSEN_R {
488 DELTACTSEN_R::new(((self.bits >> 5) & 0x01) != 0)
489 }
490 #[doc = "Bit 6 - When 1, enables an interrupt when the transmitter is fully disabled as indicated by the TXDISINT flag in STAT. See description of the TXDISINT bit for details."]
491 #[inline(always)]
492 pub fn txdisen(&self) -> TXDISEN_R {
493 TXDISEN_R::new(((self.bits >> 6) & 0x01) != 0)
494 }
495 #[doc = "Bit 8 - When 1, enables an interrupt when an overrun error occurred."]
496 #[inline(always)]
497 pub fn overrunen(&self) -> OVERRUNEN_R {
498 OVERRUNEN_R::new(((self.bits >> 8) & 0x01) != 0)
499 }
500 #[doc = "Bit 11 - When 1, enables an interrupt when a change of state has occurred in the detection of a received break condition (break condition asserted or deasserted)."]
501 #[inline(always)]
502 pub fn deltarxbrken(&self) -> DELTARXBRKEN_R {
503 DELTARXBRKEN_R::new(((self.bits >> 11) & 0x01) != 0)
504 }
505 #[doc = "Bit 12 - When 1, enables an interrupt when a received start bit has been detected."]
506 #[inline(always)]
507 pub fn starten(&self) -> STARTEN_R {
508 STARTEN_R::new(((self.bits >> 12) & 0x01) != 0)
509 }
510 #[doc = "Bit 13 - When 1, enables an interrupt when a framing error has been detected."]
511 #[inline(always)]
512 pub fn framerren(&self) -> FRAMERREN_R {
513 FRAMERREN_R::new(((self.bits >> 13) & 0x01) != 0)
514 }
515 #[doc = "Bit 14 - When 1, enables an interrupt when a parity error has been detected."]
516 #[inline(always)]
517 pub fn parityerren(&self) -> PARITYERREN_R {
518 PARITYERREN_R::new(((self.bits >> 14) & 0x01) != 0)
519 }
520 #[doc = "Bit 15 - When 1, enables an interrupt when noise is detected."]
521 #[inline(always)]
522 pub fn rxnoiseen(&self) -> RXNOISEEN_R {
523 RXNOISEEN_R::new(((self.bits >> 15) & 0x01) != 0)
524 }
525 #[doc = "Bit 16 - When 1, enables an interrupt when an autobaud error occurs."]
526 #[inline(always)]
527 pub fn aberren(&self) -> ABERREN_R {
528 ABERREN_R::new(((self.bits >> 16) & 0x01) != 0)
529 }
530}
531impl W {
532 #[doc = "Bit 0 - When 1, enables an interrupt when there is a received character available to be read from the RXDAT register."]
533 #[inline(always)]
534 pub fn rxrdyen(&mut self) -> RXRDYEN_W {
535 RXRDYEN_W { w: self }
536 }
537 #[doc = "Bit 2 - When 1, enables an interrupt when the TXDAT register is available to take another character to transmit."]
538 #[inline(always)]
539 pub fn txrdyen(&mut self) -> TXRDYEN_W {
540 TXRDYEN_W { w: self }
541 }
542 #[doc = "Bit 3 - When 1, enables an interrupt when the transmitter becomes idle (TXIDLE = 1)."]
543 #[inline(always)]
544 pub fn txidleen(&mut self) -> TXIDLEEN_W {
545 TXIDLEEN_W { w: self }
546 }
547 #[doc = "Bit 5 - When 1, enables an interrupt when there is a change in the state of the CTS input."]
548 #[inline(always)]
549 pub fn deltactsen(&mut self) -> DELTACTSEN_W {
550 DELTACTSEN_W { w: self }
551 }
552 #[doc = "Bit 6 - When 1, enables an interrupt when the transmitter is fully disabled as indicated by the TXDISINT flag in STAT. See description of the TXDISINT bit for details."]
553 #[inline(always)]
554 pub fn txdisen(&mut self) -> TXDISEN_W {
555 TXDISEN_W { w: self }
556 }
557 #[doc = "Bit 8 - When 1, enables an interrupt when an overrun error occurred."]
558 #[inline(always)]
559 pub fn overrunen(&mut self) -> OVERRUNEN_W {
560 OVERRUNEN_W { w: self }
561 }
562 #[doc = "Bit 11 - When 1, enables an interrupt when a change of state has occurred in the detection of a received break condition (break condition asserted or deasserted)."]
563 #[inline(always)]
564 pub fn deltarxbrken(&mut self) -> DELTARXBRKEN_W {
565 DELTARXBRKEN_W { w: self }
566 }
567 #[doc = "Bit 12 - When 1, enables an interrupt when a received start bit has been detected."]
568 #[inline(always)]
569 pub fn starten(&mut self) -> STARTEN_W {
570 STARTEN_W { w: self }
571 }
572 #[doc = "Bit 13 - When 1, enables an interrupt when a framing error has been detected."]
573 #[inline(always)]
574 pub fn framerren(&mut self) -> FRAMERREN_W {
575 FRAMERREN_W { w: self }
576 }
577 #[doc = "Bit 14 - When 1, enables an interrupt when a parity error has been detected."]
578 #[inline(always)]
579 pub fn parityerren(&mut self) -> PARITYERREN_W {
580 PARITYERREN_W { w: self }
581 }
582 #[doc = "Bit 15 - When 1, enables an interrupt when noise is detected."]
583 #[inline(always)]
584 pub fn rxnoiseen(&mut self) -> RXNOISEEN_W {
585 RXNOISEEN_W { w: self }
586 }
587 #[doc = "Bit 16 - When 1, enables an interrupt when an autobaud error occurs."]
588 #[inline(always)]
589 pub fn aberren(&mut self) -> ABERREN_W {
590 ABERREN_W { w: self }
591 }
592 #[doc = "Writes raw bits to the register."]
593 #[inline(always)]
594 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
595 self.0.bits(bits);
596 self
597 }
598}
599#[doc = "Interrupt Enable read and Set register. Contains an individual interrupt enable bit for each potential USART interrupt. A complete value may be read from this register. Writing a 1 to any implemented bit position causes that bit to be set.\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 [intenset](index.html) module"]
600pub struct INTENSET_SPEC;
601impl crate::RegisterSpec for INTENSET_SPEC {
602 type Ux = u32;
603}
604#[doc = "`read()` method returns [intenset::R](R) reader structure"]
605impl crate::Readable for INTENSET_SPEC {
606 type Reader = R;
607}
608#[doc = "`write(|w| ..)` method takes [intenset::W](W) writer structure"]
609impl crate::Writable for INTENSET_SPEC {
610 type Writer = W;
611}
612#[doc = "`reset()` method sets INTENSET to value 0"]
613impl crate::Resettable for INTENSET_SPEC {
614 #[inline(always)]
615 fn reset_value() -> Self::Ux {
616 0
617 }
618}