コード例 #1
0
    def _wait_for_events(self):
        events_caught = 0
        self.dev = os.open("/dev/uio0", os.O_RDONLY)
        self.new_events = 0
        self.old_events = 0
        nr_interrupts = 0
        while self.running:
            ret = select.select( [self.dev],[],[], 1.0 )
            if ret[0] == [self.dev]:
                self._wait_for_event()
                pypruss.clear_event(PRU0_ARM_INTERRUPT)			# Clear the event        
                nr_events = struct.unpack("L", self.ddr_mem[self.DDR_END-4:self.DDR_END])[0]   
            else:
                nr_events = struct.unpack("L", self.ddr_mem[self.DDR_END-4:self.DDR_END])[0]

            while nr_interrupts < nr_events:
                ddr = self.ddr_used.get()                       # Pop the first ddr memory amount           
                with Pru.ddr_lock: 
                    self.ddr_mem_used -= ddr                    
                #logging.debug("Popped "+str(ddr)+"\tnow "+hex(self.get_capacity()))
                if self.get_capacity() < 0:
                    logging.error("Capacity less than 0!")
                if self.get_capacity() == 0x40000:
                    logging.warning("PRU empty!")                    
                nr_interrupts += 1  
                self.ddr_used.task_done()
コード例 #2
0
    def run(self):
        old_consume = 0
        while not self.stopped.is_set():
            pypruss.wait_for_event(TARGET_PRU_NO)
            pypruss.clear_event(TARGET_PRU_NO, TARGET_PRU_INTERRUPT)
            self.calls += 1
            (produce, consume) = \
                struct.unpack("LL", self.ddr_mem[DDR_START:DDR_START +
                                                 RX_RING_BUFFER_FRAMES_OFFSET])
            while consume != produce:
                length = struct.unpack("B", self.ddr_mem[self.frames_ptr])[0]
                frame = \
                    struct.unpack("B"*length,
                                  self.ddr_mem[self.frames_ptr+1:
                                               self.frames_ptr+1+length])

                #sys.stderr.write('rx ' + str(frame) + '\n')

                consume = (consume + 1) % RX_RING_BUFFER_LEN
                self.frames_ptr = self.frames_base + \
                    (consume * RX_FRAME_SIZE)
            if old_consume != consume:
                self.ddr_mem[DDR_START + RX_RING_BUFFER_CONSUME_OFFSET:
                             DDR_START + RX_RING_BUFFER_FRAMES_OFFSET] = \
                             struct.pack('L', consume)
                old_consume = consume
コード例 #3
0
 def run(self):
     old_consume = 0
     while not self.stopped.is_set():
         pypruss.wait_for_event(TARGET_PRU_NO)
         pypruss.clear_event(TARGET_PRU_NO, TARGET_PRU_INTERRUPT)
         self.calls += 1
         (produce, consume) = \
             struct.unpack("LL", self.ddr_mem[DDR_START:DDR_START +
                                              RING_BUFFER_FRAMES_OFFSET])
         while consume != produce:
             length = struct.unpack("B", self.ddr_mem[self.frames_ptr])[0]
             frame = \
                 struct.unpack("B"*length,
                               self.ddr_mem[self.frames_ptr+1:
                                            self.frames_ptr+1+length])
             self.socket.sendto(''.join(map(chr, frame)),
                                ('localhost', UDP_PORTS[1]))
             consume = (consume + 1) % RX_RING_BUFFER_LEN
             self.frames_ptr = self.frames_base + \
                 (consume * FRAME_SIZE)
         if old_consume != consume:
             self.ddr_mem[DDR_START + RING_BUFFER_CONSUME_OFFSET:
                          DDR_START + RING_BUFFER_FRAMES_OFFSET] = \
                          struct.pack('L', consume)
             old_consume = consume
コード例 #4
0
    def run(self):
        ddr_start = 0x10000000
        old_consume = 0
        while not self.stopped.is_set():
            pypruss.wait_for_event(
                1)  # Wait for event 0 which is connected to PRU0_ARM_INTERRUPT
            pypruss.clear_event(1,
                                pypruss.PRU1_ARM_INTERRUPT)  # Clear the event
            self.calls += 1
            (produce,
             consume) = struct.unpack("LL",
                                      self.ddr_mem[ddr_start:ddr_start + 8])
            while consume != produce:
                length = struct.unpack("B", self.ddr_mem[self.messages_ptr])[0]
                message = struct.unpack(
                    "B" * length,
                    self.ddr_mem[self.messages_ptr + 1:self.messages_ptr + 1 +
                                 length])
                #                print(",".join(map(lambda x: "{:02x}".format(x), message)))
                self.socket.sendto(''.join(map(chr, message)),
                                   ('localhost', 6972))

                consume = (consume + 1) % 16
                self.messages_ptr = self.messages_base + (consume * 43)
            if old_consume != consume:
                self.ddr_mem[ddr_start + 4:ddr_start + 8] = struct.pack(
                    'L', consume)
                old_consume = consume
コード例 #5
0
ファイル: test.py プロジェクト: ncsurobotics/acoustics
def main():
    # Initialize environment
    pypruss.modprobe()

    pypruss.init()              # Init the PRU
    pypruss.open(0)             # Open PRU event 0 which is PRU0_ARM_INTERRUPT
    pypruss.pruintc_init()      # Init the interrupt controller
    pypruss.exec_program(0, "./hello_pru.bin")  # Load firmware on PRU0
    pypruss.wait_for_event(0)   # Wait for event 0 which is conn to PRU0_ARM_INTERUPT
    pypruss.clear_event(0)      # Clear the event
    pypruss.exit()              # Exit PRU

    print("Test completed: PRU was successfully opened and closed.")
コード例 #6
0
def runOnPRU(PRU, binFile, interrupt=1):
    try:
        pypruss.init()  # Init the PRU
        pypruss.open(interrupt)  # Open PRU  PRU1_ARM_INTERRUPT
        pypruss.pruintc_init()  # Init the interrupt controller
        pypruss.exec_program(PRU, binFile)
        log.info('PRU %s executing %s' % (PRU, os.path.split(binFile)[len(os.path.split(binFile)) - 1]))
        pypruss.wait_for_event(interrupt)  # Wait for event 0 which is connected to PRU0_ARM_INTERRUPT
        pypruss.clear_event(interrupt)  # Clear the event
        pypruss.exit()
    except Exception, e:
        log.error(e)
        pypruss.exit()
        raise Exception('Error executing file %s on PRU' % binFile)
コード例 #7
0
ファイル: backlight.py プロジェクト: nycresistor/TotU
    def stop(self):
        print("Ending")
        # Set our command byte to FF and write it out
        self.data[0] = 0x000000FF
        pypruss.pru_write_memory(0, 0, self.data)

        # Wait for event 0 which is connected to PRU0_ARM_INTERRUPT
        pypruss.wait_for_event(0)
        # Clear the event
        pypruss.clear_event(0)
        # Disable PRU 0, this is already done by the firmware
        pypruss.pru_disable(0)
        # Exit, don't know what this does.
        pypruss.exit()
コード例 #8
0
ファイル: backlight.py プロジェクト: nycresistor/TotU
	def stop(self):
		print("Ending")
		# Set our command byte to FF and write it out
		self.data[0] = 0x000000FF
		pypruss.pru_write_memory(0, 0, self.data)

		# Wait for event 0 which is connected to PRU0_ARM_INTERRUPT
		pypruss.wait_for_event(0)
		# Clear the event
		pypruss.clear_event(0)
		# Disable PRU 0, this is already done by the firmware
		pypruss.pru_disable(0)
		# Exit, don't know what this does.
		pypruss.exit()
コード例 #9
0
ファイル: dallas.py プロジェクト: Miaou/BBB
def ExecuteActions(prussmem, lActions):
    # Write actions (PRU is in standby)
    WriteActions(prussmem, lActions)
    # Makes the PRU treat actions
    prussmem[SHARED] = 1 # COMMAND_START
    # Waits for completion.
    pypruss.wait_for_event(pypruss.PRU_EVTOUT_0)
    pypruss.clear_event(pypruss.PRU_EVTOUT_0, pypruss.PRU0_ARM_INTERRUPT)
    # I don't know why we have to wait and clear 2 times...
    # I thought that there was a delay between the PRU signaled the interrupt and
    #  and the Linux updating the shared mem, but no, you have to wait for event twice...
    pypruss.wait_for_event(pypruss.PRU_EVTOUT_0)
    pypruss.clear_event(pypruss.PRU_EVTOUT_0, pypruss.PRU0_ARM_INTERRUPT)
    return ReadActions(prussmem, lActions)
コード例 #10
0
def ExecuteActions(prussmem, lActions):
    # Write actions (PRU is in standby)
    WriteActions(prussmem, lActions)
    # Makes the PRU treat actions
    prussmem[SHARED] = 1  # COMMAND_START
    # Waits for completion.
    pypruss.wait_for_event(pypruss.PRU_EVTOUT_0)
    pypruss.clear_event(pypruss.PRU_EVTOUT_0, pypruss.PRU0_ARM_INTERRUPT)
    # I don't know why we have to wait and clear 2 times...
    # I thought that there was a delay between the PRU signaled the interrupt and
    #  and the Linux updating the shared mem, but no, you have to wait for event twice...
    pypruss.wait_for_event(pypruss.PRU_EVTOUT_0)
    pypruss.clear_event(pypruss.PRU_EVTOUT_0, pypruss.PRU0_ARM_INTERRUPT)
    return ReadActions(prussmem, lActions)
コード例 #11
0
ファイル: Pru.py プロジェクト: zittix/redeem
    def __init__(self, firmware):
        self.pru_hz		    = 200*1000*1000             # The PRU has a speed of 200 MHz
        self.s_pr_inst      = (1.0/self.pru_hz)          # I take it every instruction is a single cycle instruction
        self.max_delay_cycles = self.pru_hz*4           #Maximum delay to avoid bugs (4 seconds)
        self.pru_data       = []      	    	        # This holds all data for one move (x,y,z,e1,e2)
        self.ddr_used       = Queue.Queue()             # List of data lengths currently in DDR for execution
        self.ddr_reserved   = 0      
        self.ddr_mem_used   = 0  
        self.clear_events   = []       
        self.firmware = firmware

        self.ddr_addr = int(open("/sys/class/uio/uio0/maps/map1/addr","rb").read().rstrip(), 0)
        self.ddr_size = int(open("/sys/class/uio/uio0/maps/map1/size","rb").read().rstrip(), 0)
        logging.info("The DDR memory reserved for the PRU is "+hex(self.ddr_size)+" and has addr "+hex(self.ddr_addr))

        ddr_offset     		= self.ddr_addr-0x20000000  # The Python mmap function cannot accept unsigned longs. 
        ddr_filelen    		= self.ddr_size+0x20000000
        self.DDR_START      = 0x20000000
        self.DDR_END        = 0x20000000+self.ddr_size
        self.ddr_start      = self.DDR_START
        self.ddr_nr_events  = self.ddr_addr+self.ddr_size-4

        with open("/dev/mem", "r+b") as f:	            # Open the memory device
            self.ddr_mem = mmap.mmap(f.fileno(), ddr_filelen, offset=ddr_offset) # mmap the right area            
            self.ddr_mem[self.ddr_start:self.ddr_start+4] = struct.pack('L', 0)  # Add a zero to the first reg to make it wait
       
        self.init_pru();
       
        #Wait until we get the GPIO output in the DDR
        self.dev = os.open("/dev/uio0", os.O_RDONLY)

        ret = select.select( [self.dev],[],[], 1.0 )
        if ret[0] == [self.dev]:
            pypruss.clear_event(PRU0_ARM_INTERRUPT)         # Clear the event        
        
        self.initial_gpio = [struct.unpack("L", self.ddr_mem[self.DDR_START+4:self.DDR_START+8])[0], struct.unpack("L", self.ddr_mem[self.DDR_START+8:self.DDR_START+12])[0], struct.unpack("L", self.ddr_mem[self.DDR_START+12:self.DDR_START+16])[0], struct.unpack("L", self.ddr_mem[self.DDR_START+16:self.DDR_START+20])[0] ]

        os.close(self.dev)

        #Clear DDR
        self.ddr_mem[self.DDR_START+4:self.DDR_START+8] = struct.pack('L', 0)
        self.ddr_mem[self.DDR_START+8:self.DDR_START+12] = struct.pack('L', 0)
        self.ddr_mem[self.DDR_START+12:self.DDR_START+16] = struct.pack('L', 0)
        self.ddr_mem[self.DDR_START+16:self.DDR_START+20] = struct.pack('L', 0)

        self.t = Thread(target=self._wait_for_events)         # Make the thread
        self.t.daemon = True
        self.running = True
        self.t.start()		
コード例 #12
0
ファイル: starter.py プロジェクト: SadatAnwar/TI-Internship
def resetPRU(start_stop):
    for PRU in range(0, 2):
        if os.path.isfile(reset_pru_bin):
            pypruss.init()  # Init the PRU
            pypruss.open(1)  # Open PRU event 0 which is PRU0_ARM_INTERRUPT
            pypruss.pruintc_init()  # Init the interrupt controller
            pypruss.exec_program(
                PRU, reset_pru_bin)  # Load firmware "mem_write.bin" on PRU 0
            pypruss.wait_for_event(
                1)  # Wait for event 0 which is connected to PRU0_ARM_INTERRUPT
            print("PRU " + str(PRU) + " " + start_stop)
            pypruss.clear_event(1)  # Clear the event
            pypruss.exit()
        else:
            compile_assembler(os.path.join(header_folder, "reset.p"))
コード例 #13
0
ファイル: servos.py プロジェクト: Miaou/BBB
 def __del__(self):
     # Tells the PRU program to end (optional)
     # Using __del__ to clean out is not a very brilliant idea, as many objects are already deleted
     global ServoController  # Pb with order of del
     print('Waiting for the PRU program to self-stop')
     pMem = PruInterface.MASK_FETCH | PruInterface.P_HEADER
     self.pruface.getMappedMem()[pMem:pMem + 4] = self.struct.pack('<I', 2)
     # Waits for completion.
     pypruss.wait_for_event(pypruss.PRU_EVTOUT_0)
     pypruss.clear_event(pypruss.PRU_EVTOUT_0, pypruss.PRU0_ARM_INTERRUPT)
     # I don't know why we have to wait and clear 2 times...
     # I thought that there was a delay between the PRU signaled the interrupt and
     #  and the Linux updating the shared mem, but no, you have to wait for event twice...
     pypruss.wait_for_event(pypruss.PRU_EVTOUT_0)
     pypruss.clear_event(pypruss.PRU_EVTOUT_0, pypruss.PRU0_ARM_INTERRUPT)
コード例 #14
0
ファイル: servos.py プロジェクト: Miaou/BBB
 def __del__(self):
     # Tells the PRU program to end (optional)
     # Using __del__ to clean out is not a very brilliant idea, as many objects are already deleted
     global ServoController # Pb with order of del
     print('Waiting for the PRU program to self-stop')
     pMem = PruInterface.MASK_FETCH|PruInterface.P_HEADER
     self.pruface.getMappedMem()[pMem:pMem+4] = self.struct.pack('<I', 2)
     # Waits for completion.
     pypruss.wait_for_event(pypruss.PRU_EVTOUT_0)
     pypruss.clear_event(pypruss.PRU_EVTOUT_0, pypruss.PRU0_ARM_INTERRUPT)
     # I don't know why we have to wait and clear 2 times...
     # I thought that there was a delay between the PRU signaled the interrupt and
     #  and the Linux updating the shared mem, but no, you have to wait for event twice...
     pypruss.wait_for_event(pypruss.PRU_EVTOUT_0)
     pypruss.clear_event(pypruss.PRU_EVTOUT_0, pypruss.PRU0_ARM_INTERRUPT)
コード例 #15
0
def moveStepper_p9_15(steps):
    pypruss.modprobe()
    pypruss.init()
    pypruss.open(0)  # Open PRU event 0 which is PRU0_ARM_INTERRUPT
    pypruss.pruintc_init()  # Init the interrupt controller

    setSteps(steps)

    pypruss.exec_program(
        0, "./pru/p9_15.bin")  # Load firmware "blinkled.bin" on PRU 0
    pypruss.wait_for_event(
        0)  # Wait for event 0 which is connected to PRU0_ARM_INTERRUPT
    pypruss.clear_event(0)  # Clear the event
    pypruss.pru_disable(
        0)  # Disable PRU 0, this is already done by the firmware
    pypruss.exit()  # Exit, don't know what this does.
コード例 #16
0
 def initReceiver(self, clearMem=True, copyMem=False, memBlock=100):
     """Initialize the input receiver
     1. copy out the memory content if set, default false
     2. Reset the moemory contents if set, default True
     3. Start the receiver binary on the receiving PRU"""
     if copyMem:
         self.PRUMemContents = readOutPRUMem(blocks=0)
     if clearMem:
         resetPRUMem(memBlock)
         log.info('PRU Memory Cleared %s blocks' % memBlock)
     pypruss.init()  # Init the PRU
     pypruss.open(0)  # Open PRU event 0 which is PRU0_ARM_INTERRUPT
     pypruss.pruintc_init()  # Init the interrupt controller
     pypruss.exec_program(receivingPRU, self.inputBinary)  # Load firmware for input recording
     pypruss.clear_event(0)
     pypruss.exit()
コード例 #17
0
    def get_distances(self):

        distances = []

        pypruss.wait_for_event(
            0)  # Wait for event 0 which is connected to PRU0_ARM_INTERRUPT
        time.sleep(0.2)

        pypruss.clear_event(0, pypruss.PRU0_ARM_INTERRUPT)  # Clear the event

        for j in range(5):
            distances.append(
                round(
                    float(
                        struct.unpack(
                            'L', self.pruData[offset + j * 4:offset +
                                              (j + 1) * 4])[0] / 58.44), 2))
        return distances
コード例 #18
0
ファイル: Pru.py プロジェクト: Bingzo/replicape
 def _wait_for_events(self):
     events_caught = 0
     self.dev = os.open("/dev/uio0", os.O_RDONLY)
     self.new_events = 0
     self.old_events = 0
     nr_interrupts = 0
     while self.running:
         ret = select.select( [self.dev],[],[], 1.0 )
         if ret[0] == [self.dev]:
             self._wait_for_event()
             pypruss.clear_event(PRU0_ARM_INTERRUPT)			# Clear the event        
             nr_events = struct.unpack("L", self.ddr_mem[self.DDR_END-4:self.DDR_END])[0]            
             while nr_interrupts < nr_events:
                 ddr = self.ddr_used.get()                       # Pop the first ddr memory amount           
                 with self.ddr_lock:
                     self.ddr_mem_used -= ddr                    
                 if self.debug > 0:
                     print "Popped "+str(ddr)+"\tnow "+hex(self.get_capacity())
                 self.ddr_used.task_done()
                 nr_interrupts += 1                         
コード例 #19
0
ファイル: spi_awg.py プロジェクト: antarctica/EMSLED
def sendData(addr, data, rx=0):
    if (rx == 0):
        data = [int((0x00 << 24) + (addr << 16) + data)]
    else:
        data = [int((0x80 << 24) + (addr << 16) + 0x0000)]

    # data = [0x80272345]
    GPIO.output("P8_30", GPIO.LOW)
    pypruss.init()  # Init the PRU
    pypruss.open(0)  # Open PRU event 0 which is PRU0_ARM_INTERRUPT
    pypruss.pruintc_init()  # Init the interrupt controller
    pypruss.pru_write_memory(1, 0, data)  # Load the data in the PRU ram
    pypruss.exec_program(
        1, "arm/spi_awg.bin")  # Load firmware "mem_write.bin" on PRU 0
    pypruss.wait_for_event(
        0)  # Wait for event 0 which is connected to PRU0_ARM_INTERRUPT
    pypruss.clear_event(0)  # Clear the event
    # data = [0x12345678]
    pypruss.pru_write_memory(1, 0, data)  # Load the data in the PRU ram
    GPIO.output("P8_30", GPIO.HIGH)
    if (rx == 1):

        PRU_ICSS = 0x4A300000
        PRU_ICSS_LEN = 512 * 1024

        # RAM0_START = 0x00000000
        # RAM1_START = 0x00002000
        RAM2_START = 0x00012000

        with open("/dev/mem", "r+b") as f:
            ddr_mem = mmap.mmap(f.fileno(), PRU_ICSS_LEN, offset=PRU_ICSS)
            # local = struct.unpack('LLLL', ddr_mem[RAM1_START:RAM1_START+16])
            shared = struct.unpack('L', ddr_mem[RAM2_START:RAM2_START + 4])
        f.close()
    pypruss.exit()  # Exit
    if (rx == 1):
        return shared[0]
    else:
        return 0
コード例 #20
0
ファイル: spi_awg.py プロジェクト: antarctica/EMSLED
def sendData(addr,data,rx=0):
	if(rx==0):
		data = [int((0x00 << 24) + (addr << 16) + data)]
	else:
		data = [int((0x80 << 24) + (addr << 16) + 0x0000)]
	
	# data = [0x80272345]	
	GPIO.output("P8_30",GPIO.LOW)
	pypruss.init()						# Init the PRU
	pypruss.open(0)						# Open PRU event 0 which is PRU0_ARM_INTERRUPT
	pypruss.pruintc_init()					# Init the interrupt controller
	pypruss.pru_write_memory(1, 0, data)			# Load the data in the PRU ram
	pypruss.exec_program(1, "arm/spi_awg.bin")		# Load firmware "mem_write.bin" on PRU 0
	pypruss.wait_for_event(0)				# Wait for event 0 which is connected to PRU0_ARM_INTERRUPT
	pypruss.clear_event(0)					# Clear the event
	# data = [0x12345678]
	pypruss.pru_write_memory(1, 0, data)			# Load the data in the PRU ram
	GPIO.output("P8_30",GPIO.HIGH)
	if (rx == 1):

		PRU_ICSS = 0x4A300000  
		PRU_ICSS_LEN = 512*1024 

		# RAM0_START = 0x00000000
		# RAM1_START = 0x00002000
		RAM2_START = 0x00012000


		with open("/dev/mem", "r+b") as f:
			ddr_mem = mmap.mmap(f.fileno(), PRU_ICSS_LEN, offset=PRU_ICSS) 
			# local = struct.unpack('LLLL', ddr_mem[RAM1_START:RAM1_START+16])
			shared = struct.unpack('L', ddr_mem[RAM2_START:RAM2_START+4])
		f.close()
	pypruss.exit()							# Exit
	if (rx == 1):
		return shared[0]
	else:
		return 0
コード例 #21
0
ファイル: ultrasonic.py プロジェクト: travislovespie/bot
    def read_times(self):
        """Get readings from all ultrasonic sensors, as a pulse time.

        :returns: Readings from all ultrasonic sensors

        """
        self.logger.debug("Waiting for PRU interrupt")
        pypruss.wait_for_event(self.PRU_EVOUT_0)
        self.logger.debug("Received PRU interrupt")
        pypruss.clear_event(self.PRU_EVOUT_0, self.PRU0_ARM_INTERRUPT)
        times = {}
        inches = {}
        for i in self.sensors:
            times[i] = struct.unpack_from(
                'I', self.pru_mem, self.sensors[i]['offset'])[0]
            self.logger.debug("Sensor: %s = %d", i, times[i])

        self.logger.debug("Waiting for duplicate PRU interrupt")
        pypruss.wait_for_event(self.PRU_EVOUT_0)
        self.logger.debug("Received (expected) duplicated PRU interrupt")
        pypruss.clear_event(self.PRU_EVOUT_0, self.PRU0_ARM_INTERRUPT)
        self.logger.debug("Times: {}".format(times))
        return times
コード例 #22
0
ファイル: timer_app.py プロジェクト: ncsurobotics/acoustics
def main():
    # Initialize evironment
    pypruss.modprobe()
    pypruss.init()		# Init the PRU
    pypruss.open(0)		# Open PRU event 0 which is PRU0_ARM_INTERRUPT
    pypruss.pruintc_init()  # Init the interrupt controller

    # Configure PRU Registers
    pypruss.pru_write_memory(0, 0, [0, ])

    # Execute the PRU program
    a = time.time()
    pypruss.exec_program(0, "./bin/timer_app.bin")  # Load firmware on PRU0

    # Wait for PRU to finish its job.
    pypruss.wait_for_event(0)  # Wait for event 0 which is conn to PRU0_ARM_INTERUPT
    loop_time = time.time() - a

    # Once signal has been received, clean up house
    pypruss.clear_event(0)  # Clear the event
    pypruss.exit()		# Exit PRU

    print("That's a %ds loop you have there." % loop_time)
    print("Test completed: PRU was successfully opened and closed.")
コード例 #23
0
ファイル: pypruss_test.py プロジェクト: AhmedSamara/bot-1
with open("/dev/mem", "r+b") as f:  # Open the memory device
    mem = mmap.mmap(f.fileno(), 32, offset=pru_addr)  # mmap the right area

pypruss.init()  # Init the PRU
try:
    pypruss.open(0)  # Open PRU event 0 which is PRU0_ARM_INTERRUPT
except SystemError as e:
    print e
    print "Is the PRU module (uio_pruss) loaded?"

pypruss.pruintc_init()  # Init the interrupt controller
pypruss.exec_program(0, "./ultrasonic.bin")

while True:
    print "Wait for event... ",
    pypruss.wait_for_event(PRU_EVOUT_0)
    print "Got event"
    pypruss.clear_event(PRU_EVOUT_0, PRU0_ARM_INTERRUPT)
    time1, pre1, time2, pre2, time3, pre3, time4, pre4 = \
        struct.unpack_from('LLLLLLLL', mem, 0)
    print "Vals:"
    print "  %d, %d = %0.2f in" % (pre1, time1, time1 / 149.3)
    print "  %d, %d = %0.2f in" % (pre2, time2, time2 / 149.3)
    print "  %d, %d = %0.2f in" % (pre3, time3, time3 / 149.3)
    print "  %d, %d = %0.2f in" % (pre4, time4, time4 / 149.3)

    print "Wait for event2... ",
    pypruss.wait_for_event(PRU_EVOUT_0)
    print "Got event"
    pypruss.clear_event(PRU_EVOUT_0, PRU0_ARM_INTERRUPT)
コード例 #24
0
    print percentChange
    #Now we've compared. Let's write the most recent speed to our file.
    f = open('speed.txt', 'w')
    f.write(speed[0])
    f.close()

    pypruss.modprobe()  # This only has to be called once pr boot
    pypruss.init()  # Init the PRU
    pypruss.open(0)  # Open PRU event 0 which is PRU0_ARM_INTERRUPT
    pypruss.pruintc_init()  # Init the interrupt controller

    if percentChange < -5:
        pypruss.exec_program(0, "./red.bin")
    else:
        if percentChange < 0:
            pypruss.exec_program(0, "./orange.bin")
        else:
            if percentChange > 0:
                pypruss.exec_program(0, "./green.bin")
            else:
                pypruss.exec_program(0, "./other.bin")  #should never hit this

    pypruss.wait_for_event(
        0)  # Wait for event 0 which is connected to PRU0_ARM_INTERRUPT
    pypruss.clear_event(0)  # Clear the event
    pypruss.pru_disable(
        0)  # Disable PRU 0, this is already done by the firmware
    pypruss.exit()  # Exits pypruss
    time.sleep(interval)  # restarts speed evaluation after 'interval' seconds
コード例 #25
0
ファイル: ddr_write.py プロジェクト: smosh/BBB-PRU-Exercises
ddr_size = pypruss.ddr_size()

print "DDR memory address is 0x%x and the size is 0x%x"%(ddr_addr, ddr_size)

ddr_offset  = ddr_addr-0x10000000
ddr_filelen = ddr_size+0x10000000
ddr_start 	= 0x10000000
ddr_end 	= 0x10000000+ddr_size

pypruss.init()		# Init the PRU
pypruss.open(0)		# Open PRU event 0 which is PRU0_ARM_INTERRUPT
pypruss.pruintc_init()	# Init the interrupt controller
pypruss.pru_write_memory(0, 0, [ddr_addr, ddr_addr+ddr_size-4])	# Put the ddr address in the first region 
pypruss.exec_program(0, "./ddr_write.bin")	# Load firmware "ddr_write.bin" on PRU 0
pypruss.wait_for_event(0)	# Wait for event 0 which is connected to PRU0_ARM_INTERRUPT
pypruss.clear_event(0)		# Clear the event
pypruss.exit()			# Exit PRU

with open("/dev/mem", "r+b") as f:	# Open the physical memory device
	ddr_mem = mmap.mmap(f.fileno(), ddr_filelen, offset=ddr_offset) # mmap the right area

read_back = struct.unpack("L", ddr_mem[ddr_start:ddr_start+4])[0]	# Parse the data
read_back2 = struct.unpack("L", ddr_mem[ddr_end-4:ddr_end])[0]		# Parse the data

print "The first 4 bytes of DDR memory reads "+hex(read_back)
print "The last 4 bytes of DDR memory reads "+hex(read_back2)

ddr_mem.close()								# Close the memory 
f.close()								# Close the file

コード例 #26
0
ファイル: Ledgrid.py プロジェクト: CoryStewart/ledgrid
 def _sendPixels( self, data ):
     pypruss.pru_write_memory(0, 0, data)    # Load the data in the PRU ram
     pypruss.exec_program(0, self.prucode_file )    # Load firmware on PRU 0
     pypruss.wait_for_event(0)               # Wait for event 0 which is connected to PRU0_ARM_INTERRUPT
     sleep( 0.003 )                          # Allow pru to complete
     pypruss.clear_event(0)                  # Clear the event
コード例 #27
0
ファイル: pru_stick.py プロジェクト: pbrook/beagle-football
        pypruss.exec_program(1, prog)

    def read32(self, offset):
        return struct.unpack('L', self.data[offset:offset+4])[0]
    def write32(self, offset, val):
        self.data[offset:offset+4] = struct.pack('L', val)
    def poll(self, offset):
        newval = self.read32(offset)
        prev = self.val.get(offset)
        if prev != newval:
            self.val[offset] = newval
            print "%x = %x" % (offset, newval)
        return newval
    def stop(self):
        pypruss.pru_disable(1)				# Disable PRU 1, this is already done by the firmware
        pypruss.exit()
        self.data = None

if __name__ == '__main__':
    mon = PRUMonitor("./pru_stick.bin")
    mon.write32(COM_SET_POS, 0x808080)
    while True:
        mon.poll(0xf0)
        mon.poll(COM_RANGE)
        mon.poll(COM_CURRENT_POS)
        mon.poll(COM_INPUT_BITS)
        time.sleep(1.0/1000)
    pypruss.wait_for_event(event_nr)
    pypruss.clear_event(event_nr)
    mon.stop()
コード例 #28
0
ファイル: stabilizer.py プロジェクト: hexastorm/ldgraphy
pypruss.exec_program(0, "./stabilizer.bin")

if total_lines > queue_len:
    total_lines -= queue_len

# continue_line
#data = ([1] + line)
#bit_data = (len(data)//4+1)*[0]
#for idx, item in enumerate(data):
#    bit_data[idx//4]+=item<<(8*(idx%4))

byte = 1  # note byte0 is error
response = 1
while True:
    pypruss.wait_for_event(0)
    pypruss.clear_event(0, pypruss.PRU0_ARM_INTERRUPT)
    # read out result and state of the program
    with open("/dev/mem", "r+b") as f:
        # byte number should be set via amount interrupts received
        ddr_mem = mmap.mmap(f.fileno(), PRU_ICSS_LEN, offset=PRU_ICSS)
        # substracted 1 to read out error
        local = struct.unpack(
            'L', ddr_mem[RAM0_START + byte - 1:RAM0_START + byte - 1 + 4])
    # START_RINGBUFFER 1 --> ja hij zit in de 1//4 (eerste vier bytes)
    # bit shift to get the first byte
    # bit mask to ignore higher bytes
    command_index = (local[0] >> 8 * 1) & 255
    try:
        command = COMMANDS[command_index]
        if command == 'CMD_EMPTY':
            if response % queue_len == 0:
コード例 #29
0
ファイル: pypruss_test.py プロジェクト: AhmedSamara/bot-1
with open("/dev/mem", "r+b") as f:	            # Open the memory device
    mem = mmap.mmap(f.fileno(), 32, offset=pru_addr)  # mmap the right area

pypruss.init()    # Init the PRU
try:
    pypruss.open(0)  # Open PRU event 0 which is PRU0_ARM_INTERRUPT
except SystemError as e:
    print e
    print "Is the PRU module (uio_pruss) loaded?"

pypruss.pruintc_init()  # Init the interrupt controller
pypruss.exec_program(0, "./ultrasonic.bin")

while True:
    print "Wait for event... ",
    pypruss.wait_for_event(PRU_EVOUT_0)
    print "Got event"
    pypruss.clear_event(PRU_EVOUT_0, PRU0_ARM_INTERRUPT)
    time1, pre1, time2, pre2, time3, pre3, time4, pre4 = \
        struct.unpack_from('LLLLLLLL', mem, 0)
    print "Vals:"
    print "  %d, %d = %0.2f in" % (pre1, time1, time1/149.3)
    print "  %d, %d = %0.2f in" % (pre2, time2, time2/149.3)
    print "  %d, %d = %0.2f in" % (pre3, time3, time3/149.3)
    print "  %d, %d = %0.2f in" % (pre4, time4, time4/149.3)

    print "Wait for event2... ",
    pypruss.wait_for_event(PRU_EVOUT_0)
    print "Got event"
    pypruss.clear_event(PRU_EVOUT_0, PRU0_ARM_INTERRUPT)
コード例 #30
0
ファイル: stepper.py プロジェクト: miaoqqqq123/quickstep
#      self.rest = 0
      pass

steps, speed, acc, dec = (float(arg) for arg in sys.argv[1:5])

if sim:
  fifo = SimFifo()
else:
  fifo = init('./stepper.bin')

stepper = Stepper(fifo)
stepper.move(steps, speed, acc, dec)

if not sim:
  fifo.write([0,0,0,0])

  olda = fifo.front()
  while True:
    a = fifo.front()
    if not olda == a:
      print 'front:',a
      olda = a
    if a == fifo.back:
      break
    time.sleep(0.1)

  pypruss.wait_for_event(0)
  pypruss.clear_event(0)
  pypruss.pru_disable(0)
  pypruss.exit()
コード例 #31
0
        mem = mmap.mmap( m.fileno(), 512*1024, offset=PRU_ICSS)

        valuestring = mem[START:START+4]
        value = struct.unpack('L', valuestring)[0]
        seconds = value * 0.000000005   # 5ns per cycle

        return seconds


os.system("config-pin p8.15 pruin")

pypruss.modprobe()                                  # This only has to be called once pr boot
pypruss.init()                                      # Init the PRU
pypruss.open(0)                                     # Open PRU event 0 which is PRU0_ARM_INTERRUPT
pypruss.pruintc_init()                              # Init the interrupt controller
pypruss.exec_program(0, "./rpm.bin")                # Load firmware "blinkled.bin" on PRU 0

try:
    while True:
        pypruss.wait_for_event(0)                           # Wait for event 0 which is connected to PRU0_ARM_INTERRUPT

        seconds = readrpm()
        print( r'{} seconds'.format(seconds) )

        pypruss.clear_event(0,pypruss.PRU0_ARM_INTERRUPT)   # Clear the event

except KeyboardInterrupt as e:
    print(e)
    pypruss.pru_disable(0)                             # Disable PRU 0, this is already done by the firmware
    pypruss.exit()                                     # Exit, don't know what this does.
コード例 #32
0
 def _sendPixels( self, data ):
     pypruss.pru_write_memory(0, 0, data)    # Load the data in the PRU ram
     pypruss.exec_program(0, "./ledgriddrvr.bin")    # Load firmware on PRU 0
     pypruss.wait_for_event(0)               # Wait for event 0 which is connected to PRU0_ARM_INTERRUPT
     pypruss.clear_event(0)                  # Clear the event