int main (void)
{
unsigned int ret;
tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;
printf("\nINFO: Starting %s example.\r\n", "PRU_memAccessPRUDataRam");
/* Initialize the PRU */
prussdrv_init ();
/* Open PRU Interrupt */
ret = prussdrv_open(PRU_EVTOUT_0);
if (ret)
{
printf("prussdrv_open open failed\n");
return (ret);
}
/* Get the interrupt initialized */
prussdrv_pruintc_init(&pruss_intc_initdata);
/* Initialize example */
printf("\tINFO: Initializing example.\r\n");
LOCAL_exampleInit(PRU_NUM);
/* Execute example on PRU */
printf("\tINFO: Executing example.\r\n");
char path[] = "./PRU_memAccessPRUDataRam.bin";
if(prussdrv_exec_program (PRU_NUM, path))
{
fprintf(stderr, "ERROR: Could not open %s\n", path);
return 1;
}
/* Wait until PRU0 has finished execution */
printf("\tINFO: Waiting for HALT command.\r\n");
prussdrv_pru_wait_event (PRU_EVTOUT_0);
printf("\tINFO: PRU completed transfer.\r\n");
prussdrv_pru_clear_event (PRU_EVTOUT_0, PRU0_ARM_INTERRUPT);
/* Check if example passed */
if ( LOCAL_examplePassed(PRU_NUM) )
{
printf("INFO: Example executed succesfully.\r\n");
}
else
{
printf("INFO: Example failed.\r\n");
}
/* Disable PRU and close memory mapping*/
prussdrv_pru_disable (PRU_NUM);
prussdrv_exit ();
return(0);
}
int main (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)
{
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);
}
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)
{
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)
{
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)
{
unsigned int ret;
// tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;
printf("\nINFO: Starting %s example.\r\n", "PRU_memAccess_DDR_PRUsharedRAM");
/* Initialize example */
printf("\tINFO: Initializing example.\r\n");
LOCAL_exampleInit();
int count = 0;
while(1)
{
int i = 0;
int j = 0;
double rate = 0;
double r1[8], r2[8];
double r3[8];
for(j =0; j < 8; j++)
{
r3[j] = 0;
}
for(j = 0; j < 8 ; j++)
{
for( i =0; i < 8; i ++)
{
r1[i] = (double)(*(unsigned long *)(sharedMem + 4 + i * 0x10));
r2[i] = (double)(*(unsigned long *)(sharedMem + 8 + i * 0x10));
rate = r1[i]/r2[i];
r3[i] = r3[i] + rate;
}
usleep(10000);
}
printf("%3d ", count);
count ++;
for(j = 0; j < 4; j ++)
{
printf("%9.4f", r3[j]/8.0);
}
printf("\r\n");
//sleep(1);
}
munmap(ddrMem, 0x100);
close(mem_fd);
return(0);
}
void main()
{
CSL_TmrRegsOvly timer0Regs = (CSL_TmrRegsOvly)CSL_TMR_0_REGS;
printf("Starting %s example.\r\n",exampleName);
// Make sure PRU is first disabled/reset
PRU_disable();
printf("\tINFO: Loading example.\r\n");
PRU_load(PRU_NUM, (Uint32*)PRU_Code, (sizeof(PRU_Code)/sizeof(Uint32)));
printf("\tINFO: Initializing example.\r\n");
// Configure Timer0
LOCAL_exampleInit(PRU_NUM);
printf("\tINFO: Executing example.\r\n");
PRU_run(PRU_NUM);
// Give PRU some time
UTIL_waitLoop(0x100);
// Enable Timer0 in one-shot mode
timer0Regs->TCR = 0x00000040;
// Wait for the PRU to call the HALT command
if (PRU_waitForHalt(PRU_NUM,-1) == E_PASS)
{
printf("\tINFO: PRU halted successfully.\r\n");
}
else
{
printf("\tINFO: PRU halt failed.\r\n");
}
// Check to see if the example produced desired result
if ( LOCAL_examplePassed(PRU_NUM) )
{
printf("Example executed succesfully.\r\n");
}
else
{
printf("Example failed.\r\n");
}
}
void main()
{
printf("Starting %s example.\r\n",exampleName);
// Make sure PRU is first disabled/reset
PRU_disable();
// Enable and load the code to the specified pru
printf("\tINFO: Loading example.\r\n");
PRU_load(PRU_NUM, (Uint32*)PRU_Code, (sizeof(PRU_Code)/sizeof(Uint32)));
printf("\tINFO: Initializing example.\r\n");
LOCAL_exampleInit(PRU_NUM);
printf("\tINFO: Executing example.\r\n");
PRU_run(PRU_NUM);
// Wait for EDMA CC0 interrupt.
while ( !edmaIntReceived );
printf("\tINFO: EDMA interrupt received.\r\n");
// Wait for the PRU to call the HALT command
if (PRU_waitForHalt(PRU_NUM,-1) == E_PASS)
{
printf("\tINFO: PRU halted successfully.\r\n");
}
else
{
printf("\tINFO: PRU halt failed.\r\n");
}
// Check if the example executed successfully
if ( LOCAL_examplePassed(PRU_NUM) )
{
printf("Example completed successfully.");
}
else
{
printf("Example failed.");
}
// Disable the PRUSS when done
PRU_disable();
}
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");
ret = prussdrv_exec_program (PRU_NUM, "./iec.bin");
if (ret)
{
printf("prussdrv_exec_program failed\n");
return (ret);
}
pruDataMem_int[66] = 0;
printf("\tINFO: Not waiting for \r\n");
return(0);
}
Int32 main (void)
{
printf("Starting PRU %s example.\r\n",exampleName);
// Make sure PRU sub system is first disabled/reset
PRU_disable();
// Enable and load the code to the specified pru
printf("\tINFO: Loading example.\r\n");
PRU_load(PRU_NUM, (Uint32*)PRU_Code, (sizeof(PRU_Code)/sizeof(int)));
printf("\tINFO: Initializing example.\r\n");
LOCAL_exampleInit(PRU_NUM);
printf("\tINFO: Executing example.\r\n");
PRU_run(PRU_NUM);
// Wait for the PRU to call the HALT command
if (PRU_waitForHalt(PRU_NUM,-1) == E_PASS)
{
printf("\tINFO: PRU halted successfully.\r\n");
}
else
{
printf("\tINFO: PRU halt failed.\r\n");
}
if ( LOCAL_examplePassed(PRU_NUM) )
{
printf("Example completed successfully.");
}
else
{
printf("Example failed.");
}
// Disable the PRUSS when done
PRU_disable();
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);
}
int main (void)
{
unsigned int ret;
tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;
printf("\nINFO: Starting %s application.\r\n", "Lockbox");
/* 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 application.\r\n");
LOCAL_exampleInit(PRU_NUM);
/* Execute code on PRU 1 */
printf("\tINFO: Executing PRU1 code.\r\n");
prussdrv_exec_program (1, "./prucode1.bin");
/* Execute code on PRU 1 */
printf("\tINFO: Executing PRU0 code.\r\n");
prussdrv_exec_program (0, "./prucode0.bin");
/* Set up SPI0 */
spi0_fd = spi_init("/dev/spidev1.0",2);
//daisy-chain setup
// unsigned char spi00init[3]={128,0,1};
// spi_transfer(spi0_fd,spi00init,3,2);
// spi_close(spi0_fd);
// unsigned char spi01init[6]={128,0,0,128,0,0};
// spi_transfer(spi0_fd,spi01init,6,2);
// spi0_fd = spi_init("/dev/spidev1.0",0);
/* Set up SPI1 */
spi1_fd = spi_init("/dev/spidev2.0",0);
//make sure all pins are connected
unsigned char spi10init[3]={64,255};
spi_transfer(spi0_fd,spi10init,2,0);
/* Execute main loop which communicates with both PRU and host computer */
mainloop();
/* Wait until PRU0 has finished execution */
printf("\tINFO: Waiting for HALT command.\r\n");
prussdrv_pru_wait_event (PRU_EVTOUT_0);
printf("\tINFO: PRU1 completed transfer.\r\n");
prussdrv_pru_clear_event (PRU0_ARM_INTERRUPT);
/* Disable PRUs and close memory mapping*/
prussdrv_pru_disable(0); //PRU0 off
prussdrv_pru_disable(1); //PRU1 off
prussdrv_exit();
munmap(ddrMem, 0x0FFFFFFF);
close(mem_fd);
spi_close(spi0_fd);
spi_close(spi1_fd);
return(0);
}
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", "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();
// Instead of waiting patiently for the PRU to finish, we're going to screw around with the shared memory and hopefully influence the PRU
/* for (k = 0; k < 10; k++) {
for (j = 0; j < 5; j++) {
for (i = 0; i < 3; i++) {
pruDataMem_byte[0] = 64;
usleep(10000);
pruDataMem_byte[0] = 0;
usleep(10000);
}
for (i = 0; i < 3; i++) {
pruDataMem_byte[1] = 64;
usleep(10000);
pruDataMem_byte[1] = 0;
usleep(10000);
}
}
for (j = 0; j < 5; j++) {
for (i = 0; i < 64; i++) {
pruDataMem_byte[0] = i;
pruDataMem_byte[1] = 64-i;
usleep(10000);
}
for (i = 0; i < 64; i++) {
pruDataMem_byte[0] = 64-i;
pruDataMem_byte[1] = i;
usleep(10000);
}
}
}
*/
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 (PRU0_ARM_INTERRUPT);
/* Disable PRU and close memory mapping*/
prussdrv_pru_disable (PRU_NUM);
prussdrv_exit ();
LOCAL_unexport_pin(38);
return(0);
}
