コード例 #1
0
ファイル: pru.c プロジェクト: lchamon/protoarray
int pru_setup()
{
  /* Initialize the PRU and prussdrv module (always returns 0) */
  prussdrv_init();

  /* Open interrupt(s): you should open at least PRU_EVTOUT_0 */
  if (prussdrv_open(PRU_EVTOUT_0) != 0) {
    fprintf(stderr, "There was an error while opening PRU_EVTOUT_0.\n");
    fprintf(stderr, "Did you load the PRU DTO?\n");
    return(-1);
  }

  if (prussdrv_open(PRU_EVTOUT_1) != 0) {
    fprintf(stderr, "There was an error while opening PRU_EVTOUT_1.\n");
    fprintf(stderr, "Did you load the PRU DTO?\n");
    return(-1);
  }

  /* Initialize struct with INTC interrupt map (see PRU ref. guide, Fig. 97) */
  tpruss_intc_initdata pru_intc_data = PRUSS_INTC_INITDATA;

  /* Initialize INTC */
  if (prussdrv_pruintc_init(&pru_intc_data) != 0) {
    return(-1);
    fprintf(stderr, "An error occurred while initializing INTC.");
  }

  return(0);
}
コード例 #2
0
void initialize_pru(){
	unsigned int ret;
	tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;

	prussdrv_init ();
	/* Open PRU Interrupt */
	if (PRU_NUM == 0){
		ret = prussdrv_open(PRU_EVTOUT_0);
	}
	if (PRU_NUM == 1){
		ret = prussdrv_open(PRU_EVTOUT_1);
	}
	if (ret)
	{
		printf("prussdrv_open open failed\n");
		exit(ret);
	}

	/* Get the interrupt initialized */
	prussdrv_pruintc_init(&pruss_intc_initdata);

	//Initialize pointer to PRU data memory
	if (PRU_NUM == 0)
	{
		prussdrv_map_prumem (PRUSS0_PRU0_DATARAM, &pruDataMem);
	}
	else if (PRU_NUM == 1)
	{
		prussdrv_map_prumem (PRUSS0_PRU1_DATARAM, &pruDataMem);
	}
	pruDataMem_int = (volatile signed int*) pruDataMem;

	//initialize external ram:
	//
	int mem_fd = open("/dev/mem", O_RDWR);
	if (mem_fd < 0){
		printf("couldn't open /dev/mem\n");
		exit(-1);
	}

	pru1_ddr= (uint8_t*)mmap(0, PRU_DDR_SIZE, PROT_WRITE | PROT_READ, MAP_SHARED, mem_fd, PRU1_DDR);
	if (pru1_ddr == NULL){
		printf("couldn't map pru1 ddr\n");
		exit(-1);
	}



	pruDataMem_int[0] = 1;
	pruDataMem_int[1] = 0;
	pruDataMem_int[2] = PRU1_DDR;
	pruDataMem_int[3] = PRU1_DDR+320*240*2;
	pruDataMem_int[4] = PRU1_DDR+320*240*4;
	pruDataMem_int[5] = PRU1_DDR+320*240*6;
	pruDataMem_int[6] = PRU1_DDR+320*240*8;
	printf("WE DIDN'T ALL DIE!\n");
	fflush(stdout);

}
コード例 #3
0
int PRUloader::setup_pruss(void) {
	/* Allocate and initialize memory */
	if (prussdrv_init()){
		perror("prussdrv_init failed");
		return -1;
	}
	if (prussdrv_open(PRU_EVTOUT_0)){
		perror("prussdrv_open evt0 failed");
		return -1;
	}
    if (prussdrv_open(PRU_EVTOUT_1)){
        printf("prussdrv_open evt1 failed\n");
        return -1;
    }
	if (prussdrv_pruintc_init(&pruss_intc_initdata)){
		perror("prussdrv_pruintc_init failed");
		return -1;
	}

    /* Start IRQ thread for event handling */
    pthread_attr_t pthread_attr;
    struct sched_param sched_param;
    pthread_attr_init(&pthread_attr);
    int evt_priority = sched_get_priority_max(SCHED_FIFO) - 2;
    pthread_attr_setinheritsched(&pthread_attr, PTHREAD_EXPLICIT_SCHED);
    pthread_attr_setschedpolicy(&pthread_attr, SCHED_FIFO);
    sched_param.sched_priority = evt_priority;
    pthread_attr_setschedparam(&pthread_attr, &sched_param);
    quit_rx_thread = false;
    if(pthread_create(&irq_thread_evt0, &pthread_attr, &pruevtout0_thread, this) != 0){
    	printf("ERR >> Event thread not created\r\n");
    	return -1;
    }
    pthread_attr_destroy(&pthread_attr);

	// map pruss memory
	prussdrv_map_extmem(&ddrMemOrigin);
	// get max size
	ddr_mem_size = prussdrv_extmem_size();
	printf("PRU_DEBUG >> DDR size is 0x%0x bytes\r\nPRU_DEBUG >> DDR virtual address is 0x%0x\r\n", (uint32_t)ddr_mem_size, (uint32_t)ddrMemOrigin);
	// Get physical address
	phy_add = prussdrv_get_phys_addr(ddrMemOrigin);
	printf("PRU_DEBUG >> Start of physical address allocated is 0x%X\r\n",	phy_add);

	memset((char *)ddrMemOrigin, 0, ddr_mem_size);

	return 1;
}
コード例 #4
0
ファイル: follow.c プロジェクト: dresco/pru_examples
int main (void)
{
    // Initialize the PRU
    printf("Initializing PRU\n");
    prussdrv_init ();
    
    // Open an event
    if (prussdrv_open(PRU_EVTOUT_0))
    {
        printf("prussdrv_open open failed\n");
        return -1;
    }
    
    // Execute code on PRU
    printf("Executing follow pru code\n");
    prussdrv_exec_program (0, "follow.bin");

    // Wait for Ctrl-C
    signal(SIGINT, on_sigint);
    while (is_sigint == 0)
    {
    }
    
    // Disable PRU and close memory mapping
    prussdrv_pru_disable (0);
    prussdrv_exit ();
    
    return(0);
}
コード例 #5
0
ファイル: main.c プロジェクト: BestFriendofDoug/pru_sdk
int main(int ac, char** av)
{
  tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;
  uint32_t x[2];

  prussdrv_init();

  if (prussdrv_open(PRU_EVTOUT_0))
  {
    printf("prussdrv_open open failed\n");
    return -1;
  }

  prussdrv_pruintc_init(&pruss_intc_initdata);

  /* execute code on pru0 */
#define PRU_NUM 0
  prussdrv_exec_program(PRU_NUM, "./iep.bin");

  signal(SIGINT, on_sigint);
  while (is_sigint == 0)
  {
    usleep(500000);
    read_words(x);
    printf("0x%08x, 0x%08x\n", x[0], x[1]);
  }

  /* disable pru and close memory mapping */
  prussdrv_pru_disable(PRU_NUM);
  prussdrv_exit();

  return 0;
}
コード例 #6
0
ファイル: int.c プロジェクト: bkovitz/pru
int main(void) {

  prussdrv_init();
  prussdrv_open(PRU_EVTOUT_0);
  prussdrv_pru_reset(PRU0);

  enable_pru_interrupts();
  
  prussdrv_map_prumem(PRUSS0_PRU0_DATARAM, (void**)&pru0_data_ram);
  *pru0_data_ram = 99;
  prussdrv_pru_write_memory(
    PRUSS0_PRU0_IRAM, 0, (unsigned int*)intp_bin, intp_bin_len
  );

// Contra the ARM PRU Linux API documentation, this function does not exist!
//  prussdrv_start_irqthread(
//    PRU_EVTOUT_0, sched_get_priority_max(SCHED_FIFO) - 2, pruevtout0_thread
//  );

  pthread_t irqthread;
  int iret = pthread_create(&irqthread, NULL, pruevtout0_thread, NULL);
  printf("iret = %d\n", iret);
  sleep(1);

  printf("starting PRU...\n");
  prussdrv_pru_enable(PRU0);

  sleep(3);
  printf("after sleep\n");
  printf("count = %d\n", *pru0_data_ram);
  prussdrv_pru_disable(PRU0);
  printf("PRU disabled\n");
  printf("count = %d\n", *pru0_data_ram);
}
コード例 #7
0
ファイル: pruss_add.c プロジェクト: DTJF/libpruio
//! 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;
}
コード例 #8
0
ファイル: flashLED.c プロジェクト: 19Dan01/exploringBB
/*** 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;
   }

   /* 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;
}
コード例 #9
0
ファイル: counter.c プロジェクト: aumgn/pru-bbb-alarm
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);

}
コード例 #10
0
ファイル: pwm.c プロジェクト: PHV1/1314-BeagleBone-Quadcopter
void initialize_pru(){
    unsigned int ret;
    tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;

    prussdrv_init ();
    /* Open PRU Interrupt */
    ret = prussdrv_open(PRU_EVTOUT_0);
    if (ret)
    {
        printf("prussdrv_open open failed\n");
        exit(ret);
    }
    
    /* Get the interrupt initialized */
    prussdrv_pruintc_init(&pruss_intc_initdata);

    //Initialize pointer to PRU data memory
    if (PRU_NUM == 0)
    {
      prussdrv_map_prumem (PRUSS0_PRU0_DATARAM, &pruDataMem);
    }
    else if (PRU_NUM == 1)
    {
      prussdrv_map_prumem (PRUSS0_PRU1_DATARAM, &pruDataMem);
    }  
    pruDataMem_int = (volatile signed int*) pruDataMem;
}
コード例 #11
0
ファイル: PRU1.c プロジェクト: jselfridge/BBB
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//  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* SERVO_CH );

  // Load assembly code
  prussdrv_exec_program ( 1, "PRU1.bin" );

  // Loops per PWM period
  memoryPtr[2048] = 150000;

}
コード例 #12
0
 int main(int argc, char **argv) {  
  if (argc != 2) {  
   printf("Usage: %s pru_code.bin\n", argv[0]);  
   return 1;  
  }  
   
  // If this segfaults, make sure you're executing as root.  
  prussdrv_init();  
  if (prussdrv_open(PRU_EVTOUT_0) == -1) {  
   printf("prussdrv_open() failed\n");  
   return 1;  
  }  
    
  tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;  
  prussdrv_pruintc_init(&pruss_intc_initdata);  
   
  // Change to 1 to use PRU1  
  int which_pru = 0;  
  printf("Executing program and waiting for termination\n");  
  prussdrv_exec_program(which_pru, argv[1]);  
   
  // Wait for the PRU to let us know it's done  
  prussdrv_pru_wait_event(PRU_EVTOUT_0);  
  printf("All done\n");  
   
  prussdrv_pru_disable(which_pru);  
  prussdrv_exit();  
   
  return 0;  
 }  
コード例 #13
0
ファイル: buttonTest.c プロジェクト: 19Dan01/exploringBB
   void main (void)
   {
       int n;
       /* 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 INTC */
       prussdrv_pruintc_init(&pruss_intc_initdata);

       /* Copy data to PRU memory */
       unsigned int x = 7;
       prussdrv_pru_write_memory(PRUSS0_PRU0_DATARAM, 0, &x, 4);

       /* Load and execute binary on PRU */
       prussdrv_exec_program (PRU_NUM, "./buttonTest.bin");

       /* Wait for event completion from PRU */
       n = prussdrv_pru_wait_event (PRU_EVTOUT_0);  // This assumes the PRU generates an interrupt
                                                    // connected to event out 0 immediately before halting
       printf("PRU program completed, event number %d.\n", n);

       /* Disable PRU and close memory mappings */
       prussdrv_pru_disable(PRU_NUM);
       prussdrv_exit ();
    }
コード例 #14
0
ファイル: hcsr04.c プロジェクト: adamolek/beaglebone
int main()
{
	void *pru0_memory;
	unsigned int *pru0_memory_uint;
	int distance_samples;
	int n;

	tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;

	prussdrv_init();
	prussdrv_open(PRU_EVTOUT_0);

	prussdrv_pruintc_init(&pruss_intc_initdata);
	prussdrv_map_prumem(PRUSS0_PRU0_DATARAM, &pru0_memory);
	pru0_memory_uint = (unsigned int*)pru0_memory;

	prussdrv_exec_program(0, "./hcsr04.bin");

	n = prussdrv_pru_wait_event(PRU_EVTOUT_0);
	distance_samples = *pru0_memory_uint;

	printf("Measured distance: %f cm\n", (float)distance_samples / (USECS_DIV * HCSR04_DIV));

	prussdrv_pru_disable(0);
	prussdrv_exit();
	return 0;
}
コード例 #15
0
ファイル: pru.cpp プロジェクト: legege/bbb-rc-switch
PRU::PRU(int number) {
    // Store the PRU number (0 or 1)
    if (number < 2) {
        this->pruNumber = number;
    } else {
        this->pruNumber = 0;
    }

    // Initialise driver
    prussdrv_init ();
    
    // Open interrupt
    unsigned int ret = prussdrv_open(PRU_EVTOUT_0);
    if (ret) {
        printf("prussdrv_open open failed\n");
        return;
    }
    
    //Initialise interrupt
    tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;    
    prussdrv_pruintc_init(&pruss_intc_initdata);
    
    // Allocate shared PRU memory
    if (!this->memoryPtr) {
        static void *sharedMem;
        prussdrv_map_prumem(PRUSS0_SHARED_DATARAM, &sharedMem);
        this->memoryPtr = (unsigned int*) sharedMem;
    }
}
コード例 #16
0
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 */

    /* Initialize example */
    
    /* Execute example on PRU */
    /* Disable PRU and close memory mapping*/
    prussdrv_pru_disable (PRU_NUM);
    prussdrv_exit ();

    return(0);

}
コード例 #17
0
ファイル: TLC5946PRUSSphy.cpp プロジェクト: jadedanemone/IOoo
TLC5946PRUSSphy::TLC5946PRUSSphy(SPI *spi, GPIOpin *ctrl, char *pruBinFile) :
		TLC5946phy(spi, ctrl)
{
	use_pruss = true;

	//active has been set to true by superclass constructor
	active = false;

	gsclk_pin_pin = ctrl->findPinIndex((char *) "gsclk");
	printf("prussdrv_open()\n");
	if (prussdrv_open(PRU_EVTOUT_0))
	{
		iooo_debug(0, "Cannot setup PRU_EVTOUT_0.\n");
		use_pruss = false;
		return;
	}
	iooo_debug(2, "PRUSS driver initialized");

	if (use_pruss && prussdrv_exec_program(0, pruBinFile))
	{
		iooo_debug(0, "Non-zero result from prussdrv_pruintc_init\n");
		use_pruss = false;
		return;
	}
	iooo_debug(2, "PRU binary loaded");
	prussdrv_exit();

	//setup clocking lines as outputs
	//ctrl->enableOutput(blank_pin_pin,true);
	ctrl->enableOutput(gsclk_pin_pin, true);

	active = true;
	use_pruss = true;
}
コード例 #18
0
ファイル: pir.c プロジェクト: Gustavxerxes/DFTPIR
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;
}
コード例 #19
0
ファイル: main.c プロジェクト: s-nguyen/memory_writing_to_pru
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;

}
コード例 #20
0
ファイル: prufh_term.c プロジェクト: biocode3D/prufh
// Initialize the pruss
int pruInit(unsigned short pruNum) {
    int         i,  n;

    tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;

    prussdrv_init();

    // Open PRU Interrupt 
    int pru_int = (pru_num == 0) ? PRU_EVTOUT_0 : PRU_EVTOUT_1;
    if (prussdrv_open(pru_int) != 0) {
        fprintf(stderr, "prussdrv_open open failed\n");
        return EXIT_FAILURE;
    }

    // initialize the interrupt
    prussdrv_pruintc_init(&pruss_intc_initdata);

    // Set up shared memory area for arm--pru communication
    prussdrv_map_prumem(PRUSS0_SHARED_DATARAM, &pruSharedMem); 

    pruSharedMem_int = (uint32_t *)pruSharedMem;

    pruSharedMem_int[TOPRU] = 0x00;
    pruSharedMem_int[TOPRU_F] = 0x00;
    pruSharedMem_int[FROMPRU] = 0x00;
    pruSharedMem_int[FROMPRU_F] = 0x00;

    // Initialize pointer to PRU data memory
    if (pruNum == 0) {
      prussdrv_map_prumem (PRUSS0_PRU0_DATARAM, &pruDataMem);
    }
    else if (pruNum == 1) {
      prussdrv_map_prumem (PRUSS0_PRU1_DATARAM, &pruDataMem);
    }  
    pruDataMem_int = (uint16_t *)pruDataMem;

    strcpy(&filename[namelen], ".dat");

    // Load dictionary into data memory
    FILE *file = fopen(filename, "r");
    if (file == NULL) {
        fprintf(stderr, "Unable to open dictionary file, %s\n", filename);
        return EXIT_FAILURE;
    }

    i = 0;
    while (fscanf(file, "%x", &n) == 1) {
        pruDataMem_int[i++] = (uint16_t)n; 
    }
    fclose(file);

    strcpy(&filename[namelen], ".bin");

    // start pru program
    prussdrv_exec_program (pru_num, filename);

    return EXIT_SUCCESS;
}
コード例 #21
0
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);

}
コード例 #22
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;
}
コード例 #23
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);

}
コード例 #24
0
ファイル: blink.c プロジェクト: fparaggio/PuggleDriver
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);
}
コード例 #25
0
ファイル: levelIn.c プロジェクト: bcaine/VLC-Transceiver
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);
}
コード例 #26
0
ファイル: gpiodump.c プロジェクト: 23ars/bbbtools
void init_pru_program(){
	  tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;
	  prussdrv_init();
	  dbg("\tPRUSS driver was initialized...\n");
	  prussdrv_open(PRU_EVTOUT_0);
	  prussdrv_pruintc_init(&pruss_intc_initdata);
	  dbg("\tPRUSS driver intc was initialized...\n");
	  prussdrv_load_datafile(PRU_NUM, "./data.bin");
	  dbg("\tDatafile was loaded...\n");
	  prussdrv_exec_program_at(PRU_NUM, "./text.bin", START_ADDR);
	  dbg("\tTextfile was loaded...\n");

}
コード例 #27
0
ファイル: host.c プロジェクト: zzongaly/bbsettings
void init_pru_program(){
   tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;
   prussdrv_init();
   prussdrv_open(PRU_EVTOUT_0);
   prussdrv_pruintc_init(&pruss_intc_initdata);

   // Get pointer to shared ram
   void* p;
   prussdrv_map_prumem(PRUSS0_SHARED_DATARAM, &p);
   shared_ram = (unsigned int*)p;

   prussdrv_load_datafile(PRU_NUM, "./data.bin");
   prussdrv_exec_program_at(PRU_NUM, "./text.bin", START_ADDR);
}
コード例 #28
0
ファイル: buttonTest.c プロジェクト: paulcle/exploringBB
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 ();
}
コード例 #29
0
ファイル: pu.c プロジェクト: idaohang/Pruuart
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);

}
コード例 #30
0
ファイル: host_main.c プロジェクト: zhanglongqi/pru_sdk
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;
}