Extras/pru-pwm/render.cpp

Pulse width modulation on the PRU

This example uses the PRU onboard microcontroller to drive 8 channels of PWM. The default behaviour is to run with 8 channels of PWM, a PWM frequency of 24.038kHz and a precision of 8 bit.

You can set the pwm for each channel with set_widths() at any time in the code.

The carrier frequency and precision can be modified by changing PWM_MAX_WIDTH in common_defs.h

A slightly higher (25.773kHz) carrier frequency could be achieved by refactoring the code so to use only one byte per channel, which would clearly limit PWM_MAX_WIDTH <= 255

An even higher (30.864kHz)) carrier frequecny could be achieved by taking the LBBO operation out of USER_LOOP in pru_pwm.p, however this would mean that some PWM values (either close to 100% or close to 0%) could not be achieved

Pinout: we are using PRU1's R30, that is:

``` BBB pin PWM channel P8_45: 0 P8_46: 1 P8_43: 2 P8_44: 3 P8_41: 4 P8_42: 5 P8_39: 6 // this will require a change to the dtb P8_40: 7 // this will require a change to the dtb ```

/*
 ____  _____ _        _
| __ )| ____| |      / \
|  _ \|  _| | |     / _ \
| |_) | |___| |___ / ___ \
|____/|_____|_____/_/   \_\
http://bela.io
*/
#include <Bela.h>
#include <GPIOcontrol.h>
#include "prussdrv.h"
#include "pruss_intc_mapping.h"
#include <string.h>
#include "pru_pwm_bin.h"
#include "common_defs.h"

typedef uint16_t count_t;

uint32_t *gPRUCommunicationMem = 0;

bool load_pru(int pru_number);                  // Load the PRU environment
bool start_pru(int pru_number);                 // Start the PRU
void set_widths(count_t* counts, unsigned int length);
int gPruNumber;

void Bela_userSettings(BelaInitSettings* settings)
{
        settings->pruNumber = 0;
        // Set user PRU to the opposite number as the default Bela PRU
        if(settings->pruNumber == 0)
                gPruNumber = 1;
        else
                gPruNumber = 0;
}

bool setup(BelaContext *context, void *userData)
{
        // Load PRU environment and map memory
        if(!load_pru(gPruNumber)) {
                printf("Error: could not initialise user PRU code.\n");
                return false;
        }

        unsigned int length = 8;
        count_t counts[length];
        memset(gPRUCommunicationMem, 0, 128);

        for(unsigned int n = 0; n < length; ++n) {
                counts[n] = PWM_MAX_WIDTH * (1+n)/(float)length;
        }
        set_widths(counts, length);

        if(!start_pru(gPruNumber)) {
                printf("Error: could not start user PRU code.\n");
                return false;
        }
        return true;
}

void render(BelaContext *context, void *userData)
{


}

void cleanup(BelaContext *context, void *userData)
{
    /* Disable PRU */
    prussdrv_pru_disable(gPruNumber);
}

// Load environment for the second PRU, but don't run it yet
bool load_pru(int pru_number)
{
        void *pruMemRaw;
        uint32_t *pruMemInt;

        /* There is less to do here than usual for prussdrv because
         * the core code will already have done basic initialisation
         * of the library. */

    /* Allocate and initialize memory */
    if(prussdrv_open(PRU_EVTOUT_1)) {
        rt_printf("Failed to open user-side PRU driver\n");
        return false;
    }

        /* Map shared memory to a local pointer */
        prussdrv_map_prumem(PRUSS0_SHARED_DATARAM, (void **)&pruMemRaw);

        /* The first 0x800 is reserved by Bela. The next part is available
           for our application. */
        pruMemInt = (uint32_t *)pruMemRaw;
        gPRUCommunicationMem = &pruMemInt[0x800/sizeof(uint32_t)];

        return true;
}

// Start the second PRU running
bool start_pru(int pru_number)
{
        if(prussdrv_exec_code(pru_number, PRUcode, sizeof(PRUcode))) {
                rt_printf("Failed to execute user-side PRU code\n");
                return false;
        }

        return true;
}

void set_widths(count_t* counts, unsigned int length)
{
        // Set the period in counter units
        memcpy(&gPRUCommunicationMem[PRU_COMM_USER_WIDTH], counts, length * sizeof(counts[0]));
}