コード例 #1
0
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*/

}
コード例 #2
0
ファイル: pir.c プロジェクト: Gustavxerxes/DFTPIR
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);
}
コード例 #3
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;
}
コード例 #4
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);

}
コード例 #5
0
ファイル: host.c プロジェクト: zzongaly/bbsettings
/* 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;
}
コード例 #6
0
ファイル: gpiodump.c プロジェクト: 23ars/bbbtools
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);
}
コード例 #7
0
ファイル: pru-motion-queue.c プロジェクト: miloh/beagleg
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);
  }
}
コード例 #8
0
ファイル: pru-motion-queue.c プロジェクト: miloh/beagleg
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_++];
}
コード例 #9
0
ファイル: PruTimer.cpp プロジェクト: quillford/redeem
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;
}
コード例 #10
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);

}
コード例 #11
0
ファイル: ledgrid.c プロジェクト: CoryStewart/ledgrid
/*****************************************************************************
* 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()
コード例 #12
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();
}
コード例 #13
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);

}
コード例 #14
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);
}
コード例 #15
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);
}
コード例 #16
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
}
コード例 #17
0
ファイル: int.c プロジェクト: bkovitz/pru
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);
}
コード例 #18
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);

}
コード例 #19
0
ファイル: hcsr04_demo.c プロジェクト: 19Dan01/beaglebot
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);
    
}
コード例 #20
0
ファイル: hcsr04.c プロジェクト: MA303893/QUADCAPE
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);

}
コード例 #21
0
ファイル: dmx.c プロジェクト: SuperVirus/beaglebone-DMX
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);

}
コード例 #22
0
ファイル: spi_test.c プロジェクト: lchamon/bbb_ads131
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);
}
コード例 #23
0
ファイル: iep2.c プロジェクト: jstampfl/PruIEP_Int
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);

}
コード例 #24
0
ファイル: main.c プロジェクト: cheehieu/pru-printer
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);
    }
}
コード例 #25
0
ファイル: main.c プロジェクト: cheehieu/pru-printer
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();
    }
}
コード例 #26
0
ファイル: pru_realtime.c プロジェクト: jks-prv/5370_proc
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
}
コード例 #27
0
ファイル: flashLED.c プロジェクト: 19Dan01/exploringBB
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;
}
コード例 #28
0
ファイル: unicorn.c プロジェクト: SHINOTECH/firmware
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;
}
コード例 #29
0
ファイル: pru_pwm.c プロジェクト: kvzhao/arm-joystick
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);
}
コード例 #30
0
ファイル: blinkslave.c プロジェクト: korytov/bone
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);

}