|
Nano102_112 Series BSP
V3.03.002
The Board Support Package for Nano102_112 Series
|
#include <Nano1X2Series.h>
Data Fields | |
| __IO uint32_t | PRES |
| __IO uint32_t | CLKSEL |
| __IO uint32_t | CTL |
| __IO uint32_t | INTEN |
| __IO uint32_t | INTSTS |
| __IO uint32_t | OE |
| uint32_t | RESERVE0 [1] |
| __IO uint32_t | DUTY0 |
| __I uint32_t | DATA0 |
| uint32_t | RESERVE1 [1] |
| __IO uint32_t | DUTY1 |
| __I uint32_t | DATA1 |
| uint32_t | RESERVE2 [1] |
| __IO uint32_t | DUTY2 |
| __I uint32_t | DATA2 |
| uint32_t | RESERVE3 [1] |
| __IO uint32_t | DUTY3 |
| __I uint32_t | DATA3 |
| uint32_t | RESERVE4 [3] |
| __IO uint32_t | CAPCTL |
| __IO uint32_t | CAPINTEN |
| __IO uint32_t | CAPINTSTS |
| __I uint32_t | CRL0 |
| __I uint32_t | CFL0 |
| __I uint32_t | CRL1 |
| __I uint32_t | CFL1 |
| __I uint32_t | CRL2 |
| __I uint32_t | CFL2 |
| __I uint32_t | CRL3 |
| __I uint32_t | CFL3 |
| __I uint32_t | PDMACH0 |
| __I uint32_t | PDMACH2 |
| __IO uint32_t | ADTRGEN |
| __IO uint32_t | ADTRGSTS |
@addtogroup PWM Pulse Width Modulation Controller(PWM) Memory Mapped Structure for PWM Controller
Definition at line 5734 of file Nano1X2Series.h.
| __IO uint32_t PWM_T::ADTRGEN |
| Bits | Field | Descriptions |
|---|---|---|
| [0] | TRGCH0EN | PWM CH0 Center-Triggered Enable Control |
| 0 = PWM CH0 center-triggered function Disabled. | ||
| 1 = PWM CH0 center-triggered function Enabled. | ||
| Note: The center-triggered function is only valid in PWM center-aligned mode. | ||
| [1] | TRGCH1EN | PWM CH1 Center-Triggered Enable Control |
| 0 = PWM CH1 center-triggered function Disabled. | ||
| 1 = PWM CH1 center-triggered function Enabled. | ||
| Note: The center-triggered function is only valid in PWM center-aligned mode. | ||
| [2] | TRGCH2EN | PWM CH2 Center-Triggered Enable Control |
| 0 = PWM CH2 center-triggered function Disabled. | ||
| 1 = PWM CH2 center-triggered function Enabled. | ||
| Note: The center-triggered function is only valid in PWM center-aligned mode. | ||
| [3] | TRGCH3EN | PWM CH3 Center-Triggered Enable Control |
| 0 = PWM CH3 center-triggered function Disabled. | ||
| 1 = PWM CH3 center-triggered function Enabled. | ||
| Note: The center-triggered function is only valid in PWM center-aligned mode. |
Definition at line 6579 of file Nano1X2Series.h.
| __IO uint32_t PWM_T::ADTRGSTS |
| Bits | Field | Descriptions |
|---|---|---|
| [0] | ADTRG0Flag | PWM CH0 Center-Triggered Flag |
| 0 = PWM CH0 has not crossed half of PWM period yet. | ||
| 1 = PWM CH0 has crossed half of PWM period. | ||
| Note: This flag is only valid in center-aligned mode, and software could write 1 into this bit to clear the flag | ||
| [1] | ADTRG1Flag | PWM CH1 Center-Triggered Flag |
| 0 = PWM CH1 has not crossed half of PWM period yet. | ||
| 1 = PWM CH1 has crossed half of PWM period. | ||
| Note: This flag is only valid in center-aligned mode, and software could write 1 into this bit to clear the flag | ||
| [2] | ADTRG2Flag | PWM CH2 Center-Triggered Flag |
| 0 = PWM CH2 has not crossed half of PWM period yet. | ||
| 1 = PWM CH2 has crossed half of PWM period. | ||
| Note: This flag is only valid in center-aligned mode, and software could write 1 into this bit to clear the flag | ||
| [3] | ADTRG3Flag | PWM CH3 Center-Triggered Flag |
| 0 = PWM CH3 has not crossed half of PWM period yet. | ||
| 1 = PWM CH3 has crossed half of PWM period. | ||
| Note: This flag is only valid in center-aligned mode, and software could write 1 into this bit to clear the flag |
Definition at line 6605 of file Nano1X2Series.h.
| __IO uint32_t PWM_T::CAPCTL |
| Bits | Field | Descriptions |
|---|---|---|
| [0] | INV0 | Channel 0 Inverter ON/OFF |
| 0 = Inverter OFF. | ||
| 1 = Inverter ON. Reverse the input signal from GPIO before fed to Capture timer | ||
| [1] | CAPCH0EN | Capture Channel 0 Transition Enable/Disable Control |
| 0 = Capture function on channel 0 Disabled. | ||
| 1 = Capture function on channel 0 Enabled. | ||
| When Enabled, Capture latched the PWM-timer value and saved to CRL0 (PWM_CRL0[15:0]) for rising latch and CFL0 (PWM_CFL0[15:0]) for falling latch. | ||
| When Disabled, Capture does not update CRL0 (PWM_CRL0[15:0]) and CFL0 (PWM_CFL0[15:0]), and disable Channel 0 Interrupt. | ||
| [2] | CAPCH0PADEN | Capture Input Enable Control |
| 0 = Disable the channel 0 input capture signal from corresponding multi-function pin. | ||
| 1 = Enable the channel 0 input capture signal from corresponding multi-function pin. | ||
| [3] | CH0PDMAEN | Channel 0 PDMA Enable Control |
| 0 = Channel 0 PDMA function Disabled. | ||
| 1 = Channel 0 PDMA function Enabled for the channel 0 captured data and transfer to memory. | ||
| [5:4] | PDMACAPMOD0 | Select CRL0 Or CFL0 For PDMA Transfer |
| 00 = reserved. | ||
| 01 = CRL0 will be transmitted. | ||
| 10 = CFL0 will be transmitted. | ||
| 11 = Both CRL0 and CFL0 will be transmitted. | ||
| [6] | CAPRELOADREN0 | Reload CNR0 When CH0 Capture Rising Event Comes |
| 0 = Rising capture reload for CH0 Disabled. | ||
| 1 = Rising capture reload for CH0 Enabled. | ||
| [7] | CAPRELOADFEN0 | Reload CNR0 When CH0 Capture Falling Event Comes |
| 0 = Falling capture reload for CH0 Disabled. | ||
| 1 = Falling capture reload for CH0 Enabled. | ||
| [8] | INV1 | Channel 1 Inverter ON/OFF |
| 0 = Inverter OFF. | ||
| 1 = Inverter ON. Reverse the input signal from GPIO before fed to Capture timer | ||
| [9] | CAPCH1EN | Capture Channel 1 Transition Enable/Disable Control |
| 0 = Capture function on channel 1 Disabled. | ||
| 1 = Capture function on channel 1 Enabled. | ||
| When Enabled, Capture latched the PMW-counter and saved to CRL1 (PWM_CRL1[15:0]) for rising latch and CFL1 (PWM_CFL1[15:0]) for falling latch. | ||
| When Disabled, Capture does not update CRL1 (PWM_CRL1[15:0]) and CFL1 (PWM_CFL1[15:0]), and disable Channel 1 Interrupt. | ||
| [10] | CAPCH1PADEN | Capture Input Enable Control |
| 0 = Disable the channel 1 input capture signal from corresponding multi-function pin. | ||
| 1 = Enable the channel 1 input capture signal from corresponding multi-function pin. | ||
| [12] | CH0RFORDER | Channel 0 capture order control |
| Set this bit to determine whether the PWM_CRL0 or PWM_CFL0 is the first captured data transferred to memory through PDMA when PDMACAPMOD0 =2'b11. | ||
| 0 = PWM_CFL0 is the first captured data to memory. | ||
| 1 = PWM_CRL0 is the first captured data to memory. | ||
| [13] | CH01CASK | Cascade channel 0 and channel 1 PWM timer for capturing usage |
| [14] | CAPRELOADREN1 | Reload CNR1 When CH1 Capture Rising Event Comes |
| 0 = Rising capture reload for CH1 Disabled. | ||
| 1 = Rising capture reload for CH1 Enabled. | ||
| [15] | CAPRELOADFEN1 | Reload CNR1 When CH1 Capture Falling Event Coming |
| 0 = Capture falling reload for CH1 Disabled. | ||
| 1 = Capture falling reload for CH1 Enabled. | ||
| [16] | INV2 | Channel 2 Inverter ON/OFF |
| 0 = Inverter OFF. | ||
| 1 = Inverter ON. Reverse the input signal from GPIO before fed to Capture timer | ||
| [17] | CAPCH2EN | Capture Channel 2 Transition Enable/Disable Control |
| 0 = Capture function on channel 2 Disabled. | ||
| 1 = Capture function on channel 2 Enabled. | ||
| When Enabled, Capture latched the PWM-timer value and saved to CRL2 (PWM_CRL2[15:0]) for rising latch and CFL2 (PWM_CFL2[15:0]) for falling latch. | ||
| When Disabled, Capture does not update CRL2 (PWM_CRL2[15:0]) and CFL2 (PWM_CFL2[15:0]), and disable Channel 2 Interrupt. | ||
| [18] | CAPCH2PADEN | Capture Input Enable Control |
| 0 = Disable the channel 2 input capture signal from corresponding multi-function pin. | ||
| 1 = Enable the channel 2 input capture signal from corresponding multi-function pin. | ||
| [19] | CH2PDMAEN | Channel 2 PDMA Enable Control |
| 0 = Channel 2 PDMA function Disabled. | ||
| 1 = Channel 2 PDMA function Enabled for the channel 2 captured data and transfer to memory. | ||
| [21:20] | PDMACAPMOD2 | Select CRL2 Or CFL2 For PDMA Transfer |
| 00 = reserved. | ||
| 01 = CRL2 will be transmitted. | ||
| 10 = CFL2 will be transmitted. | ||
| 11 = Both CRL2 and CFL2 will be transmitted. | ||
| [22] | CAPRELOADREN2 | Reload CNR2 When CH2 Capture Rising Event Coming |
| 0 = Rising capture reload for CH2 Disabled. | ||
| 1 = Rising capture reload for CH2 Enabled. | ||
| [23] | CAPRELOADFEN2 | Reload CNR2 When CH2 Capture Failing Event Coming |
| 0 = Failing capture reload for CH2 Disabled. | ||
| 1 = Failing capture reload for CH2 Enabled. | ||
| [24] | INV3 | Channel 3 Inverter ON/OFF |
| 0 = Inverter OFF. | ||
| 1 = Inverter ON. Reverse the input signal from GPIO before fed to Capture timer | ||
| [25] | CAPCH3EN | Capture Channel 3 Transition Enable/Disable Control |
| 0 = Capture function on channel 3 Disabled. | ||
| 1 = Capture function on channel 3 Enabled. | ||
| When Enabled, Capture latched the PMW-timer and saved to CRL3 (PWM_CRL3[15:0]) for rising latch and CFL3 (PWM_CFL3[15:0]) for falling latch. | ||
| When Disabled, Capture does not update CRL3 (PWM_CRL3[15:0]) and CFL3 (PWM_CFL3[15:0]), and disable Channel 3 Interrupt. | ||
| [26] | CAPCH3PADEN | Capture Input Enable Control |
| 0 = Disable the channel 3 input capture signal from corresponding multi-function pin. | ||
| 1 = Enable the channel 3 input capture signal from corresponding multi-function pin. | ||
| [28] | CH2RFORDER | Channel 2 capture order control |
| Set this bit to determine whether the PWM_CRL2 or PWM_CFL2 is the first captured data transferred to memory through PDMA when PDMACAPMOD2 = 2'b11. | ||
| 0 = PWM_CFL2 is the first captured data to memory. | ||
| 1 = PWM_CRL2 is the first captured data to memory. | ||
| [29] | CH23CASK | Cascade channel 2 and channel 3 PWM counter for capturing usage |
| [30] | CAPRELOADREN3 | Reload CNR3 When CH3 Rising Capture Event Comes |
| 0 = Rising capture reload for CH3 Disabled. | ||
| 1 = Rising capture reload for CH3 Enabled. | ||
| [31] | CAPRELOADFEN3 | Reload CNR3 When CH3 Falling Capture Event Comes |
| 0 = Falling capture reload for CH3 Disabled. | ||
| 1 = Falling capture reload for CH3 Enabled. |
Definition at line 6296 of file Nano1X2Series.h.
| __IO uint32_t PWM_T::CAPINTEN |
| Bits | Field | Descriptions |
|---|---|---|
| [0] | CRL_IE0 | Channel 0 Rising Latch Interrupt Enable ON/OFF |
| 0 = Rising latch interrupt Disabled. | ||
| 1 = Rising latch interrupt Enabled. | ||
| When Enabled, if Capture detects Channel 0 has rising transition, Capture issues an Interrupt. | ||
| [1] | CFL_IE0 | Channel 0 Falling Latch Interrupt Enable ON/OFF |
| 0 = Falling latch interrupt Disabled. | ||
| 1 = Falling latch interrupt Enabled. | ||
| When Enabled, if Capture detects Channel 0 has falling transition, Capture issues an Interrupt. | ||
| [8] | CRL_IE1 | Channel 1 Rising Latch Interrupt Enable Control |
| 0 = Rising latch interrupt Disabled. | ||
| 1 = Rising latch interrupt Enabled. | ||
| When Enabled, if Capture detects Channel 1 has rising transition, Capture issues an Interrupt. | ||
| [9] | CFL_IE1 | Channel 1 Falling Latch Interrupt Enable Control |
| 0 = Falling latch interrupt Disabled. | ||
| 1 = Falling latch interrupt Enabled. | ||
| When Enabled, if Capture detects Channel 1 has falling transition, Capture issues an Interrupt. | ||
| [16] | CRL_IE2 | Channel 2 Rising Latch Interrupt Enable ON/OFF |
| 0 = Rising latch interrupt Disabled. | ||
| 1 = Rising latch interrupt Enabled. | ||
| When Enabled, if Capture detects Channel 2 has rising transition, Capture issues an Interrupt. | ||
| [17] | CFL_IE2 | Channel 2 Falling Latch Interrupt Enable ON/OFF |
| 0 = Falling latch interrupt Disabled. | ||
| 1 = Falling latch interrupt Enabled. | ||
| When Enabled, if Capture detects Channel 2 has falling transition, Capture issues an Interrupt. | ||
| [24] | CRL_IE3 | Channel 3 Rising Latch Interrupt Enable ON/OFF |
| 0 = Rising latch interrupt Disabled. | ||
| 1 = Rising latch interrupt Enabled. | ||
| When Enabled, if Capture detects Channel 3 has rising transition, Capture issues an Interrupt. | ||
| [25] | CFL_IE3 | Channel 3 Falling Latch Interrupt Enable ON/OFF |
| 0 = Falling latch interrupt Disabled. | ||
| 1 = Falling latch interrupt Enabled. | ||
| When Enabled, if Capture detects Channel 3 has falling transition, Capture issues an Interrupt. |
Definition at line 6338 of file Nano1X2Series.h.
| __IO uint32_t PWM_T::CAPINTSTS |
| Bits | Field | Descriptions |
|---|---|---|
| [0] | CAPIF0 | Capture0 Interrupt Indication Flag |
| If channel 0 rising latch interrupt (CRL_IE0, PWM_CAPINTEN[0]) is enabled, a rising transition occurs at input channel 0 will result in CAPIF0 to high; Similarly, a falling transition will cause CAPIF0 to be set high if channel 0 falling latch interrupt (CFL_IE0, PWM_CAPINTEN[1]) is enabled. | ||
| This flag is cleared by software with a write 1 on it. | ||
| [1] | CRLI0 | PWM_CRL0 Latched Indicator Bit |
| When input channel 0 has a rising transition, PWM0_CRL0 was latched with the value of PWM down-counter and this bit is set by hardware, software can clear this bit by writing 1 to it. | ||
| [2] | CFLI0 | PWM_CFL0 Latched Indicator Bit |
| When input channel 0 has a falling transition, PWM0_CFL0 was latched with the value of PWM down-counter and this bit is set by hardware, software can clear this bit by writing 1 to it. | ||
| [3] | CAPOVR0 | Capture Rising Flag Over Run For Channel 0 |
| This flag indicate CRL0 update faster than software reading it when it is set | ||
| This bit will be cleared automatically when user clears CRLI0 (PWM_CAPINTSTS[1]). | ||
| [4] | CAPOVF0 | Capture Falling Flag Over Run For Channel 0 |
| This flag indicate CFL0 update faster than software read it when it is set | ||
| This bit will be cleared automatically when user clear CFLI0 (PWM_CAPINTSTS[2]) | ||
| [8] | CAPIF1 | Capture1 Interrupt Indication Flag |
| If channel 1 rising latch interrupt (CRL_IE1, PWM_CAPINTEN[8]) is enabled, a rising transition occurs at input channel 1 will result in CAPIF1 to high; Similarly, a falling transition will cause CAPIF1 to be set high if channel 1 falling latch interrupt (CFL_IE1, PWM_CAPINTEN[9]) is enabled. | ||
| This flag is cleared by software with a write 1 on it. | ||
| [9] | CRLI1 | PWM_CRL1 Latched Indicator Bit |
| When input channel 1 has a rising transition, PWM_CRL1 was latched with the value of PWM down-counter and this bit is set by hardware, software can clear this bit by writing 1 to it. | ||
| [10] | CFLI1 | PWM_CFL1 Latched Indicator Bit |
| When input channel 1 has a falling transition, PWM_CFL1 was latched with the value of PWM down-counter and this bit is set by hardware, software can clear this bit by writing 1 to it. | ||
| [11] | CAPOVR1 | Capture Rising Flag Over Run For Channel 1 |
| This flag indicate CRL1 update faster than software reading it when it is set | ||
| This bit will be cleared automatically when user clear CRLI1 (PWM_CAPINTSTS[9]) | ||
| [12] | CAPOVF1 | Capture Falling Flag Over Run For Channel 1 |
| This flag indicate CFL1 update faster than software reading it when it is set | ||
| This bit will be cleared automatically when user clear CFLI1 (PWM_CAPINTSTS[10]) | ||
| [16] | CAPIF2 | Capture2 Interrupt Indication Flag |
| If channel 2 rising latch interrupt (CRL_IE2, PWM_CAPINTEN[16]) is enabled, a rising transition occurs at input channel 2 will result in CAPIF2 to high; Similarly, a falling transition will cause CAPIF2 to be set high if channel 2 falling latch interrupt (CFL_IE2, PWM_CAPINTEN[17]) is enabled. | ||
| This flag is cleared by software with a write 1 on it. | ||
| [17] | CRLI2 | PWM_CRL2 Latched Indicator Bit |
| When input channel 2 has a rising transition, PWM0_CRL2 was latched with the value of PWM down-counter and this bit is set by hardware, software can clear this bit by writing 1 to it. | ||
| [18] | CFLI2 | PWM_CFL2 Latched Indicator Bit |
| When input channel 2 has a falling transition, PWM0_CFL2 was latched with the value of PWM down-counter and this bit is set by hardware, software can clear this bit by writing 1 to it. | ||
| [19] | CAPOVR2 | Capture Rising Flag Over Run For Channel 2 |
| This flag indicate CRL2 update faster than software reading it when it is set | ||
| This bit will be cleared automatically when user clear CRLI2 (PWM_CAPINTSTS[17]) | ||
| [20] | CAPOVF2 | Capture Falling Flag Over Run For Channel 2 |
| This flag indicate CFL2 update faster than software reading it when it is set | ||
| This bit will be cleared automatically when user clear CFLI2 (PWM_CAPINTSTS[18]) | ||
| [24] | CAPIF3 | Capture3 Interrupt Indication Flag |
| If channel 3 rising latch interrupt (CRL_IE3, PWM_CAPINTEN[24]) is enabled, a rising transition occurs at input channel 3 will result in CAPIF3 to high; Similarly, a falling transition will cause CAPIF3 to be set high if channel 3 falling latch interrupt (CFL_IE3, PWM_CAPINTEN[25]) is enabled. | ||
| This flag is cleared by software with a write 1 on it. | ||
| [25] | CRLI3 | PWM_CRL3 Latched Indicator Bit |
| When input channel 3 has a rising transition, PWM_CRL3 was latched with the value of PWM down-counter and this bit is set by hardware, software can clear this bit by writing 1 to it. | ||
| [26] | CFLI3 | PWM_CFL3 Latched Indicator Bit |
| When input channel 3 has a falling transition, PWM_CFL3 was latched with the value of PWM down-counter and this bit is set by hardware, software can clear this bit by writing 1 to it. | ||
| [27] | CAPOVR3 | Capture Rising Flag Over Run For Channel 3 |
| This flag indicate CRL3update faster than software reading it when it is set | ||
| This bit will be cleared automatically when user clear CRLI3 (PWM_CAPINTSTS[25]) | ||
| [28] | CAPOVF3 | Capture Falling Flag Over Run For Channel 3 |
| This flag indicate CFL3 update faster than software reading it when it is set | ||
| This bit will be cleared automatically when user clear CFLI3 (PWM_CAPINTSTS[26]) |
Definition at line 6400 of file Nano1X2Series.h.
| __I uint32_t PWM_T::CFL0 |
| Bits | Field | Descriptions |
|---|---|---|
| [15:0] | CFL | Capture Falling Latch Register |
| Latch the PWM counter when Channel 0/1/2/3 has Falling transition. | ||
| [31:16] | CFL_H | Upper Half Word Of 32-Bit Capture Data When Cascade Enabled |
| When cascade is enabled for capture channel 0, 2, the original 16 bit counter extend to 32 bit, and capture result CFL0 and CFL2 are also extend to 32 bit, |
Definition at line 6428 of file Nano1X2Series.h.
| __I uint32_t PWM_T::CFL1 |
| Bits | Field | Descriptions |
|---|---|---|
| [15:0] | CFL | Capture Falling Latch Register |
| Latch the PWM counter when Channel 0/1/2/3 has Falling transition. | ||
| [31:16] | CFL_H | Upper Half Word Of 32-Bit Capture Data When Cascade Enabled |
| When cascade is enabled for capture channel 0, 2, the original 16 bit counter extend to 32 bit, and capture result CFL0 and CFL2 are also extend to 32 bit, |
Definition at line 6456 of file Nano1X2Series.h.
| __I uint32_t PWM_T::CFL2 |
| Bits | Field | Descriptions |
|---|---|---|
| [15:0] | CFL | Capture Falling Latch Register |
| Latch the PWM counter when Channel 0/1/2/3 has Falling transition. | ||
| [31:16] | CFL_H | Upper Half Word Of 32-Bit Capture Data When Cascade Enabled |
| When cascade is enabled for capture channel 0, 2, the original 16 bit counter extend to 32 bit, and capture result CFL0 and CFL2 are also extend to 32 bit, |
Definition at line 6484 of file Nano1X2Series.h.
| __I uint32_t PWM_T::CFL3 |
| Bits | Field | Descriptions |
|---|---|---|
| [15:0] | CFL | Capture Falling Latch Register |
| Latch the PWM counter when Channel 0/1/2/3 has Falling transition. | ||
| [31:16] | CFL_H | Upper Half Word Of 32-Bit Capture Data When Cascade Enabled |
| When cascade is enabled for capture channel 0, 2, the original 16 bit counter extend to 32 bit, and capture result CFL0 and CFL2 are also extend to 32 bit, |
Definition at line 6512 of file Nano1X2Series.h.
| __IO uint32_t PWM_T::CLKSEL |
| Bits | Field | Descriptions |
|---|---|---|
| [2:0] | CLKSEL0 | Timer 0 Clock Source Selection |
| Select clock input for timer 0. | ||
| (Table is the same as CLKSEL3) | ||
| [6:4] | CLKSEL1 | Timer 1 Clock Source Selection |
| Select clock input for timer 1. | ||
| (Table is the same as CLKSEL3) | ||
| [10:8] | CLKSEL2 | Timer 2 Clock Source Selection |
| Select clock input for timer 2. | ||
| (Table is the same as CLKSEL3) | ||
| [14:12] | CLKSEL3 | Timer 3 Clock Source Selection |
| Select clock input for timer 3. | ||
| 000 = input clock is divided by 2. | ||
| 001 = input clock is divided by 4. | ||
| 010 = input clock is divided by 8. | ||
| 011 = input clock is divided by 16. | ||
| 100 = input clock is divided by 1. |
Definition at line 5784 of file Nano1X2Series.h.
| __I uint32_t PWM_T::CRL0 |
| Bits | Field | Descriptions |
|---|---|---|
| [15:0] | CRL | Capture Rising Latch Register |
| Latch the PWM counter when Channel 0/1/2/3 has rising transition. | ||
| [31:16] | CRL_H | Upper Half Word Of 32-Bit Capture Data When Cascade Enabled |
| When cascade is enabled for capture channel 0, 2,the original 16 bit counter extend to 32 bit, and capture result CRL0 and CRL2 are also extend to 32 bit, |
Definition at line 6414 of file Nano1X2Series.h.
| __I uint32_t PWM_T::CRL1 |
| Bits | Field | Descriptions |
|---|---|---|
| [15:0] | CRL | Capture Rising Latch Register |
| Latch the PWM counter when Channel 0/1/2/3 has rising transition. | ||
| [31:16] | CRL_H | Upper Half Word Of 32-Bit Capture Data When Cascade Enabled |
| When cascade is enabled for capture channel 0, 2,the original 16 bit counter extend to 32 bit, and capture result CRL0 and CRL2 are also extend to 32 bit, |
Definition at line 6442 of file Nano1X2Series.h.
| __I uint32_t PWM_T::CRL2 |
| Bits | Field | Descriptions |
|---|---|---|
| [15:0] | CRL | Capture Rising Latch Register |
| Latch the PWM counter when Channel 0/1/2/3 has rising transition. | ||
| [31:16] | CRL_H | Upper Half Word Of 32-Bit Capture Data When Cascade Enabled |
| When cascade is enabled for capture channel 0, 2,the original 16 bit counter extend to 32 bit, and capture result CRL0 and CRL2 are also extend to 32 bit, |
Definition at line 6470 of file Nano1X2Series.h.
| __I uint32_t PWM_T::CRL3 |
| Bits | Field | Descriptions |
|---|---|---|
| [15:0] | CRL | Capture Rising Latch Register |
| Latch the PWM counter when Channel 0/1/2/3 has rising transition. | ||
| [31:16] | CRL_H | Upper Half Word Of 32-Bit Capture Data When Cascade Enabled |
| When cascade is enabled for capture channel 0, 2,the original 16 bit counter extend to 32 bit, and capture result CRL0 and CRL2 are also extend to 32 bit, |
Definition at line 6498 of file Nano1X2Series.h.
| __IO uint32_t PWM_T::CTL |
| Bits | Field | Descriptions |
|---|---|---|
| [0] | CH0EN | PWM-Timer 0 Enable/Disable Start Run |
| 0 = PWM-Timer 0 Running Stopped. | ||
| 1 = PWM-Timer 0 Start Run Enabled. | ||
| [2] | CH0INV | PWM-Timer 0 Output Inverter ON/OFF |
| 0 = Inverter OFF. | ||
| 1 = Inverter ON. | ||
| [3] | CH0MOD | PWM-Timer 0 Continuous/One-Shot Mode |
| 0 = One-Shot Mode. | ||
| 1 = Continuous Mode. | ||
| Note: If there is a rising transition at this bit, it will cause CN and CM of PWM0_DUTY0 to be cleared. | ||
| [4] | DZEN01 | Dead-Zone 0 Generator Enable/Disable Control |
| 0 = Disabled. | ||
| 1 = Enabled. | ||
| Note: When Dead-Zone Generator is enabled, the pair of PWM0 and PWM1 becomes a complementary pair. | ||
| [5] | DZEN23 | Dead-Zone 2 Generator Enable/Disable Control |
| 0 = Disabled. | ||
| 1 = Enabled. | ||
| Note: When Dead-Zone Generator is enabled, the pair of PWM2 and PWM3 becomes a complementary pair. | ||
| [8] | CH1EN | PWM-Timer 1 Enable/Disable Start Run |
| 0 = PWM-Timer 1 Running Stopped. | ||
| 1 = PWM-Timer 1 Start Run Enabled. | ||
| [10] | CH1INV | PWM-Timer 1 Output Inverter ON/OFF |
| 0 = Inverter OFF. | ||
| 1 = Inverter ON. | ||
| [11] | CH1MOD | PWM-Timer 1 Continuous/One-Shot Mode |
| 0 = One-Shot Mode. | ||
| 1 = Continuous Mode. | ||
| Note: If there is a rising transition at this bit, it will cause CN and CM of PWM0_DUTY1 to be cleared. | ||
| [16] | CH2EN | PWM-Timer 2 Enable/Disable Start Run |
| 0 = PWM-Timer 2 Running Stopped. | ||
| 1 = PWM-Timer 2 Start Run Enabled. | ||
| [18] | CH2INV | PWM-Timer 2 Output Inverter ON/OFF |
| 0 = Inverter OFF. | ||
| 1 = Inverter ON. | ||
| [19] | CH2MOD | PWM-Timer 2 Continuous/One-Shot Mode |
| 0 = One-Shot Mode. | ||
| 1 = Continuous Mode. | ||
| Note: If there is a rising transition at this bit, it will cause CN and CM of PWM0_DUTY2 be cleared. | ||
| [24] | CH3EN | PWM-Timer 3 Enable/Disable Start Run |
| 0 = PWM-Timer 3 Running Stopped. | ||
| 1 = PWM-Timer 3 Start Run Enabled. | ||
| [26] | CH3INV | PWM-Timer 3 Output Inverter ON/OFF |
| 0 = Inverter OFF. | ||
| 1 = Inverter ON. | ||
| [27] | CH3MOD | PWM-Timer 3 Continuous/One-Shot Mode |
| 0 = One-Shot Mode. | ||
| 1 = Continuous Mode. | ||
| Note: If there is a rising transition at this bit, it will cause CN and CM of PWM0_DUTY3 to be cleared. | ||
| [30] | PWMTYPE01 | Channel 0,1 Counter Mode |
| 0 = Edge-aligned Mode. | ||
| 1 = Center-aligned Mode. | ||
| [31] | PWMTYPE23 | Channel 2,3 Counter Mode |
| 0 = Edge-aligned Mode. | ||
| 1 = Center-aligned Mode. |
Definition at line 5848 of file Nano1X2Series.h.
| __I uint32_t PWM_T::DATA0 |
| Bits | Field | Descriptions |
|---|---|---|
| [15:0] | DATA | PWM Data Register |
| User can monitor PWM_DATA to know the current value in 16-bit down count counter of corresponding channel. | ||
| [30:16] | DATA_H | PWM Data Register |
| User can monitor PWM_DATA to know the current value in 32-bit down count counter of corresponding channel. | ||
| Notes: This will be valid only for the corresponding cascade enable bit is set | ||
| [31] | sync | CN Value Sync With PWM Counter |
| 0 = CN value is sync to PWM counter. | ||
| 1 = CN value is not sync to PWM counter. | ||
| Note: when the corresponding cascade enable bit is set, this bit will not appear in the corresponding channel |
Definition at line 5995 of file Nano1X2Series.h.
| __I uint32_t PWM_T::DATA1 |
| Bits | Field | Descriptions |
|---|---|---|
| [15:0] | DATA | PWM Data Register |
| User can monitor PWM_DATA to know the current value in 16-bit down count counter of corresponding channel. | ||
| [30:16] | DATA_H | PWM Data Register |
| User can monitor PWM_DATA to know the current value in 32-bit down count counter of corresponding channel. | ||
| Notes: This will be valid only for the corresponding cascade enable bit is set | ||
| [31] | sync | CN Value Sync With PWM Counter |
| 0 = CN value is sync to PWM counter. | ||
| 1 = CN value is not sync to PWM counter. | ||
| Note: when the corresponding cascade enable bit is set, this bit will not appear in the corresponding channel |
Definition at line 6060 of file Nano1X2Series.h.
| __I uint32_t PWM_T::DATA2 |
| Bits | Field | Descriptions |
|---|---|---|
| [15:0] | DATA | PWM Data Register |
| User can monitor PWM_DATA to know the current value in 16-bit down count counter of corresponding channel. | ||
| [30:16] | DATA_H | PWM Data Register |
| User can monitor PWM_DATA to know the current value in 32-bit down count counter of corresponding channel. | ||
| Notes: This will be valid only for the corresponding cascade enable bit is set | ||
| [31] | sync | CN Value Sync With PWM Counter |
| 0 = CN value is sync to PWM counter. | ||
| 1 = CN value is not sync to PWM counter. | ||
| Note: when the corresponding cascade enable bit is set, this bit will not appear in the corresponding channel |
Definition at line 6125 of file Nano1X2Series.h.
| __I uint32_t PWM_T::DATA3 |
| Bits | Field | Descriptions |
|---|---|---|
| [15:0] | DATA | PWM Data Register |
| User can monitor PWM_DATA to know the current value in 16-bit down count counter of corresponding channel. | ||
| [30:16] | DATA_H | PWM Data Register |
| User can monitor PWM_DATA to know the current value in 32-bit down count counter of corresponding channel. | ||
| Notes: This will be valid only for the corresponding cascade enable bit is set | ||
| [31] | sync | CN Value Sync With PWM Counter |
| 0 = CN value is sync to PWM counter. | ||
| 1 = CN value is not sync to PWM counter. | ||
| Note: when the corresponding cascade enable bit is set, this bit will not appear in the corresponding channel |
Definition at line 6190 of file Nano1X2Series.h.
| __IO uint32_t PWM_T::DUTY0 |
| Bits | Field | Descriptions |
|---|---|---|
| [15:0] | CN | PWM Counter/Timer Loaded Value |
| CN determines the PWM period. | ||
| In edge-aligned mode, | ||
| PWM frequency = PWMxy_CLK/(prescale+1)*(clock divider)/(CN+1); where xy could be 01, 23, depending on the selected PWM channel. | ||
| Duty ratio = (CM+1)/(CN+1). | ||
| CM >= CN: PWM output is always high. | ||
| CM < CN: PWM low width = (CN-CM) unit; PWM high width = (CM+1) unit. | ||
| CM = 0: PWM low width = (CN) unit; PWM high width = 1 unit. | ||
| (Unit = one PWM clock cycle). | ||
| In center-aligned mode, | ||
| PWM frequency = PWMxy_CLK/(prescale+1)*(clock divider)/(2x(CN+1)); where xy could be 01, 23, depending on the selected PWM channel. | ||
| Duty ratio = (2xCM+1)/(2x(CN+1)). | ||
| CM >= CN: PWM output is always high. | ||
| CM < CN: PWM low width = 2x(CN-CM)+1 unit; PWM high width = (2xCM+1) unit. | ||
| CM = 0: PWM low width = (2xCN+1) unit; PWM high width = 1 unit. | ||
| (Unit = one PWM clock cycle). | ||
| Note: Any write to CN will take effect in next PWM cycle. | ||
| [31:16] | CM | PWM Comparator Register |
| CM determines the PWM duty. | ||
| In edge-aligned mode, | ||
| PWM frequency = PWMxy_CLK/(prescale+1)*(clock divider)/(CN+1); where xy could be 01, 23, depending on the selected PWM channel. | ||
| Duty ratio = (CM+1)/(CN+1). | ||
| CM >= CN: PWM output is always high. | ||
| CM < CN: PWM low width = (CN-CM) unit; PWM high width = (CM+1) unit. | ||
| CM = 0: PWM low width = (CN) unit; PWM high width = 1 unit. | ||
| (Unit = one PWM clock cycle). | ||
| In center-aligned mode, | ||
| PWM frequency = PWMxy_CLK/(prescale+1)*(clock divider)/(2x(CN+1)); where xy could be 01, 23, depending on the selected PWM channel. | ||
| Duty ratio = (2xCM+1)/(2x(CN+1)). | ||
| CM >= CN: PWM output is always high. | ||
| CM < CN: PWM low width = 2x(CN-CM)+1 unit; PWM high width = (2xCM+1) unit. | ||
| CM = 0: PWM low width = (2xCN+1) unit; PWM high width = 1 unit. | ||
| (Unit = one PWM clock cycle). | ||
| Note:Any write to CM will take effect in next PWM cycle. |
Definition at line 5976 of file Nano1X2Series.h.
| __IO uint32_t PWM_T::DUTY1 |
| Bits | Field | Descriptions |
|---|---|---|
| [15:0] | CN | PWM Counter/Timer Loaded Value |
| CN determines the PWM period. | ||
| In edge-aligned mode, | ||
| PWM frequency = PWMxy_CLK/(prescale+1)*(clock divider)/(CN+1); where xy could be 01, 23, depending on the selected PWM channel. | ||
| Duty ratio = (CM+1)/(CN+1). | ||
| CM >= CN: PWM output is always high. | ||
| CM < CN: PWM low width = (CN-CM) unit; PWM high width = (CM+1) unit. | ||
| CM = 0: PWM low width = (CN) unit; PWM high width = 1 unit. | ||
| (Unit = one PWM clock cycle). | ||
| In center-aligned mode, | ||
| PWM frequency = PWMxy_CLK/(prescale+1)*(clock divider)/(2x(CN+1)); where xy could be 01, 23, depending on the selected PWM channel. | ||
| Duty ratio = (2xCM+1)/(2x(CN+1)). | ||
| CM >= CN: PWM output is always high. | ||
| CM < CN: PWM low width = 2x(CN-CM)+1 unit; PWM high width = (2xCM+1) unit. | ||
| CM = 0: PWM low width = (2xCN+1) unit; PWM high width = 1 unit. | ||
| (Unit = one PWM clock cycle). | ||
| Note: Any write to CN will take effect in next PWM cycle. | ||
| [31:16] | CM | PWM Comparator Register |
| CM determines the PWM duty. | ||
| In edge-aligned mode, | ||
| PWM frequency = PWMxy_CLK/(prescale+1)*(clock divider)/(CN+1); where xy could be 01, 23, depending on the selected PWM channel. | ||
| Duty ratio = (CM+1)/(CN+1). | ||
| CM >= CN: PWM output is always high. | ||
| CM < CN: PWM low width = (CN-CM) unit; PWM high width = (CM+1) unit. | ||
| CM = 0: PWM low width = (CN) unit; PWM high width = 1 unit. | ||
| (Unit = one PWM clock cycle). | ||
| In center-aligned mode, | ||
| PWM frequency = PWMxy_CLK/(prescale+1)*(clock divider)/(2x(CN+1)); where xy could be 01, 23, depending on the selected PWM channel. | ||
| Duty ratio = (2xCM+1)/(2x(CN+1)). | ||
| CM >= CN: PWM output is always high. | ||
| CM < CN: PWM low width = 2x(CN-CM)+1 unit; PWM high width = (2xCM+1) unit. | ||
| CM = 0: PWM low width = (2xCN+1) unit; PWM high width = 1 unit. | ||
| (Unit = one PWM clock cycle). | ||
| Note:Any write to CM will take effect in next PWM cycle. |
Definition at line 6041 of file Nano1X2Series.h.
| __IO uint32_t PWM_T::DUTY2 |
| Bits | Field | Descriptions |
|---|---|---|
| [15:0] | CN | PWM Counter/Timer Loaded Value |
| CN determines the PWM period. | ||
| In edge-aligned mode, | ||
| PWM frequency = PWMxy_CLK/(prescale+1)*(clock divider)/(CN+1); where xy could be 01, 23, depending on the selected PWM channel. | ||
| Duty ratio = (CM+1)/(CN+1). | ||
| CM >= CN: PWM output is always high. | ||
| CM < CN: PWM low width = (CN-CM) unit; PWM high width = (CM+1) unit. | ||
| CM = 0: PWM low width = (CN) unit; PWM high width = 1 unit. | ||
| (Unit = one PWM clock cycle). | ||
| In center-aligned mode, | ||
| PWM frequency = PWMxy_CLK/(prescale+1)*(clock divider)/(2x(CN+1)); where xy could be 01, 23, depending on the selected PWM channel. | ||
| Duty ratio = (2xCM+1)/(2x(CN+1)). | ||
| CM >= CN: PWM output is always high. | ||
| CM < CN: PWM low width = 2x(CN-CM)+1 unit; PWM high width = (2xCM+1) unit. | ||
| CM = 0: PWM low width = (2xCN+1) unit; PWM high width = 1 unit. | ||
| (Unit = one PWM clock cycle). | ||
| Note: Any write to CN will take effect in next PWM cycle. | ||
| [31:16] | CM | PWM Comparator Register |
| CM determines the PWM duty. | ||
| In edge-aligned mode, | ||
| PWM frequency = PWMxy_CLK/(prescale+1)*(clock divider)/(CN+1); where xy could be 01, 23, depending on the selected PWM channel. | ||
| Duty ratio = (CM+1)/(CN+1). | ||
| CM >= CN: PWM output is always high. | ||
| CM < CN: PWM low width = (CN-CM) unit; PWM high width = (CM+1) unit. | ||
| CM = 0: PWM low width = (CN) unit; PWM high width = 1 unit. | ||
| (Unit = one PWM clock cycle). | ||
| In center-aligned mode, | ||
| PWM frequency = PWMxy_CLK/(prescale+1)*(clock divider)/(2x(CN+1)); where xy could be 01, 23, depending on the selected PWM channel. | ||
| Duty ratio = (2xCM+1)/(2x(CN+1)). | ||
| CM >= CN: PWM output is always high. | ||
| CM < CN: PWM low width = 2x(CN-CM)+1 unit; PWM high width = (2xCM+1) unit. | ||
| CM = 0: PWM low width = (2xCN+1) unit; PWM high width = 1 unit. | ||
| (Unit = one PWM clock cycle). | ||
| Note:Any write to CM will take effect in next PWM cycle. |
Definition at line 6106 of file Nano1X2Series.h.
| __IO uint32_t PWM_T::DUTY3 |
| Bits | Field | Descriptions |
|---|---|---|
| [15:0] | CN | PWM Counter/Timer Loaded Value |
| CN determines the PWM period. | ||
| In edge-aligned mode, | ||
| PWM frequency = PWMxy_CLK/(prescale+1)*(clock divider)/(CN+1); where xy could be 01, 23, depending on the selected PWM channel. | ||
| Duty ratio = (CM+1)/(CN+1). | ||
| CM >= CN: PWM output is always high. | ||
| CM < CN: PWM low width = (CN-CM) unit; PWM high width = (CM+1) unit. | ||
| CM = 0: PWM low width = (CN) unit; PWM high width = 1 unit. | ||
| (Unit = one PWM clock cycle). | ||
| In center-aligned mode, | ||
| PWM frequency = PWMxy_CLK/(prescale+1)*(clock divider)/(2x(CN+1)); where xy could be 01, 23, depending on the selected PWM channel. | ||
| Duty ratio = (2xCM+1)/(2x(CN+1)). | ||
| CM >= CN: PWM output is always high. | ||
| CM < CN: PWM low width = 2x(CN-CM)+1 unit; PWM high width = (2xCM+1) unit. | ||
| CM = 0: PWM low width = (2xCN+1) unit; PWM high width = 1 unit. | ||
| (Unit = one PWM clock cycle). | ||
| Note: Any write to CN will take effect in next PWM cycle. | ||
| [31:16] | CM | PWM Comparator Register |
| CM determines the PWM duty. | ||
| In edge-aligned mode, | ||
| PWM frequency = PWMxy_CLK/(prescale+1)*(clock divider)/(CN+1); where xy could be 01, 23, depending on the selected PWM channel. | ||
| Duty ratio = (CM+1)/(CN+1). | ||
| CM >= CN: PWM output is always high. | ||
| CM < CN: PWM low width = (CN-CM) unit; PWM high width = (CM+1) unit. | ||
| CM = 0: PWM low width = (CN) unit; PWM high width = 1 unit. | ||
| (Unit = one PWM clock cycle). | ||
| In center-aligned mode, | ||
| PWM frequency = PWMxy_CLK/(prescale+1)*(clock divider)/(2x(CN+1)); where xy could be 01, 23, depending on the selected PWM channel. | ||
| Duty ratio = (2xCM+1)/(2x(CN+1)). | ||
| CM >= CN: PWM output is always high. | ||
| CM < CN: PWM low width = 2x(CN-CM)+1 unit; PWM high width = (2xCM+1) unit. | ||
| CM = 0: PWM low width = (2xCN+1) unit; PWM high width = 1 unit. | ||
| (Unit = one PWM clock cycle). | ||
| Note:Any write to CM will take effect in next PWM cycle. |
Definition at line 6171 of file Nano1X2Series.h.
| __IO uint32_t PWM_T::INTEN |
| Bits | Field | Descriptions |
|---|---|---|
| [0] | TMIE0 | PWM Timer 0 Interrupt Enable Control |
| 0 = Disabled. | ||
| 1 = Enabled. | ||
| [1] | TMIE1 | PWM Timer 1 Interrupt Enable Control |
| 0 = Disabled. | ||
| 1 = Enabled. | ||
| [2] | TMIE2 | PWM Timer 2 Interrupt Enable Control |
| 0 = Disabled. | ||
| 1 = Enabled. | ||
| [3] | TMIE3 | PWM Timer 3 Interrupt Enable Control |
| 0 = Disabled. | ||
| 1 = Enabled. |
Definition at line 5870 of file Nano1X2Series.h.
| __IO uint32_t PWM_T::INTSTS |
| Bits | Field | Descriptions |
|---|---|---|
| [0] | TMINT0 | PWM Timer 0 Interrupt Flag |
| Flag is set by hardware when PWM0 down counter reaches 0, software can clear this bit by writing a one to it. | ||
| [1] | TMINT1 | PWM Timer 1 Interrupt Flag |
| Flag is set by hardware when PWM1 down counter reaches 0, software can clear this bit by writing a one to it. | ||
| [2] | TMINT2 | PWM Timer 2 Interrupt Flag |
| Flag is set by hardware when PWM2 down counter reaches 0, software can clear this bit by writing a one to it. | ||
| [3] | TMINT3 | PWM Timer 3 Interrupt Flag |
| Flag is set by hardware when PWM3 down counter reaches 0, software can clear this bit by writing a one to it. | ||
| [4] | Duty0Syncflag | Duty0 Synchronize Flag |
| 0 = Duty0 has been synchronized to PWM_CLK domain of channel 0, 1. | ||
| 1 = Duty0 is synchronizing to PWM_CLK domain of channel 0, 1. | ||
| Note: software should check this flag when writing duty0, if this flag is set, and user ignore this flag and change duty0, the corresponding CNR and CMR may be wrong for one duty cycle | ||
| [5] | Duty1Syncflag | Duty1 Synchronize Flag |
| 0 = Duty1 has been synchronized to PWM_CLK domain of channel 0, 1. | ||
| 1 = Duty1 is synchronizing to PWM_CLK domain of channel 0, 1. | ||
| Note: software should check this flag when writing duty1, if this flag is set, and user ignore this flag and change duty1, the corresponding CNR and CMR may be wrong for one duty cycle | ||
| [6] | Duty2Syncflag | Duty2 Synchronize Flag |
| 0 = Duty2 has been synchronized to PWM_CLK domain of channel 2, 3. | ||
| 1 = Duty2 is synchronizing to PWM_CLK domain of channel 2, 3. | ||
| Note: software should check this flag when writing duty2, if this flag is set, and user ignore this flag and change duty2, the corresponding CNR and CMR may be wrong for one duty cycle | ||
| [7] | Duty3Syncflag | Duty3 Synchronize Flag |
| 0 = Duty3 has been synchronized to PWM_CLK domain of channel 2, 3. | ||
| 1 = Duty3 is synchronizing to PWM_CLK domain of channel 2, 3. | ||
| Note: software should check this flag when writing duty3, if this flag is set, and user ignore this flag and change duty3, the corresponding CNR and CMR may be wrong for one duty cycle | ||
| [8] | PresSyncFlag | Prescale Synchronize Flag |
| 0 = Two Prescales have been synchronized to corresponding PWM_CLK (of channel 0,1 or channel 2, 3) domain respectively. | ||
| 1 = Prescale01 is synchronizing to PWM_CLK domain of channel 0,1 or Prescaler23 is synchronizing to PWM_CLK domain of channel 2, 3. | ||
| Note: software should check this flag when writing Prescale, if this flag is set, and user ignore this flag and change Prescale, the Prescale may be wrong for one prescale cycle |
Definition at line 5908 of file Nano1X2Series.h.
| __IO uint32_t PWM_T::OE |
| Bits | Field | Descriptions |
|---|---|---|
| [0] | CH0_OE | PWM CH0 Output Enable Control |
| 0 = PWM CH0 output to pin Disabled. | ||
| 1 = PWM CH0 output to pin Enabled. | ||
| [1] | CH1_OE | PWM CH1 Output Enable Control |
| 0 = PWM CH1 output to pin Disabled. | ||
| 1 = PWM CH1 output to pin Enabled. | ||
| [2] | CH2_OE | PWM CH2 Output Enable Control R |
| 0 = PWM CH2 output to pin Disabled. | ||
| 1 = PWM CH2 output to pin Enabled. | ||
| [3] | CH3_OE | PWM CH3 Output Enable Control |
| 0 = PWM CH3 output to pin Disabled. | ||
| 1 = PWM CH3 output to pin Enabled. |
Definition at line 5930 of file Nano1X2Series.h.
| __I uint32_t PWM_T::PDMACH0 |
| Bits | Field | Descriptions |
|---|---|---|
| [7:0] | PDMACH01 | Captured Data Of Channel 0 When CH01CASK Is Disabled, It Is The Capturing Value(CFL0/CRL0) For Channel 0 |
| When CH01CASK is enabled, It is the for the first byte of 32 bit capturing data for channel 0 | ||
| [15:8] | PDMACH02 | Captured Data Of Channel 0 |
| When CH01CASK is disabled, it is the capturing value(CFL0/CRL0) for channel 0 | ||
| When CH01CASK is enabled, It is the second byte of 32 bit capturing data for channel 0 | ||
| [23:16] | PDMACH03 | Captured Data Of Channel 0 When CH01CASK Is Disabled, This Byte Is 0 |
| When CH01CASK is enabled, It is the third byte of 32 bit capturing data for channel 0 | ||
| [31:24] | PDMACH04 | Captured Data Of Channel 0 |
| When CH01CASK is disabled, this byte is 0 | ||
| When CH01CASK is enabled, It is the 4th byte of 32 bit capturing data for channel 0 |
Definition at line 6532 of file Nano1X2Series.h.
| __I uint32_t PWM_T::PDMACH2 |
| Bits | Field | Descriptions |
|---|---|---|
| [7:0] | PDMACH21 | Captured Data Of Channel 2 When CH23CASK Is Disabled, It Is The Capturing Value(CFL2/CRL2) For Channel 2 |
| When CH23CASK is enabled, It is the for the first byte of 32 bit capturing data for channel 2 | ||
| [15:8] | PDMACH22 | Captured Data Of Channel 2 |
| When CH23CASK is disabled, it is the capturing value(CFL2/CRL2) for channel 2 | ||
| When CH23CASK is enabled, It is the second byte of 32 bit capturing data for channel 2 | ||
| [23:16] | PDMACH23 | Captured Data Of Channel 2 |
| When CH23CASK is disabled, this byte is 0 | ||
| When CH23CASK is enabled, It is the third byte of 32 bit capturing data for channel 2 | ||
| [31:24] | PDMACH24 | Captured Data Of Channel 2 |
| When CH23CASK is disabled, this byte is 0 | ||
| When CH23CASK is enabled, It is the 4th byte of 32 bit capturing data for channel 2 |
Definition at line 6553 of file Nano1X2Series.h.
| __IO uint32_t PWM_T::PRES |
| Bits | Field | Descriptions |
|---|---|---|
| [7:0] | CP01 | Clock Prescaler 0 For PWM Timer 0 & 1 |
| Clock input is divided by (CP01 + 1) before it is fed to the PWM counter 0 & 1 | ||
| If CP01 =0, the prescaler 0 output clock will be stopped. So PWM counter 0 and 1 will be stopped also. | ||
| [15:8] | CP23 | Clock Prescaler 2 For PWM Timer 2 & 3 |
| Clock input is divided by (CP23 + 1) before it is fed to the PWM counter 2 & 3 | ||
| If CP23=0, the prescaler 2 output clock will be stopped. So PWM counter 2 and 3 will be stopped also. | ||
| [23:16] | DZ01 | Dead Zone Interval Register For CH0 And CH1 Pair |
| These 8 bits determine dead zone length. | ||
| The unit time of dead zone length is received from clock selector 0. | ||
| [31:24] | DZ23 | Dead Zone Interval Register For CH2 And CH3 Pair |
| These 8 bits determine dead zone length. | ||
| The unit time of dead zone length is received from clock selector 2. |
Definition at line 5758 of file Nano1X2Series.h.
| uint32_t PWM_T::RESERVE0[1] |
Definition at line 5931 of file Nano1X2Series.h.
| uint32_t PWM_T::RESERVE1[1] |
Definition at line 5996 of file Nano1X2Series.h.
| uint32_t PWM_T::RESERVE2[1] |
Definition at line 6061 of file Nano1X2Series.h.
| uint32_t PWM_T::RESERVE3[1] |
Definition at line 6126 of file Nano1X2Series.h.
| uint32_t PWM_T::RESERVE4[3] |
Definition at line 6191 of file Nano1X2Series.h.


Song Recommender
Discover quality tracks
Start from an Artist and Song that you love
{% for hit in top_hits %}
{{ hit.song_name }}, by {{ hit.artist_name }}
{% endfor %}


This part of alastair is still in construction. Development is dependant on oms-events to be stable again, however I hope to be able to rework this soon. Until then please don't mind this page being mildly ugly, it will be replaced soon


Duke of York seen for first time after stepping down from royal duties
Andrew was seen leaving his home in Windsor the day after his bombshell announcement.
The Duke of York has been seen in public for the first time after his dramatic decision to step down from official royal duties.
Andrew, who quit his life as a working royal on Wednesday evening over his association with convicted sex offender Jeffrey Epstein, was pictured leaving Royal Lodge in Berkshire.
The duke, dressed in a suit and tie, gave a wave as he drove away from his family home in Windsor Great Park.
In the aftermath of the Queen’s second son announcing he would step down from public duties for the “foreseeable future”, a US lawyer representing some of Epstein’s alleged victims has raised the possibility of questioning the duke under oath over his relationship with Epstein.
Discussing how Andrew could become involved in any legal process, Lisa Bloom said that, as an attorney, she had “the right” to seek a statement from individuals she deemed to have “relevant information”.
The duke is to continue working on his flagship project Pitch@Palace but will do so privately without the support of Buckingham Palace, it emerged.
A Buckingham Palace spokeswoman told the PA news agency on Thursday: “He will continue to work on Pitch but will look at how to do that outside and entirely separate from the palace.”
It is thought the duke will not have any involvement with the dozens of charities, organisations and military units he is associated with.
Graham Smith, of Republic, which campaigns for an elected head of state, called the move “more smoke and mirrors”.
“Prince Andrew’s decision to step back is more smoke and mirrors to protect the image of the monarchy,” Mr Smith said.
He added: “Several years ago Andrew was stripped of his trade ambassador title, but then continued to fly around the world representing this country.
“The palace needs to clarify exactly what they mean by him stepping back and explain why he isn’t stepping down.
“Otherwise, this just looks like more spin to cover royal backs than real accountability.”
In his statement, Andrew said he was “willing to help any appropriate law enforcement agency with their investigations, if required”.
Ms Bloom told BBC Breakfast: “It’s not going to be easy to subpoena someone like Prince Andrew, he’s obviously not walking down the street where a process server can just hand him a piece of paper, it’s a lot more complicated.
“If he refused to come, we may have a diplomatic situation between (the UK) and (the US). I hope it doesn’t come to that.
“I take him at his word that he says he is going to co-operate, and I hope that’s what’s going to happen.”
Pressure had been mounting on the duke in the wake of his so-called ‘car crash’ Newsnight interview, with a growing number of multimillion-pound businesses, universities and charities distancing themselves from him and Pitch@Palace.
He faced criticism for showing a lack of empathy towards Epstein’s victims and a lack of remorse over his friendship with the financier, who took his own life while in prison earlier this year awaiting trial on sex trafficking and conspiracy charges.
In the interview, the duke denied claims that he slept with Virginia Giuffre, one of Epstein’s victims, on three separate occasions, twice while she was underage.


import QualitySet from './QualitySet.js'
import { v4 as uuidv4 } from 'uuid'
import State from './State.js'
/**
* @class Card
* @module Card
* @see QualitySet
*/
export default class Card {
/**
* @function Card
* @class
* @param {string} content - Text content of card.
* @param {Array} qualities - Array of qualities.
*/
constructor (content = '', qualities = []) {
// Update internal content.
this.content = content
// Update internal qualities.
this.qualities = qualities
// Each card must have a unique value.
this._hash = uuidv4()
}
/**
* Text content of Card.
*
* @type {string}
*/
get content () {
return this._content
}
set content (s) {
// Do we have a string?
if (typeof s === 'string') {
this._content = s
} else {
throw new Error('Content must be expressed as a string!')
}
}
/**
* QualitySet of qualities.
*
* @type {QualitySet}
*/
get qualities () {
return this._qualities
}
set qualities (q) {
// Is this an array?
if (!Array.isArray(q)) {
throw new Error('Qualities must be expressed as an array!')
}
// Cards have qualities (set of qualities).
this._qualities = new QualitySet(this.state)
// Add all the qualities to the card.
q.forEach(element => this.addQuality(element))
}
/**
* Internal UUID Hash of Card.
*
* @type {string}
*/
get hash () {
return this._hash
}
/**
* Check if card is available.
*
* @function isAvailable
* @param {State} s - State to check against.
* @returns {boolean} If card is available.
*/
isAvailable (s) {
if (s instanceof State) {
return this._qualities.check(s)
} else {
throw new Error('Must be passed State to check if available')
}
};
/**
* Add a quality to the Card.
*
* @function addQuality
* @param {object} s - The quality to add.
*/
addQuality (s) {
this._qualities.add(s)
}
/**
* Remove a quality from the Card.
*
* @function removeQuality
* @param {object} s - The quality to remove.
*/
removeQuality (s) {
this._qualities.remove(s)
}
}


Self Portrait As Doomed Amphibian
At first, such calm: the river
drifting sleepily along its banks,
sunlight glinting off water – no sound
but the hush of the current,
splashing over sun-bleached bones,
a dead log rising in the air
like summer heat, the garden snake
lounging in dirt & dry leaves.
Then: a thrashing in the water,
the sun's reflection broken
into wicked, grinning knives, the water
frothed by twisting scales,
the predator
coiled in a pulsing half-knot,
emerging from beneath the glass waves
in triumph.
Jaws clamped tight
& dragging the tiny green frog –
frozen, in shock, or terror,
or denial –
which puts up no struggle at all, but sits,
so perfectly still, so utterly silent in defeat,
slowly retreating without a fight
deep into the serpent's maw


-->
Directory
Posts
About
Contact
Archive of posts with
category 'Government'
Alphabet Soup: Deciphering Thailand's Digital Departments and Agencies
We may sometimes think of startups as pulling themselves up by their bootstraps, but few things in this world are created in a vacuum. When it comes to developing essential...
Never miss a
story
from us
subscribe to our newsletter
Explore Posts
→
coworking (1)
resources (4)
spaces (2)
collaboration (2)
entrepreneurship (2)
Communities (2)
Events (1)
Software Companies (1)
Government (1)
Ecosystem (1)
Visa (1)
Editorial (1)
Startups (1)
Directory (1)


Learn about Pager.js by looking through this demo. This page is both a demo of what Pager.js is capable of doing and meanwhile documentation and recipes.


The Alexa skill for Nightscout is written by Ruud de Rooij and is not endorsed by the Nightscout Foundation. Please refer to nightscout.info and nightscoutfoundation.org for more information about Nightscout and the Nightscout Foundation.
All information provided is intended for informational and educational purposes only. Use Nightscout at your own risk, and do not use the information to make medical decisions.
The skill collects the following information:
- Upon initial activation, the address of a Nightscout server is collected.
- At the user's request, information from the server specified in item 1 is retrieved and presented to the user.
Other than outlined above, no information is collected or shared with any parties, unless required by law.


[ ]:
# uncomment the bottom line to install the package
# !pip install -i https://test.pypi.org/simple/ TCalc==1.1.1
Importing classes from the tcalc
module
[1]:
from TCalc.tcalc import eyepiece, telescope, barlow_lens, focal_reducer
To quickly access the docstring, run help(classname)
[2]:
help(eyepiece)
Help on class eyepiece in module TCalc.tcalc:
class eyepiece(builtins.object)
| eyepiece(f_e, fov_e=50)
|
| Class representing a single eyepiece
| Args:
| f_e: focal length of the eyepiece (mm)
| fov_e: field of view of the eyepiece (deg). Defaults to 50 degrees.
|
| Methods defined here:
|
| __init__(self, f_e, fov_e=50)
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
For an example, let’s try to have estimate the specifications of Celestron’s 8 SE telescope.
[3]:
c8 = telescope(D_o=203.2, f_o=2032, user_D_eye=None, user_age=22) # adding configuration of 8in scope
omni_40 = eyepiece(40, 52) # defining 40 mm eyepiece
omni_25 = eyepiece(25, 52) # defining 25 mm eyepiece
Focal Ratio:'10.0'
True Focal Ratio:'10.0'
[5]:
# adding eyepiece to the telescope
c8.add_eyepiece(omni_40, id='omni_40', select=True)
c8.add_eyepiece(omni_25, id='omni_25', select=True)
[6]:
# listing all the added eyepieces in a table format
c8.list_eyepiece()
Currently included eyepieces:
Name Focal Length FOV
-------------- -------------- --------------
'omni_40' 40 mm 52 degrees
'omni_25' 25 mm 52 degrees
The currently selected eyepiece is 'omni_25'
Additional optical parts available:
Name Type Power
-------------- -------------- --------------
No optical part is selected
[7]:
# listing overall configuration of the telescope
c8.say_configuration() # remember this with 25 mm eyepiece
The telescope has the following layout:
Aperture diameter: 203.2 mm
Focal length: 2032 mm, corresponding to a focal ratio of 10.0
In good atmospheric conditions, the resolution of the telescope (Dawes limit) is 0.6 arcseconds
By wavelength, the resolution is
400 nm (blue): 0.5 arcsec
550 nm (green): 0.7 arcsec
700 nm (red): 0.9 arcsec
The maximum possible magnification factor is 406.4
This means the minimum compatible eyepiece focal length is 5.0 mm
The minimum magnification factor and corresponding maximum eyepiece focal length depend on the diameter of the observer's eye.
For a telescope user with an eye diameter of 7 mm (apropriate for an age around 25 years):
The minimum magnification factor is 29.0
This means the maximum compatible eyepiece focal length is 406.4 mm
The faintest star that can be seen by this telescope is 13.5 mag
The currently selected eyepiece is 'omni_25', which has the following layout:
Focal length: 25 mm
Field of view: 52 degrees
With this eyepiece:
The magnification factor is 81.3. This is compatible with the telescope limits.
The true field of view is 1 degrees
The exit pupil diameter is 2.5 mm
The faintest surface brightness that can be seen by this telescope is 12.50
[8]:
# selecting different eyepiece
c8.select_eyepiece('omni_40')
c8.say_configuration()
The telescope has the following layout:
Aperture diameter: 203.2 mm
Focal length: 2032 mm, corresponding to a focal ratio of 10.0
In good atmospheric conditions, the resolution of the telescope (Dawes limit) is 0.6 arcseconds
By wavelength, the resolution is
400 nm (blue): 0.5 arcsec
550 nm (green): 0.7 arcsec
700 nm (red): 0.9 arcsec
The maximum possible magnification factor is 406.4
This means the minimum compatible eyepiece focal length is 5.0 mm
The minimum magnification factor and corresponding maximum eyepiece focal length depend on the diameter of the observer's eye.
For a telescope user with an eye diameter of 7 mm (apropriate for an age around 25 years):
The minimum magnification factor is 29.0
This means the maximum compatible eyepiece focal length is 406.4 mm
The faintest star that can be seen by this telescope is 13.5 mag
The currently selected eyepiece is 'omni_40', which has the following layout:
Focal length: 40 mm
Field of view: 52 degrees
With this eyepiece:
The magnification factor is 50.8. This is compatible with the telescope limits.
The true field of view is 1 degrees
The exit pupil diameter is 4.0 mm
The faintest surface brightness that can be seen by this telescope is 32.00
[9]:
# calling individual functions
c8._compute_focal_ratio()
Focal Ratio:'10.0'
True Focal Ratio:'10.0'
[10]:
# adding additional optical parts
reducer = focal_reducer(.5) # defining focal reducer of 0.5x
barlow = barlow_lens(2) # defining barlow lens of 2x
[11]:
c8.add_optic(reducer,'reducer 1', select=True) # adding reducer to the telescope
c8.add_optic(barlow,'barlow 1', select=False) # adding barlow to the telescope
#if the magnifications limits get reached then warning will be printed.
Focal Ratio:'5.0'
True Focal Ratio:'10.0'
Note: The magnification produced by this eyepiece is not compatible with the telescope.
[12]:
c8.add_optic(reducer,'reducer 1', select=False)
c8.add_optic(barlow,'barlow 1', select=True)
Focal Ratio:'20.0'
True Focal Ratio:'10.0'
[13]:
# printing configuration again with barlow lens
c8.say_configuration()
The telescope has the following layout:
Aperture diameter: 203.2 mm
Focal length: 2032 mm, corresponding to a focal ratio of 10.0
'barlow 1', a Barlow lens, has been added to the optical path. This increases the focal length by 2
This results in
Focal length: 4064 mm, corresponding to a focal ratio of 20.0
In good atmospheric conditions, the resolution of the telescope (Dawes limit) is 0.6 arcseconds
By wavelength, the resolution is
400 nm (blue): 0.5 arcsec
550 nm (green): 0.7 arcsec
700 nm (red): 0.9 arcsec
The maximum possible magnification factor is 406.4
This means the minimum compatible eyepiece focal length is 10.0 mm
The minimum magnification factor and corresponding maximum eyepiece focal length depend on the diameter of the observer's eye.
For a telescope user with an eye diameter of 7 mm (apropriate for an age around 25 years):
The minimum magnification factor is 29.0
This means the maximum compatible eyepiece focal length is 406.4 mm
The faintest star that can be seen by this telescope is 13.5 mag
The currently selected eyepiece is 'omni_40', which has the following layout:
Focal length: 40 mm
Field of view: 52 degrees
With this eyepiece:
The magnification factor is 101.6. This is compatible with the telescope limits.
The true field of view is 1 degrees
The exit pupil diameter is 2.0 mm
The faintest surface brightness that can be seen by this telescope is 8.00
You can notice that if used a 2x barlow lens on a 40mm eyepiece, the brightness of the object will be decresead by 4 times!
This way you can simulate different scenarios and find out which accesories are optimal for your purpose. This will save you both time and money on costly accesories!
For advanced users, the plot functionality provides the plots of resolution performance
, maginfication_limits
and eyepiece_limits
.
[14]:
c8.show_resolving_power()
c8.show_magnification_limits()
c8.show_eyepiece_limits()
[ ]:


System Test
This script tests the whole system, it simulates the geolocation API and stores the track on the server.
Start Tracking
Save To Server
Load From Server
Get Track List From Server


{% extends "base.html" %} {% block content %}
ExoCTK (the Exoplanet Characterization Tool Kit) is an open-source, modular, data analysis software package focused primarily on atmospheric characterization of exoplanets and observation planning. This web application runs the most recent available version of ExoCTK through this web portal designed to single out the most useful tools for observation planning, forward modeling, data reduction, limb darkening, light curve fitting, and retrievals.
Tools to estimate limb darkening in your host star.


A solution to the freecodecamp.org "Build a Personal Portfolio Webpage" challenge.
A solution to the freecodecamp.org "Build a Technical Documentation Page" challenge.
A solution to the freecodecamp.org "Build a Product Landing Page" challenge.
A solution to the freecodecamp.org "Build a Survey Form" challenge.
A solution to the freecodecamp.org "Build a Tribute Page" challenge.


Api setting: allowChildExpandOnMatch
if true
- — and if only parent got match then add all children nodes too
- — or if one or more child node got match then add parent node and all the children nodes
if false
- — and if only parent got match then make expand/collapse button to be collapsed, disabled and do not add any children nodes
- — or if one or more child node got match then add parent node and only matching children nodes


{# Do not translate anything on this page. #}
This is some long text to increase the size of the gutter


Alibaba's US$13.4 billion bookbuild covered multiple times: sources
Alibaba's US$13.4 billion institutional bookbuild for its Hong Kong listing is already covered "multiple times," according to a message sent to investors and verified by sources with direct knowledge of the matter.
HONG KONG: Alibaba's US$13.4 billion institutional bookbuild for its Hong Kong listing is already covered "multiple times," according to a message sent to investors and verified by sources with direct knowledge of the matter.
The Chinese e-commerce giant plans to list its shares in Hong Kong from November 26 and is currently marketing the deal to investors around the world.
The message sent to potential investors said the "quality of demand is high" and that there "continues to be very strong feedback" about the deal.
Pricing of the stock for institutional shareholders will be set on November 20, a prospectus lodged with the Hong Kong Stock Exchange shows.
Retail investors will not pay more than US$HK188 per share, a statement from the company published on Friday showed.
(Editing by Jason Neely)


{% extends 'base.html' %} {% block content %}
ID: {{ venue.id }}
Name: {{ venue.name }}
Address: {{ venue.address }}
Primary category: {{ venue.primary_category }}
Distance: {{ venue.distance }}


You can run very light - just import web components and whatever elements you want
Simple example from the Polymer website
You can scaffold out a production project
Set up project folder - bower & npm for dependancy management
Include web-components (or web-components-lite) + polymer.html
Need to run local dev server - npm polyserve works right out of the box, but there are more options depending on your needs.
For importing link rel="import" href="elements/elements.html"
Grunt/gulp for task for automation - this project is using gulp
Unit testing using Web Component Tester
You can vulcanize and combine your project into 1 element
Page.js for routing (on this project, more-routing is great too)


Simulation¶
Simulation.NetToComp¶
Use the triangle class to represent triangles.
-
class
Simulation.NetToComp.
NetToComp
(filename)[source]¶ Bases:
object
Beispielkommentar
-
getCommentsFromNetlist
(netListFile)[source]¶ Create a triangle with sides of lengths a, b, and c.
Raises ValueError if the three length values provided cannot actually form a triangle.
-


Tesco issues warning to shoppers over dangerous new scam on social media
A new scam is sweeping across social media
by James Andrew, Sophie BarleyThis year Tesco turned 100 and to celebrate the chain launched a string of discounts.
However it did not do was launch a voucher giveaway on Facebook to celebrate - but that's exactly what scammers are claiming on Facebook.
A Tesco spokeswoman told Mirror Money : “This is not a Tesco offer. We would always ask customers to be vigilant and to double check the legitimacy of any online coupons, vouchers or competitions.
"If you are ever unsure about coupons/vouchers you see online you can always check by calling our customer service team on 0800 50 55 55.
"Customers can also visit our privacy centre, where we have some advice regarding staying safe online and how to be aware of scams and phishing.”
Worryingly, the last time this sort of scam hit Facebook in 2017, Tesco shoppers were far from the only ones targeted.
Fake vouchers started circulating for Sainsbury's, Asda, Waitrose, Iceland, Argos, John Lewis and Morrisons too.
An Action Fraud spokesman told Mirror Money customers should be wary before clicking on an unsolicited links.
"Fraudsters will do everything they can to try and take personal and financial details from their victims. It is extremely tempting to click on links for vouchers whilst browsing on social media," a spokesperson said.
"However we ask people to be wary of clicking on unsolicited links and advise that they do their research first, before giving away any personal or financial details.”
Action Fraud tips to protect yourself from online voucher scams
- Be wary of clicking on unsolicited messages on social media, even if they appear to come from a trusted contact.
- Do some online research first - check the official supermarket website to see if there are any genuine offers available.
- Ensure that you have anti-virus software on your computer
- Never give out personal or financial data including usernames, passwords, PINs, ID numbers or memorable phrases.


In this project, we're going to build a basic 3D driving simulator! Check it out!
1) Go to the link below and click "Remix" at the top. This will get us our backdrop and an important block: "Draw Line From To"! We will use it many times. Don't worry if you don't understand, we are only learning how to use it today!
2) The first thing you'll notice is that the remix came with a sprite! Called Drawer? It's a purple dot? Weird! That's because in 3D we DON'T use sprites AT ALL. That dot is hidden and you'll never see it! Instead, in the Drawer sprite, we'll write all of our code to 'draw' the 3D models.
Find the "Draw Line From To block" in the "My Blocks" category.  Remember this is 3D, so you'll need to think about Z now! Don't worry about the variables that came with the remix just yet. Focus on drawing a line.
3) Figure out how to erase your line! Then code it to repeatedly erase and draw your road line again and again. Once you do that, show these variables:
camera X
camera Y
camera Z
Play around with them. What happens when you change X? Y? Z? What are these variables for? What do they mean? Change the Z-coordinates of your line a few times using the "Draw From Line To" block. Can you make the line start at different places closer and farther from the screen? Z is just like X and Y except it's the direction leading OUT OF THE SCREEN. Remember that towards the screen is the negative Z direction.
4) Now show one more variable: timer! You can find this one in the "Sensing" category. It's the number of seconds that have passed since the game began! Open up a new project and try using timer, the "mod" operator, and some number in a loop, saying the calculation. What do you notice? How can this be useful in controlling the position of something that moves in loops?
Use this concept and the Z-coordinates of your line to make your line move down the screen. You may need to multiply it by a bigger number to get it moving fast!
5) Then add more lines!
6) Now for a tree! Use what you learned about road lines to make a tree on the side of the road. It should move towards you just like the road lines.
7) You guessed it. Make a second tree.
8) And then make them start at different spots! By now your code must be sooooooo long. Maybe you should make some "My Blocks" to help you keep it short and clean?
9) Last but not least, model you a car! It doesn't need to move, but don't let that make you think it'll be easy! This is your final challenge! Great Work!
Bonus) Add steering! And don't let us stop you there: acceleration/deceleration for your car might be cool. What about the variable FOV? Hmm what does that do?


Hello,and WELCOME to our BUSMALL
Please, select your items by clicking on the Product. Each time you will see three products,select the one you want by clicking on the product.you can select products only 25 times. when you finish, click on the VIEW RESULT button to see your picks :).


pizzApostrophe
Don't miss this!
Order Below
add as many as you like!
Sizes
8" Pie
12" Pie
16" Pie
Choose a crust:
Hand-Tossed
Thin($+1)
Pan($+1)
Toppings, First One on the House
Then $1.50 per
Meats
Bacon
Beef
Extra Cheese
Chicken
Pepperoni
Sausage
Zebra
Veggies & Fruit
Tomato
Spinach
Pineapple
Artichoke
Mushroom
Olives
Add a Pizza
Submit Order


Best of BS Opinion: Olympics in India, intoxication of power, and more
Here's a selection of Business Standard opinion pieces for the day
by Uddalok BhattacharyaWhen an essentially weak nation poses to be strong, its strengths and weaknesses start resembling one another. That’s what is likely to happen if India holds the Olympics. And economists and sociologists can have field day. Uddalok Bhattacharya sums up
India is now far too strong for anyone to push it around.
That should’ve made us more secure, not get caught in old fears and insecurities. Shekhar Gupta looks at faultlines
Time to hold Olympics in India, says Shashank Mani Tripathi
Good intentions should not be woven into economics, says TCA Srinivasa-Raghavan. Both are left poorer.
The BJP would do well to heed warning signals. Aditi Phadnis explains
QUOTE I look forward to the government's goal of USD 5 trillion. And I think that they're going to hit that goal, even faster than they expect with what are great economic opportunities as they promote growth -US Treasury Secretary Steve Mnuchin


 You
can perform a limit of moviments and can store a limit of
instructions denoted by the robot's battery and memory.
To control the robot you need to program him using the left
panels.
Robot Moviments:
move forward, move backward, rotate left, rotate right
Control Operations:
repeat n times instruction
if condition instruction
if condition instruction else instruction
Conditions:
wall ahead, rock ahead, no wall ahead, no rock ahead
Instructions:
A instruction can be a moviment, a control operation or a block
of instructions: { instructions }


The nightly builds on this page have been automatically generated and are not guaranteed to be stable. It is possible that these builds have major bugs and may not run at all. Be sure to check junit test results to understand what is working and what is not in this drop.


1. Run local http serer at the project root e.g. > cd path/to/vanillajs-datepicker > http-server ./ 2, Using Chromium-based browser, open this test file through the local http serer e.g. http://localhost:8080/test/non-automated/for-issue-144-autofill/index.html 3. Type a date in the input field (do not choose from Datepicker), and submit 4. Open the browser's console in Dev Tools 5. Click the input field, and select a date from the autofill 5. See if no error is output in the console


On 17 February 2020, 8 new articles were published in 3 journals.
A Methodology For Estimating the Illicit Consumption of Cigarettes At the Country Level
Mathematical Approach to the Analysis of Terrorism Dynamics
Boko Haram, Pro-Synergic Conditions and Community Involvement in Counterinsurgency
Boko Haram Insurgency: A Decade of Dynamic Evolution and Struggle For A Caliphate
Automated Monitoring For Security Camera Networks: Promise From Computer Vision Labs
The Juridification of the Uk’s Counter Terrorism Prevent Policy


Miscellaneous DOW Policies and Information
Email
Please be sure to include your ship name if you email me. With so many
members, I can't always remember everybody's email address.
The DOW front page
The official DOW front page is
http://janin.org/dow/front.cgi.
It contains important news and links
to recently added features. Please check it out occasionally.
Anonymous Members of DOW
Because of several verifiable threats by big ships to begin attacking
DOW members on sight, membership in DOW is now by default completely
anonymous. You can change to being non-anonymous by going to your
membership data page.
Yahoo Forums
Because of anonymity issues (see above), I am no longer using the
Yahoo Forums for DOW. Instead, I will be hosting the forums directly
on the DOW server at
http://janin.org/dow/forumread.cgi.
Many topics are discussed on the forums. I especially suggest that
newbies join, as there are many quite knowledgeable posters.
Currently, there are three forums:
xeno, for Institute of Xenology
members, advice, and general, for
everything else. If more forums would be useful, let me know.
DOW, Pirates, Purgers, Releasers, and the UPF
I created DOW specifically because I wanted an information sharing
system that did not welcome pirates and bullies. Information is a
valuable resource, and giving it away to captains who abuse other
ships just didn't seem right.
Certain ships are permanently banned from DOW. I will not allow
them to join under any circumstances. These ships include UPF members,
chronic terminal purgers, and pirates. (Clarifying note: This list was
fixed shortly after DOW formed. No ships will be added or removed.)
Other ships may be banned, but then pardoned if their behavior
changes. The procedure to ban a ship starts by nominating them for
banning on the DOW forum. After some discussion, I will post a
poll. After one week, the nominated ship will be banned if more
members voted for banning than against banning. A ship may be forgiven
using a similar method.
With DOW now anonymous, I strongly suggest you consider who
might be a member, and propose bannings accordingly.
DOW Conduct Rules
The only official rule is that you do not share DOW data with
non-members.
Alliances and DOW
Alliances have no special status within DOW (e.g. no access to data
beyond what their members already have). However, I encourage members
to form alliances, and may provide scripting support if the alliance
is interesting.
Out of Character
I really like the "evil" ships in the game. They add spice. Without
them, I probably would have quit in boredom. Instead, I'm doing
everything I can to fight them -- DOW is one prong of the attack.
As long as the big, old ships continue to cooperate among themselves,
the only way small to medium ships can compete is by likewise
cooperating.
For some of my random musings on DOW and TBG, see http://janin.org/~janin/tbg-dow.html.


Travis Howey Design
Portfolio
About Me
Photography
Contact
Go Ahead And Shoot Me An Email!
Email
Reason For Email
Inquiries
Personal
Questions
Write something...
Submit
801-462-6552
traviswhowey@gmail.com


Setup Required
Phone is not configured, run setup first.
Setup
{{invalidBrowserMessage}}
Phone is offline.
Could not refresh expired token, check your internet connection.
incoming call from
{{phoneNumber}}
1
2
ABC
3
DEF
4
GHI
5
JKL
6
MNO
7
PQRS
8
TUV
9
WXYZ
*
0
+
#
{{duration | ElapsedTime}}
{{phoneNumber}}
Waiting for incoming calls ...
Invalid phone number
1
2
ABC
3
DEF
4
GHI
5
JKL
6
MNO
7
PQRS
8
TUV
9
WXYZ
*
0
+
#
You
called
tried to call
{{call.to}}
{{call.updatedAt | CallDate}}
, {{call.duration | CallDuration}}
{{call.from}}
called
tried to call
You
{{call.updatedAt | CallDate}}
, {{call.duration | CallDuration}}
more ...


We offer quality national brands such as IBP, Excel, Cargill, Harris Ranch, Swift, Great Omaha and National;
names you can trust in over 40 different cuts of beef. For your convenience most beef products are available
for you to purchase less than a case.
-
Back Ribs Bone In
- Bone Cut
- Brisket-Boneless
- Ball Tip
- Cheek Meat
- Chuck Roll
- Eye Round
- Feet / Tail / Cheek
- Steer Flank Steak
- Steer Flap Meat
- Franks: 6” 5/1, and 6.75” 4/1
- Ground 80%/20%
- Inside Round
- Leg Tendons
- Patties: Ground 4/1, 5/1
- Ribeye Steak 8 oz.
- Short Rib: Korean Style Center Cut 3/8”
- New York Steak 8 oz. End-End
- Stew: Asada Boneless
-
Top Sirloin Boneless
Tripe: Honeycomb, Omasum, Scalded


Class CardChannelObservable
Allows an existing ICardChannel instance to be observed by using delegates and wrapping it.
Inheritance
System.Object
CardChannelObservable
Inherited Members
System.Object.Equals(System.Object)
System.Object.Equals(System.Object, System.Object)
System.Object.GetHashCode()
System.Object.GetType()
System.Object.MemberwiseClone()
System.Object.ReferenceEquals(System.Object, System.Object)
System.Object.ToString()
Assembly: WSCT.dll
Syntax
public class CardChannelObservable : ICardChannelObservable, ICardChannel
Constructors
|
Improve this Doc
View Source
CardChannelObservable(ICardChannel)
Initializes a new instance.
Declaration
public CardChannelObservable(ICardChannel channel)
Parameters
| Type |
Name |
Description |
| ICardChannel |
channel |
ICardChannel instance to wrap.
|
Fields
|
Improve this Doc
View Source
channel
Declaration
protected ICardChannel channel
Field Value
Properties
|
Improve this Doc
View Source
Protocol
Declaration
public Protocol Protocol { get; }
Property Value
|
Improve this Doc
View Source
ReaderName
Declaration
public string ReaderName { get; }
Property Value
| Type |
Description |
| System.String |
|
Methods
|
Improve this Doc
View Source
Attach(ICardContext, String)
Declaration
public void Attach(ICardContext context, string readerName)
Parameters
| Type |
Name |
Description |
| ICardContext |
context |
|
| System.String |
readerName |
|
|
Improve this Doc
View Source
Connect(ShareMode, Protocol)
Declaration
public ErrorCode Connect(ShareMode shareMode, Protocol preferedProtocol)
Parameters
Returns
|
Improve this Doc
View Source
Disconnect(Disposition)
Declaration
public ErrorCode Disconnect(Disposition disposition)
Parameters
Returns
|
Improve this Doc
View Source
GetAttrib(Attrib, ref Byte[])
Declaration
public ErrorCode GetAttrib(Attrib attrib, ref byte[] buffer)
Parameters
| Type |
Name |
Description |
| Attrib |
attrib |
|
| System.Byte[] |
buffer |
|
Returns
|
Improve this Doc
View Source
GetStatus()
Declaration
Returns
|
Improve this Doc
View Source
Reconnect(ShareMode, Protocol, Disposition)
Declaration
public ErrorCode Reconnect(ShareMode shareMode, Protocol preferedProtocol, Disposition initialization)
Parameters
Returns
|
Improve this Doc
View Source
Transmit(ICardCommand, ICardResponse)
Declaration
public ErrorCode Transmit(ICardCommand command, ICardResponse response)
Parameters
Returns
Events
|
Improve this Doc
View Source
AfterConnectEvent
Declaration
public event EventHandler<AfterConnectEventArgs> AfterConnectEvent
Event Type
|
Improve this Doc
View Source
AfterDisconnectEvent
Declaration
public event EventHandler<AfterDisconnectEventArgs> AfterDisconnectEvent
Event Type
|
Improve this Doc
View Source
AfterGetAttribEvent
Declaration
public event EventHandler<AfterGetAttribEventArgs> AfterGetAttribEvent
Event Type
|
Improve this Doc
View Source
AfterGetStatusEvent
Declaration
public event EventHandler<AfterGetStatusEventArgs> AfterGetStatusEvent
Event Type
|
Improve this Doc
View Source
AfterReconnectEvent
Declaration
public event EventHandler<AfterReconnectEventArgs> AfterReconnectEvent
Event Type
|
Improve this Doc
View Source
AfterTransmitEvent
Declaration
public event EventHandler<AfterTransmitEventArgs> AfterTransmitEvent
Event Type
|
Improve this Doc
View Source
BeforeConnectEvent
Declaration
public event EventHandler<BeforeConnectEventArgs> BeforeConnectEvent
Event Type
|
Improve this Doc
View Source
BeforeDisconnectEvent
Declaration
public event EventHandler<BeforeDisconnectEventArgs> BeforeDisconnectEvent
Event Type
|
Improve this Doc
View Source
BeforeGetAttribEvent
Declaration
public event EventHandler<BeforeGetAttribEventArgs> BeforeGetAttribEvent
Event Type
|
Improve this Doc
View Source
BeforeGetStatusEvent
Declaration
public event EventHandler<BeforeGetStatusEventArgs> BeforeGetStatusEvent
Event Type
|
Improve this Doc
View Source
BeforeReconnectEvent
Declaration
public event EventHandler<BeforeReconnectEventArgs> BeforeReconnectEvent
Event Type
|
Improve this Doc
View Source
BeforeTransmitEvent
Declaration
public event EventHandler<BeforeTransmitEventArgs> BeforeTransmitEvent
Event Type
Implements
Extension Methods


<?php
public class Bicycle
{
public $size;
public $chain;
public $tireSize;
public function __construct($size, $chain, $tireSize)
{
$this->size = $size;
$this->chain = $chain;
$this->tireSize = $tireSize;
}
public function tireSize()
{
return "The tire size is " . $this->tireSize . " inches";
}
}
$bike = new Bike("26", "10-speed", "23");
echo $bike->tireSize(); // 23
echo $bike->chain; // 10-speed
?>
Your first class
<?php
?>
Magic Methods
<?php
__construct();
__destruct();
?>
Visibility and Inheritance
<?php
public class Bicycle
{
public $size;
public $chain;
public $tireSize;
public function __construct($size, $chain, $tireSize)
{
$this->size = $size;
$this->chain = $chain;
$this->tireSize = $tireSize;
}
public function tireSize()
{
return "The tire size is " . $this->tireSize . " inches";
}
}
public class RoadBike extends Bicycle
{
public function __construct($size, $chain, $tireSize)
{
$this->size = $size;
$this->chain = $chain;
$this->tireSize = $tireSize;
}
public function tireSize()
{
return "The tire size is " . $this->tireSize . " inches";
}
}
$bike = new Bike("26", "10-speed", "23");
echo $bike->tireSize(); // 23
echo $bike->chain; // 10-speed
?>


3. View the video with overdubbed spoken audio in your chosen langauge.
1. Upload a video to have it automatically transcribed.
2. Review and edit the computer assisted translation.


Interactor object that runs at the front of the `ManageMessage` interactor, ensuring that all handled messages are from verified users. Rate limits if not.
Namespace
- CLASS VerifyUser
Interactor object that runs at the front of the `ManageMessage` interactor, ensuring that all handled messages are from verified users. Rate limits if not.


{% extends 'client/profile_client_intake.html' %}
{% block javascripts %}
{{ block.super }}
{% load staticfiles %}
{% endblock %}
{% block body %}
{% include 'client/profile_open_or_transfer_account.html' with form=form client=client ria_company_information=ria_company_information %}
{% endblock %}


This set of examples shows how to iterate over the contents of collections. In HTML, collections are usually output using a element specifically designed to support repetition (li, option, tr, or dt/dd). Dynamator allows any HTML element to be repeated for iteration. Dynamator can generate code to support any JDK 1.1 or 1.2 collection: array, Vector, Enumeration, Dictionary, Properties, Iterator, and Map. This tutorial covers only JDK 1.1 collections.
Iteration is accomplished by adding a 'foreach' element to the Dynamator entry for an id or class value. In the 'foreach' element, you can specify attributes that identify the type of the collection and the name of each Java variable that needs to be generated to support iteration. Most of the time, such fine-grained control is not needed. In this tutorial, we will be demonstrating use of only the required attributes. For complete information about the syntax of the 'foreach' element in Dynamator for JSP, see the man page for Dynamator Language Support for JSP.
The 'foreach' element has two required attributes:
| type | The type of the collection. This may be one of the following:
|
||||||||||||||
| element | The name of the variable that references the current element. |


To review, in Chapter 2 we stated that given an array of integers we could point an integer pointer at that array using:
int *ptr; ptr = &my_array[0]; /* point our pointer at the first integer in our array */As we stated there, the type of the pointer variable must match the type of the first element of the array.
In addition, we can use a pointer as a formal parameter of a function which is designed to manipulate an array. e.g.
Given:
int array[3] = {'1', '5', '7'}; void a_func(int *p);Some programmers might prefer to write the function prototype as:
void a_func(int p[]);which would tend to inform others who might use this function that the function is designed to manipulate the elements of an array. Of course, in either case, what actually gets passed is the value of a pointer to the first element of the array, independent of which notation is used in the function prototype or definition. Note that if the array notation is used, there is no need to pass the actual dimension of the array since we are not passing the whole array, only the address to the first element.
We now turn to the problem of the 2 dimensional array. As stated in the last chapter, C interprets a 2 dimensional array as an array of one dimensional arrays. That being the case, the first element of a 2 dimensional array of integers is a one dimensional array of integers. And a pointer to a two dimensional array of integers must be a pointer to that data type. One way of accomplishing this is through the use of the keyword "typedef". typedef assigns a new name to a specified data type. For example:
typedef unsigned char byte;causes the name byte to mean type unsigned char. Hence
byte b[10]; would be an array of unsigned characters.Note that in the typedef declaration, the word byte has replaced that which would normally be the name of our unsigned char. That is, the rule for using typedef is that the new name for the data type is the name used in the definition of the data type. Thus in:
typedef int Array[10];Array becomes a data type for an array of 10 integers. i.e. Array my_arr; declares my_arr as an array of 10 integers and Array arr2d[5]; makes arr2d an array of 5 arrays of 10 integers each.
Also note that Array *p1d; makes p1d a pointer to an array of 10 integers. Because *p1d points to the same type as arr2d, assigning the address of the two dimensional array arr2d to p1d, the pointer to a one dimensional array of 10 integers is acceptable. i.e. p1d = &arr2d[0]; or p1d = arr2d; are both correct.
Since the data type we use for our pointer is an array of 10 integers we would expect that incrementing p1d by 1 would change its value by 10*sizeof(int), which it does. That is, sizeof(*p1d) is 20. You can prove this to yourself by writing and running a simple short program.
Now, while using typedef makes things clearer for the reader and easier on the programmer, it is not really necessary. What we need is a way of declaring a pointer like p1d without the need of the typedef keyword. It turns out that this can be done and that
int (*p1d)[10];is the proper declaration, i.e. p1d here is a pointer to an array of 10 integers just as it was under the declaration using the Array type. Note that this is different from
int *p1d[10];which would make p1d the name of an array of 10 pointers to type int.


Canvas Engine
Bring your web canvases to life with this simple to use game engine!
Chakara Demo
Start Chakara


Information
Client-side spatial analysis of radiological data using turf.js (Buffer, Intersections, Interpolation, Voronoi, TIN).
Our goal was: to develop a web map where it is possible to edit a vector datas with turf.js. This webmap is available for everybody to use it for free. Our licence is MIT License. We used for the project OpenLayers3, turf.js, JavaScript, HTML, CSS, QGIS.
License
Our licence is MIT License. This is a simple type whose conditions only requiring preservation of copyright and license notices. Licensed works, modifications, and larger works may be distributed under different terms and without source code.
More information about license: http://choosealicense.com/licenses/mit/


glitch.camp
Welcome to
glitch.camp
!
FAQ
How do I make a web page?
How does CSS positioning work?
How do I create a fluid layout using absolute positioning?
How do I use custom web fonts?
How do I make a lightbox effect?
How to Publish a Website using GitHub Pages
Recommended
DevDocs
Document and website structure
Modern JavaScript Cheatsheet
MarkSheet
Eloquent JavaScript
Laws of UX
What Makes For a Semantic Class Name?
Hardware Hacking
CanaKit


---
layout: default
---
Useful reminders:
- Hemingway rewrote the last page of A Farewell to Arms 47 times. Behind Edward Hopper's masterpieces is a series of sketches. Creative process is inherently messy and chaotic.
- If Barack Obama found time to read amid the Arab Spring and the killing of Osama bin Laden, so can you during the job market preparation.
- Parable of the arrow: When struck by a poisoned arrow, it is crucial to remove the arrow and treat the wound, rather than waste time questioning the arrow's origins or the archer's motives.
- Parable of the airbag: When you know with certainty that you will be in a car accident someday, invest in advanced airbag systems rather than dwell on the inevitability of the crash.
- Under pressure, you always go back to your habits. Building habits is preparing for the worst-case scenario.
- “The art of war teaches us to rely not on the likelihood of the enemy's not coming, but on our own readiness to receive him; not on the chance of his not attacking, but rather on the fact that we have made our position unassailable.” - Sun Tzu
- Sprezzatura: You have to put in more effort to make something appear effortless.
- Clear writing gives poor thinking nowhere to hide. This is also why writing is difficult.
- "When you plan something well, there's no need to rush." - Thomas Shelby
To slow down time:
- Interval trainings using a fan bike.
- Plan out your day. See Ben Franklin's example or other routines of famous creatives.
- Use a time tracker to record your daily activities.
- Start a new habit and witness how long it takes to reach 100 days
When in need of a tangible productivity boost:
- Start by creating the Right Now List
- Classical music for when you’re on a deadline
- "5-4-3-2-1...act." -- the 5 Second Rule is a technique that helps you overcome procrastination and take action by counting down from 5 to 1 and physically moving towards your goal.
- AI tools to help you read papers: Typeset, Unriddle
- "Academic writers cannot get writer’s block. Don’t confuse yourself with your friends teaching creative writing in the fine arts department. You’re not crafting a deep narrative or composing metaphors that expose mysteries of the human heart. The subtlety of your analysis of variance will not move readers to tears, although the tediousness of it might. People will not photocopy your reference list and pass it out to friends whom they wish to inspire.  [source]
When burned out:
- Live cameras at San Diego Zoo
- Paintings
- Ultimate freestyle rap videos by Harry Mack
- Lofi and Games with casual games and music
- Collection of motivational videos by Michelle Ellsworth
When confused:
- Draw your latex symbol to find out what it's called.
- Notes on empirical methods in corporate finance by Todd Gormley
- Notes on applied empirical methods by Paul Goldsmith-Pinkham
- Notes on applied econometrics by Peter Hull
- Online books on causal inference: Matheus Facure Alves, Scott Cunningham
- Literature on recent advances in applied micro models by Christine Cai
- Notes on empirical asset pricing by Ralph Koijen and Stijn Van Nieuwerburgh
- Review of canonical asset pricing models by Kenneth Kasa
- Principles for combining descriptive and model-based analysis by Neale Mahoney
- Examples: Budish, Roin, & Williams (AER, 2015), Einav, Finkelstein, and Schrimpf (QJE, 2015), Kapor, Neilson, & Zimmerman (AER, 2020), Agarwal, Chomsisengphet, Mahoney, and Stroebel (QJE, 2018)
When in need of a perspective:
- Job market timeline overview by Alex Albright
- The purpose of a finance professor by Alex Edmans
- "It is the job of the creator to explode. It is the task of the academic to walk around the bomb site, gathering up the shrapnel, to figure out what kind of an explosion it was, who was killed, how much damage it was meant to do and how close it came to actually achieving that."
- Quotes
- Of Rules and Razors
When in need of an even bigger perspective:
- The Library of Babel by Jorge Luis Borges. Contained somewhere in this infinite library is our JMP.
- The modern interpretation of Thomas Aquinas's Summa Theologiae implies that everyone is driven by the pursuit by (i) money (wealth), (ii) pleasure, (iii) power, or (iv) fame (honor). So which one is it?
- How to Grow Old by Bertrand Russell
- List of best best alternate histories
- Best places to retire: US states
- Philisophy Bro explains complex ideas of philosophy in easy to understand language.
- "Medicine, law, business, engineering, these are all noble pursuits, and necessary to sustain life. But poetry, beauty, romance, love, these are what we stay alive for." (Dead Poet’s Society)
- Résumé Virtues are the things you put on your resume. Your professional accolades, education credentials, titles, status, net worth, and more. Eulogy Virtues are the things people talk about at your funeral. Whether you had a clear purpose and worked with meaning, whether you were curious and interested, whether you were kind, loving, and trustworthy, whether you were a loyal friend, partner, and parent, and more.


--- layout: post title: "morning lyrics" comments: true ---
And if the darkness is to keep us apart
And if the daylight feels like it's a long way off
And if your glass heart should crack
And for a second you turn back
Oh no, be strong
Oh, oh
Walk on, walk on
What you got, they can't steal it
No, they can't even feel it
Walk on, walk on
Stay safe tonight