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);
}
