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 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 (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); }
static int LOCAL_exampleInit () { int i; prussdrv_map_prumem (PRUSS0_PRU0_DATARAM, &pruDataMem); pruDataMem_byte = (unsigned char*) pruDataMem; pruDataMem_byte[DMX_HALT_ADDR] = 0; pruDataMem_byte[DMX_CHANNELS_ADDR] = DMX_CHANNELS; pruDataMem_byte[DMX_PIN_ADDR] = DMX_PIN; for (i = 0; i < DMX_CHANNELS; i++) { pruDataMem_byte[i] = 0; } 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; } /* map PRU DATA RAM */ prussdrv_map_prumem(PRUSS0_PRU0_DATARAM, (void**)&pruDataMem); //pruDataMem[0] = 0x01020304; pruDataMem->hi_delay = 1000; pruDataMem->lo_delay = 19000; /* 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; }
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 }
static bool initPru(void) { tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA; printf("Initializing PRU\n"); prussdrv_init(); // Open PRU driver and prepare for using the interrupt on event output 1 if (prussdrv_open(PRU_EVTOUT_1)) { fprintf(stderr, "prussdrv_open failed!\n"); return false; } // Initialize the PRUSS interrupt controller if (prussdrv_pruintc_init(&pruss_intc_initdata)) { fprintf(stderr, "prussdrv_pruintc_init failed!\n"); return false; } // Get pointer to the shared PRUSS memory. On the AM355x this block is 12KB // in size and located locally at 0x0001_0000 within the PRU cores and // globally at 0x4A31_0000 in the MPU's memory map. The entire memory is // used as our printer queue so we map the global variable to that address. prussdrv_map_prumem(PRUSS0_SHARED_DATARAM, (void *)&queue); // Initialize the PRU from an array in memory rather than from a file on // disk. Make sure PRU sub system is first disabled/reset. Then, transfer // the program into the PRU. Note that the write memory functions expect // the offsets to be provided in words so we our byte-addresses by four. printf("Loading PRU firmware and enabling PRU\n"); prussdrv_pru_disable(1); prussdrv_pru_write_memory(PRUSS0_PRU1_IRAM, pruprinter_fw_iram_start / 4, (unsigned int *)&pruprinter_fw_iram, pruprinter_fw_iram_length); prussdrv_pru_write_memory(PRUSS0_PRU1_DATARAM, pruprinter_fw_dram_start / 4, (unsigned int *)&pruprinter_fw_dram, pruprinter_fw_dram_length); prussdrv_pru_enable(1); return true; }
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; }
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // 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* RADIO_CH ); // Load assembly code prussdrv_exec_program ( 1, "PRU1.bin" ); }
int pru_init(int pru, char *filename, int disabled, hal_pru_generic_t *hpg) { int i; int retval; if (geteuid()) { HPG_ERR("ERROR: not running as root - need to 'sudo make setuid'?\n"); return -1; } if ((retval = assure_module_loaded(UIO_PRUSS))) return retval; rtapi_print("prussdrv_init\n"); // Allocate and initialize memory prussdrv_init (); // opens an event out and initializes memory mapping rtapi_print("prussdrv_open\n"); if (prussdrv_open(event > -1 ? event : PRU_EVTOUT_0) < 0) return -1; // expose the driver data, filled in by prussdrv_open pruss = &prussdrv; // Map PRU's INTC rtapi_print("prussdrv_pruintc_init\n"); if (prussdrv_pruintc_init(&pruss_intc_initdata) < 0) return -1; // Maps the PRU DRAM memory to input pointer rtapi_print("prussdrv_map_prumem\n"); if (prussdrv_map_prumem(pru ? PRUSS0_PRU1_DATARAM : PRUSS0_PRU0_DATARAM, (void **) &pru_data_ram) < 0) return -1; rtapi_print("PRU data ram mapped\n"); rtapi_print_msg(RTAPI_MSG_DBG, "%s: PRU data ram mapped at %p\n", modname, pru_data_ram); hpg->pru_data = (u32 *) pru_data_ram; // Zero PRU data memory for (i = 0; i < 8192/4; i++) { hpg->pru_data[i] = 0; } // Reserve PRU memory for static configuration variables hpg->pru_stat_addr = PRU_DATA_START; hpg->pru_data_free = hpg->pru_stat_addr + sizeof(PRU_statics_t); // Setup PRU globals hpg->pru_stat.task.hdr.dataX = 0xAB; hpg->pru_stat.task.hdr.dataY = 0xFE; hpg->pru_stat.period = pru_period; hpg->config.pru_period = pru_period; PRU_statics_t *stat = (PRU_statics_t *) ((u32) hpg->pru_data + (u32) hpg->pru_stat_addr); *stat = hpg->pru_stat; return 0; }
int main (int argc, char *argv[]){ // Confirm root status (UART/PRU will not run otherwise) if(getuid()!=0){ printf("You must run this program as root. Exiting.\n"); exit(EXIT_FAILURE); } // Set Collision Limit // By default, it is unlimited. User may supply an argument to limit it. int collisionLimit; if(argc > 1){ if(argc == 2){ collisionLimit = atoi(argv[1]); // Assumes user knows what they are doing and will only put in an int } else { printf("Invalid argument: Collisions will not be limited.\n"); collisionLimit = -1; } } else { collisionLimit = -1; } // For catching SIGINT and avoiding UART errors signal(SIGINT, INThandler); // UART Initialization int count; if ((file = open("/dev/ttyO2", O_RDWR | O_NOCTTY | O_NDELAY))<0){ perror("UART: Failed to open the file.\n"); exit(EXIT_FAILURE); } struct termios options; tcgetattr(file, &options); options.c_cflag = B19200 | CS8 | CREAD | CLOCAL; options.c_iflag = IGNPAR | ICRNL; options.c_lflag &= ~(ICANON|ECHO); tcflush(file, TCIFLUSH); tcsetattr(file, TCSANOW, &options); // Initialize PRU structures tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA; prussdrv_init (); prussdrv_open (PRU_EVTOUT_0); // Declare and assign pointers to PRU Memory unsigned char *pruMem[2]; prussdrv_map_prumem (0, (void*) &pruMem[0]); if (pruMem[0] == NULL){ printf("PRU: Data Memory not mapped!\nExiting."); exit(EXIT_FAILURE); } pruMem[1] = pruMem[0] + 1; // Map PRU's interrupts prussdrv_pruintc_init(&pruss_intc_initdata); // Load and execute the PRU program on the PRU prussdrv_exec_program (PRU_0, "./pru_0_clk.bin"); prussdrv_exec_program (PRU_1, "./pru_1_clk.bin"); printf("EBB fixed-frequency clock PRU program now running\n"); // Data Collection Loop int i = 0; while(i != collisionLimit){ // Increment collision counter i++; // Wait for interrupt from PRU printf("Waiting for intc...\n"); prussdrv_pru_wait_event (PRU_EVTOUT_0); prussdrv_pru_clear_event (PRU_EVTOUT_0, PRU0_ARM_INTERRUPT); // Print data for user (Future feature: Disable printing to stdout unless a -DEBUG argument is passed) printf("Collision %d\n", i); printf("\tValue: %d\n", *pruMem[0]); printf("\tChannel: %d\n", *pruMem[1] + 1); // Store data for transmission unsigned char transmit[2]; transmit[0] = *pruMem[0]; transmit[1] = *pruMem[1] + 1; //Add 1 to channel for readability // Transmit data over UART if ((count = write(file, &transmit, 2))<0){ //send the string perror("Failed to write to the output\n"); } usleep(1000); // Sleep 1ms for MBM to read data (otherwise overflows UART buffer) // This value can be lowered to increase speed, at the cost of security } // Clear PRU memory pointers *pruMem[0] = 0; *pruMem[1] = 0; // Disable PRUs and close UART efireExit(); /* Exit -- This should not be reached efireExit() will ensure UART and PRU are disabled. */ return EXIT_FAILURE; }
int main (void) { unsigned int ret; unsigned int i, j, k; struct timespec requested_time, elapsed_time; requested_time.tv_sec = 0; requested_time.tv_nsec = 100 * 1000000; // 100ms tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA; printf("\nINFO: Starting %s example.\r\n", "ledgrid"); prussdrv_init (); // Initialize the PRU /* 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"); prussdrv_map_prumem( PRUSS0_SHARED_DATARAM, &sharedMem ); sharedMem_int = (unsigned int*) sharedMem; if( 1 == 0 ) { for( i=0 ; i < 3 ; i++ ) { //for( j=0 ; j < 3 ; j++ ) { for( j=1 ; j <= NUM_OF_PIXELS ; j++ ) { initPixelArr3( j, i % 3 ); updatePixelStrip(); nanosleep( &requested_time, &elapsed_time ); } } clearPixelArr(); updatePixelStrip(); } if( 1 == 1 ) { for( i=0 ; i < 30 ; i++ ) { initPixelArr_Mario1(); updatePixelStrip(); nanosleep( &requested_time, &elapsed_time ); initPixelArr_Mario2(); updatePixelStrip(); nanosleep( &requested_time, &elapsed_time ); initPixelArr_Mario3(); updatePixelStrip(); nanosleep( &requested_time, &elapsed_time ); } //sleep( 2 ); // seconds clearPixelArr(); updatePixelStrip(); } // cory: Confirm PRU operation by checking that it wrote a signature into the shared ram: if( (sharedMem_int[OFFSET_SHAREDRAM + 0] == 0xACEDACED) && (sharedMem_int[OFFSET_SHAREDRAM + 1] == 0xC001BABE) && (sharedMem_int[OFFSET_SHAREDRAM + 2] == 0xFACEFACE) ) { printf( "PRU wrote the signature correctly... Confirmed by c-code.\n" ); } else { printf( "PRU did NOT write the signature correctly...\n" ); printf( " sig1 = 0x%08x (expected=0x%08x)\n", sharedMem_int[OFFSET_SHAREDRAM + 0], 0xACEDACED ); printf( " sig2 = 0x%08x (expected=0x%08x)\n", sharedMem_int[OFFSET_SHAREDRAM + 1], 0xC001BABE ); printf( " sig3 = 0x%08x (expected=0x%08x)\n", sharedMem_int[OFFSET_SHAREDRAM + 2], 0xFACEFACE ); } /* Disable PRU and close memory mapping*/ prussdrv_pru_disable(PRU_NUM); prussdrv_exit (); return(0); }
int main(int argc, char **argv) { char buf[32]; char *bin_path, *ptr; struct pru_data pru; int fd; #ifndef DEBUG if (fork() != 0) { return 0; } #endif 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; } /* Create the FIFO if it does not exist */ umask(0); mknod(FIFO_FILE, S_IFIFO|0666, 0); fd = open(FIFO_FILE, O_RDONLY); if (fd < 0) { fprintf(stderr, "Cannot open FIFO.\n"); return -EINVAL; } pru.prumem[RUN_FLAG_IDX] = 1; /* startup */ bin_path = strdup(argv[0]); ptr = strrchr(bin_path, '/'); *ptr = '\0'; chdir(bin_path); prussdrv_exec_program(0, "pru0_nixie.bin"); blank_vfd(&pru); signal(SIGINT, shutdown_clock); signal(SIGTERM, shutdown_clock); while (running) { if (read(fd, buf, sizeof(buf) - 1) > 0) { update_buffer((const char *) &buf, &pru); trigger_update(&pru); } usleep(msecs(10)); } close(fd); pru.prumem[RUN_FLAG_IDX] = 0; trigger_update(&pru); #ifdef DEBUG fprintf(stdout, "Waiting for PRU core to shutdown..\n"); #endif prussdrv_pru_wait_event(PRU_EVTOUT_0); prussdrv_pru_clear_event(PRU0_ARM_INTERRUPT); prussdrv_pru_disable(0); prussdrv_exit(); if (bin_path) { free(bin_path); } return 0; }
static void mainloop(void) { int i; char c=0; char string[1024]; int mem,offset,length,data; unsigned short int rambuffer[12288]; unsigned char spidata[256]; prussdrv_map_prumem(PRUSS0_PRU0_DATARAM, &pru0Mem); pru0Mem_int = (unsigned short*) pru0Mem; prussdrv_map_prumem(PRUSS0_PRU1_DATARAM, &pru1Mem); pru1Mem_int = (unsigned short*) pru1Mem; prussdrv_map_prumem(PRUSS0_SHARED_DATARAM, &sharedMem); sharedMem_int = (unsigned short*) sharedMem; unsigned short* memories[] = {pru0Mem_int,pru1Mem_int,sharedMem_int}; while(1) { c=getchar(); switch(c) { //Say hello, test is the program is still alive case 'H': case 'h': printf("Hello Master\n"); break; //Write to memory case 'W': case 'w': printf("Memory?\n"); scanf("%d",&mem); printf("Offset?\n"); scanf("%d",&offset); printf("Length?\n"); scanf("%d",&length); printf("Data?\n"); for(i=offset;i<length+offset;i++) { scanf("%d",&data); memories[mem][i] = data; } printf("Write operation complete: %d words written to memory location %d:%X!\nSuccess!\n",length,mem,offset); break; //Read from memory case 'R': case 'r': printf("Memory?\n"); scanf("%d",&mem); printf("Offset?\n"); scanf("%d",&offset); printf("Length?\n"); scanf("%d",&length); for(i=offset;i<length+offset;i++) printf("%d\n",memories[mem][i]); printf("Read operation complete: %d words transferred from memory location %d:%X!\nSuccess!\n",length,mem,offset); break; //Periperal - control SPI DAC's and / or digital potentiometers case 'P': case 'p': printf("SPI?\n"); scanf("%d",&mem); printf("Length?\n"); scanf("%d",&length); if (length > 256) length=256; printf("Data?\n"); for(i=0;i<length;i++) { scanf("%d",&data); spidata[i]=data; } if (mem==0) { //daisy chain preparation unsigned char daisy[]={128,0,1}; //spi_transfer(spi0_fd, daisy, 3, 2); //data transfer spi_transfer(spi0_fd, spidata, length, 2); } else if (mem==1) { spi_transfer(spi1_fd, spidata, length, 0); } else { printf("SPI write failed: No device at given SPI number"); break; } printf("SPI write operation complete: %d words transferred from memory location %d:%X!\nSuccess!\n",length,mem,offset); break; //Terminate the program case 'T': case 't': //send('T'); return; default: break; } } return; }
int main(int argc, char **argv) { int opt; uint8_t bufferIndexPins; uint8_t sampleRateOption; pthread_t producer_thread, consumer_thread; /*pointer to shared RAM*/ void *p; struct sigaction signalaction; memset(&signalaction, 0, sizeof(signalaction)); signalaction.sa_sigaction = &sighandler; signalaction.sa_flags = SA_SIGINFO; if (sigaction(SIGTERM, &signalaction, NULL) < 0 || sigaction(SIGHUP, &signalaction, NULL) < 0 || sigaction(SIGINT, &signalaction, NULL) < 0) { fprintf(stderr, "%s\n", strerror(errno)); return (-1); } if (argc == 1) { help(argv[0]); return (-1); } sampleRateOption=0; if (buffer_init(&dataCapturedValues, BUFFER_LENGTH) == -1) { return (-3); } init_channels(); while ((opt = getopt(argc, argv, "p:s:f:")) != -1) { switch (opt) { case 'p': { bufferIndexPins = atoi(optarg); cfgPins[bufferIndexPins] = 1; break; } case 's': { sampleRateOption = atoi(optarg); break; } case 'f': { fd=open(optarg,O_WRONLY|O_CREAT,S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH); if(fd==-1) { fprintf(stderr,"%s\n",strerror(errno)); fd=STDOUT_FILENO; } break; } default: { help(argv[0]); buffer_destroy(&dataCapturedValues); return (-5); } } } calculate_sample_period(sampleRateOption); init_pru_program(); dbg("PRU program initialized...\n"); prussdrv_map_prumem(PRUSS0_SHARED_DATARAM, &p); shared_ram=(unsigned int *)p; dbg("PRU shared memory was mapped...\n"); shared_ram[0]=sample_delay; shared_ram[1]=sample_delay>>8; shared_ram[2]=sample_delay>>16; shared_ram[3]=sample_delay>>24; create_header(fd,sample_delay,cfgPins); /*Initialize mutex and condition variables*/ pthread_mutex_init(&shared_var_mutex, NULL); pthread_cond_init(&cond_consumer, NULL); pthread_cond_init(&cond_producer, NULL); dbg("Mutex and conditions were initialized..."); /*create threads*/ pthread_create(&consumer_thread, NULL, consumer, NULL); pthread_create(&producer_thread, NULL, producer, NULL); pthread_join(consumer_thread, NULL); pthread_join(producer_thread, NULL); /*Cleanup threads*/ pthread_mutex_destroy(&shared_var_mutex); pthread_cond_destroy(&cond_consumer); pthread_cond_destroy(&cond_producer); close(fd); prussdrv_pru_disable(PRU_NUM); prussdrv_exit(); close(fd); buffer_destroy(&dataCapturedValues); return 0; }
int main() { unsigned int ret; tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA; printf("\n--Test of ring buffer functionality--\n"); printf("Initializing PRU..."); prussdrv_init(); printf("\t\t\t\tDone\n"); ret = prussdrv_open(PRU_EVTOUT_0); printf("Checking prussdrv_open()..."); if (ret) { printf("prussdrv_open failed!\n"); printf("Aborting application!\n"); return (ret); } printf("\t\t\tDone\n"); printf("Initializing INTC..."); prussdrv_pruintc_init(&pruss_intc_initdata); printf("\t\t\t\tDone\n"); //map PRU shared RAM to userspace printf("Mapping PRU memory to userspace..."); prussdrv_map_prumem(PRUSS0_SHAREDRAM, &sharedMem); printf("\t\t\tDone\n"); //create and initialize ring buffer printf("Initializing ring buffer in PRU shared memory..."); sharedMem_rbint = (unsigned int *) sharedMem; rbInit(sharedMem_rbint, DEF_RB_SIZE); printf("\t\t\t\tDone\n"); //printf("Loading test program...\n"); //prussdrv_exec_program(PRU_NUM, "./boneclamp.bin"); prussdrv_exec_program(PRU_NUM, "./test.bin"); /* read stuff from ring buffer */ /* data *currentDatapoint = calloc(1, sizeof(data)); while(1) { if (!rbIsEmpty(buffer)) { rbRead(buffer, currentDatapoint); printf("Channel: %i Value: %i", currentDatapoint->channelNumber, currentDatapoint->datap); if (currentDatapoint->datap == 20) { break; } } else printf("Buffer currently empty"); } */ //free(currentDatapoint); //rbFree(sharedMem_rb); //wait until PRU program is completed printf("Test complete. Do the results make sense?\n"); prussdrv_pru_wait_event(PRU_EVTOUT_0); prussdrv_pru_clear_event(PRU_EVTOUT_0); //shut down the pru printf("Shutting down the PRU..."); prussdrv_pru_disable(PRU_NUM); prussdrv_exit(); //close(mem_fd); printf("\t\t\t\tDone\n"); return 0; }
int main(int argc, char **argv) { char buf[32]; struct pru_data pru; int fd, rdsize; #ifndef DEBUG if (fork() != 0) { return 0; } #endif tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA; printf("Initializing pruss\n"); prussdrv_init(); if (prussdrv_open(PRU_EVTOUT_0)) { fprintf(stderr, "Cannot setup PRU_EVTOUT_0.\n"); return -EINVAL; } printf("Initializing interrupts\n"); prussdrv_pruintc_init(&pruss_intc_initdata); printf("Mapping PRUSS0 RAM\n"); prussdrv_map_prumem(PRUSS0_PRU0_DATARAM, (void *) &pru.prumem); if (pru.prumem == NULL) { fprintf(stderr, "Cannot map PRU0 memory buffer.\n"); return -ENOMEM; } printf("Creating FIFO\n"); /* Create the FIFO if it does not exist */ umask(0); mknod(FIFO_FILE, S_IFIFO|0666, 0); printf("Opening FIFO\n"); fd = open(FIFO_FILE, O_RDONLY); if (fd < 0) { fprintf(stderr, "Cannot open FIFO.\n"); return -EINVAL; } pru.prumem[RUN_FLAG_IDX] = 1; /* startup */ printf("Loading PRU0 program\n"); prussdrv_exec_program(0, "7seg_spi_test_fifo.bin"); signal(SIGINT, shutdown_clock); signal(SIGTERM, shutdown_clock); printf("Entering runloop\n"); while (running) { if ((rdsize = read(fd, buf, sizeof(buf) - 1)) > 0) { update_buffer((const char *) &buf, &pru, rdsize); } usleep(msecs(10)); } close(fd); pru.prumem[RUN_FLAG_IDX] = 0; #ifdef DEBUG fprintf(stdout, "Waiting for PRU core to shutdown..\n"); #endif prussdrv_pru_wait_event(PRU_EVTOUT_0); prussdrv_pru_clear_event(PRU0_ARM_INTERRUPT); prussdrv_pru_disable(0); prussdrv_exit(); return 0; }
static void *Speed_Thread(void *arg) { struct TimerInfo info; //return NULL; // Initialise the PRU //printf("Initialising PRU\n"); if (prussdrv_init() != 0) { snprintf(DisplayMessage, DISPLAY_MAX_MSG_SIZE, "prussdrv_init failed"); return NULL; } // Open an event if (prussdrv_open(PRU_EVTOUT_0)) { //printf("prussdrv_open failed\n"); snprintf(DisplayMessage, DISPLAY_MAX_MSG_SIZE, "prussdrv_open failed"); return NULL; } // Get pointers to PRU0 local memory void *pruDataMem; prussdrv_map_prumem (PRUSS0_PRU0_DATARAM, &pruDataMem); unsigned int *pruData = (unsigned int *) pruDataMem; // Execute code on PRU //printf("Executing speed pru code\n"); if (prussdrv_exec_program (0, "../pru/BeagleTrainer.bin") < 0) { //printf("prussdrv_exec_program failed\n"); snprintf(DisplayMessage, DISPLAY_MAX_MSG_SIZE, "prussdrv_exec_program failed"); return NULL; } // Start the periodic timer @ 125ms TimerStart (125000, &info); // Run until terminated from main thread while (runSpeedThread) { // Wait for periodic timer to expire TimerWait (&info); // Broadcast data ////printf("Speed Thread: timer expired...\n"); uint32_t events = pruData[0]; uint32_t frequency = events * PRU_UPDATE_FREQ; double rps = (double)frequency / PULSE_PER_REV; //double rpm = rps * 60.0; double mps = rps * 2.0 * M_PI * RADIUS / 1000.0; double kph = mps * 3.6; currentSpeed = kph; currentFrequency = events; // Print out the value received from the PRU code ////printf("%u events, %.0f RPM, %.2f km/h\r\n", events, rpm, kph); //snprintf(DisplayMessage, DISPLAY_MAX_MSG_SIZE, "%u events, %.0f RPM, %.2f km/h", events, rpm, kph); } // cleanup //printf("Speed Thread: cleanup\n"); prussdrv_pru_disable(0); prussdrv_exit(); return NULL; }