int pru_setup() { /* Initialize the PRU and prussdrv module (always returns 0) */ prussdrv_init(); /* Open interrupt(s): you should open at least PRU_EVTOUT_0 */ if (prussdrv_open(PRU_EVTOUT_0) != 0) { fprintf(stderr, "There was an error while opening PRU_EVTOUT_0.\n"); fprintf(stderr, "Did you load the PRU DTO?\n"); return(-1); } if (prussdrv_open(PRU_EVTOUT_1) != 0) { fprintf(stderr, "There was an error while opening PRU_EVTOUT_1.\n"); fprintf(stderr, "Did you load the PRU DTO?\n"); return(-1); } /* Initialize struct with INTC interrupt map (see PRU ref. guide, Fig. 97) */ tpruss_intc_initdata pru_intc_data = PRUSS_INTC_INITDATA; /* Initialize INTC */ if (prussdrv_pruintc_init(&pru_intc_data) != 0) { return(-1); fprintf(stderr, "An error occurred while initializing INTC."); } return(0); }
void initialize_pru(){ unsigned int ret; tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA; prussdrv_init (); /* Open PRU Interrupt */ if (PRU_NUM == 0){ ret = prussdrv_open(PRU_EVTOUT_0); } if (PRU_NUM == 1){ ret = prussdrv_open(PRU_EVTOUT_1); } if (ret) { printf("prussdrv_open open failed\n"); exit(ret); } /* Get the interrupt initialized */ prussdrv_pruintc_init(&pruss_intc_initdata); //Initialize pointer to PRU data memory if (PRU_NUM == 0) { prussdrv_map_prumem (PRUSS0_PRU0_DATARAM, &pruDataMem); } else if (PRU_NUM == 1) { prussdrv_map_prumem (PRUSS0_PRU1_DATARAM, &pruDataMem); } pruDataMem_int = (volatile signed int*) pruDataMem; //initialize external ram: // int mem_fd = open("/dev/mem", O_RDWR); if (mem_fd < 0){ printf("couldn't open /dev/mem\n"); exit(-1); } pru1_ddr= (uint8_t*)mmap(0, PRU_DDR_SIZE, PROT_WRITE | PROT_READ, MAP_SHARED, mem_fd, PRU1_DDR); if (pru1_ddr == NULL){ printf("couldn't map pru1 ddr\n"); exit(-1); } pruDataMem_int[0] = 1; pruDataMem_int[1] = 0; pruDataMem_int[2] = PRU1_DDR; pruDataMem_int[3] = PRU1_DDR+320*240*2; pruDataMem_int[4] = PRU1_DDR+320*240*4; pruDataMem_int[5] = PRU1_DDR+320*240*6; pruDataMem_int[6] = PRU1_DDR+320*240*8; printf("WE DIDN'T ALL DIE!\n"); fflush(stdout); }
int PRUloader::setup_pruss(void) { /* Allocate and initialize memory */ if (prussdrv_init()){ perror("prussdrv_init failed"); return -1; } if (prussdrv_open(PRU_EVTOUT_0)){ perror("prussdrv_open evt0 failed"); return -1; } if (prussdrv_open(PRU_EVTOUT_1)){ printf("prussdrv_open evt1 failed\n"); return -1; } if (prussdrv_pruintc_init(&pruss_intc_initdata)){ perror("prussdrv_pruintc_init failed"); return -1; } /* Start IRQ thread for event handling */ pthread_attr_t pthread_attr; struct sched_param sched_param; pthread_attr_init(&pthread_attr); int evt_priority = sched_get_priority_max(SCHED_FIFO) - 2; pthread_attr_setinheritsched(&pthread_attr, PTHREAD_EXPLICIT_SCHED); pthread_attr_setschedpolicy(&pthread_attr, SCHED_FIFO); sched_param.sched_priority = evt_priority; pthread_attr_setschedparam(&pthread_attr, &sched_param); quit_rx_thread = false; if(pthread_create(&irq_thread_evt0, &pthread_attr, &pruevtout0_thread, this) != 0){ printf("ERR >> Event thread not created\r\n"); return -1; } pthread_attr_destroy(&pthread_attr); // map pruss memory prussdrv_map_extmem(&ddrMemOrigin); // get max size ddr_mem_size = prussdrv_extmem_size(); printf("PRU_DEBUG >> DDR size is 0x%0x bytes\r\nPRU_DEBUG >> DDR virtual address is 0x%0x\r\n", (uint32_t)ddr_mem_size, (uint32_t)ddrMemOrigin); // Get physical address phy_add = prussdrv_get_phys_addr(ddrMemOrigin); printf("PRU_DEBUG >> Start of physical address allocated is 0x%X\r\n", phy_add); memset((char *)ddrMemOrigin, 0, ddr_mem_size); return 1; }
int main (void) { // Initialize the PRU printf("Initializing PRU\n"); prussdrv_init (); // Open an event if (prussdrv_open(PRU_EVTOUT_0)) { printf("prussdrv_open open failed\n"); return -1; } // Execute code on PRU printf("Executing follow pru code\n"); prussdrv_exec_program (0, "follow.bin"); // Wait for Ctrl-C signal(SIGINT, on_sigint); while (is_sigint == 0) { } // Disable PRU and close memory mapping prussdrv_pru_disable (0); prussdrv_exit (); return(0); }
int main(int ac, char** av) { tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA; uint32_t x[2]; prussdrv_init(); if (prussdrv_open(PRU_EVTOUT_0)) { printf("prussdrv_open open failed\n"); return -1; } prussdrv_pruintc_init(&pruss_intc_initdata); /* execute code on pru0 */ #define PRU_NUM 0 prussdrv_exec_program(PRU_NUM, "./iep.bin"); signal(SIGINT, on_sigint); while (is_sigint == 0) { usleep(500000); read_words(x); printf("0x%08x, 0x%08x\n", x[0], x[1]); } /* disable pru and close memory mapping */ prussdrv_pru_disable(PRU_NUM); prussdrv_exit(); return 0; }
int main(void) { prussdrv_init(); prussdrv_open(PRU_EVTOUT_0); prussdrv_pru_reset(PRU0); enable_pru_interrupts(); prussdrv_map_prumem(PRUSS0_PRU0_DATARAM, (void**)&pru0_data_ram); *pru0_data_ram = 99; prussdrv_pru_write_memory( PRUSS0_PRU0_IRAM, 0, (unsigned int*)intp_bin, intp_bin_len ); // Contra the ARM PRU Linux API documentation, this function does not exist! // prussdrv_start_irqthread( // PRU_EVTOUT_0, sched_get_priority_max(SCHED_FIFO) - 2, pruevtout0_thread // ); pthread_t irqthread; int iret = pthread_create(&irqthread, NULL, pruevtout0_thread, NULL); printf("iret = %d\n", iret); sleep(1); printf("starting PRU...\n"); prussdrv_pru_enable(PRU0); sleep(3); printf("after sleep\n"); printf("count = %d\n", *pru0_data_ram); prussdrv_pru_disable(PRU0); printf("PRU disabled\n"); printf("count = %d\n", *pru0_data_ram); }
//! 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; }
/*** pru_setup() -- initialize PRU and interrupt handler Initializes the PRU specified by PRU_NUM and sets up PRU_EVTOUT_0 handler. The argument is a pointer to a nul-terminated string containing the path to the file containing the PRU program binary. Returns 0 on success, non-0 on error. ***/ static int pru_setup(const char * const path) { int rtn; tpruss_intc_initdata intc = PRUSS_INTC_INITDATA; if(!path) { fprintf(stderr, "pru_setup(): path is NULL\n"); return -1; } /* initialize PRU */ if((rtn = prussdrv_init()) != 0) { fprintf(stderr, "prussdrv_init() failed\n"); return rtn; } /* open the interrupt */ if((rtn = prussdrv_open(PRU_EVTOUT_0)) != 0) { fprintf(stderr, "prussdrv_open() failed\n"); return rtn; } /* initialize interrupt */ if((rtn = prussdrv_pruintc_init(&intc)) != 0) { fprintf(stderr, "prussdrv_pruintc_init() failed\n"); return rtn; } /* load and run the PRU program */ if((rtn = prussdrv_exec_program(PRU_NUM, path)) < 0) { fprintf(stderr, "prussdrv_exec_program() failed\n"); return rtn; } return rtn; }
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); }
void initialize_pru(){ unsigned int ret; tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA; prussdrv_init (); /* Open PRU Interrupt */ ret = prussdrv_open(PRU_EVTOUT_0); if (ret) { printf("prussdrv_open open failed\n"); exit(ret); } /* Get the interrupt initialized */ prussdrv_pruintc_init(&pruss_intc_initdata); //Initialize pointer to PRU data memory if (PRU_NUM == 0) { prussdrv_map_prumem (PRUSS0_PRU0_DATARAM, &pruDataMem); } else if (PRU_NUM == 1) { prussdrv_map_prumem (PRUSS0_PRU1_DATARAM, &pruDataMem); } pruDataMem_int = (volatile signed int*) pruDataMem; }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // pru_init // Initializes the PRU system //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ void pru_init() { // Initialise driver prussdrv_init(); // Open interrupt unsigned int ret = prussdrv_open(PRU_EVTOUT_0); if (ret) { printf("prussdrv_open open failed\n"); } //Initialise interrupt tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA; prussdrv_pruintc_init(&pruss_intc_initdata); // Point to PRU shared memory static void* sharedMem; prussdrv_map_prumem( PRUSS0_SHARED_DATARAM, &sharedMem ); memoryPtr = (unsigned int*) sharedMem; memset( memoryPtr, 0, 4* SERVO_CH ); // Load assembly code prussdrv_exec_program ( 1, "PRU1.bin" ); // Loops per PWM period memoryPtr[2048] = 150000; }
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; }
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 (); }
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; }
PRU::PRU(int number) { // Store the PRU number (0 or 1) if (number < 2) { this->pruNumber = number; } else { this->pruNumber = 0; } // Initialise driver prussdrv_init (); // Open interrupt unsigned int ret = prussdrv_open(PRU_EVTOUT_0); if (ret) { printf("prussdrv_open open failed\n"); return; } //Initialise interrupt tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA; prussdrv_pruintc_init(&pruss_intc_initdata); // Allocate shared PRU memory if (!this->memoryPtr) { static void *sharedMem; prussdrv_map_prumem(PRUSS0_SHARED_DATARAM, &sharedMem); this->memoryPtr = (unsigned int*) sharedMem; } }
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 */ /* Initialize example */ /* Execute example on PRU */ /* Disable PRU and close memory mapping*/ prussdrv_pru_disable (PRU_NUM); prussdrv_exit (); return(0); }
TLC5946PRUSSphy::TLC5946PRUSSphy(SPI *spi, GPIOpin *ctrl, char *pruBinFile) : TLC5946phy(spi, ctrl) { use_pruss = true; //active has been set to true by superclass constructor active = false; gsclk_pin_pin = ctrl->findPinIndex((char *) "gsclk"); printf("prussdrv_open()\n"); if (prussdrv_open(PRU_EVTOUT_0)) { iooo_debug(0, "Cannot setup PRU_EVTOUT_0.\n"); use_pruss = false; return; } iooo_debug(2, "PRUSS driver initialized"); if (use_pruss && prussdrv_exec_program(0, pruBinFile)) { iooo_debug(0, "Non-zero result from prussdrv_pruintc_init\n"); use_pruss = false; return; } iooo_debug(2, "PRU binary loaded"); prussdrv_exit(); //setup clocking lines as outputs //ctrl->enableOutput(blank_pin_pin,true); ctrl->enableOutput(gsclk_pin_pin, true); active = true; use_pruss = true; }
int init_PRUSS(){ unsigned int ret; tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA; prussdrv_init (); /* Open PRU Interrupt */ puts("pruss intialized"); ret =prussdrv_open(PRU_EVTOUT_0); if (ret) { printf("prussdrv_open open failed\n"); return (ret); } puts("pru0 evntout done"); /* Open PRU Interrupt */ ret = prussdrv_open(PRU_EVTOUT_1); if (ret) { printf("prussdrv_open open failed\n"); return (ret); } puts("pru1 evntout"); /* Get the interrupt initialized */ prussdrv_pruintc_init(&pruss_intc_initdata); puts("pruss intc init done"); /* Execute example on PRU */ prussdrv_exec_program (0, "./buffer.bin"); puts("exec pru0"); prussdrv_exec_program (1, "./sampler.bin"); puts("exec pru1"); /* Allocate Shared PRU memory. */ prussdrv_map_prumem(PRUSS0_SHARED_DATARAM, &sharedMem); sharedMem_int = (uint32_t*) sharedMem; sharedMem_chan = (uint16_t*) sharedMem; return 0; }
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; }
// Initialize the pruss int pruInit(unsigned short pruNum) { int i, n; tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA; prussdrv_init(); // Open PRU Interrupt int pru_int = (pru_num == 0) ? PRU_EVTOUT_0 : PRU_EVTOUT_1; if (prussdrv_open(pru_int) != 0) { fprintf(stderr, "prussdrv_open open failed\n"); return EXIT_FAILURE; } // initialize the interrupt prussdrv_pruintc_init(&pruss_intc_initdata); // Set up shared memory area for arm--pru communication prussdrv_map_prumem(PRUSS0_SHARED_DATARAM, &pruSharedMem); pruSharedMem_int = (uint32_t *)pruSharedMem; pruSharedMem_int[TOPRU] = 0x00; pruSharedMem_int[TOPRU_F] = 0x00; pruSharedMem_int[FROMPRU] = 0x00; pruSharedMem_int[FROMPRU_F] = 0x00; // Initialize pointer to PRU data memory if (pruNum == 0) { prussdrv_map_prumem (PRUSS0_PRU0_DATARAM, &pruDataMem); } else if (pruNum == 1) { prussdrv_map_prumem (PRUSS0_PRU1_DATARAM, &pruDataMem); } pruDataMem_int = (uint16_t *)pruDataMem; strcpy(&filename[namelen], ".dat"); // Load dictionary into data memory FILE *file = fopen(filename, "r"); if (file == NULL) { fprintf(stderr, "Unable to open dictionary file, %s\n", filename); return EXIT_FAILURE; } i = 0; while (fscanf(file, "%x", &n) == 1) { pruDataMem_int[i++] = (uint16_t)n; } fclose(file); strcpy(&filename[namelen], ".bin"); // start pru program prussdrv_exec_program (pru_num, filename); 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); }
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) { unsigned int ret, i, j, k; tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA; printf("\nINFO: Starting %s example.\r\n", "pru_gpio"); /* Initialize the PRU */ prussdrv_init (); //NOTE : The PRU code does not export the PIN so this must be //done for any pin that used. LOCAL_export_pin(32 + 16,"out"); //GPIO1_16 LOCAL_export_pin(32 + 13,"in"); //GPIO1_13 /* 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(); //Start th emain loop pruDataMem_byte[CMD_VALUE] = CMD_NO_OP; /* Execute example on PRU */ printf("\tINFO: Executing example.\r\n"); prussdrv_exec_program (PRU_NUM, "./pru_gpio.bin"); //The PRU is just configured to use GPIO1 for now. This can be changed easily in the assembly. set_pin(16); //GPIO1_16 clear_pin(16); int value = read_pin(13); //GPIO1_13 printf("PIN value is %d\n",value); 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 (); LOCAL_unexport_pin(38); return(0); }
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 init_pru_program(){ tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA; prussdrv_init(); dbg("\tPRUSS driver was initialized...\n"); prussdrv_open(PRU_EVTOUT_0); prussdrv_pruintc_init(&pruss_intc_initdata); dbg("\tPRUSS driver intc was initialized...\n"); prussdrv_load_datafile(PRU_NUM, "./data.bin"); dbg("\tDatafile was loaded...\n"); prussdrv_exec_program_at(PRU_NUM, "./text.bin", START_ADDR); dbg("\tTextfile was loaded...\n"); }
void init_pru_program(){ tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA; prussdrv_init(); prussdrv_open(PRU_EVTOUT_0); prussdrv_pruintc_init(&pruss_intc_initdata); // Get pointer to shared ram void* p; prussdrv_map_prumem(PRUSS0_SHARED_DATARAM, &p); shared_ram = (unsigned int*)p; prussdrv_load_datafile(PRU_NUM, "./data.bin"); prussdrv_exec_program_at(PRU_NUM, "./text.bin", START_ADDR); }
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 (int ac, char** av) { tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA; uint32_t x[MEM_SIZE]; const size_t n = sizeof (x) / sizeof (x[0]); size_t i; size_t count = 0; printf ("n: %u \n", n); prussdrv_init (); if (prussdrv_open (PRU_EVTOUT_0)) { printf ("prussdrv_open open failed\n"); return -1; } prussdrv_pruintc_init (&pruss_intc_initdata); /* zero_words(n); */ /* write data from data.bin */ prussdrv_load_datafile (PRU_NUM, "./data.bin"); /* execute code on pru0 */ prussdrv_exec_program_at (PRU_NUM, "./text.bin", START_ADDR); // prussdrv_exec_program(PRU_NUM, "./text.bin"); signal (SIGINT, on_sigint); while (is_sigint == 0) { printf ("reading count: %d\n", count++); usleep (1000000); read_words (x, n); for (i = 0; i != n; ++i) { //printf("mem 0x%08x: (%f)\n", x[i], *((float*)(x + i))); printf ("mem %d %08x: (%08x)\n", i, (x + i), (unsigned int) (*(x + i))); } printf ("\n"); } /* disable pru and close memory mapping */ prussdrv_pru_disable (PRU_NUM); prussdrv_exit (); return 0; }