Example #1
0
int main(void) {

	/* Initialize the PRU */
	//printf(">> Initializing PRU\n");
	tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;
	prussdrv_init();

	/* Open PRU Interrupt */
	if (prussdrv_open (PRU_EVTOUT_0)) {
		// Handle failure
		printf("-1");
		return 1;
	}

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

	/* Get pointers to PRU local memory */
	void *pruDataMem;
	prussdrv_map_prumem(PRUSS0_PRU0_DATARAM, &pruDataMem);
	unsigned int *pruData = (unsigned int *) pruDataMem;

	/* Execute code on PRU */
	//printf(">> Executing HCSR-04 code\n");
	prussdrv_exec_program(0, "hcsr04.bin");

	/* Get measurements */
	//int i = 0;
	//while (i++ < 20) {

		// Wait for the PRU interrupt
		prussdrv_pru_wait_event (PRU_EVTOUT_0);
		prussdrv_pru_clear_event(PRU_EVTOUT_0, PRU0_ARM_INTERRUPT);
		
		// Print the distance received from the sonar
		// At 20 degrees in dry air the speed of sound is 342.2 cm/sec
		// so it takes 29.12 us to make 1 cm, i.e. 58.44 us for a roundtrip of 1 cm
		printf("%.2f \n", (float) pruData[0] / 58.44);
		//sleep(1);
	//}

	/* Disable PRU and close memory mapping*/
	prussdrv_pru_disable(0);
	prussdrv_exit();
	//printf(">> PRU Disabled.\r\n");
	return (0);

}
Example #2
0
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;
}
Example #3
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);
}
Example #4
0
static int LOCAL_exampleInit ()
{  
    int i;

    prussdrv_map_prumem (PRUSS0_PRU0_DATARAM, &pruDataMem);
    pruDataMem_byte = (unsigned char*) pruDataMem;

    pruDataMem_byte[DMX_HALT_ADDR] = 0;
    pruDataMem_byte[DMX_CHANNELS_ADDR] = DMX_CHANNELS;
    pruDataMem_byte[DMX_PIN_ADDR] = DMX_PIN;

    for (i = 0; i < DMX_CHANNELS; i++) {
        pruDataMem_byte[i] = 0;
    }

    return(0);
}
Example #5
0
/*** 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;
   }

   /* map PRU DATA RAM */
   prussdrv_map_prumem(PRUSS0_PRU0_DATARAM, (void**)&pruDataMem);
   //pruDataMem[0] = 0x01020304;
   pruDataMem->hi_delay = 1000;
   pruDataMem->lo_delay = 19000;

   /* 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;
}
Example #6
0
void pru_start()
{
    unsigned int ret;
    char *bin;
    
    tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;

    prussdrv_init();		
    if (prussdrv_open(PRU_EVTOUT_0)) panic("prussdrv_open");
    if (prussdrv_pruintc_init(&pruss_intc_initdata)) panic("prussdrv_pruintc_init");

	if (prussdrv_map_prumem(PRUSS0_PRU0_DATARAM, &pruDataMem)) panic("prussdrv_map_prumem");
    pru = (com_t *) pruDataMem;
    pru2 = (com2_t *) (pruDataMem + PRU_COM_SIZE);

	bin = background_mode? "/usr/local/bin/hp5370d_realtime.bin" : "pru/pru_realtime.bin";
    if (prussdrv_exec_program(PRU_NUM, bin)) panic("prussdrv_exec_program");
    
    u4_t key1 = timer_us();
    u4_t key2 = key1 >> 8;
    pru->p[0] = key1;
    pru->p[1] = key2;
    pru->p[2] = 0;
    pru->p[3] = 0;
    pru2->m2_offset = 0xbeefcafe;
    send_pru_cmd(PRU_PING);
    if (pru->p[2] != (key1+key2)) panic("PRU didn't start");
    if (pru->p[3] != 0xbeefcafe) panic("PRU com2_t at wrong offset?");
    send_pru_cmd(PRU_CLEAR);
    lprintf("PRU started\n");

#if 0
    prussdrv_pru_wait_event(PRU_EVTOUT_0);		// wait for halt
    prussdrv_pru_clear_event(PRU_EVTOUT_0, PRU0_ARM_INTERRUPT);
    prussdrv_pru_disable(PRU_NUM);
    prussdrv_exit();
#endif
}
Example #7
0
static bool initPru(void) {
    tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;

    printf("Initializing PRU\n");
    prussdrv_init();

    // Open PRU driver and prepare for using the interrupt on event output 1
    if (prussdrv_open(PRU_EVTOUT_1)) {
        fprintf(stderr, "prussdrv_open failed!\n");
        return false;
    }

    // Initialize the PRUSS interrupt controller
    if (prussdrv_pruintc_init(&pruss_intc_initdata)) {
        fprintf(stderr, "prussdrv_pruintc_init failed!\n");
        return false;
    }

    // Get pointer to the shared PRUSS memory. On the AM355x this block is 12KB
    // in size and located locally at 0x0001_0000 within the PRU cores and
    // globally at 0x4A31_0000 in the MPU's memory map. The entire memory is
    // used as our printer queue so we map the global variable to that address.
    prussdrv_map_prumem(PRUSS0_SHARED_DATARAM, (void *)&queue);

    // Initialize the PRU from an array in memory rather than from a file on
    // disk. Make sure PRU sub system is first disabled/reset. Then, transfer
    // the program into the PRU. Note that the write memory functions expect
    // the offsets to be provided in words so we our byte-addresses by four.
    printf("Loading PRU firmware and enabling PRU\n");
    prussdrv_pru_disable(1);
    prussdrv_pru_write_memory(PRUSS0_PRU1_IRAM, pruprinter_fw_iram_start / 4,
            (unsigned int *)&pruprinter_fw_iram, pruprinter_fw_iram_length);
    prussdrv_pru_write_memory(PRUSS0_PRU1_DATARAM, pruprinter_fw_dram_start / 4,
            (unsigned int *)&pruprinter_fw_dram, pruprinter_fw_dram_length);
    prussdrv_pru_enable(1);

    return true;
}
Example #8
0
int main(int argc, char **argv) {
	char *bin_path, *ptr;
	struct pru_data	pru;

	tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;
	prussdrv_init();
	if (prussdrv_open(PRU_EVTOUT_0)) {
		fprintf(stderr, "Cannot setup PRU_EVTOUT_0.\n");
		return -EINVAL;
	}
	prussdrv_pruintc_init(&pruss_intc_initdata);

	prussdrv_map_prumem(PRUSS0_PRU0_DATARAM, (void *) &pru.prumem);
	if (pru.prumem == NULL) {
		fprintf(stderr, "Cannot map PRU0 memory buffer.\n");
		return -ENOMEM;
	}
	init_time(&pru);

	bin_path = strdup(argv[0]);

	ptr = strrchr(bin_path, '/');
	*ptr = '\0';

	chdir(bin_path);
	/*
	 * Display PRU
	 */
	prussdrv_exec_program(0, "pru0_clock.bin");

	/*
	 * Clock PRU
	 */
	prussdrv_exec_program(1, "pru1_clock.bin");
	prussdrv_exit();

	return 0;
}
Example #9
0
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//  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* RADIO_CH );

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

}
Example #10
0
int pru_init(int pru, char *filename, int disabled, hal_pru_generic_t *hpg) {
    
    int i;
    int retval;

    if (geteuid()) {
        HPG_ERR("ERROR: not running as root - need to 'sudo make setuid'?\n");
        return -1;
    }
    if ((retval = assure_module_loaded(UIO_PRUSS)))
    return retval;

rtapi_print("prussdrv_init\n");
    // Allocate and initialize memory
    prussdrv_init ();

    // opens an event out and initializes memory mapping
rtapi_print("prussdrv_open\n");
    if (prussdrv_open(event > -1 ? event : PRU_EVTOUT_0) < 0)
    return -1;

    // expose the driver data, filled in by prussdrv_open
    pruss = &prussdrv;

    // Map PRU's INTC
rtapi_print("prussdrv_pruintc_init\n");
    if (prussdrv_pruintc_init(&pruss_intc_initdata) < 0)
    return -1;

    // Maps the PRU DRAM memory to input pointer
rtapi_print("prussdrv_map_prumem\n");
    if (prussdrv_map_prumem(pru ? PRUSS0_PRU1_DATARAM : PRUSS0_PRU0_DATARAM,
            (void **) &pru_data_ram) < 0)
    return -1;

rtapi_print("PRU data ram mapped\n");
    rtapi_print_msg(RTAPI_MSG_DBG, "%s: PRU data ram mapped at %p\n",
            modname, pru_data_ram);

    hpg->pru_data = (u32 *) pru_data_ram;

    // Zero PRU data memory
    for (i = 0; i < 8192/4; i++) {
        hpg->pru_data[i] = 0;
    }

    // Reserve PRU memory for static configuration variables
    hpg->pru_stat_addr = PRU_DATA_START;
    hpg->pru_data_free = hpg->pru_stat_addr + sizeof(PRU_statics_t);

    // Setup PRU globals
    hpg->pru_stat.task.hdr.dataX = 0xAB;
    hpg->pru_stat.task.hdr.dataY = 0xFE;
    hpg->pru_stat.period = pru_period;
    hpg->config.pru_period = pru_period;

    PRU_statics_t *stat = (PRU_statics_t *) ((u32) hpg->pru_data + (u32) hpg->pru_stat_addr);
    *stat = hpg->pru_stat;

    return 0;
}
Example #11
0
int main (int argc, char *argv[]){
	// Confirm root status (UART/PRU will not run otherwise)
	if(getuid()!=0){
		printf("You must run this program as root. Exiting.\n");
		exit(EXIT_FAILURE);
	}

	// Set Collision Limit
	// By default, it is unlimited. User may supply an argument to limit it.
	int collisionLimit;
	if(argc > 1){
		if(argc == 2){
			collisionLimit = atoi(argv[1]);	// Assumes user knows what they are doing and will only put in an int
		} else {
			printf("Invalid argument: Collisions will not be limited.\n");
			collisionLimit = -1;
		}
	} else {
		collisionLimit = -1;
	}

	// For catching SIGINT and avoiding UART errors
	signal(SIGINT, INThandler);

	// UART Initialization
	int count;
	if ((file = open("/dev/ttyO2", O_RDWR | O_NOCTTY | O_NDELAY))<0){
		perror("UART: Failed to open the file.\n");
		exit(EXIT_FAILURE);
	}
	struct termios options;
	tcgetattr(file, &options);
	options.c_cflag = B19200 | CS8 | CREAD | CLOCAL;
	options.c_iflag = IGNPAR | ICRNL;
	options.c_lflag &= ~(ICANON|ECHO);
	tcflush(file, TCIFLUSH);
	tcsetattr(file, TCSANOW, &options);

	// Initialize PRU structures
	tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;
	prussdrv_init ();
	prussdrv_open (PRU_EVTOUT_0);

	// Declare and assign pointers to PRU Memory
	unsigned char *pruMem[2];
	prussdrv_map_prumem (0, (void*) &pruMem[0]);
	if (pruMem[0] == NULL){
		printf("PRU: Data Memory not mapped!\nExiting.");
		exit(EXIT_FAILURE);
	}
	pruMem[1] = pruMem[0] + 1;

	// Map PRU's interrupts
	prussdrv_pruintc_init(&pruss_intc_initdata);

	// Load and execute the PRU program on the PRU
	prussdrv_exec_program (PRU_0, "./pru_0_clk.bin");
	prussdrv_exec_program (PRU_1, "./pru_1_clk.bin");
	printf("EBB fixed-frequency clock PRU program now running\n");

	// Data Collection Loop
	int i = 0;
	while(i != collisionLimit){
		// Increment collision counter
		i++;

		// Wait for interrupt from PRU
		printf("Waiting for intc...\n");
		prussdrv_pru_wait_event (PRU_EVTOUT_0);
		prussdrv_pru_clear_event (PRU_EVTOUT_0, PRU0_ARM_INTERRUPT);

		// Print data for user (Future feature: Disable printing to stdout unless a -DEBUG argument is passed)
		printf("Collision %d\n", i);
		printf("\tValue:   %d\n", *pruMem[0]);
		printf("\tChannel: %d\n", *pruMem[1] + 1);

		// Store data for transmission
		unsigned char transmit[2];
		transmit[0] = *pruMem[0];
		transmit[1] = *pruMem[1] + 1; //Add 1 to channel for readability

		// Transmit data over UART
		if ((count = write(file, &transmit, 2))<0){  //send the string
			perror("Failed to write to the output\n");
		}

		usleep(1000); 	// Sleep 1ms for MBM to read data (otherwise overflows UART buffer)
						// This value can be lowered to increase speed, at the cost of security
	}

	// Clear PRU memory pointers
	*pruMem[0] = 0;
	*pruMem[1] = 0;
	// Disable PRUs and close UART
	efireExit();

	/* Exit -- This should not be reached
	 efireExit() will ensure UART and PRU are disabled. */
	return EXIT_FAILURE;
}
Example #12
0
int main (void) {
    unsigned int ret;
    unsigned int i, j, k;
    struct timespec requested_time, elapsed_time;

    requested_time.tv_sec = 0;
    requested_time.tv_nsec = 100 * 1000000; // 100ms


    tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;
    
    printf("\nINFO: Starting %s example.\r\n", "ledgrid");
    prussdrv_init (); // Initialize the PRU
    
    /* 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");
    prussdrv_map_prumem( PRUSS0_SHARED_DATARAM, &sharedMem );
    sharedMem_int = (unsigned int*) sharedMem;


    if( 1 == 0 ) {
        for( i=0 ; i < 3 ; i++ ) {
            //for( j=0 ; j < 3 ; j++ ) {
            for( j=1 ; j <= NUM_OF_PIXELS ; j++ ) {
                initPixelArr3( j, i % 3 );
                updatePixelStrip();
                nanosleep( &requested_time, &elapsed_time );
            }
        }
        clearPixelArr();
        updatePixelStrip();
    }

    if( 1 == 1 ) {
        for( i=0 ; i < 30 ; i++ ) {
            initPixelArr_Mario1();
            updatePixelStrip();
            nanosleep( &requested_time, &elapsed_time );
            initPixelArr_Mario2();
            updatePixelStrip();
            nanosleep( &requested_time, &elapsed_time );
            initPixelArr_Mario3();
            updatePixelStrip();
            nanosleep( &requested_time, &elapsed_time );
        }
        //sleep( 2 ); // seconds
        clearPixelArr();
        updatePixelStrip();
    }
    
    // cory: Confirm PRU operation by checking that it wrote a signature into the shared ram:
    if( (sharedMem_int[OFFSET_SHAREDRAM + 0] == 0xACEDACED) &&
        (sharedMem_int[OFFSET_SHAREDRAM + 1] == 0xC001BABE) &&
        (sharedMem_int[OFFSET_SHAREDRAM + 2] == 0xFACEFACE) ) {
        printf( "PRU wrote the signature correctly... Confirmed by c-code.\n" );
    } else {
        printf( "PRU did NOT write the signature correctly...\n" );
        printf( "   sig1 = 0x%08x (expected=0x%08x)\n", sharedMem_int[OFFSET_SHAREDRAM + 0], 0xACEDACED );
        printf( "   sig2 = 0x%08x (expected=0x%08x)\n", sharedMem_int[OFFSET_SHAREDRAM + 1], 0xC001BABE );
        printf( "   sig3 = 0x%08x (expected=0x%08x)\n", sharedMem_int[OFFSET_SHAREDRAM + 2], 0xFACEFACE );
    }

    
    /* Disable PRU and close memory mapping*/
    prussdrv_pru_disable(PRU_NUM); 
    prussdrv_exit ();

    return(0);
}
Example #13
0
int main(int argc, char **argv) {
	char buf[32];
	char *bin_path, *ptr;
	struct pru_data	pru;
	int fd;

#ifndef DEBUG
	if (fork() != 0) {
		return 0;
	}
#endif
	tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;
	prussdrv_init();
	if (prussdrv_open(PRU_EVTOUT_0)) {
		fprintf(stderr, "Cannot setup PRU_EVTOUT_0.\n");
		return -EINVAL;
	}
	prussdrv_pruintc_init(&pruss_intc_initdata);

	prussdrv_map_prumem(PRUSS0_PRU0_DATARAM, (void *) &pru.prumem);
	if (pru.prumem == NULL) {
		fprintf(stderr, "Cannot map PRU0 memory buffer.\n");
		return -ENOMEM;
	}


	/* Create the FIFO if it does not exist */
	umask(0);
	mknod(FIFO_FILE, S_IFIFO|0666, 0);

	fd = open(FIFO_FILE, O_RDONLY);
	if (fd < 0) {
		fprintf(stderr, "Cannot open FIFO.\n");
		return -EINVAL;
	}

	pru.prumem[RUN_FLAG_IDX] = 1; /* startup */
	bin_path = strdup(argv[0]);

	ptr = strrchr(bin_path, '/');
	*ptr = '\0';

	chdir(bin_path);
	prussdrv_exec_program(0, "pru0_nixie.bin");

	blank_vfd(&pru);
	signal(SIGINT, shutdown_clock);
	signal(SIGTERM, shutdown_clock);

	while (running) {	
		if (read(fd, buf, sizeof(buf) - 1) > 0) {
			update_buffer((const char *) &buf, &pru);
			trigger_update(&pru);
		}
		usleep(msecs(10));
	}
	close(fd);

	pru.prumem[RUN_FLAG_IDX] = 0;
	trigger_update(&pru);
#ifdef DEBUG
	fprintf(stdout, "Waiting for PRU core to shutdown..\n");
#endif
	prussdrv_pru_wait_event(PRU_EVTOUT_0);
	prussdrv_pru_clear_event(PRU0_ARM_INTERRUPT);

	prussdrv_pru_disable(0);
	prussdrv_exit();

	if (bin_path) {
		free(bin_path);
	}

	return 0;
}
Example #14
0
static void mainloop(void) 
	{
	int i;
	char c=0;
	char string[1024];
	int mem,offset,length,data;
	unsigned short int rambuffer[12288];
	unsigned char spidata[256];
	
	prussdrv_map_prumem(PRUSS0_PRU0_DATARAM, &pru0Mem);
	pru0Mem_int = (unsigned short*) pru0Mem;
	prussdrv_map_prumem(PRUSS0_PRU1_DATARAM, &pru1Mem);
	pru1Mem_int = (unsigned short*) pru1Mem;
	prussdrv_map_prumem(PRUSS0_SHARED_DATARAM, &sharedMem);
	sharedMem_int = (unsigned short*) sharedMem;
	
	unsigned short* memories[] = {pru0Mem_int,pru1Mem_int,sharedMem_int};
	
	while(1)
			{
			
			c=getchar();
			switch(c)
				{
				//Say hello, test is the program is still alive
				case 'H':
				case 'h':
					printf("Hello Master\n");
					break;

				//Write to memory
				case 'W':
				case 'w':
					printf("Memory?\n");
					scanf("%d",&mem);
					
					printf("Offset?\n");
					scanf("%d",&offset);
					
					printf("Length?\n");
					scanf("%d",&length);
					
					printf("Data?\n");
					for(i=offset;i<length+offset;i++)
						{
						scanf("%d",&data);
						memories[mem][i] = data;
						}
					
					printf("Write operation complete: %d words written to memory location %d:%X!\nSuccess!\n",length,mem,offset);
					break;
				
				//Read from memory
				case 'R':
				case 'r':
					printf("Memory?\n");
					scanf("%d",&mem);
					
					printf("Offset?\n");
					scanf("%d",&offset);
					
					printf("Length?\n");
					scanf("%d",&length);
					
					for(i=offset;i<length+offset;i++)
						printf("%d\n",memories[mem][i]);
					
					printf("Read operation complete: %d words transferred from memory location %d:%X!\nSuccess!\n",length,mem,offset);
					break;
				
				//Periperal - control SPI DAC's and / or digital potentiometers
				case 'P':
				case 'p':
					printf("SPI?\n");
					scanf("%d",&mem);
										
					printf("Length?\n");
					scanf("%d",&length);
					if (length > 256)
						length=256;						
					
					printf("Data?\n");
					for(i=0;i<length;i++)
						{
						scanf("%d",&data);
						spidata[i]=data;
						}
					
					if (mem==0)
						{
						//daisy chain preparation
						unsigned char daisy[]={128,0,1};						
						//spi_transfer(spi0_fd, daisy, 3, 2);
						//data transfer
						spi_transfer(spi0_fd, spidata, length, 2);
						}
					else if (mem==1)
						{
						spi_transfer(spi1_fd, spidata, length, 0);
						}
					else 
						{
						printf("SPI write failed: No device at given SPI number");
						break;
						}
						
					printf("SPI write operation complete: %d words transferred from memory location %d:%X!\nSuccess!\n",length,mem,offset);
					break;

				//Terminate the program
				case 'T':
				case 't':
					//send('T');
					return;					

				default:
					break;
				}
		}
	return;
	}
Example #15
0
int main(int argc, char **argv)
{

	int opt;
	uint8_t bufferIndexPins;
	uint8_t sampleRateOption;
	pthread_t producer_thread, consumer_thread;
	/*pointer to shared RAM*/
	void *p;
	struct sigaction signalaction;
	memset(&signalaction, 0, sizeof(signalaction));
	signalaction.sa_sigaction = &sighandler;
	signalaction.sa_flags = SA_SIGINFO;

	if (sigaction(SIGTERM, &signalaction, NULL) < 0
			|| sigaction(SIGHUP, &signalaction, NULL) < 0
			|| sigaction(SIGINT, &signalaction, NULL) < 0)
	{
		fprintf(stderr, "%s\n", strerror(errno));
		return (-1);
	}
	
	if (argc == 1)
	{
		help(argv[0]);
		return (-1);
	}
	sampleRateOption=0;
	if (buffer_init(&dataCapturedValues, BUFFER_LENGTH) == -1)
	{
		return (-3);
	}
	init_channels();
	while ((opt = getopt(argc, argv, "p:s:f:")) != -1)
	{
		switch (opt)
		{
			case 'p':
			{
				bufferIndexPins = atoi(optarg);
				cfgPins[bufferIndexPins] = 1;
				break;
			}
			case 's':
			{
				sampleRateOption = atoi(optarg);
				break;
			}
			case 'f':
			{
				fd=open(optarg,O_WRONLY|O_CREAT,S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH);
				if(fd==-1)
				{
					fprintf(stderr,"%s\n",strerror(errno));
					fd=STDOUT_FILENO;
				}
				break;
			}
			default:
			{
				help(argv[0]);
				buffer_destroy(&dataCapturedValues);
				return (-5);
			}
		}
	}
	calculate_sample_period(sampleRateOption);
	init_pru_program();
	dbg("PRU program initialized...\n");
	prussdrv_map_prumem(PRUSS0_SHARED_DATARAM, &p);
	shared_ram=(unsigned int *)p;
	dbg("PRU shared memory was mapped...\n");
	shared_ram[0]=sample_delay;
	shared_ram[1]=sample_delay>>8;
	shared_ram[2]=sample_delay>>16;
	shared_ram[3]=sample_delay>>24;
	create_header(fd,sample_delay,cfgPins);
	/*Initialize mutex and condition variables*/
	pthread_mutex_init(&shared_var_mutex, NULL);
	pthread_cond_init(&cond_consumer, NULL);
	pthread_cond_init(&cond_producer, NULL);
	dbg("Mutex and conditions were initialized...");

	/*create threads*/
	pthread_create(&consumer_thread, NULL, consumer, NULL);
	pthread_create(&producer_thread, NULL, producer, NULL);
	
	pthread_join(consumer_thread, NULL);
	pthread_join(producer_thread, NULL);
	/*Cleanup threads*/
	pthread_mutex_destroy(&shared_var_mutex);
	pthread_cond_destroy(&cond_consumer);
	pthread_cond_destroy(&cond_producer);
	close(fd);

	prussdrv_pru_disable(PRU_NUM);
	prussdrv_exit();
	
	close(fd);
	buffer_destroy(&dataCapturedValues);
	return 0;
}
Example #16
0
int main()  {
    unsigned int ret;
	tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;

    printf("\n--Test of ring buffer functionality--\n");

    printf("Initializing PRU...");
    prussdrv_init();
    printf("\t\t\t\tDone\n");

    ret = prussdrv_open(PRU_EVTOUT_0);
    printf("Checking prussdrv_open()...");
    if (ret) {
        printf("prussdrv_open failed!\n");
        printf("Aborting application!\n");
        return (ret);
    }
    printf("\t\t\tDone\n");

    
    printf("Initializing INTC...");
    prussdrv_pruintc_init(&pruss_intc_initdata);
    printf("\t\t\t\tDone\n");
    

    //map PRU shared RAM to userspace
    printf("Mapping PRU memory to userspace...");
    prussdrv_map_prumem(PRUSS0_SHAREDRAM, &sharedMem);
    printf("\t\t\tDone\n");

    //create and initialize ring buffer
    printf("Initializing ring buffer in PRU shared memory...");
    sharedMem_rbint = (unsigned int *) sharedMem;
    rbInit(sharedMem_rbint, DEF_RB_SIZE);
    printf("\t\t\t\tDone\n");

    //printf("Loading test program...\n");
    //prussdrv_exec_program(PRU_NUM, "./boneclamp.bin");
    prussdrv_exec_program(PRU_NUM, "./test.bin");

    /* read stuff from ring buffer */
    /*
    data *currentDatapoint = calloc(1, sizeof(data));
    while(1) {
        if (!rbIsEmpty(buffer)) {
            rbRead(buffer, currentDatapoint);
            printf("Channel: %i Value: %i", currentDatapoint->channelNumber, currentDatapoint->datap);
            if (currentDatapoint->datap == 20) {
                break;
            }
        }
        else
            printf("Buffer currently empty");
    }
    */

    //free(currentDatapoint);
    //rbFree(sharedMem_rb);

    //wait until PRU program is completed
    printf("Test complete. Do the results make sense?\n");
    prussdrv_pru_wait_event(PRU_EVTOUT_0);
    prussdrv_pru_clear_event(PRU_EVTOUT_0);

    //shut down the pru
    printf("Shutting down the PRU...");
    prussdrv_pru_disable(PRU_NUM);
    prussdrv_exit();
    //close(mem_fd);
    printf("\t\t\t\tDone\n");

	return 0;
}
Example #17
0
int main(int argc, char **argv) {
    char buf[32];
    struct pru_data	pru;
    int fd, rdsize;

#ifndef DEBUG
    if (fork() != 0) {
        return 0;
    }
#endif

    tpruss_intc_initdata pruss_intc_initdata = PRUSS_INTC_INITDATA;

    printf("Initializing pruss\n");
    prussdrv_init();
    if (prussdrv_open(PRU_EVTOUT_0)) {
        fprintf(stderr, "Cannot setup PRU_EVTOUT_0.\n");
        return -EINVAL;
    }
    
    printf("Initializing interrupts\n");
    prussdrv_pruintc_init(&pruss_intc_initdata);

    printf("Mapping PRUSS0 RAM\n");
    prussdrv_map_prumem(PRUSS0_PRU0_DATARAM, (void *) &pru.prumem);
    if (pru.prumem == NULL) {
        fprintf(stderr, "Cannot map PRU0 memory buffer.\n");
        return -ENOMEM;
    }


    printf("Creating FIFO\n");
    /* Create the FIFO if it does not exist */
    umask(0);
    mknod(FIFO_FILE, S_IFIFO|0666, 0);

    printf("Opening FIFO\n");
    fd = open(FIFO_FILE, O_RDONLY);
    if (fd < 0) {
        fprintf(stderr, "Cannot open FIFO.\n");
        return -EINVAL;
    }

    pru.prumem[RUN_FLAG_IDX] = 1; /* startup */

    printf("Loading PRU0 program\n");
    prussdrv_exec_program(0, "7seg_spi_test_fifo.bin");

    signal(SIGINT, shutdown_clock);
    signal(SIGTERM, shutdown_clock);

    printf("Entering runloop\n");
    while (running) {	
        if ((rdsize = read(fd, buf, sizeof(buf) - 1)) > 0) {
            update_buffer((const char *) &buf, &pru, rdsize);
        }
        usleep(msecs(10));
    }
    close(fd);

    pru.prumem[RUN_FLAG_IDX] = 0;
    
#ifdef DEBUG
    fprintf(stdout, "Waiting for PRU core to shutdown..\n");
#endif

    prussdrv_pru_wait_event(PRU_EVTOUT_0);
    prussdrv_pru_clear_event(PRU0_ARM_INTERRUPT);

    prussdrv_pru_disable(0);
    prussdrv_exit();

    return 0;
}
Example #18
0
static void *Speed_Thread(void *arg)
{
    struct TimerInfo info;

    //return NULL;

    // Initialise the PRU
    //printf("Initialising PRU\n");
    if (prussdrv_init() != 0)
    {
        snprintf(DisplayMessage, DISPLAY_MAX_MSG_SIZE, "prussdrv_init failed");
        return NULL;
    }

    // Open an event
    if (prussdrv_open(PRU_EVTOUT_0))
    {
        //printf("prussdrv_open failed\n");
        snprintf(DisplayMessage, DISPLAY_MAX_MSG_SIZE, "prussdrv_open failed");
        return NULL;
    }

    // Get pointers to PRU0 local memory
    void *pruDataMem;
    prussdrv_map_prumem (PRUSS0_PRU0_DATARAM, &pruDataMem);
    unsigned int *pruData = (unsigned int *) pruDataMem;

    // Execute code on PRU
    //printf("Executing speed pru code\n");
    if (prussdrv_exec_program (0, "../pru/BeagleTrainer.bin") < 0)
    {
        //printf("prussdrv_exec_program failed\n");
        snprintf(DisplayMessage, DISPLAY_MAX_MSG_SIZE, "prussdrv_exec_program failed");
        return NULL;
    }

    // Start the periodic timer @ 125ms
    TimerStart (125000, &info);

    // Run until terminated from main thread
    while (runSpeedThread)
    {
        // Wait for periodic timer to expire
        TimerWait (&info);

        // Broadcast data
        ////printf("Speed Thread: timer expired...\n");
        uint32_t events = pruData[0];
        uint32_t frequency = events * PRU_UPDATE_FREQ;

        double rps = (double)frequency / PULSE_PER_REV;
        //double rpm = rps * 60.0;
        double mps = rps * 2.0 * M_PI * RADIUS / 1000.0;
        double kph = mps * 3.6;

        currentSpeed = kph;
        currentFrequency = events;

        // Print out the value received from the PRU code
        ////printf("%u events, %.0f RPM, %.2f km/h\r\n", events, rpm, kph);
        //snprintf(DisplayMessage, DISPLAY_MAX_MSG_SIZE, "%u events, %.0f RPM, %.2f km/h", events, rpm, kph);

}

    // cleanup
    //printf("Speed Thread: cleanup\n");
    prussdrv_pru_disable(0);
    prussdrv_exit();

    return NULL;
}