void PruTimer::stopThread(bool join) { LOG( "Stopping PruTimer..." << std::endl); stop=true; /* Disable PRU and close memory mapping*/ prussdrv_pru_disable (PRU_NUM0); prussdrv_pru_disable (PRU_NUM1); prussdrv_exit (); if(ddr_mem) { #ifdef DEMO_PRU free(ddr_mem); ddr_mem = NULL; #else munmap(ddr_mem, ddr_size); close(mem_fd); ddr_mem = NULL; mem_fd=-1; #endif } LOG( "PRU disabled, DDR released, FD closed." << std::endl); blockAvailable.notify_all(); if(join && runningThread.joinable()) { runningThread.join(); } LOG( "PruTimer stopped." << std::endl); }
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); }
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(); }
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 (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 (int argc, char ** argv) { if (argc != 2){ printf("you need to give me the number of frames to captures\n"); exit(-1); } int num_frames = atoi(argv[1]); initialize_pru(); start_pru(); FILE * image_data = fopen("/media/usb/image.data", "w"); if (image_data == NULL){ fprintf(stderr, "Failed to open image output file"); exit(-1); } const char *version = FreeImage_GetVersion(); printf("Freeimage version %s\n", version); FIBITMAP* dib = FreeImage_Allocate(320, 203, 16, 0xF800, 0x07E0,0x001F); // allocate 320x203 RGB565 bitmap int bytespp = FreeImage_GetLine(dib)/FreeImage_GetWidth(dib); FREE_IMAGE_TYPE image_type = FreeImage_GetImageType(dib); if (image_type == FIT_BITMAP){ printf("1\n"); } printf("%d %d\n", FreeImage_GetHeight(dib), FreeImage_GetWidth(dib)); BYTE * bits = FreeImage_GetBits(dib); FILE * fp = fopen("image.data", "rb"); char filename[] = "/root/1314-BeagleBone-Quadcopter/code/ControlTower/ramfs/latest_image.bmp"; int i = 0; for (i = 0; i < num_frames; i++){ while(i==pruDataMem_int[100]){usleep(100000);} int buffer = pruDataMem_int[1]; printf("%d buffer=%d\n", pruDataMem_int[100], buffer); if (i%10==0){ memcpy(bits, pru1_ddr+buffer*320*240*2, 320*203*2); FreeImage_Save(FIF_BMP, dib, filename,0); } } uninitialize_pru(); fflush(image_data); printf("%d\n", ((volatile uint8_t *)pru1_ddr)[0]); fclose(image_data); prussdrv_pru_disable (PRU_NUM); prussdrv_exit (); return(0); }
/* This method frees the shared memory and disables the PRU's again. * Take not that the Device Tree Overlay will NOT be unloaded, as doing this may result in an unstable system. */ unsigned int mdau_destroy(){ // Disable PRU and close memory mappings prussdrv_pru_disable(ADC_PRU_NUM); prussdrv_pru_disable(CLK_PRU_NUM); prussdrv_exit (); if(system("rmmod uio_pruss")==1){ return EXIT_FAILURE; } 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); }
static void pru_shutdown(char flush_queue) { if (flush_queue) { struct MotionSegment end_element; bzero(&end_element, sizeof(end_element)); end_element.state = STATE_EXIT; pru_enqueue_segment(&end_element); pru_wait_queue_empty(); } prussdrv_pru_disable(PRU_NUM); prussdrv_exit(); pru_motor_enable_nowait(0); unmap_gpio(); }
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); }
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 (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; }
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) { 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(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); }
void uninitialize_pru(){ pruDataMem_int[0] = 0; /* 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 (); }
int main (void) { unsigned int ret, i; tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA; printf("\nINFO: Starting %s example.\r\n", "WritePPM"); /* 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, "./WritePPM.bin"); prussdrv_map_prumem(PRUSS0_PRU1_DATARAM, &dataMem); dataMem_int = (unsigned int*) dataMem; printf("local dataram addr: %08X\n", (unsigned int) dataMem); while (1) { //for (i = 0; i < 6; i++) { //printf("%08X : %08X\n", dataMem_int[0], dataMem_int[1]); //printf("%08X:%08X | ", dataMem_int[(4*i)+2], dataMem_int[(4*i)+3]); //} printf("%08X\n", dataMem_int[2]); usleep(10000); } /* Disable PRU and close memory mapping*/ prussdrv_pru_disable(PRU_NUM); prussdrv_exit (); close(mem_fd); return(0); }
int main (void) { int ret1,i,cnt; int fd,len,msig,messno; short ret2; unsigned int ret,value,en = 0; tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA; 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, "./iep2.bin"); pruDataMem_int[66] = 0; printf("\tINFO: Waiting for \r\n"); prussdrv_pru_wait_event (PRU_EVTOUT_0); prussdrv_pru_clear_event (PRU_EVTOUT_0, PRU0_ARM_INTERRUPT); prussdrv_pru_disable (PRU_NUM); prussdrv_exit (); return(0); }
int main (void) { 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; // Read in the location and address of the shared memory. This value changes // each time a new block of memory is allocated. unsigned int values[2]; values[0] = readFileValue(MMAP_LOC "addr"); values[1] = readFileValue(MMAP_LOC "size"); printf("The shared memory has location: %x and size %x\n", values[0], values[1]); // Allocate and initialize memory prussdrv_init (); prussdrv_open (PRU_EVTOUT_0); // Write the address and size into PRU0 Data RAM0. You can edit the value to // PRUSS0_PRU1_DATARAM if you wish to write to PRU1 prussdrv_pru_write_memory(PRUSS0_PRU0_DATARAM, 0, values, 8); // Map PRU's interrupts prussdrv_pruintc_init(&pruss_intc_initdata); // Load and execute the PRU program on the PRU prussdrv_exec_program (PRU_NUM, "./memExample.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(int argc, const char *argv[]){ printf("\n\n"); // Listen to SIGINT signals (program termination) signal(SIGINT, signal_handler); // Load device tree overlay to enable PRU hardware. load_device_tree_overlay(); // Load and run binary into pru0 init_pru_program(); open_sound_file(); /* sleep(1); */ start_thread(); while(!finish){} //sleep(500); prussdrv_pru_disable(PRU_NUM); prussdrv_exit (); stop_thread(); close_sound_file(); // Calculate sample rate /* int i; */ /* unsigned long sum = 0; */ /* for(i=0; i<times_count; i++){ */ /* sum += times[i]; */ /* } */ /* float avg = (float)sum / (float)times_count; */ /* printf("Freq: %f \n", 128.0*1000000.0/avg); */ return 0; }
void pru_start() { unsigned int ret; char *bin; tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA; prussdrv_init(); if (prussdrv_open(PRU_EVTOUT_0)) panic("prussdrv_open"); if (prussdrv_pruintc_init(&pruss_intc_initdata)) panic("prussdrv_pruintc_init"); if (prussdrv_map_prumem(PRUSS0_PRU0_DATARAM, &pruDataMem)) panic("prussdrv_map_prumem"); pru = (com_t *) pruDataMem; pru2 = (com2_t *) (pruDataMem + PRU_COM_SIZE); bin = background_mode? "/usr/local/bin/hp5370d_realtime.bin" : "pru/pru_realtime.bin"; if (prussdrv_exec_program(PRU_NUM, bin)) panic("prussdrv_exec_program"); u4_t key1 = timer_us(); u4_t key2 = key1 >> 8; pru->p[0] = key1; pru->p[1] = key2; pru->p[2] = 0; pru->p[3] = 0; pru2->m2_offset = 0xbeefcafe; send_pru_cmd(PRU_PING); if (pru->p[2] != (key1+key2)) panic("PRU didn't start"); if (pru->p[3] != 0xbeefcafe) panic("PRU com2_t at wrong offset?"); send_pru_cmd(PRU_CLEAR); lprintf("PRU started\n"); #if 0 prussdrv_pru_wait_event(PRU_EVTOUT_0); // wait for halt prussdrv_pru_clear_event(PRU_EVTOUT_0, PRU0_ARM_INTERRUPT); prussdrv_pru_disable(PRU_NUM); prussdrv_exit(); #endif }
int main(int argc, char **argv) { char *bin_path, *ptr; struct pru_data pru; tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA; prussdrv_init(); if (prussdrv_open(PRU_EVTOUT_0)) { fprintf(stderr, "Cannot setup PRU_EVTOUT_0.\n"); return -EINVAL; } prussdrv_pruintc_init(&pruss_intc_initdata); prussdrv_map_prumem(PRUSS0_PRU0_DATARAM, (void *) &pru.prumem); if (pru.prumem == NULL) { fprintf(stderr, "Cannot map PRU0 memory buffer.\n"); return -ENOMEM; } init_time(&pru); bin_path = strdup(argv[0]); ptr = strrchr(bin_path, '/'); *ptr = '\0'; chdir(bin_path); /* * Display PRU */ prussdrv_exec_program(0, "pru0_clock.bin"); /* * Clock PRU */ prussdrv_exec_program(1, "pru1_clock.bin"); prussdrv_exit(); return 0; }
static int pru_cleanup(void) { int rtn = 0; /* clear the event (if asserted) */ if(prussdrv_pru_clear_event(PRU_EVTOUT_0, PRU0_ARM_INTERRUPT)) { fprintf(stderr, "prussdrv_pru_clear_event() failed\n"); rtn = -1; } /* halt and disable the PRU (if running) */ if((rtn = prussdrv_pru_disable(PRU_NUM)) != 0) { fprintf(stderr, "prussdrv_pru_disable() failed\n"); rtn = -1; } /* release the PRU clocks and disable prussdrv module */ if((rtn = prussdrv_exit()) != 0) { fprintf(stderr, "prussdrv_exit() failed\n"); rtn = -1; } return rtn; }
int main (void) { 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; // Read in the location and address of the shared memory. This value changes // each time a new block of memory is allocated. unsigned int values[2]; values[0] = FREQ_1MHz; values[1] = RUNNING; printf("The clock state is set as period: %d (0x%x) and state: %d\n", values[0], values[0], values[1]); printf("This is mapped at the base address: %x\n", readFileValue(MMAP_LOC "addr")); // Allocate and initialize memory prussdrv_init (); prussdrv_open (PRU_EVTOUT_0); // Write the address and size into PRU0 Data RAM0. You can edit the value to // PRUSS0_PRU1_DATARAM if you wish to write to PRU1 prussdrv_pru_write_memory(PRUSS0_PRU0_DATARAM, 0, values, 8); // Map PRU's interrupts prussdrv_pruintc_init(&pruss_intc_initdata); // Load and execute the PRU program on the PRU prussdrv_exec_program (PRU_NUM, "./PRUClock.bin"); printf("EBB Clock PRU program now running (%d)\n", values[0]); prussdrv_exit (); return EXIT_SUCCESS; }
int main (void) { 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 and execute the PRU program on the PRU prussdrv_exec_program (PRU_NUM, "./FixedPRUClock.bin"); printf("EBB fixed-frequency clock PRU program now running\n"); prussdrv_exit (); return EXIT_SUCCESS; }
int main (int argc, char* argv[]) { unsigned int ret; tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA; printf("\nINFO: Starting single channel PWM on P9_27.\r\n"); /* 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 PWM with default values.\r\n"); //LOCAL_exampleInit(PRU_NUM); //////////////////// LOAD VALUES INTO MEMORY ///////////////// void *DDR_regaddr1, *DDR_regaddr2, *DDR_regaddr3; /* open the device */ mem_fd = open("/dev/mem", O_RDWR); if (mem_fd < 0) { printf("Failed to open /dev/mem (%s)\n", strerror(errno)); return 1; } /* map the DDR memory */ ddrMem = mmap(0, 0x0FFFFFFF, PROT_WRITE | PROT_READ, MAP_SHARED, mem_fd, DDR_BASEADDR); if (ddrMem == NULL) { printf("Failed to map the device (%s)\n", strerror(errno)); close(mem_fd); return 1; } /* Store Addends in DDR memory location */ DDR_regaddr1 = ddrMem + OFFSET_DDR; DDR_regaddr2 = ddrMem + OFFSET_DDR + 0x00000004; DDR_regaddr3 = ddrMem + OFFSET_DDR + 0x00000008; *(unsigned int*) DDR_regaddr1 = PERIOD_CYCLES; *(unsigned int*) DDR_regaddr2 = DUTY_CYCLES; *(unsigned int*) DDR_regaddr3 = STOP_FLAG; /* Execute example on PRU */ printf("\tINFO: Starting PWM output on P9_27.\r\n"); prussdrv_exec_program (PRU_NUM, "./prucode.bin"); signal(SIGINT, intHandler); int fd = open(PORT, O_RDWR); if (fd < 0) error("can't open %s - %m", PORT); if (ioctl(fd, I2C_SLAVE, ADDR) < 0) error("can't ioctl %s:0x%02x - %m", PORT, ADDR); if (write(fd, "\x40", 2) < 0) error("can't setup %s:0x%02x - %m", PORT, ADDR); // again, keep supposedly safe values for start (although this might arm some motors) int last_input = 1060; int input = 1060; int converted = 212000; int loopkey = 1; struct nunchuck_packet packet; int js_x, js_y; while (loopkey) { *(unsigned int*) DDR_regaddr2 = converted; printf("Value entered: %i\n Value sent: %i\n", input, converted); ret = read(fd, &packet, sizeof(struct nunchuck_packet)); if (ret <0) error("read error: %s : 0x%02x - %m ", PORT, ADDR); if (!ret) continue; js_x = (packet.joystick_val[0] ^ 0x17) + 0x17 ; js_y = (packet.joystick_val[1] ^ 0x17) + 0x17 ; input = linear_map(js_x, 0, 255, 0, 3000); printf("input : %d\n", input); last_input = input; //scanf(" %i", &loopkey); if(input > 100 && input < 10000) { // sane value converted = input * 1000 / 5; //input in microseconds converted to nanoseconds and then divided by 5 to get cycles } else { // restore sanity input = last_input; } write(fd, "", 1); } *(unsigned int*) DDR_regaddr3 = 1; // set close register, wait for PRU to halt /* 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("Example executed succesfully.\r\n"); } else { printf("Example failed.\r\n"); } */ /* Disable PRU and close memory mapping*/ prussdrv_pru_disable(PRU_NUM); prussdrv_exit (); munmap(ddrMem, 0x0FFFFFFF); close(mem_fd); return(0); }
int main (void) { unsigned int ret, i, j; tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA; printf("\nINFO: Starting %s example.\r\n", "blinkslave"); /* 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(); /* Execute example on PRU */ printf("\tINFO: Executing example.\r\n"); prussdrv_exec_program (PRU_NUM, "./blinkslave.bin"); // Instead of waiting patiently for the PRU to finish, we're going to screw around with the shared memory and hopefully influence the PRU const int pruDramPosition = 0; const int pruDramMaxDelay = 4; const int pruDramMinDelay = 8; const int pruDramAccelDelta = 12; const int pruDramDirection = 16; const int pruDramTarget = 20; const int pruDramAccelLength = 24; int position = 0; int accelDelta = 500; int maxDelay = 100000; int minDelay = 1000; int direction = 1; int target = 100000; int target2 = 4000; int accelLength = 200; memcpy(pruDataMem_byte + pruDramMaxDelay, &maxDelay, 4); memcpy(pruDataMem_byte + pruDramMinDelay, &minDelay, 4); memcpy(pruDataMem_byte + pruDramAccelDelta, &accelDelta, 4); memcpy(pruDataMem_byte + pruDramTarget, &target, 4); memcpy(pruDataMem_byte + pruDramDirection, &direction, 4); memcpy(pruDataMem_byte + pruDramAccelLength, &accelLength, 4); j = 20000; int prev_pos = 0; int cdelay = 0; while (--j) { memcpy(&position, pruDataMem_byte + pruDramPosition, 4); memcpy(&cdelay, pruDataMem_byte + pruDramMinDelay, 4); std::cout << "inc:" << prev_pos - position << ",cdelay:" << cdelay << "\n" << std::flush; prev_pos = position; if(position > 3000)memcpy(pruDataMem_byte + pruDramTarget, &target2, 4); std::cout << position << "\n" << std::flush; usleep(1000); } /* 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); }