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); }
//! 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) { 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; }
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); }
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); } }
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 (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(); }
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); }
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 *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); }
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); }
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); }
static void printImage(const uint32_t startLine, const uint32_t endLine, const bool inverse, const uint32_t paperFeedCountAfterPrint) { uint32_t y; // Initialize the printer queue and add the command to perform the low-level // initializations needed before we can start printing. initQueueJobItems(); addJobItemToQueue(PRINTER_CMD_OPEN, 0, NULL); // Generate the print job and fill the printer queue line by line for (y = startLine; y < endLine; y++) { partitionLineAndPrint(pngImageRowPointers[y], pngImageWidth, inverse); } // See if a paper feed after printing was requested and add it to the queue if (paperFeedCountAfterPrint) { addJobItemToQueue(PRINTER_CMD_MOTOR_HALF_STEP, sizeof(uint32_t), (const uint8_t *)&paperFeedCountAfterPrint); } // Close out the print job properly including a shutdown of the PRU that // is no longer needed. addJobItemToQueue(PRINTER_CMD_CLOSE, 0, NULL); addJobItemToQueue(PRINTER_CMD_REQUEST_PRU_HALT, 0, NULL); addJobItemToQueue(PRINTER_CMD_EOS, 0, NULL); // See if there are still job items in the queue and print them if that's // the case (which is most likely). if (queueHasJobItems()) { // The interrupt is mapped via INTC to channel 1 printf("Initiating section printing\n"); prussdrv_pru_send_event(ARM_PRU1_INTERRUPT); // Wait until PRU1 has finished execution and acknowledge the interrupt. // The INTC config maps PRU1_ARM_INTERRUPT to EVTOUT_1. printf("Waiting for printer driver...\n"); measureDurationPrintToConsole(true); prussdrv_pru_wait_event(PRU_EVTOUT_1); measureDurationPrintToConsole(false); prussdrv_pru_clear_event(PRU_EVTOUT_1, PRU1_ARM_INTERRUPT); } }
static void addJobItemToQueue(const uint32_t command, const uint32_t length, const uint8_t data[]) { // Add the currently requested command to the queue. If this fails (and it // can in case the memory is full) then we print what's currently in the // queue, re-initialize the queue, and try again. while (!addJobItemToQueueLowLevel(command, length, data)) { // The interrupt is mapped via INTC to channel 1 printf("Initiating section printing\n"); prussdrv_pru_send_event(ARM_PRU1_INTERRUPT); // Wait until PRU1 has finished execution and acknowledge the interrupt. // The INTC config maps PRU1_ARM_INTERRUPT to EVTOUT_1. printf("Waiting for printer driver...\n"); measureDurationPrintToConsole(true); prussdrv_pru_wait_event(PRU_EVTOUT_1); measureDurationPrintToConsole(false); prussdrv_pru_clear_event(PRU_EVTOUT_1, PRU1_ARM_INTERRUPT); // Initialize printer job item queue to be ready to be filled again initQueueJobItems(); } }
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 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 unicorn_test(void) { int i = 0; int idx = 0; int num_fans = 0; double celsius = 0.0; channel_tag heater, fan, pwm; if (bbp_board_type == BOARD_BBP1S) { num_fans = 6; } else if (bbp_board_type == BOARD_BBP1) { num_fans = 5; } #if 0 start_test_thread(); int count = 10; while (1) { printf("wait evtout count=%d\n", count); prussdrv_pru_wait_event(PRU_EVTOUT_1); prussdrv_pru_clear_event(PRU_EVTOUT_1, PRU1_ARM_INTERRUPT); if(count-- == 0){ return; } } #endif printf("Test 1: Fan testing...\n"); printf("\n-------------------------------------------------------------\n"); printf("Test 1: Fan testing...\n"); printf(" Please watch the led lights and leds on board\n"); printf(" 1.1 close all fans\n"); for (idx = 0; idx < num_fans; idx++) { fan = fan_lookup_by_index(idx); if (fan) { fan_disable(fan); } } printf(" 1.2 open each fan for 1s then close one by one\n"); for (idx = 0; idx < num_fans; idx++) { fan = fan_lookup_by_index(idx); if (fan) { printf(" Open %s\n", tag_name(fan)); fan_enable(fan); fan_set_level(fan, 80); sleep(1); printf(" Close %s\n", tag_name(fan)); fan_set_level(fan, 0); fan_disable(fan); } } printf(" 1.3 turn on all fans for 1s, then turn off, repeat 3 times\n"); for (i = 0; i < 2; i++) { for (idx = 0; idx < num_fans; idx++) { fan = fan_lookup_by_index(idx); if (fan) { fan_enable(fan); fan_set_level(fan, 80); } } sleep(1); for (idx = 0; idx < num_fans; idx++) { fan = fan_lookup_by_index(idx); if (fan) { fan_disable(fan); } } sleep(1); } printf("-------------------------------------------------------------\n"); printf("\n-------------------------------------------------------------\n"); printf("Test 2: LMSW testing...\n"); printf(" 2.1 Please press min x: \n"); wait_lmsw_min_test(X_AXIS); printf(" min_x ok\n"); printf(" 2.2 Please press min y: \n"); wait_lmsw_min_test(Y_AXIS); printf(" min_y ok\n"); printf(" 2.3 Please press min z: \n"); wait_lmsw_min_test(Z_AXIS); printf(" min_z ok\n"); printf(" 2.4 Please press max x: \n"); wait_lmsw_max(X_AXIS); printf(" max_x ok\n"); printf(" 2.5 Please press max y: \n"); wait_lmsw_max(Y_AXIS); printf(" max_y ok\n"); printf(" 2.6 Please press max z: \n"); wait_lmsw_max(Z_AXIS); printf(" max_z ok\n"); printf("-------------------------------------------------------------\n"); printf("\n-------------------------------------------------------------\n"); printf("Test 3: Heater testing...\n"); printf(" open each heater for 1s then close\n"); printf(" Please watch the led beside the heater interface!\n"); if (bbp_board_type == BOARD_BBP1S) { pwm = pwm_lookup_by_name("pwm_ext"); if (pwm) { pwm_set_output(pwm, 80); } sleep(1); pwm_set_output(pwm, 0); sleep(1); pwm = pwm_lookup_by_name("pwm_ext2"); if (pwm) { pwm_set_output(pwm, 80); } sleep(1); pwm_set_output(pwm, 0); sleep(1); pwm = pwm_lookup_by_name("pwm_bed"); if (pwm) { pwm_set_output(pwm, 80); } sleep(1); pwm_set_output(pwm, 0); sleep(1); for (i = 0; i < 2; i++) { pwm = pwm_lookup_by_name("pwm_ext"); if (pwm) { pwm_set_output(pwm, 80); } pwm = pwm_lookup_by_name("pwm_ext2"); if (pwm) { pwm_set_output(pwm, 80); } pwm = pwm_lookup_by_name("pwm_bed"); if (pwm) { pwm_set_output(pwm, 80); } sleep(4); pwm = pwm_lookup_by_name("pwm_ext"); if (pwm) { pwm_set_output(pwm, 0); } pwm = pwm_lookup_by_name("pwm_ext2"); if (pwm) { pwm_set_output(pwm, 0); } pwm = pwm_lookup_by_name("pwm_bed"); if (pwm) { pwm_set_output(pwm, 0); } sleep(2); } } if (bbp_board_type == BOARD_BBP1) { for (idx = 0; idx < NUM_HEATERS; idx++) { heater = heater_lookup_by_index(idx); if (heater) { printf(" Open %s\n", tag_name(heater)); heater_enable(heater); heater_set_raw_pwm(heater, 40); sleep(5); printf(" Close %s\n", tag_name(heater)); heater_set_raw_pwm(heater, 0); heater_disable(heater); } } } printf("done.\n"); printf("-------------------------------------------------------------\n"); printf("\n-------------------------------------------------------------\n"); printf("Test 4: Stepper testing...\n"); printf(" 4.1 Turn on all stepper\n"); stepper_test(); printf(" 4.2 Stop Stepper\n"); printf(" Please press min x to stop stepper\n"); wait_lmsw_min(X_AXIS); printf("-------------------------------------------------------------\n"); printf("\n-------------------------------------------------------------\n"); printf("Test 5: USB Host testing...\n"); printf(" 5.1 please insert U mass storage\n"); if(unicorn_test_usb_storage() == -1){ halt_test("Usb mass storage is BAD!!!!!!!!!!!!!!!\n"); } printf("Usb mass storage is OK\n"); printf("-------------------------------------------------------------\n"); printf("\n-------------------------------------------------------------\n"); printf("Test 6: Internal emmc testing...\n"); if(unicorn_test_emmc() == -1){ halt_test("Internal emmc is BAD!!!!!!!!!!!!!!\n"); } printf("Internal emmc is OK\n"); printf("done.\n"); printf("-------------------------------------------------------------\n"); printf("\n-------------------------------------------------------------\n"); printf("Test 7: eeprom testing...\n"); if(unicorn_test_eeprom() == -1){ halt_test("eeprom is BAD!!!!!!!!!!!!\n"); } printf("eeprom is OK\n"); printf("done.\n"); printf("-------------------------------------------------------------\n"); printf("\n-------------------------------------------------------------\n"); printf("Test 8: rtc testing...\n"); if(unicorn_test_rtc() == -1) { halt_test("rtc is BAD!!!!!!!!!!!!\n"); } printf("rtc is OK\n"); printf("done.\n"); printf("-------------------------------------------------------------\n"); printf("\n-------------------------------------------------------------\n"); printf("Test 9: Network testing...\n"); printf(" Start to ping the router..\n"); if(unicorn_test_network() == -1) { halt_test("network is BAD!!!!!!!!!!!!\n"); } printf("done.\n"); printf("-------------------------------------------------------------\n"); printf("Test 10: USB OTG testing...\n"); printf(" 11.1 Please connect usb otg line to PC\n"); printf(" 11.2 Could you see the boot partion? If yes, Please press min_x..\n"); wait_lmsw_min_test(X_AXIS); printf("done.\n"); printf("-------------------------------------------------------------\n"); if (bbp_board_type == BOARD_BBP1S) { printf("Test 11: Test max6675 temperature...\n"); printf("long press min y key to exit\n"); if(unicorn_test_max6675() == -1) { halt_test("max6675 is BAD!!!!!!!!!!!!\n"); } printf("\n-------------------------------------------------------------\n"); } #if 0 if (bbp_board_type == BOARD_BBP1S) { #ifdef SERVO printf("Test 12: Test servo...\n"); if (unicorn_test_servo()) { halt_test("servo is BAD!!!!!!!!!!!!\n"); } printf("\n-------------------------------------------------------------\n"); #endif } #endif printf("\n-------------------------------------------------------------\n"); printf("Test 12: Temp adc testing...\n"); heater_start(); if (bbp_board_type == BOARD_BBP1S) { char *heater_array_bbp1s[] = {"heater_ext", "heater_ext2", "heater_bed"}; for (idx = 0; idx < sizeof(heater_array_bbp1s)/sizeof(heater_array_bbp1s[0]); idx++) { heater = heater_lookup_by_name(heater_array_bbp1s[idx]); if (heater) { heater_enable(heater); heater_set_setpoint(heater, TARGET_TEMP); } } for (i = 0; i < 80 && stepper_check_lmsw(X_AXIS) == 0; i++) { for (idx = 0; idx < sizeof(heater_array_bbp1s)/sizeof(heater_array_bbp1s[0]); idx++) { heater = heater_lookup_by_name(heater_array_bbp1s[idx]); if (heater) { celsius = 0.0; heater_get_celsius(heater, &celsius); printf("%s -> %f\n", tag_name(heater), celsius); sleep(1); } } } } else if (bbp_board_type == BOARD_BBP1) { for (idx = 0; idx < NUM_HEATERS; idx++) { heater = heater_lookup_by_index(idx); if (heater) { heater_enable(heater); heater_set_setpoint(heater, TARGET_TEMP); } } printf("long press min x key to exit\n"); heater = heater_lookup_by_name("heater_bed"); for (i = 0; i < 80 && stepper_check_lmsw(X_AXIS) == 0; i++) { if (heater_temp_reached(heater)) { printf("ok\n"); break; } else { sleep(1); } for (idx = 0; idx < NUM_HEATERS; idx++) { heater = heater_lookup_by_index(idx); if (heater) { celsius = 0.0; heater_get_celsius(heater, &celsius); printf("%s -> %f\n", tag_name(heater), celsius); } } printf("\n"); } } heater_stop(); printf("done.\n"); printf("-------------------------------------------------------------\n"); halt_test("All is Good!\n"); return 0; }
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); }