static void ILI9488_InitInterface(void)
{
PIO_Configure(ILI9488_Reset, PIO_LISTSIZE(ILI9488_Reset));
PIO_Configure(spi_pins, PIO_LISTSIZE(spi_pins));
PIO_Configure(ILI9488_Pwm, PIO_LISTSIZE(ILI9488_Pwm));
/* Enable PWM peripheral clock */
PMC_EnablePeripheral(ID_PWM0);
/* Set clock A and clock B */
// set for 14.11 KHz for CABC control
// mode = PWM_CLK_PREB(0x0A) | (PWM_CLK_DIVB(110)) |
// PWM_CLK_PREA(0x0A) | (PWM_CLK_DIVA(110));
PWMC_ConfigureClocks(PWM0, 14200, 0, BOARD_MCK);
/* Configure PWM channel 1 for LED0 */
PWMC_DisableChannel(PWM0, CHANNEL_PWM_LCD);
PWMC_ConfigureChannel(PWM0, CHANNEL_PWM_LCD, PWM_CMR_CPRE_CLKA,0,PWM_CMR_CPOL);
PWMC_SetPeriod(PWM0, CHANNEL_PWM_LCD, 16);
PWMC_SetDutyCycle(PWM0, CHANNEL_PWM_LCD, 8);
PWMC_EnableChannel(PWM0, CHANNEL_PWM_LCD);
SPI_Configure(ILI9488, ILI9488_ID, (SPI_MR_MSTR | SPI_MR_MODFDIS | SPI_PCS( ILI9488_cs )));
SPI_ConfigureNPCS( ILI9488, ILI9488_cs,
SPI_CSR_CPOL | SPI_CSR_BITS_9_BIT |
SPI_DLYBS(100, BOARD_MCK) | SPI_DLYBCT(100, BOARD_MCK) |
SPI_SCBR( 35000000, BOARD_MCK) ) ;
SPI_Enable(ILI9488);
}
/**
* \brief ILI9488 Hardware Initialization for SPI/SMC LCD.
*/
static void _ILI9488_Spi_HW_Initialize(void)
{
/* Pin configurations */
PIO_Configure(&lcd_spi_reset_pin, 1);
PIO_Configure(&lcd_spi_cds_pin, 1);
PIO_Configure(lcd_pins, PIO_LISTSIZE(lcd_pins));
PIO_Configure(&lcd_spi_pwm_pin, 1);
/* Enable PWM peripheral clock */
PMC_EnablePeripheral(ID_PWM0);
PMC_EnablePeripheral(ID_SPI0);
/* Set clock A and clock B */
// set for 14.11 KHz for CABC control
//mode = PWM_CLK_PREB(0x0A) | (PWM_CLK_DIVB(110)) |
//PWM_CLK_PREA(0x0A) | (PWM_CLK_DIVA(110));
PWMC_ConfigureClocks(PWM0, 14200, 0, BOARD_MCK);
/* Configure PWM channel 1 for LED0 */
PWMC_DisableChannel(PWM0, CHANNEL_PWM_LCD);
PWMC_ConfigureChannel(PWM0, CHANNEL_PWM_LCD, PWM_CMR_CPRE_CLKA, 0,
PWM_CMR_CPOL);
PWMC_SetPeriod(PWM0, CHANNEL_PWM_LCD, 16);
PWMC_SetDutyCycle(PWM0, CHANNEL_PWM_LCD, 8);
PWMC_EnableChannel(PWM0, CHANNEL_PWM_LCD);
SPI_Configure(ILI9488_SPI, ID_SPI0, (SPI_MR_MSTR | SPI_MR_MODFDIS
| SPI_PCS(SMC_EBI_LCD_CS)));
SPI_ConfigureNPCS(ILI9488_SPI,
SMC_EBI_LCD_CS,
SPI_CSR_CPOL | SPI_CSR_BITS_8_BIT | SPI_DLYBS(6, BOARD_MCK)
| SPI_DLYBCT(100, BOARD_MCK) | SPI_SCBR(20000000, BOARD_MCK));
SPI_Enable(ILI9488_SPI);
}
int platform_init()
{
int i;
// Enable the peripherals we use in the PMC
PMC_EnablePeripheral( AT91C_ID_US0 );
PMC_EnablePeripheral( AT91C_ID_US1 );
PMC_EnablePeripheral( AT91C_ID_PIOA );
PMC_EnablePeripheral( AT91C_ID_PIOB );
PMC_EnablePeripheral( AT91C_ID_TC0 );
PMC_EnablePeripheral( AT91C_ID_TC1 );
PMC_EnablePeripheral( AT91C_ID_TC2 );
PMC_EnablePeripheral( AT91C_ID_PWMC );
// Configure the timers
AT91C_BASE_TCB->TCB_BMR = 0x15;
for( i = 0; i < 3; i ++ )
TC_Configure( ( AT91S_TC* )timer_base[ i ], AT91C_TC_CLKS_TIMER_DIV5_CLOCK | AT91C_TC_WAVE );
// PWM setup (only the clocks are set at this point)
PWMC_ConfigureClocks( BOARD_MCK, BOARD_MCK, BOARD_MCK );
PWMC_ConfigureChannel( 0, AT91C_PWMC_CPRE_MCKA, 0, 0 );
PWMC_ConfigureChannel( 1, AT91C_PWMC_CPRE_MCKA, 0, 0 );
PWMC_ConfigureChannel( 2, AT91C_PWMC_CPRE_MCKB, 0, 0 );
PWMC_ConfigureChannel( 3, AT91C_PWMC_CPRE_MCKB, 0, 0 );
for( i = 0; i < 4; i ++ )
{
PWMC_EnableChannel( i );
PWMC_EnableChannelIt( i );
}
cmn_platform_init();
#if VTMR_NUM_TIMERS > 0
// Virtual timer initialization
TC_Configure( AT91C_BASE_TC2, AT91C_TC_CLKS_TIMER_DIV5_CLOCK | AT91C_TC_WAVE | AT91C_TC_WAVESEL_UP_AUTO );
AT91C_BASE_TC2->TC_RC = ( BOARD_MCK / 1024 ) / VTMR_FREQ_HZ;
AIC_DisableIT( AT91C_ID_TC2 );
AIC_ConfigureIT( AT91C_ID_TC2, 0, ISR_Tc2 );
AT91C_BASE_TC2->TC_IER = AT91C_TC_CPCS;
AIC_EnableIT( AT91C_ID_TC2 );
TC_Start( AT91C_BASE_TC2 );
#endif
// Initialize the system timer
cmn_systimer_set_base_freq( BOARD_MCK / 16 );
cmn_systimer_set_interrupt_period_us( SYSTIMER_US_PER_INTERRUPT );
platform_systimer_init();
return PLATFORM_OK;
}
void audioInit(void)
{
PMC_EnablePeripheral(ID_PWM);
PWMC_ConfigureClocks(0, 0, BOARD_MCK);
PWMC_ConfigureChannel(PWM, 0, PWM_CMR_CPRE_MCK, 0, 0);
PWMC_ConfigureEventLineMode(PWM, 0, 1);
audioSetSample(AUDIO_NULL, DEFAULT_AUDIO_SAMPLERATE);
PWMC_EnableChannel(PWM, 0);
PMC_EnablePeripheral(ID_DACC);
DACC_Initialize(DACC, ID_DACC, 1, 4, 0, 0, BOARD_MCK, 8, DACC_CHANNEL_0, 0, 16 );
DACC_EnableChannel(DACC, DACC_CHANNEL_0);
}
//Setup the hardware for the PWM with a specific frequency and period
bool customPWMinit(unsigned long freq, unsigned long per){
if(!isEnabled)
{
globFrequency = freq;
globPeriod = per;
//Turn on the PWM peripheral
pmc_enable_periph_clk(PWM_INTERFACE_ID);
//Configure the clocks
PWMC_ConfigureClocks(freq*per, 0, VARIANT_MCK); //VARIANT_MCK is the master clock frequency
isEnabled = true;
return 0;
}
else
{
//The hardware is already set, and you are trying to set it again
return 1;
}
}
/**
* \brief Application entry point for PWM with PDC example.
*
* Outputs a PWM on LED1.
* Channel #0 is configured as synchronous channels.
* The update of the duty cycle values is made automatically by the Peripheral DMA Controller.
*
* \return Unused (ANSI-C compatibility).
*/
int main(void)
{
uint32_t i;
/* Disable watchdog */
WDT_Disable( WDT ) ;
/* Enable I and D cache */
SCB_EnableICache();
SCB_EnableDCache();
/* Output example information */
printf("-- PWM with DMA Example %s --\n\r", SOFTPACK_VERSION);
printf("-- %s\n\r", BOARD_NAME);
printf("-- Compiled: %s %s --\n\r", __DATE__, __TIME__);
/* PIO configuration */
PIO_Configure(pinPwm, PIO_LISTSIZE(pinPwm));
for (i= 0; i< DUTY_BUFFER_LENGTH; i++) dwDutys[i] = i/2;
/* Enable PWMC peripheral clock */
PMC_EnablePeripheral(ID_PWM0);
/* Configure interrupt for PWM transfer */
NVIC_DisableIRQ(PWM0_IRQn);
NVIC_ClearPendingIRQ(PWM0_IRQn);
NVIC_SetPriority(PWM0_IRQn, 0);
/* Configure DMA channel for PWM transfer */
_ConfigureDma();
/* Set clock A to run at PWM_FREQUENCY * MAX_DUTY_CYCLE (clock B is not used) */
PWMC_ConfigureClocks(PWM0, PWM_FREQUENCY * MAX_DUTY_CYCLE , 0, BOARD_MCK);
/* Configure PWMC channel for LED0 (left-aligned, enable dead time generator) */
PWMC_ConfigureChannel( PWM0,
0, /* channel */
PWM_CMR_CPRE_CLKA, /* prescaler, CLKA */
0, /* alignment */
0 /* polarity */
);
PWMC_ConfigureSyncChannel(PWM0,
(1 << CHANNEL_PWM_LED0), /* Define the synchronous channels by the bits SYNCx */
PWM_SCM_UPDM_MODE2, /* Select the manual write of duty-cycle values and the automatic update by setting the field UPDM to 鈥�1鈥� */
0,
0);
/* Configure channel 0 period */
PWMC_SetPeriod(PWM0, 0, DUTY_BUFFER_LENGTH);
/* Configure channel 0 duty cycle */
PWMC_SetDutyCycle(PWM0, 0, MIN_DUTY_CYCLE);
/* Define the update period by the field UPR in the PWM_SCUP register*/
PWMC_SetSyncChannelUpdatePeriod(PWM0, 8);
/* Enable the synchronous channels by writing CHID0 in the PWM_ENA register */
PWMC_EnableChannel(PWM0, 0);
/* Enable PWM interrupt */
PWMC_EnableIt(PWM0, 0, PWM_IER2_WRDY);
NVIC_EnableIRQ(PWM0_IRQn);
_PwmDmaTransfer();
while(1);
}
void Mower::setup(){
Wire.begin();
Console.begin(BAUDRATE);
//while (!Console) ; // required if using Due native port
Console.println("SETUP");
rc.initSerial(PFOD_BAUDRATE);
// keep battery switched ON
pinMode(pinBatterySwitch, OUTPUT);
digitalWrite(pinBatterySwitch, HIGH);
// LED, buzzer, battery
pinMode(pinLED, OUTPUT);
pinMode(pinBuzzer, OUTPUT);
digitalWrite(pinBuzzer,0);
pinMode(pinBatteryVoltage, INPUT);
pinMode(pinChargeCurrent, INPUT);
pinMode(pinChargeVoltage, INPUT);
pinMode(pinChargeRelay, OUTPUT);
setActuator(ACT_CHGRELAY, 0);
// left wheel motor
pinMode(pinMotorEnable, OUTPUT);
digitalWrite(pinMotorEnable, HIGH);
pinMode(pinMotorLeftPWM, OUTPUT);
pinMode(pinMotorLeftDir, OUTPUT);
pinMode(pinMotorLeftSense, INPUT);
pinMode(pinMotorLeftFault, INPUT);
// right wheel motor
pinMode(pinMotorRightPWM, OUTPUT);
pinMode(pinMotorRightDir, OUTPUT);
pinMode(pinMotorRightSense, INPUT);
pinMode(pinMotorRightFault, INPUT);
// mower motor
pinMode(pinMotorMowDir, OUTPUT);
pinMode(pinMotorMowPWM, OUTPUT);
pinMode(pinMotorMowSense, INPUT);
pinMode(pinMotorMowRpm, INPUT);
pinMode(pinMotorMowEnable, OUTPUT);
digitalWrite(pinMotorMowEnable, HIGH);
pinMode(pinMotorMowFault, INPUT);
// lawn sensor
pinMode(pinLawnBackRecv, INPUT);
pinMode(pinLawnBackSend, OUTPUT);
pinMode(pinLawnFrontRecv, INPUT);
pinMode(pinLawnFrontSend, OUTPUT);
// perimeter
pinMode(pinPerimeterRight, INPUT);
pinMode(pinPerimeterLeft, INPUT);
// button
pinMode(pinButton, INPUT);
pinMode(pinButton, INPUT_PULLUP);
// bumpers
pinMode(pinBumperLeft, INPUT);
pinMode(pinBumperLeft, INPUT_PULLUP);
pinMode(pinBumperRight, INPUT);
pinMode(pinBumperRight, INPUT_PULLUP);
// drops
pinMode(pinDropLeft, INPUT); // Dropsensor - Absturzsensor - Deklariert als Eingang
pinMode(pinDropLeft, INPUT_PULLUP); // Dropsensor - Absturzsensor - Intern Pullab Widerstand aktiviert (Auslösung erfolgt gegen GND)
pinMode(pinDropRight, INPUT); // Dropsensor - Absturzsensor - Deklariert als Eingang
pinMode(pinDropRight, INPUT_PULLUP); // Dropsensor - Absturzsensor - Intern Pullab Widerstand aktiviert (Auslösung erfolgt gegen GND)
// sonar
pinMode(pinSonarCenterTrigger, OUTPUT);
pinMode(pinSonarCenterEcho, INPUT);
pinMode(pinSonarLeftTrigger, OUTPUT);
pinMode(pinSonarLeftEcho, INPUT);
pinMode(pinSonarRightTrigger, OUTPUT);
pinMode(pinSonarRightEcho, INPUT);
// rain
pinMode(pinRain, INPUT);
// R/C
pinMode(pinRemoteMow, INPUT);
pinMode(pinRemoteSteer, INPUT);
pinMode(pinRemoteSpeed, INPUT);
pinMode(pinRemoteSwitch, INPUT);
// odometry
pinMode(pinOdometryLeft, INPUT_PULLUP);
pinMode(pinOdometryLeft2, INPUT_PULLUP);
pinMode(pinOdometryRight, INPUT_PULLUP);
pinMode(pinOdometryRight2, INPUT_PULLUP);
// user switches
pinMode(pinUserSwitch1, OUTPUT);
pinMode(pinUserSwitch2, OUTPUT);
pinMode(pinUserSwitch3, OUTPUT);
// other
pinMode(pinVoltageMeasurement, INPUT);
// PWM frequency setup
// For obstacle detection, motor torque should be detectable - torque can be computed by motor current.
// To get consistent current values, PWM frequency should be 3.9 Khz
// http://wiki.ardumower.de/index.php?title=Motor_driver
// http://sobisource.com/arduino-mega-pwm-pin-and-frequency-timer-control/
// http://www.atmel.com/images/doc2549.pdf
#ifdef __AVR__
TCCR3B = (TCCR3B & 0xF8) | 0x02; // set PWM frequency 3.9 Khz (pin2,3,5)
#else
analogWrite(pinMotorMowPWM, 0); // sets PWMEnabled=true in Arduino library
pmc_enable_periph_clk(PWM_INTERFACE_ID);
PWMC_ConfigureClocks(3900 * PWM_MAX_DUTY_CYCLE, 0, VARIANT_MCK); // 3.9 Khz
#endif
// enable interrupts
#ifdef __AVR__
// R/C
PCICR |= (1<<PCIE0);
PCMSK0 |= (1<<PCINT4);
PCMSK0 |= (1<<PCINT5);
PCMSK0 |= (1<<PCINT6);
PCMSK0 |= (1<<PCINT1);
// odometry
PCICR |= (1<<PCIE2);
PCMSK2 |= (1<<PCINT20);
PCMSK2 |= (1<<PCINT21);
PCMSK2 |= (1<<PCINT22);
PCMSK2 |= (1<<PCINT23);
// mower motor speed sensor interrupt
//attachInterrupt(5, rpm_interrupt, CHANGE);
PCMSK2 |= (1<<PCINT19);
#else
// Due interrupts
attachInterrupt(pinOdometryLeft, PCINT2_vect, CHANGE);
attachInterrupt(pinOdometryLeft2, PCINT2_vect, CHANGE);
attachInterrupt(pinOdometryRight, PCINT2_vect, CHANGE);
attachInterrupt(pinOdometryRight2, PCINT2_vect, CHANGE);
attachInterrupt(pinRemoteSpeed, PCINT0_vect, CHANGE);
attachInterrupt(pinRemoteSteer, PCINT0_vect, CHANGE);
attachInterrupt(pinRemoteMow, PCINT0_vect, CHANGE);
attachInterrupt(pinRemoteSwitch, PCINT0_vect, CHANGE);
//attachInterrupt(pinMotorMowRpm, rpm_interrupt, CHANGE);
attachInterrupt(pinMotorMowRpm, PCINT2_vect, CHANGE);
#endif
// ADC
ADCMan.init();
ADCMan.setCapture(pinChargeCurrent, 1, true);//Aktivierung des LaddeStrom Pins beim ADC-Managers
ADCMan.setCapture(pinMotorMowSense, 1, true);
ADCMan.setCapture(pinMotorLeftSense, 1, true);
ADCMan.setCapture(pinMotorRightSense, 1, true);
ADCMan.setCapture(pinBatteryVoltage, 1, false);
ADCMan.setCapture(pinChargeVoltage, 1, false);
ADCMan.setCapture(pinVoltageMeasurement, 1, false);
perimeter.setPins(pinPerimeterLeft, pinPerimeterRight);
imu.init(pinBuzzer);
gps.init();
Robot::setup();
}
/**
* \brief Application entry point for PWM with PDC example.
*
* Outputs a PWM on LED1 & LED2 & LED3 to makes it fade in repeatedly.
* Channel #0, #1, #2 are linked together as synchronous channels, so they have
* the same source clock, the same period, the same alignment and
* are started together. The update of the duty cycle values is made
* automatically by the Peripheral DMA Controller (PDC).
*
* \return Unused (ANSI-C compatibility).
*/
int main(void)
{
uint32_t i;
uint8_t key;
int32_t numkey;
/* Disable watchdog */
WDT_Disable( WDT ) ;
/* Output example information */
printf("-- PWM with PDC Example %s --\n\r", SOFTPACK_VERSION);
printf("-- %s\n\r", BOARD_NAME);
printf("-- Compiled: %s %s --\n\r", __DATE__, __TIME__);
/* PIO configuration */
PIO_Configure(pins, PIO_LISTSIZE(pins));
/* Enable PWMC peripheral clock */
PMC_EnablePeripheral(ID_PWM);
/* Set clock A to run at PWM_FREQUENCY * MAX_DUTY_CYCLE (clock B is not used) */
PWMC_ConfigureClocks(PWM_FREQUENCY * MAX_DUTY_CYCLE, 0, BOARD_MCK);
/* Configure PWMC channel for LED0 (left-aligned, enable dead time generator) */
PWMC_ConfigureChannelExt( PWM,
CHANNEL_PWM_LED0, /* channel */
PWM_CMR_CPRE_CKA, /* prescaler */
0, /* alignment */
0, /* polarity */
0, /* countEventSelect */
PWM_CMR_DTE, /* DTEnable */
0, /* DTHInverte */
0 ); /* DTLInverte */
PWMC_SetPeriod(PWM, CHANNEL_PWM_LED0, MAX_DUTY_CYCLE);
PWMC_SetDutyCycle(PWM, CHANNEL_PWM_LED0, MIN_DUTY_CYCLE);
PWMC_SetDeadTime(PWM, CHANNEL_PWM_LED0, 5, 5);
/* Configure PWMC channel for LED1 */
PWMC_ConfigureChannelExt( PWM,
CHANNEL_PWM_LED1, /* channel */
PWM_CMR_CPRE_CKA, /* prescaler */
0, /* alignment */
0, /* polarity */
0, /* countEventSelect */
0, /* DTEnable */
0, /* DTHInverte */
0 ); /* DTLInverte */
PWMC_SetPeriod(PWM, CHANNEL_PWM_LED1, MAX_DUTY_CYCLE);
PWMC_SetDutyCycle(PWM, CHANNEL_PWM_LED1, MIN_DUTY_CYCLE);
/* Configure PWMC channel for LED2 */
PWMC_ConfigureChannelExt( PWM,
CHANNEL_PWM_LED2, /* channel */
PWM_CMR_CPRE_CKA, /* prescaler */
0, /* alignment */
0, /* polarity */
0, /* countEventSelect */
0, /* DTEnable */
0, /* DTHInverte */
0 ); /* DTLInverte */
PWMC_SetPeriod(PWM, CHANNEL_PWM_LED2, MAX_DUTY_CYCLE);
PWMC_SetDutyCycle(PWM, CHANNEL_PWM_LED2, MIN_DUTY_CYCLE);
/* Set synchronous channels, update mode = 2 */
PWMC_ConfigureSyncChannel(PWM,
(1 << CHANNEL_PWM_LED0) |
(1 << CHANNEL_PWM_LED1) |
(1 << CHANNEL_PWM_LED2),
PWM_SCM_UPDM_MODE2, // (PWMC) Automatic write of data and automatic trigger of the update
0,
0);
/* Set Synchronous channel update period value */
PWMC_SetSyncChannelUpdatePeriod(PWM, PWM_SCUP_UPR(0xF));
/* Configure interrupt for PDC transfer */
NVIC_DisableIRQ(PWM_IRQn);
NVIC_ClearPendingIRQ(PWM_IRQn);
NVIC_SetPriority(PWM_IRQn, 0);
NVIC_EnableIRQ(PWM_IRQn);
PWMC_EnableIt(PWM, 0, PWM_IER2_ENDTX);
/* Set override value to 1 on PWMH0, others is 0. */
PWMC_SetOverrideValue(PWM, PWM_OOV_OOVH0);
/* Fill duty cycle buffer for channel #0, #1 and #2 */
/* For Channel #0, #1, #2 duty cycle are from MIN_DUTY_CYCLE to MAX_DUTY_CYCLE */
for (i = 0; i < DUTY_BUFFER_LENGTH/3; i++) {
dutyBuffer[i*3] = (i + MIN_DUTY_CYCLE);
dutyBuffer[i*3+1] = (i + MIN_DUTY_CYCLE);
dutyBuffer[i*3+2] = (i + MIN_DUTY_CYCLE);
}
/* Define the PDC transfer */
PWMC_WriteBuffer(PWM, dutyBuffer, DUTY_BUFFER_LENGTH);
/* Enable syncronous channels by enable channel #0 */
PWMC_EnableChannel(PWM, CHANNEL_PWM_LED0);
while (1) {
_DisplayMenu();
key = UART_GetChar();
switch (key) {
case 'u':
printf("Input update period between %d to %d.\n\r", 0, PWM_SCUP_UPR_Msk);
numkey = _GetNumkey2Digit();
if(numkey <= PWM_SCUP_UPR_Msk) {
/* Set synchronous channel update period value */
PWMC_SetSyncChannelUpdatePeriod(PWM, numkey);
printf("Done\n\r");
} else {
printf("Invalid input\n\r");
}
break;
case 'd':
printf("Input dead time for channel #0 between %d to %d.\n\r",
MIN_DUTY_CYCLE, MAX_DUTY_CYCLE);
numkey = _GetNumkey2Digit();
if(numkey >= MIN_DUTY_CYCLE && numkey <= MAX_DUTY_CYCLE) {
/* Set synchronous channel update period value */
PWMC_SetDeadTime(PWM, CHANNEL_PWM_LED0, numkey, numkey);
/* Update synchronous channel */
PWMC_SetSyncChannelUpdateUnlock(PWM);
printf("Done\n\r");
} else {
printf("Invalid input\n\r");
}
break;
case 'o':
printf("0: Disable override output on channel #0\n\r");
printf("1: Enable override output on channel #0\n\r");
key = UART_GetChar();
if (key == '1') {
PWMC_EnableOverrideOutput(PWM, PWM_OSSUPD_OSSUPH0 | PWM_OSSUPD_OSSUPL0, 1);
printf("Done\n\r");
} else if (key == '0') {
PWMC_DisableOverrideOutput(PWM, PWM_OSSUPD_OSSUPH0 | PWM_OSSUPD_OSSUPL0, 1);
printf("Done\n\r");
}
break;
default:
printf("Invalid input\n\r");
break;
}
}
}
/*------------------------------------------------------------------------------
Name: configurePWMC
parameters: -
description: initializes the PWM controller
------------------------------------------------------------------------------*/
void BldcControl::configurePWMC(void)
{
uint32_t clka = 0; /* clock A not used */
uint32_t clkb = 0; /* clock B not used */
uint32_t mck = MCK_CLOCK_42MHZ;
uint16_t duty = 0;
uint16_t deadTime;
pwmPeriod = MCK_CLOCK_42MHZ / this->periphery->Pwm.pwmSwFrq;
deadTime = (uint16_t)(pwmPeriod * (DEAD_TIME * this->periphery->Pwm.pwmSwFrq * 2));
/* disable all 3 channels */
PWMC_DisableChannel(PWM, this->periphery->Pwm.pwmChU);
PWMC_DisableChannel(PWM, this->periphery->Pwm.pwmChV);
PWMC_DisableChannel(PWM, this->periphery->Pwm.pwmChW);
PWMC_ConfigureClocks(clka, clkb, mck);
/* initialize all 3 channels */
PWMC_ConfigureChannelExt(PWM,
this->periphery->Pwm.pwmChU, /* channel ID */
PWM_CMR_CPRE_MCK, /* use main clock */
PWM_CMR_CALG, /* center alligned */
0, /* polarity low level */
0, /* event counter = 0 */
PWM_CMR_DTE, /* enable dead time */
0, /* no inversion of dead time H */
0); /* no inversion of dead time L */
PWMC_ConfigureChannelExt(PWM,
this->periphery->Pwm.pwmChV, /* channel ID */
PWM_CMR_CPRE_MCK,
PWM_CMR_CALG, /* center alligned */
0, /* polarity low level */
0, /* event counter = 0 */
PWM_CMR_DTE, /* enable dead time */
0, /* no inversion of dead time H */
0); /* no inversion of dead time L */
PWMC_ConfigureChannelExt(PWM,
this->periphery->Pwm.pwmChW, /* channel ID */
PWM_CMR_CPRE_MCK,
PWM_CMR_CALG, /* center alligned */
0, /* polarity low level */
0, /* event counter = 0 */
PWM_CMR_DTE, /* enable dead time */
0, /* no inversion of dead time H */
0); /* no inversion of dead time L */
PWMC_ConfigureSyncChannel(PWM,
PWM_SCM_SYNC0|PWM_SCM_SYNC1|PWM_SCM_SYNC2,
PWM_SCM_UPDM_MODE0,
PWM_SCM_PTRM,
PWM_SCM_PTRCS(0)) ;
/* set periods */
PWMC_SetPeriod(PWM, this->periphery->Pwm.pwmChU, pwmPeriod);
PWMC_SetPeriod(PWM, this->periphery->Pwm.pwmChV, pwmPeriod);
PWMC_SetPeriod(PWM, this->periphery->Pwm.pwmChW, pwmPeriod);
/* set duty cycles */
PWMC_SetDutyCycle(PWM, this->periphery->Pwm.pwmChU, duty);
PWMC_SetDutyCycle(PWM, this->periphery->Pwm.pwmChV, duty);
PWMC_SetDutyCycle(PWM, this->periphery->Pwm.pwmChW, duty);
/* set dead times */
PWMC_SetDeadTime(PWM, this->periphery->Pwm.pwmChU, deadTime, deadTime);
PWMC_SetDeadTime(PWM, this->periphery->Pwm.pwmChV, deadTime, deadTime);
PWMC_SetDeadTime(PWM, this->periphery->Pwm.pwmChW, deadTime, deadTime);
/* set overwrites to 0 */
PWMC_SetOverrideValue(PWM, 0);
/* set event for ADC trigger */
PWM->PWM_CMP[this->periphery->Pwm.pwmChU].PWM_CMPM |= PWM_CMPM_CEN | /* enable */
PWM_CMPM_CTR(0) | /* each period */
PWM_CMPM_CPR(0);
PWM->PWM_CMP[this->periphery->Pwm.pwmChU].PWM_CMPV = pwmPeriod/2; /* set trigger */
PWM->PWM_ELMR[0] |= PWM_ELMR_CSEL0; /* enable event line 0 */
}