Any ideas on how to count pulses and shut off a PWM

Question

TL;DR version: How do I count pulses with programmable digital and use the count to shut off 5 PWMs. The count to shut off and the frequency of the PWMs would have to be set in software for each iteration.

I'm trying to figure out a good way to use programmable digital of the PSoC 4 on the pioneer kit to do coordinated stepper moves. Setting up a PWM module was pretty easy, I just need something to shut it off after a set number of pulses. The black box description is this, the software sets the pulse frequency for several modules, 5 in this case, with the timing already calculated so that they will finish their pulses in the same amount of time, then it starts them at the same time, then they all shut off when they're done and signal (probably via interrupt) back to the software that the move is done and they are ready for the next. I'm thinking the architecture would use one PWM module as the master, if there are not timing glitches they would all finish together, it would stop them, and interrupt that the move was done.

So far I have found that I can easily set a PWM module for a certain frequency from the software, but I'm not sure how to make a counter shut it off. The algorithm is pretty simple for these moves, you have a known speed in pulses at which each axis can move given the electrical and mechanical limitations of the system, given the number of steps required for a move on each axis and that speed you can find which one will take the longest, and divide the number of pulses for all the others to make them happen in that amount of time. At that point most controllers just use timers to generate and count those pulses, I'd like to figure out a nice efficient way to do it in programmable digital. I think it should be pretty simple if I can just figure out how to count pulses with a counter, then I would have it trigger an interrupt and stop the PWMs when the target is reached, can someone show me how to do that? I'd also be interested in other hardware architectures that can do this.

As a note, this is for the smarter life challenge, I'm not really worrying about my competitors seeing my code. If I win I want it to be by making the coolest project, not because they got stuck.

Thanks for reading

Former Member · Accepted Answer

My solution was to use a lower frequency clock to drive a PWM(acting as a counter) just to generate a time-base during which the other 4 PWMs could generate the required number of pulses. We then use a bunch of glue logic to gate the signals. I only show 2 PWMs below, to demonstrate how it will work with both fixed function PWMs and UDB PWMs. #define CLOCK_RESET_KHZ 100 //the input clock for the reset PWM
#define CLOCK_STEPPER_KHZ 12000 //the input clock for the stepper PWMs

#define PULSE_INCREMENT_INTERVAL1 10 //increment pulse1 count by this each time around (minimum of ~10 with these clocks)
#define PULSE_INCREMENT_INTERVAL2 5 //increment pulse2 count by this each time around

#define PULSE_TRAIN_LENGTH_MS 50 //length of time for each co-ordinated move

#define SW_DELAY_MS 100 //delay by this much after starting the co-ordinated move

uint8 newMoveFlag = 0xff;

int main()
{
 // Declare variables
 uint16 pulsesPerPeriod1 = 0;
 uint16 pulse1CounterPeriod;
 uint16 pulsesPerPeriod2 = 0;
 uint16 pulse2CounterPeriod; 
 uint16 resetCounterPeriod;
 
 // Start components
 PWM_Stepper1_Start();
 PWM_Stepper2_Start();
 PWM_Reset_Start();
 isr_PWM_Reset_TC_Start();
 
 // Set reset counter period (this could change at runtime also)
 resetCounterPeriod = (CLOCK_RESET_KHZ * PULSE_TRAIN_LENGTH_MS);
 PWM_Reset_WritePeriod(resetCounterPeriod); 
 
 CyGlobalIntEnable; /* Uncomment this line to enable global interrupts. */
 for(;;)
 {
 // Only update the configuration if a new co-ordinated move is desired. 
 // This flag is set in the PWM_Reset TC ISR
 if(newMoveFlag)
 {
 // Calculate the new PWM periods
 // Stepper 1
 pulsesPerPeriod1 += PULSE_INCREMENT_INTERVAL1;
 pulse1CounterPeriod = ((uint32)CLOCK_STEPPER_KHZ/CLOCK_RESET_KHZ)* resetCounterPeriod / pulsesPerPeriod1;
 if(pulse1CounterPeriod < 2) // Check for rollover
 {
 pulsesPerPeriod1 = PULSE_INCREMENT_INTERVAL1;
 pulse1CounterPeriod = ((uint32)CLOCK_STEPPER_KHZ/CLOCK_RESET_KHZ)* resetCounterPeriod / pulsesPerPeriod1;
 }
 // Stepper 2
 pulsesPerPeriod2 += PULSE_INCREMENT_INTERVAL2;
 pulse2CounterPeriod = ((uint32)CLOCK_STEPPER_KHZ/CLOCK_RESET_KHZ)* resetCounterPeriod / pulsesPerPeriod2;
 if(pulse2CounterPeriod < 2) // Check for rollover
 {
 pulsesPerPeriod2 = PULSE_INCREMENT_INTERVAL2;
 pulse2CounterPeriod = ((uint32)CLOCK_STEPPER_KHZ/CLOCK_RESET_KHZ)* resetCounterPeriod / pulsesPerPeriod2;
 }
 
 // Disable the counters
 Control_Reg_PulseEnable_Write(0x00);

// Reset the counters
 Control_Reg_PulseReset_Write(0xff);
 Control_Reg_PulseReset_Write(0x00);
 
 // Set the period of the pulse counters
 // Stepper 1 (UDB PWM)
 PWM_Stepper1_WritePeriod(pulse1CounterPeriod);
 PWM_Stepper1_WriteCompare(pulse1CounterPeriod/2);
 PWM_Stepper1_WriteCounter(0);
 // Stepper 2 (Fixed Function TCPWM)
 PWM_Stepper2_WritePeriod(pulse2CounterPeriod);
 PWM_Stepper2_WriteCompare(pulse2CounterPeriod/2);
 PWM_Stepper2_WriteCounter(0);
 
 // Enable the counters. pulses start here.
 Control_Reg_PulseEnable_Write(0xff);
 
 // Clear the flag and wait for the next update
 newMoveFlag = 0x00;
 }
 
 }
}

/* [] END OF FILE */

hlipka · Answer

A PWM can be configured to have an enable input. This can be used for disabling it. Then use an additional counter for counting the pulses of the PWM. The compare output of the counter can then drive the enables signal to stop the PWM. Or, if the frequency of your PWM is not so high, you can trigger an interrupt at the end of each period and count there.

Any ideas on how to count pulses and shut off a PWM

Top Replies