this configures timer1 for 3 phase pwm with comp. output and deadtime
not a lot of code

void Timer1_Configuration(void)
{
//
// timer1, ch1,2,3 OC and OCN outputs enabled with deadtime
// correct signaling for 3 phase inverter
//
uint16_t ccmr1=0, ccmr2=0,  ccer=0;

TIM1->BDTR = 0x0c50; // DT part is low 8 bits
TIM1->PSC = 0;
TIM1->ARR = 8400;
TIM1->CR1 = 0;
TIM1->RCR = 0;

ccmr1 = 0x6868; // ch1,2 TIM_OCPreload_Enable & PWM mode 1
ccmr2 = 0x0068;
ccer = 0x0555; // ch1,2,3 OC and OCN config   OC enabled, active high, OCN enabled, active high
TIM1->CCER = ccer;
TIM1->CCMR1 = ccmr1;
TIM1->CCMR2 = ccmr2;

TIM1->CCR1 = 100; // ch1 pwm width for boot up
TIM1->CCR2 = 100; // 100 clocks wide of 8400 clock
TIM1->CCR3 = 100; // cycle is not much power
TIM1->CR2 = 0;
TIM1->CR1 |= 0x0080; // enable preload
TIM1->BDTR |= 0x8000; // enable PWM outputs, needed for timer1
TIM1->CR1 |= 0x0001; // enable timer
}


and this is the interrupt code, called at 20kHz
where the sinewave pwm width values are updated for each of the 3 phases

void TIM1_UP_TIM10_IRQHandler(void)
{
unsigned int j,k;
if (TIM_GetITStatus(TIM1, TIM_IT_Update) != RESET)
{
TIM_ClearITPendingBit(TIM1, TIM_IT_Update);
pa++;
if (pa > 399)
{
pa=0;
GPIO_SetBits(GPIOD, GPIO_Pin_12);
}
j = pa + 133;
if (j > 399) j = j - 400;
k = pa + 266;
if (k > 399) k = k - 400;
//GPIO_SetBits(GPIOD, GPIO_Pin_12);
TIM1->CCR1 = (spwm[pa] * pwr) >> 8;
TIM1->CCR2 = (spwm[j] * pwr) >> 8;
TIM1->CCR3 = (spwm[k] * pwr) >> 8;
....
}

volatile uint16_t spwm[400],pa1, pa2,pa3,uf,oen,init_done;
volatile float pwr[3], ac_output[3];
volatile uint16_t ipwr[3],dt;
volatile uint32_t pd;
volatile int sst;

float Input[3], Output[3], Setpoint[3];
float errSum[3], lastErr[3], kp, ki, kd;

void check_switch_cont(void);
void do_pid(int);
void init_vars(void);
void pwmc_setup(void);


void do_pid(int i)
{  
  float error, dErr, timeChange = 0.01;    
  error = Setpoint[i] - Input[i];
  errSum[i] += (error * timeChange);
  dErr = (error - lastErr[i]) / timeChange;
  Output[i] = kp * error + ki * errSum[i] + kd * dErr;
  lastErr[i] = error;
}

void init_vars()
 {
 kp = 0.1;     // set up PID for AC output voltage control
 ki = 0.0;
 kd = 0.01;
 errSum[0] = errSum[1] = errSum[2] = 0.0;      
 lastErr[0] = lastErr[1] = lastErr[2] = 0.0;
 Setpoint[0] = Setpoint[1] = Setpoint[2] = 0.75;
 sst = 0;
 pwr[0] = pwr[1] = pwr[2] = 0.0;
 ipwr[0] = ipwr[1] = ipwr[2] = 0;
 uf = 0;
 ac_output[0] = ac_output[1] = ac_output[2] = 0.0;
 }

void setup()
{  
 int i;
 float th,w;
 init_vars();  
 init_done = 1;
 // sin() table, offset +1 to keep it all positive, scale by 4200 being pwm clock period
 for(i=0; i < 400; i++)
   {
     th = 2.0 * 3.14159 * (float)i / 399.0;
     w = 4200.0 * 0.5 *(1.0 + sin(th));
     spwm[i]= (int)w;
   }
 // init phase angles for 3 phases 0 to 399 possible positions (400 element sin() lookup table)  
 pa1 = 0;
 pa2 = 133;
 pa3 = 266;
 // dead time, in 84MhHz clocks, 1uS
 dt = 84;
 // pwm freq will be 20KHz
 pd = 4200;
 pwmc_setup();
 pinMode(8,INPUT_PULLUP);
 pinMode(13,OUTPUT);
}


void check_switch_cont()
{  
 if (digitalRead(8) == 0)     // pin D8 grounded
   {
   if (init_done == 0 && sst == 0)
     {
     init_vars();
     init_done = 1;
     }  
   oen = 1;      // slow start
   digitalWrite(13,1);
   }
else
 {
   oen = 0;    
   if (sst > 0)
     init_done = 0;
   digitalWrite(13,0);
 }
}


void loop()
{
int i;

for(i=0; i < 3; i++)
 {
   ac_output[i] = (float)analogRead(i) / 1024.0;   // maybe filter this?
   //ac_output[i] = 0.0;
 }

if (uf == 1)
 {  
   uf = 0;
   if (oen == 1) sst++;      // slow start. If output is enabled, keep starting up. sst = output pwm% or approx. voltage.
   if (sst > 251)sst = 251;  // stop increasing when sst has got to the end of slow start. when = 251, this enables PID. See below..
   if (oen == 0) sst--;      // if stopping, slow stop
   if (sst <= 0) sst = 0;         // once fully stopped, no more changes to sst needed
   
   if(sst > 0 && sst < 250)       // slow start timer counts to 250 with gentle ramp up, then switches over to PID control.
       {                          // sst can increase or decrease, giving the slow start and slow stop.
       for(i=0; i < 3; i++)
           {
           if (oen == 1)
             {  
             if(ac_output[i] < Setpoint[i])
               pwr[i] += 1.0/250.0;     // bang-bang control, should AC output reach setpoint prior to PID.
             else                    // During slow start need to ensure output is tracking setpoint
               pwr[i] -= 1.0/250.0;     // should output get close enough to matter.
             }
           else
             pwr[i] -= 1.0 /250.0;      // this will execute in slow stop
           }
       }  
   
   if (sst == 251)       // once sst = 251, run PID. the above bang-bang control will NOT have executed, because sst = 251
       {
       for(i=0; i < 3; i++)                        
         {      
         Input[i] = ac_output[i];  
         do_pid(i);
         pwr[i] = pwr[i] + Output[i];
         }
       }
   for(i=0; i < 3; i++)                        
     {      
     if (pwr[i] > 0.99) pwr[i] = 0.99;     // clamp. Do math in floating point to prevent any integer overflow
     if (pwr[i] < 0.01) pwr[i] = 0.01;    
     ipwr[i] = (int)(256 * pwr[i]);            
     }
 check_switch_cont();    
 }

}

void pwmc_setup()
{
 //Configure PWM channels 0,1,2,3 (PWML0,PWMH0,PWML1,PWMH1,PWML2,PWMH2,PWML3,PWMH3),
 // (port C.2,C.3,C.4,C.5,C.6,C.7,C.8,C.9), (pins P34,P35,P36,P37,P38,P39,P40,P41)
 REG_PIOC_PDR = 0x3FC;  //B1111111100, PIO Disable Register
 REG_PIOC_ABSR = REG_PIOC_ABSR | 0x3FCu; //B1111111100, Peripheral AB Select Register

 pmc_enable_periph_clk(ID_PWM);
 
 REG_PWM_ENA = REG_PWM_SR | B1111; //PWM Enable Register | PWM Status Register (activate channels 0,1,2,3)

 REG_PWM_CMR0 = 0x10000; //Channe0 Mode Register: Dead Time Enable DTE=1
 REG_PWM_CMR1 = 0x10000; //Channe1 Mode Register: Dead Time Enable DTE=1
 REG_PWM_CMR2 = 0x10000; //Channe2 Mode Register: Dead Time Enable DTE=1

 REG_PWM_DT0 = dt + (dt << 16);
 REG_PWM_DT1 = dt + (dt << 16);
 REG_PWM_DT2 = dt + (dt << 16);

 REG_PWM_CPRD0 = 4200; //Channe0 Period Register  20 kHz
 REG_PWM_CPRD1 = 4200;
 REG_PWM_CPRD2 = 4200;

 REG_PWM_CDTY0 = 100;
 REG_PWM_CDTY1 = 100;
 REG_PWM_CDTY2 = 100;

 NVIC_DisableIRQ(PWM_IRQn); // set up interrupt
 NVIC_ClearPendingIRQ(PWM_IRQn);
 NVIC_SetPriority(PWM_IRQn, 0);
 NVIC_EnableIRQ((IRQn_Type)36); //NVIC_EnableIRQ(PWM_IRQn);

 PWM_INTERFACE->PWM_IER1 = 0x0003; //enable interrupt on channel 0
 PWM_INTERFACE->PWM_IDR1 = 0x00FF00fc;
 PWM_INTERFACE->PWM_IER2 = 0x00000300;
 PWM_INTERFACE->PWM_IDR2 = 0x0FFFcFFF;

 REG_PIOD_PER = 0x00ff;
 REG_PIOD_OER = 0x00ff;
 REG_PIOD_OWER = 0xFFFF;
}


void PWM_Handler(void) // PWM interrupt handler
{
  long ir1, ir2;
  ir1 = PWM_INTERFACE->PWM_ISR1; // clear interrupt flag
  if ((ir1 & 1) == 1)
     {
       pa1++;
       if (pa1 == 200)
         uf = 1;
       if (pa1 > 399)
         {
           pa1 = 0;
           REG_PIOD_ODSR = 3;
           uf = 1;
         }
       pa2++;
       if (pa2 > 399)
         pa2 = 0;
       pa3++;
       if (pa3 > 399)
         pa3 = 0;    
       REG_PIOD_ODSR = 0;  
       REG_PWM_CDTY0 = (spwm[pa1] * ipwr[0]) >> 8;
     }
  if ((ir1 & 2) == 2)
     {
       REG_PWM_CDTY1 = (spwm[pa2] * ipwr[1]) >> 8;
     }
  if ((ir1 & 4) == 4)  
     {
       REG_PWM_CDTY2 = (spwm[pa3] * ipwr[2]) >> 8;        
     }
}