Use native u32 as PWM Duty type

nickray · nickray · commit 5d4148de43c4 · 2019-03-18T02:15:10.000+01:00
diff --git a/src/pwm.rs b/src/pwm.rs
@@ -166,7 +166,7 @@ macro_rules! hal {
             }
 
             impl hal::PwmPin for Pwm<$TIMX, C1> {
-                type Duty = u16;
+                type Duty = u32;
 
                 fn disable(&mut self) {
                     unsafe { bb::clear(&(*$TIMX::ptr()).ccer, 0) }
@@ -176,21 +176,21 @@ macro_rules! hal {
                     unsafe { bb::set(&(*$TIMX::ptr()).ccer, 0) }
                 }
 
-                fn get_duty(&self) -> u16 {
-                    unsafe { u16((*$TIMX::ptr()).ccr1.read().ccr1().bits()).unwrap() }
+                fn get_duty(&self) -> Self::Duty {
+                    unsafe { (*$TIMX::ptr()).ccr1.read().ccr1().bits() }
                 }
 
-                fn get_max_duty(&self) -> u16 {
-                    unsafe { u16((*$TIMX::ptr()).arr.read().arr().bits()).unwrap() }
+                fn get_max_duty(&self) -> Self::Duty {
+                    unsafe { (*$TIMX::ptr()).arr.read().arr().bits() }
                 }
 
-                fn set_duty(&mut self, duty: u16) {
-                    unsafe { (*$TIMX::ptr()).ccr1.write(|w| w.ccr1().bits(u32(duty))) }
+                fn set_duty(&mut self, duty: Self::Duty) {
+                    unsafe { (*$TIMX::ptr()).ccr1.write(|w| w.ccr1().bits(duty)) }
                 }
             }
 
             impl hal::PwmPin for Pwm<$TIMX, C2> {
-                type Duty = u16;
+                type Duty = u32;
 
                 fn disable(&mut self) {
                     unsafe { bb::clear(&(*$TIMX::ptr()).ccer, 4) }
@@ -200,21 +200,21 @@ macro_rules! hal {
                     unsafe { bb::set(&(*$TIMX::ptr()).ccer, 4) }
                 }
 
-                fn get_duty(&self) -> u16 {
-                    unsafe { u16((*$TIMX::ptr()).ccr2.read().ccr2().bits()).unwrap() }
+                fn get_duty(&self) -> Self::Duty {
+                    unsafe { (*$TIMX::ptr()).ccr2.read().ccr2().bits() }
                 }
 
-                fn get_max_duty(&self) -> u16 {
-                    unsafe { u16((*$TIMX::ptr()).arr.read().arr().bits()).unwrap() }
+                fn get_max_duty(&self) -> Self::Duty {
+                    unsafe { (*$TIMX::ptr()).arr.read().arr().bits() }
                 }
 
-                fn set_duty(&mut self, duty: u16) {
-                    unsafe { (*$TIMX::ptr()).ccr2.write(|w| w.ccr2().bits(u32(duty))) }
+                fn set_duty(&mut self, duty: Self::Duty) {
+                    unsafe { (*$TIMX::ptr()).ccr2.write(|w| w.ccr2().bits(duty)) }
                 }
             }
 
             impl hal::PwmPin for Pwm<$TIMX, C3> {
-                type Duty = u16;
+                type Duty = u32;
 
                 fn disable(&mut self) {
                     unsafe { bb::clear(&(*$TIMX::ptr()).ccer, 8) }
@@ -224,21 +224,21 @@ macro_rules! hal {
                     unsafe { bb::set(&(*$TIMX::ptr()).ccer, 8) }
                 }
 
-                fn get_duty(&self) -> u16 {
-                    unsafe { u16((*$TIMX::ptr()).ccr3.read().ccr3().bits()).unwrap() }
+                fn get_duty(&self) -> Self::Duty {
+                    unsafe { (*$TIMX::ptr()).ccr3.read().ccr3().bits() }
                 }
 
-                fn get_max_duty(&self) -> u16 {
-                    unsafe { u16((*$TIMX::ptr()).arr.read().arr().bits()).unwrap() }
+                fn get_max_duty(&self) -> Self::Duty {
+                    unsafe { (*$TIMX::ptr()).arr.read().arr().bits() }
                 }
 
-                fn set_duty(&mut self, duty: u16) {
-                    unsafe { (*$TIMX::ptr()).ccr3.write(|w| w.ccr3().bits(u32(duty))) }
+                fn set_duty(&mut self, duty: Self::Duty) {
+                    unsafe { (*$TIMX::ptr()).ccr3.write(|w| w.ccr3().bits(duty)) }
                 }
             }
 
             impl hal::PwmPin for Pwm<$TIMX, C4> {
-                type Duty = u16;
+                type Duty = u32;
 
                 fn disable(&mut self) {
                     unsafe { bb::clear(&(*$TIMX::ptr()).ccer, 12) }
@@ -248,16 +248,16 @@ macro_rules! hal {
                     unsafe { bb::set(&(*$TIMX::ptr()).ccer, 12) }
                 }
 
-                fn get_duty(&self) -> u16 {
-                    unsafe { u16((*$TIMX::ptr()).ccr4.read().ccr4().bits()).unwrap() }
+                fn get_duty(&self) -> Self::Duty {
+                    unsafe { (*$TIMX::ptr()).ccr4.read().ccr4().bits() }
                 }
 
-                fn get_max_duty(&self) -> u16 {
-                    unsafe { u16((*$TIMX::ptr()).arr.read().arr().bits()).unwrap() }
+                fn get_max_duty(&self) -> Self::Duty {
+                    unsafe { (*$TIMX::ptr()).arr.read().arr().bits() }
                 }
 
-                fn set_duty(&mut self, duty: u16) {
-                    unsafe { (*$TIMX::ptr()).ccr4.write(|w| w.ccr4().bits(u32(duty))) }
+                fn set_duty(&mut self, duty: Self::Duty) {
+                    unsafe { (*$TIMX::ptr()).ccr4.write(|w| w.ccr4().bits(duty)) }
                 }
             }
         )+

Original file line number	Diff line number	Diff line change
`@@ -166,7 +166,7 @@ macro_rules! hal {`
`166`	`166`	`}`
`167`	`167`
`168`	`168`	`impl hal::PwmPin for Pwm<$TIMX, C1> {`
`169`		`- type Duty = u16;`
	`169`	`+ type Duty = u32;`
`170`	`170`
`171`	`171`	`fn disable(&mut self) {`
`172`	`172`	`unsafe { bb::clear(&(*$TIMX::ptr()).ccer, 0) }`
`@@ -176,21 +176,21 @@ macro_rules! hal {`
`176`	`176`	`unsafe { bb::set(&(*$TIMX::ptr()).ccer, 0) }`
`177`	`177`	`}`
`178`	`178`
`179`		`- fn get_duty(&self) -> u16 {`
`180`		`- unsafe { u16((*$TIMX::ptr()).ccr1.read().ccr1().bits()).unwrap() }`
	`179`	`+ fn get_duty(&self) -> Self::Duty {`
	`180`	`+ unsafe { (*$TIMX::ptr()).ccr1.read().ccr1().bits() }`
`181`	`181`	`}`
`182`	`182`
`183`		`- fn get_max_duty(&self) -> u16 {`
`184`		`- unsafe { u16((*$TIMX::ptr()).arr.read().arr().bits()).unwrap() }`
	`183`	`+ fn get_max_duty(&self) -> Self::Duty {`
	`184`	`+ unsafe { (*$TIMX::ptr()).arr.read().arr().bits() }`
`185`	`185`	`}`
`186`	`186`
`187`		`- fn set_duty(&mut self, duty: u16) {`
`188`		`- unsafe { (*$TIMX::ptr()).ccr1.write(\|w\| w.ccr1().bits(u32(duty))) }`
	`187`	`+ fn set_duty(&mut self, duty: Self::Duty) {`
	`188`	`+ unsafe { (*$TIMX::ptr()).ccr1.write(\|w\| w.ccr1().bits(duty)) }`
`189`	`189`	`}`
`190`	`190`	`}`
`191`	`191`
`192`	`192`	`impl hal::PwmPin for Pwm<$TIMX, C2> {`
`193`		`- type Duty = u16;`
	`193`	`+ type Duty = u32;`
`194`	`194`
`195`	`195`	`fn disable(&mut self) {`
`196`	`196`	`unsafe { bb::clear(&(*$TIMX::ptr()).ccer, 4) }`
`@@ -200,21 +200,21 @@ macro_rules! hal {`
`200`	`200`	`unsafe { bb::set(&(*$TIMX::ptr()).ccer, 4) }`
`201`	`201`	`}`
`202`	`202`
`203`		`- fn get_duty(&self) -> u16 {`
`204`		`- unsafe { u16((*$TIMX::ptr()).ccr2.read().ccr2().bits()).unwrap() }`
	`203`	`+ fn get_duty(&self) -> Self::Duty {`
	`204`	`+ unsafe { (*$TIMX::ptr()).ccr2.read().ccr2().bits() }`
`205`	`205`	`}`
`206`	`206`
`207`		`- fn get_max_duty(&self) -> u16 {`
`208`		`- unsafe { u16((*$TIMX::ptr()).arr.read().arr().bits()).unwrap() }`
	`207`	`+ fn get_max_duty(&self) -> Self::Duty {`
	`208`	`+ unsafe { (*$TIMX::ptr()).arr.read().arr().bits() }`
`209`	`209`	`}`
`210`	`210`
`211`		`- fn set_duty(&mut self, duty: u16) {`
`212`		`- unsafe { (*$TIMX::ptr()).ccr2.write(\|w\| w.ccr2().bits(u32(duty))) }`
	`211`	`+ fn set_duty(&mut self, duty: Self::Duty) {`
	`212`	`+ unsafe { (*$TIMX::ptr()).ccr2.write(\|w\| w.ccr2().bits(duty)) }`
`213`	`213`	`}`
`214`	`214`	`}`
`215`	`215`
`216`	`216`	`impl hal::PwmPin for Pwm<$TIMX, C3> {`
`217`		`- type Duty = u16;`
	`217`	`+ type Duty = u32;`
`218`	`218`
`219`	`219`	`fn disable(&mut self) {`
`220`	`220`	`unsafe { bb::clear(&(*$TIMX::ptr()).ccer, 8) }`
`@@ -224,21 +224,21 @@ macro_rules! hal {`
`224`	`224`	`unsafe { bb::set(&(*$TIMX::ptr()).ccer, 8) }`
`225`	`225`	`}`
`226`	`226`
`227`		`- fn get_duty(&self) -> u16 {`
`228`		`- unsafe { u16((*$TIMX::ptr()).ccr3.read().ccr3().bits()).unwrap() }`
	`227`	`+ fn get_duty(&self) -> Self::Duty {`
	`228`	`+ unsafe { (*$TIMX::ptr()).ccr3.read().ccr3().bits() }`
`229`	`229`	`}`
`230`	`230`
`231`		`- fn get_max_duty(&self) -> u16 {`
`232`		`- unsafe { u16((*$TIMX::ptr()).arr.read().arr().bits()).unwrap() }`
	`231`	`+ fn get_max_duty(&self) -> Self::Duty {`
	`232`	`+ unsafe { (*$TIMX::ptr()).arr.read().arr().bits() }`
`233`	`233`	`}`
`234`	`234`
`235`		`- fn set_duty(&mut self, duty: u16) {`
`236`		`- unsafe { (*$TIMX::ptr()).ccr3.write(\|w\| w.ccr3().bits(u32(duty))) }`
	`235`	`+ fn set_duty(&mut self, duty: Self::Duty) {`
	`236`	`+ unsafe { (*$TIMX::ptr()).ccr3.write(\|w\| w.ccr3().bits(duty)) }`
`237`	`237`	`}`
`238`	`238`	`}`
`239`	`239`
`240`	`240`	`impl hal::PwmPin for Pwm<$TIMX, C4> {`
`241`		`- type Duty = u16;`
	`241`	`+ type Duty = u32;`
`242`	`242`
`243`	`243`	`fn disable(&mut self) {`
`244`	`244`	`unsafe { bb::clear(&(*$TIMX::ptr()).ccer, 12) }`
`@@ -248,16 +248,16 @@ macro_rules! hal {`
`248`	`248`	`unsafe { bb::set(&(*$TIMX::ptr()).ccer, 12) }`
`249`	`249`	`}`
`250`	`250`
`251`		`- fn get_duty(&self) -> u16 {`
`252`		`- unsafe { u16((*$TIMX::ptr()).ccr4.read().ccr4().bits()).unwrap() }`
	`251`	`+ fn get_duty(&self) -> Self::Duty {`
	`252`	`+ unsafe { (*$TIMX::ptr()).ccr4.read().ccr4().bits() }`
`253`	`253`	`}`
`254`	`254`
`255`		`- fn get_max_duty(&self) -> u16 {`
`256`		`- unsafe { u16((*$TIMX::ptr()).arr.read().arr().bits()).unwrap() }`
	`255`	`+ fn get_max_duty(&self) -> Self::Duty {`
	`256`	`+ unsafe { (*$TIMX::ptr()).arr.read().arr().bits() }`
`257`	`257`	`}`
`258`	`258`
`259`		`- fn set_duty(&mut self, duty: u16) {`
`260`		`- unsafe { (*$TIMX::ptr()).ccr4.write(\|w\| w.ccr4().bits(u32(duty))) }`
	`259`	`+ fn set_duty(&mut self, duty: Self::Duty) {`
	`260`	`+ unsafe { (*$TIMX::ptr()).ccr4.write(\|w\| w.ccr4().bits(duty)) }`
`261`	`261`	`}`
`262`	`262`	`}`
`263`	`263`	`)+`