void uninitialize_pru(){
pruDataMem_int[0] = 0;
/* Wait until PRU0 has finished execution */
printf("\tINFO: Waiting for HALT command.\r\n");
if (PRU_NUM == 0){
prussdrv_pru_wait_event (PRU_EVTOUT_0);
}
if (PRU_NUM == 1){
prussdrv_pru_wait_event (PRU_EVTOUT_1);
}
printf("\tINFO: PRU completed transfer.\r\n");
if (PRU_NUM == 0){
prussdrv_pru_clear_event (PRU0_ARM_INTERRUPT);
}
if (PRU_NUM == 1){
prussdrv_pru_clear_event (PRU1_ARM_INTERRUPT);
}
/* Disable PRU and close memory mapping*/
}
int main (void)
{
int ret = init_PRUSS();
uint16_t chan[NUM_CHANNELS][SAMPLES_PR_PACKAGE];
int offset = 0;
while(1){
/* Wait until PRU0 has finished execution */
prussdrv_pru_wait_event(PRU_EVTOUT_0); // there's a bug that makes the pruss driver execute interrupts twice, se: https://github.com/beagleboard/am335x_pru_package/issues/3
prussdrv_pru_clear_event(PRU_EVTOUT_0, PRU0_ARM_INTERRUPT);
prussdrv_pru_wait_event(PRU_EVTOUT_0); // there's a bug that makes the pruss driver execute interrupts twice, se: https://github.com/beagleboard/am335x_pru_package/issues/3
prussdrv_pru_clear_event(PRU_EVTOUT_0, PRU0_ARM_INTERRUPT);
uint32_t flag = sharedMem_int[0];
if(flag){
offset = 2;
} else {
offset = 2050;
}
//printf("flag: %08x , data: ", flag);
for(int k = 0; k < SAMPLES_PR_PACKAGE ; k +=8){
for(int i = 0 ; i< NUM_CHANNELS ; ++i){
chan[i][k] = sharedMem_chan[k+offset+i];
}
printf("chan 0 : %04.2f \n", chan[0][k]*3.2227);
}
//printf("\n");
prussdrv_pru_clear_event(PRU_EVTOUT_0, PRU0_ARM_INTERRUPT);
}
/* Disable PRU and close memory mapping*/
prussdrv_pru_disable(0);
prussdrv_pru_disable(1);
prussdrv_exit ();
return(ret);
}
static void pru_wait_queue_empty() {
const unsigned int last_insert_position = (queue_pos_ - 1) % QUEUE_LEN;
while (pru_data_->ring_buffer[last_insert_position].state != STATE_EMPTY) {
prussdrv_pru_wait_event(PRU_EVTOUT_0);
prussdrv_pru_clear_event(PRU_EVTOUT_0, PRU0_ARM_INTERRUPT);
}
}
int old_main(int argc, char **argv) {
int rtn;
/* prussdrv_init() will segfault if called with EUID != 0 */
if(geteuid()) {
fprintf(stderr, "%s must be run as root to use prussdrv\n", argv[0]);
return -1;
}
/* initialize the library, PRU and interrupt; launch our PRU program */
if(pru_setup("./pwm.bin")) {
pru_cleanup();
return -1;
}
/* wait for PRU to assert the interrupt to indicate completion */
printf("waiting for interrupt from PRU0...\n");
/* The prussdrv_pru_wait_event() function returns the number of times
the event has taken place, as an unsigned int. There is no out-of-
band value to indicate error (and it can wrap around to 0 if you
run the program just a whole lot of times). */
rtn = prussdrv_pru_wait_event(PRU_EVTOUT_0);
printf("PRU program completed, event number %d\n", rtn);
/* clear the event, disable the PRU and let the library clean up */
return pru_cleanup();
}
void *producer(void *ptr)
{
struct s_VcdFormatValues buffervalues;
static uint64_t nr_of_captures=0;
const uint8_t mem_offset=4;
while (producer_running)
{
pthread_mutex_lock(&shared_var_mutex);
while (buffer_full(&dataCapturedValues))
{
pthread_cond_wait(&cond_producer, &shared_var_mutex);
}
/*Capture values from */
dbg("\tWaiting for event...\n");
prussdrv_pru_wait_event(PRU_EVTOUT_0);
prussdrv_pru_clear_event(PRU_EVTOUT_0, PRU1_ARM_INTERRUPT);
buffervalues.values=shared_ram[mem_offset];
buffervalues.seconds = sample_delay*nr_of_captures++;
(void) buffer_push(&dataCapturedValues, buffervalues);
pthread_cond_signal(&cond_consumer);/*wake up consumer*/
pthread_mutex_unlock(&shared_var_mutex);
}
pthread_exit(0);
}
//! The main function.
int main(int argc, char **argv)
{
pruIo *io = pruio_new(PRUIO_ACT_PRU1, 0, 0, 0); //! create new driver structure
do {
uint32 pru_num, pru_iram, pru_dram, pru_intr;
//
// Check init success
//
if(io->Errr) {
printf("initialisation failed (%s)\n", io->Errr); break;}
if(io->PruNo) { // we use the other PRU
pru_num = 0;
pru_iram = PRUSS0_PRU0_IRAM;
pru_dram = PRUSS0_PRU0_DRAM;
pru_intr = PRU0_ARM_INTERRUPT; }
else {
pru_num = 1;
pru_iram = PRUSS0_PRU1_IRAM;
pru_dram = PRUSS0_PRU1_DRAM;
pru_intr = PRU1_ARM_INTERRUPT; }
//
// Now prepare the other PRU
//
if(prussdrv_open(PRU_EVTOUT_0)) { // note: libpruio uses PRU_EVTOUT_5
printf("prussdrv_open failed\n"); break;}
//Note: no prussdrv_pruintc_init(), libpruio did it already
load_firmware(pru_iram);
//
// Pass parameters to PRU
//
uint32 *dram;
prussdrv_map_prumem(pru_dram, (void *) &dram); // get dram pointer
dram[1] = 23; // start value
dram[2] = 7; // value to add
dram[3] = 67; // loop count (max 16 bit = 65536)
dram[4] = pru_intr + 16; // the interrupt we're waiting for
//
// Execute
//
printf("instructions loaded, starting PRU-%d\n", pru_num);
prussdrv_pru_enable(pru_num); // start
prussdrv_pru_wait_event(PRU_EVTOUT_0); // wait until finished
prussdrv_pru_clear_event(PRU_EVTOUT_0, pru_intr); // clear interrupt (optional, useful when starting again)
//
// Check result
//
if(dram[0] == (dram[1] + (dram[2] * dram[3])))
{printf("Test OK %d == %d + (%d * %d)\n", dram[0], dram[1], dram[2], dram[3]);}
else
{printf("Test failed: %d != %d + (%d * %d)\n", dram[0], dram[1], dram[2], dram[3]);}
prussdrv_pru_disable(pru_num); // disable PRU
// note: no prussdrv_exit(), libpruio does it in the destructor
} while (0);
pruio_destroy(io); /* destroy driver structure */
return 0;
}
int main(int argc, char **argv) {
if (argc != 2) {
printf("Usage: %s pru_code.bin\n", argv[0]);
return 1;
}
// If this segfaults, make sure you're executing as root.
prussdrv_init();
if (prussdrv_open(PRU_EVTOUT_0) == -1) {
printf("prussdrv_open() failed\n");
return 1;
}
tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;
prussdrv_pruintc_init(&pruss_intc_initdata);
// Change to 1 to use PRU1
int which_pru = 0;
printf("Executing program and waiting for termination\n");
prussdrv_exec_program(which_pru, argv[1]);
// Wait for the PRU to let us know it's done
prussdrv_pru_wait_event(PRU_EVTOUT_0);
printf("All done\n");
prussdrv_pru_disable(which_pru);
prussdrv_exit();
return 0;
}
int main(int argc, char** argv) {
printf("\nStarting %s example.\r\n", argv[0]);
/* Initialize the PRU */
prussdrv_init();
/* Open PRU Interrupt */
int open_result = prussdrv_open(PRU_EVTOUT_0);
if (open_result) {
printf("prussdrv_open open failed\n");
return open_result;
}
/* Get the interrupt initialized */
prussdrv_pruintc_init(&pruss_intc_initdata);
uint16_t* pruMemory;
prussdrv_map_prumem(PRUSS0_PRU0_DATARAM, (void**) &pruMemory);
memcpy(pruMemory, digits, sizeof(digits));
printf("\tExecuting.\r\n");
prussdrv_exec_code(PRU0, counter, sizeof(counter));
printf("\tWaiting for HALT command.\r\n");
prussdrv_pru_wait_event(PRU_EVTOUT_0);
prussdrv_pru_clear_event(PRU_EVTOUT_0, PRU0_ARM_INTERRUPT);
/* Disable PRU and close memory mapping*/
prussdrv_pru_disable(PRU0);
prussdrv_exit();
return(0);
}
/* unsigned int times_count=0; */
void* threaded_function(void* param){
printf("Started thread\n");
/* struct timeval time; */
/* unsigned long t1=0; */
/* unsigned long t2=0; */
unsigned int buffer_size=0;
unsigned int buffer_position;
/* unsigned int first=1; */
/* times_count=0; */
/* int i; */
/* float sample; */
int count = 0;
while(1){
// Wait for interrupt from PRU
prussdrv_pru_wait_event(PRU_EVTOUT_0);
prussdrv_pru_clear_event(PRU_EVTOUT_0, PRU0_ARM_INTERRUPT);
// Store time so we can average later
/* gettimeofday(&time,NULL); */
/* t2 = t1; */
/* t1 = time.tv_usec + time.tv_sec*1000000; */
/* if(times_count<1000 && !first){ */
/* times[times_count]=(t1-t2); */
/* times_count++; */
/* } */
/* first=0; */
// Read number of samples available
buffer_size = shared_ram[1];
// Read position in RAM
buffer_position = shared_ram[0];
// Write samples to buffer
memcpy(&(buffer[buffer_count]), &(shared_ram[buffer_position]), buffer_size*sizeof(unsigned int));
buffer_count += buffer_size;
/* int *p = (int *)(&shared_ram[1]); */
/* sf_write_int(sound_file, &(shared_ram[1]), buffer_size); */
/* for(i=0; i<buffer_size;i++){ */
/* sample = (float)shared_ram[i+1]; */
/* sample = sample/(float)0xFFF; */
/* sf_write_float(sound_file, &sample, 1); */
/* printf("sample: %f \n", sample); */
/* } */
if(count%1 == 0){
// Print info
//printf("Pos: %u\n", buffer_position);
//printf("Buffer size: %u\n", buffer_size);
if(shared_ram[2])
printf("%u\t", shared_ram[buffer_position]);
else
printf("%u\n", shared_ram[buffer_position]);
//printf("fifo count: %u \n", shared_ram[3]);
}
count++;
}
return NULL;
}
int main(int argc, char **argv) {
int rtn;
printf("Starting the EBB PRU Program:\n");
if(geteuid()) {
fprintf(stderr, "You must be run as root to use the prussdrv\n", argv[0]);
return -1;
}
if(pru_setup("./flashLED.bin")) {
pru_cleanup();
return -1;
}
/* wait for PRU to assert the interrupt to indicate completion */
printf("waiting for interrupt from PRU0...\n");
/* The prussdrv_pru_wait_event() function returns the number of times
the event has taken place, as an unsigned int. There is no out-of-
band value to indicate error (and it can wrap around to 0 if you
run the program just a whole lot of times). */
rtn = prussdrv_pru_wait_event(PRU_EVTOUT_0);
printf("PRU program completed, event number %d\n", rtn);
/* clear the event, disable the PRU and let the library clean up */
return pru_cleanup();
}
int main()
{
void *pru0_memory;
unsigned int *pru0_memory_uint;
int distance_samples;
int n;
tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;
prussdrv_init();
prussdrv_open(PRU_EVTOUT_0);
prussdrv_pruintc_init(&pruss_intc_initdata);
prussdrv_map_prumem(PRUSS0_PRU0_DATARAM, &pru0_memory);
pru0_memory_uint = (unsigned int*)pru0_memory;
prussdrv_exec_program(0, "./hcsr04.bin");
n = prussdrv_pru_wait_event(PRU_EVTOUT_0);
distance_samples = *pru0_memory_uint;
printf("Measured distance: %f cm\n", (float)distance_samples / (USECS_DIV * HCSR04_DIV));
prussdrv_pru_disable(0);
prussdrv_exit();
return 0;
}
void main (void)
{
int n;
/* Initialize structure used by prussdrv_pruintc_intc */
/* PRUSS_INTC_INITDATA is found in pruss_intc_mapping.h */
tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;
/* Allocate and initialize memory */
prussdrv_init ();
prussdrv_open (PRU_EVTOUT_0);
/* Map PRU's INTC */
prussdrv_pruintc_init(&pruss_intc_initdata);
/* Copy data to PRU memory */
unsigned int x = 7;
prussdrv_pru_write_memory(PRUSS0_PRU0_DATARAM, 0, &x, 4);
/* Load and execute binary on PRU */
prussdrv_exec_program (PRU_NUM, "./buttonTest.bin");
/* Wait for event completion from PRU */
n = prussdrv_pru_wait_event (PRU_EVTOUT_0); // This assumes the PRU generates an interrupt
// connected to event out 0 immediately before halting
printf("PRU program completed, event number %d.\n", n);
/* Disable PRU and close memory mappings */
prussdrv_pru_disable(PRU_NUM);
prussdrv_exit ();
}
static volatile struct MotionSegment *next_queue_element() {
queue_pos_ %= QUEUE_LEN;
while (pru_data_->ring_buffer[queue_pos_].state != STATE_EMPTY) {
prussdrv_pru_wait_event(PRU_EVTOUT_0);
prussdrv_pru_clear_event(PRU_EVTOUT_0, PRU0_ARM_INTERRUPT);
}
return &pru_data_->ring_buffer[queue_pos_++];
}
int PruTimer::waitUntilSync() {
int ret;
// Wait until the PRU sends a sync event.
ret = prussdrv_pru_wait_event(PRU_EVTOUT_1, 1000);
if(ret != 0)
prussdrv_pru_clear_event(PRU_EVTOUT_1, PRU1_ARM_INTERRUPT);
return ret;
}
int main(int argc, char** argv) {
if(getuid()!=0){
printf("You must run this program as root. Exiting.\n");
exit(EXIT_FAILURE);
}
// Initialize structure used by prussdrv_pruintc_intc
// PRUSS_INTC_INITDATA is found in pruss_intc_mapping.h
tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;
// Allocate and initialize memory
prussdrv_init ();
//Initilize Interrupts
prussdrv_open (PRU_EVTOUT_0);
// Map PRU's interrupts
prussdrv_pruintc_init(&pruss_intc_initdata);
// Map PRU memory to a pointer
prussdrv_map_prumem(PRUSS0_PRU0_DATARAM, &pru0DataMemory);
pru0DataMemory_int = (unsigned int *) pru0DataMemory;
// Map ddr memory
prussdrv_map_extmem((void **) &ddr_memory);
ddr_memory_int = (unsigned int *) ddr_memory;
unsigned int shared_ddr_len = prussdrv_extmem_size();
unsigned int physical_address = prussdrv_get_phys_addr((void *) ddr_memory);
// Use first 8 bytes of PRU memory to tell where the share memory is
pru0DataMemory_int[0] = physical_address;
pru0DataMemory_int[1] = shared_ddr_len;
printf("%u bytes of shared DDR available.\n Physical (PRU-side) address:%x\n", shared_ddr_len, physical_address);
printf("Virtual (linux-side) address: %p\n\n", ddr_memory);
// Load and execute the PRU program on the PRU
prussdrv_exec_program (PRU_NUM, "./memory.bin");
// Wait for event completion from PRU, returns the PRU_EVTOUT_0 number
int n = prussdrv_pru_wait_event (PRU_EVTOUT_0);
printf("EBB PRU program completed, event number %d.\n", n);
printf("The number read from PRU0 memory is: %d\n", *pru0DataMemory_int);
printf("%d\n", ddr_memory_int[199999]);
// Disable PRU and close memory mappings
prussdrv_pru_disable(PRU_NUM);
prussdrv_pru_disable(1);
prussdrv_exit ();
return EXIT_SUCCESS;
}
int main (void)
{
unsigned int ret;
tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;
printf("\nINFO: Starting %s example.\r\n", "PRU_memAccessPRUDataRam");
/* Initialize the PRU */
prussdrv_init ();
/* Open PRU Interrupt */
ret = prussdrv_open(PRU_EVTOUT_0);
if (ret)
{
printf("prussdrv_open open failed\n");
return (ret);
}
/* Get the interrupt initialized */
prussdrv_pruintc_init(&pruss_intc_initdata);
/* Initialize example */
printf("\tINFO: Initializing example.\r\n");
LOCAL_exampleInit(PRU_NUM);
/* Execute example on PRU */
printf("\tINFO: Executing example.\r\n");
char path[] = "./PRU_memAccessPRUDataRam.bin";
if(prussdrv_exec_program (PRU_NUM, path))
{
fprintf(stderr, "ERROR: Could not open %s\n", path);
return 1;
}
/* Wait until PRU0 has finished execution */
printf("\tINFO: Waiting for HALT command.\r\n");
prussdrv_pru_wait_event (PRU_EVTOUT_0);
printf("\tINFO: PRU completed transfer.\r\n");
prussdrv_pru_clear_event (PRU_EVTOUT_0, PRU0_ARM_INTERRUPT);
/* Check if example passed */
if ( LOCAL_examplePassed(PRU_NUM) )
{
printf("INFO: Example executed succesfully.\r\n");
}
else
{
printf("INFO: Example failed.\r\n");
}
/* Disable PRU and close memory mapping*/
prussdrv_pru_disable (PRU_NUM);
prussdrv_exit ();
return(0);
}
/*****************************************************************************
* Local Function Definitions *
*****************************************************************************/
updatePixelStrip() {
unsigned int k;
/* Execute example on PRU */
prussdrv_exec_program (PRU_NUM, "./ledgriddrvr.bin");
/* Wait until PRU0 has finished execution */
prussdrv_pru_wait_event (PRU_EVTOUT_0);
prussdrv_pru_clear_event (PRU_EVTOUT_0, PRU0_ARM_INTERRUPT);
for( k=0 ; k < INTERSCAN_DELAY ; k++ ) { ; }
} // updatePixelStrip()
void PRUloader::stopPRU(void){
pruDataMem_byte[0] = 0;
printf("\r\nWaiting for PRU to HALT\r\n");
/* Wait for event completion from PRU */
prussdrv_pru_wait_event(PRU_EVTOUT_1); // This assumes the PRU generates an interrupt connected to event out 0 immediately before halting
prussdrv_pru_clear_event(PRU_EVTOUT_1, PRU1_ARM_INTERRUPT);
/* Disable PRU and close memory mappings */
prussdrv_pru_disable(PRU_NUM);
prussdrv_exit();
}
/* This method programs the PRU's and makes them execute their program. ./PRUADC.bin and ./PRUClock.bin should be present.
* The PRU's fill the shared memory with 10-bit samples stored as uint_16. This method allocates memory to copy these values as an array
* of doubles and returns a pointer to this array. Returns NULL if VREF are not set. To set these, call mdau_create.
*/
double* mdau_read_frame(){
if(VREF == 0){
return NULL;
}
// Initialize structure used by prussdrv_pruintc_intc
// PRUSS_INTC_INITDATA is found in pruss_intc_mapping.h
tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;
// Map the PRU's interrupts
prussdrv_pruintc_init(&pruss_intc_initdata);
// Load and execute the PRU program on the PRU
prussdrv_exec_program (ADC_PRU_NUM, "./PRUADC.bin");
prussdrv_exec_program (CLK_PRU_NUM, "./PRUClock.bin");
// Wait for event completion from PRU, returns the PRU_EVTOUT_0 number
prussdrv_pru_wait_event (PRU_EVTOUT_0);
int fd;
void *map_base, *virt_addr;
unsigned long read_result;
unsigned int addr = readFileValue(MMAP1_LOC "addr");
unsigned int dataSize = readFileValue(MMAP1_LOC "size");
unsigned int frame_size = dataSize / 2;
off_t target = addr;
if((fd = open("/dev/mem", O_RDWR | O_SYNC)) == -1){
return NULL;
}
map_base = mmap(0, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, target & ~MAP_MASK);
if(map_base == (void *) -1) {
return NULL;
}
double* samples = malloc(frame_size*sizeof(double));
if(samples == NULL){
return NULL;
}
int i=0;
for(i=0; i<frame_size; i++){
virt_addr = map_base + (target & MAP_MASK);
read_result = *((uint16_t *) virt_addr);
samples[i] = VREF * read_result / ADC_MAXIMUM ;
target+=2; // 2 bytes per sample
}
if(munmap(map_base, MAP_SIZE) == -1) {
return NULL;
}
close(fd);
return samples;
}
int main (int argc, char* argv[])
{
int arg_length = strlen(argv[1]);
unsigned int code=0;
unsigned int code_array[15];
int i;
if (arg_length != 15){
printf("Number of bits in pattern is not equal to 15\n");
exit(EXIT_FAILURE);
}
for (i=0;i<15;i++)
{
code_array[i] = (unsigned int)(argv[1][i]-48);
printf("digit %d: %d\n",i, code_array[i]);
code = code | (code_array[i] << i) ;
}
printf("code: %x\n", code);
if(getuid()!=0){
printf("You must run this program as root. Exiting.\n");
exit(EXIT_FAILURE);
}
// Initialize structure used by prussdrv_pruintc_intc
// PRUSS_INTC_INITDATA is found in pruss_intc_mapping.h
tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;
// Allocate and initialize memory
prussdrv_init ();
prussdrv_open (PRU_EVTOUT_0);
// Map PRU's interrupts
prussdrv_pruintc_init(&pruss_intc_initdata);
// Load the code into the PRU memory
prussdrv_pru_write_memory(PRUSS0_PRU0_DATARAM, 0, &code, 4);
// Load and execute the PRU program on the PRU
prussdrv_exec_program (PRU_NUM, "/usr/scripts/PRU/send_15_bit_IR_pattern.bin");
// Wait for event completion from PRU, returns the PRU_EVTOUT_0 number
int n = prussdrv_pru_wait_event (PRU_EVTOUT_0);
printf("EBB PRU program completed, event number %d.\n", n);
// Disable PRU and close memory mappings
prussdrv_pru_disable(PRU_NUM);
prussdrv_exit ();
return EXIT_SUCCESS;
}
int main (void)
{
static FILE *fp = 0;
unsigned int ret;
tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;
printf("\nINFO: Starting %s example.\r\n", "blink");
/* Initialize the PRU */
prussdrv_init ();
// Set ADC CS
if((fp=fopen("/sys/class/gpio/export", "w"))==NULL){
printf("Cannot open GPIO file 62.\n");
return (1);
}
fprintf(fp,"62");
fclose(fp);
if((fp=fopen("/sys/class/gpio/gpio62/direction", "w"))==NULL){
printf("cannot open gpio direction file.\n");
return(1);
}
fprintf(fp,"out");
fclose(fp);
mux("lcd_pclk",0x0d);
/* Open PRU Interrupt */
ret = prussdrv_open(PRU_EVTOUT_0);
if (ret)
{
printf("prussdrv_open open failed\n");
return (ret);
}
/* Get the interrupt initialized */
prussdrv_pruintc_init(&pruss_intc_initdata);
/* Execute example on PRU */
printf("\tINFO: Executing example.\r\n");
prussdrv_exec_program (PRU_NUM, "./blink.bin");
/* Wait until PRU0 has finished execution */
printf("\tINFO: Waiting for HALT command.\r\n");
prussdrv_pru_wait_event (PRU_EVTOUT_0);
printf("\tINFO: PRU completed transfer.\r\n");
prussdrv_pru_clear_event (PRU0_ARM_INTERRUPT);
/* Disable PRU and close memory mapping*/
prussdrv_pru_disable (PRU_NUM);
prussdrv_exit ();
return(0);
}
int main (void)
{
unsigned int ret;
tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;
printf("\nINFO: Starting %s test.\r\n", "GPIO input level");
/* Initialize the PRU */
prussdrv_init ();
/* Open PRU Interrupt */
ret = prussdrv_open(PRU_EVTOUT_0);
if (ret)
{
printf("prussdrv_open open failed\n");
return (ret);
}
/* Get the interrupt initialized */
prussdrv_pruintc_init(&pruss_intc_initdata);
/* Initialize example */
printf("\tINFO: Initializing test.\r\n");
LOCAL_exampleInit(PRU_NUM);
/* Execute example on PRU */
printf("\tINFO: Executing test.\r\n");
prussdrv_exec_program (PRU_NUM, "./levelIn.bin");
/* Wait until PRU0 has finished execution */
printf("\tINFO: Waiting for HALT command.\r\n");
prussdrv_pru_wait_event (PRU_EVTOUT_0);
printf("\tINFO: PRU completed transfer.\r\n");
prussdrv_pru_clear_event (PRU0_ARM_INTERRUPT);
/* Check if example passed */
if ( LOCAL_examplePassed(PRU_NUM) )
{
printf("Test executed succesfully.\r\n");
}
else
{
printf("Test failed.\r\n");
}
/* Disable PRU and close memory mapping*/
prussdrv_pru_disable(PRU_NUM);
prussdrv_exit ();
munmap(ddrMem, 0x0FFFFFFF);
close(mem_fd);
return(0);
}
void *pruevtout0_thread(void *arg) {
printf("pruevtout0_thread started.\n");
printf("count = %d\n", *pru0_data_ram);
do {
prussdrv_pru_wait_event(PRU_EVTOUT_0);
printf("count = %d\n", *pru0_data_ram);
// The Linux API documentation is wrong regarding the following function:
// the documentation has the arguments reversed. If you get this wrong,
// the above prussdrv_pru_wait_event() will wait forever even if
// an interrupt is pending.
prussdrv_pru_clear_event(PRU_EVTOUT_0, PRU0_ARM_INTERRUPT);
} while (1);
}
static void *pruevent_thread(void *arg)
{
int event = (int) arg;
int event_count;
do {
if (prussdrv_pru_wait_event(event, &event_count) < 0)
continue;
HPG_ERR("PRU event %d received\n",event);
prussdrv_pru_clear_event(pru ? PRU1_ARM_INTERRUPT : PRU0_ARM_INTERRUPT);
} while (1);
HPG_ERR("pruevent_thread exiting\n");
return NULL; // silence compiler warning
}
void main (void)
{
tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;
prussdrv_init ();
prussdrv_open (PRU_EVTOUT_0);
prussdrv_pruintc_init(&pruss_intc_initdata);
prussdrv_exec_program (PRU_NUM, "./buttonTest.bin");
/* Wait for event completion from PRU */
int n = prussdrv_pru_wait_event (PRU_EVTOUT_0);
printf("PRU test completed, event number %d.\n", n);
/* Disable PRU and close memory mappings */
prussdrv_pru_disable(PRU_NUM);
prussdrv_exit ();
}
int main (void)
{
int ret1,i;
int fd,len;
char buf[64];
unsigned int ret,value;
tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;
signal(SIGINT, signal_callback_handler);
printf("\nINFO: Starting %s example.\r\n", "pt - SR04");
/* Initialize the PRU */
prussdrv_init ();
/* Open PRU Interrupt */
ret = prussdrv_open(PRU_EVTOUT_0);
if (ret)
{
printf("prussdrv_open open failed\n");
return (ret);
}
/* Get the interrupt initialized */
prussdrv_pruintc_init(&pruss_intc_initdata);
/* Initialize example */
printf("\tINFO: Initializing example.\r\n");
LOCAL_exampleInit(PRU_NUM);
/* Execute example on PRU */
printf("\tINFO: Executing example.\r\n");
prussdrv_exec_program (PRU_NUM, "./pu.bin");
printf("\tINFO: Waiting for \r\n");
while(1) {
prussdrv_pru_wait_event (PRU_EVTOUT_0);
prussdrv_pru_clear_event (PRU_EVTOUT_0, PRU0_ARM_INTERRUPT);
ret1 = LOCAL_pr(PRU_NUM); // go get & print result
}
usleep (500000); //Just pause so don't go too fast
prussdrv_pru_disable (PRU_NUM);
prussdrv_exit ();
sleep(20);
return(0);
}
int main (void)
{
/* Initialize the PRU */
printf("Initializing PRU\n");
tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;
prussdrv_init ();
/* Open PRU Interrupt */
if(prussdrv_open(PRU_EVTOUT_0))
{
// Handle failure
fprintf(stderr, "prussdrv_open open failed\n");
return 1;
}
/* Get the interrupt initialized */
prussdrv_pruintc_init(&pruss_intc_initdata);
/* Get pointers to PRU local memory */
void *pruDataMem;
prussdrv_map_prumem (PRUSS0_PRU0_DATARAM, &pruDataMem);
unsigned int *pruData = (unsigned int *) pruDataMem;
/* Execute example on PRU */
printf("Executing sonar pru code\n");
prussdrv_exec_program (0, "hcsr04_demo.bin");
/* Get 1000 measurements */
int i = 0;
while(i++ < 1000)
{
// Wait for the PRU interrupt to occur
prussdrv_pru_wait_event (PRU_EVTOUT_0);
prussdrv_pru_clear_event (PRU0_ARM_INTERRUPT);
// Print out the distance received from the sonar (sound takes 58.77 microseconds to travel 1 cm at sea level in dry air)
printf("Distance = %f cm\n", (float) pruData[0] / 58.77);
}
/* Check if example passed */
printf("Executed succesfully.\r\n");
/* Disable PRU and close memory mapping*/
prussdrv_pru_disable (0);
prussdrv_exit ();
return(0);
}
int main(void) {
/* Initialize the PRU */
//printf(">> Initializing PRU\n");
tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;
prussdrv_init();
/* Open PRU Interrupt */
if (prussdrv_open (PRU_EVTOUT_0)) {
// Handle failure
printf("-1");
return 1;
}
/* Get the interrupt initialized */
prussdrv_pruintc_init(&pruss_intc_initdata);
/* Get pointers to PRU local memory */
void *pruDataMem;
prussdrv_map_prumem(PRUSS0_PRU0_DATARAM, &pruDataMem);
unsigned int *pruData = (unsigned int *) pruDataMem;
/* Execute code on PRU */
//printf(">> Executing HCSR-04 code\n");
prussdrv_exec_program(0, "hcsr04.bin");
/* Get measurements */
//int i = 0;
//while (i++ < 20) {
// Wait for the PRU interrupt
prussdrv_pru_wait_event (PRU_EVTOUT_0);
prussdrv_pru_clear_event(PRU_EVTOUT_0, PRU0_ARM_INTERRUPT);
// Print the distance received from the sonar
// At 20 degrees in dry air the speed of sound is 342.2 cm/sec
// so it takes 29.12 us to make 1 cm, i.e. 58.44 us for a roundtrip of 1 cm
printf("%.2f \n", (float) pruData[0] / 58.44);
//sleep(1);
//}
/* Disable PRU and close memory mapping*/
prussdrv_pru_disable(0);
prussdrv_exit();
//printf(">> PRU Disabled.\r\n");
return (0);
}
int main (void)
{
unsigned int ret;
tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;
printf("\nINFO: Starting %s example.\r\n", "dmx");
/* Initialize the PRU */
prussdrv_init ();
LOCAL_export_pin(38);
/* Open PRU Interrupt */
ret = prussdrv_open(PRU_EVTOUT_0);
if (ret)
{
printf("prussdrv_open open failed\n");
return (ret);
}
/* Get the interrupt initialized */
prussdrv_pruintc_init(&pruss_intc_initdata);
/* Initialize example */
printf("\tINFO: Initializing example.\r\n");
LOCAL_exampleInit();
/* Execute example on PRU */
printf("\tINFO: Executing example.\r\n");
prussdrv_exec_program (PRU_NUM, "./dmx.bin");
LOCAL_udp_listen();
pruDataMem_byte[DMX_HALT_ADDR] = 1;
/* Wait until PRU0 has finished execution */
printf("\tINFO: Waiting for HALT command.\r\n");
prussdrv_pru_wait_event (PRU_EVTOUT_0);
printf("\tINFO: PRU completed transfer.\r\n");
prussdrv_pru_clear_event (PRU_EVTOUT_0, PRU0_ARM_INTERRUPT);
/* Disable PRU and close memory mapping*/
prussdrv_pru_disable (PRU_NUM);
prussdrv_exit ();
LOCAL_unexport_pin(38);
return(0);
}
int main(int argc, char *argv[])
{
uint32_t *pru1_mem;
/* PRU code only works if executed as root */
if (getuid() != 0) {
fprintf(stderr, "This program needs to run as root.\n");
exit(EXIT_FAILURE);
}
/* PRU START UP */
if (pru_setup() != 0) {
pru_cleanup();
exit(EXIT_FAILURE);
}
pru_mmap(PRU_N, &pru1_mem);
/* Begin test */
printf("Start SPI test.\n");
*(pru1_mem) = 0xFFFFFFFF;
if (pru_start(PRU_N, "./spi_test.bin") != 0) {
fprintf(stderr, "Error starting the PRU.\n");
pru_cleanup();
exit(EXIT_FAILURE);
}
/* Wait for PRU_EVTOUT_1 and send shared RAM data */
prussdrv_pru_wait_event(PRU_EVTOUT_1);
prussdrv_pru_clear_event(PRU_EVTOUT_1, PRU1_ARM_INTERRUPT);
printf("Received data: %#010x.\n", *(pru1_mem));
/* PRU CLEAN UP */
pru_stop(PRU_N);
pru_cleanup();
printf("Close SPI test.\n");
return(EXIT_SUCCESS);
}
