def __init__(self, num=0): self.num = num pypruss.modprobe() pypruss.init() pypruss.open(self.num) pypruss.pruintc_init() pypruss.pru_write_memory(0,0,[ddr]) pypruss.exec_program(0,'./matrix.bin')
def __init__(self):
for pwm in range(16):
self.data.append(0x00000001) # Zero out the PWMs
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.pru_write_memory(0, 0, self.data)
def __init__(self): for pwm in range(16): self.data.append(0x00000001) # Zero out the PWMs 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.pru_write_memory(0, 0, self.data)
def __init__(self, prog):
self.val = {}
pypruss.modprobe()
pypruss.init()
pypruss.open(event_nr)
pypruss.pruintc_init()
pypruss.pru_disable(1)
self.data = pypruss.map_prumem(pypruss.PRUSS0_PRU1_DATARAM)
self.write32(COM_RANGE, 0)
pypruss.exec_program(1, prog)
def start(PWM_freq=1e7, PWM_duty_cycle=50, clock_divider=2):
GPIO.setup("P8_30",GPIO.OUT) #SPI CS for AWG
GPIO.output("P8_30",GPIO.HIGH) #Set CS high initally - i.e. disabled
GPIO.setup("P9_23",GPIO.OUT) #AFG External trigger. NB check JP1 setting too!
GPIO.setup("P9_24",GPIO.OUT) #What is this for? Possibly old code for the old SPI non bit banged bus?
PWM.start("P8_34",PWM_duty_cycle,PWM_freq) # setup ADC master clock 13e6 = 25khz ~ NCO sees 50MHz clock - connects to J10 on AFG
# NCO removed P8_46 because of a device tree conflict with SPI_overlay_PRU1
# PWM.start("P8_46",50,50e6) # 100e5
pypruss.modprobe() # This only has to be called once pr boot
def setup(this): 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 this.buffer = pypruss.map_prumem(pypruss.PRUSS0_PRU0_DATARAM) pypruss.exec_program(0, "./triac.bin") # Load firmware "blinkled.bin" on PRU 0 this.brightness = [0 for x in range(N_BULBS)] this.writeOffset = 0 this.write()
def init(pru_bin): pypruss.modprobe(1024) ddr_addr = pypruss.ddr_addr() ddr_size = pypruss.ddr_size() print "DDR memory address is 0x%x and the size is 0x%x"%(ddr_addr, ddr_size) fifo = Fifo(ddr_addr, ddr_size) pypruss.init() pypruss.open(0) pypruss.pruintc_init() pypruss.pru_write_memory(0,0,[ddr_addr]) pypruss.exec_program(0, pru_bin) return fifo
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.")
def __init__(self): for pwm in range(32): # Initialize the 32 PWM channels to 1 self.data.append(0x00000001) # Init the PRU pypruss.modprobe() pypruss.init() # Open PRU event 0 (PRU0_ARM_INTERRUPT) pypruss.open(0) # Init the interrupt controller pypruss.pruintc_init() # Write out our data structure to the PRU Data Ram pypruss.pru_write_memory(0, 0, self.data)
def __init__(self):
for pwm in range(32):
# Initialize the 32 PWM channels to 1
self.data.append(0x00000001)
# Init the PRU
pypruss.modprobe()
pypruss.init()
# Open PRU event 0 (PRU0_ARM_INTERRUPT)
pypruss.open(0)
# Init the interrupt controller
pypruss.pruintc_init()
# Write out our data structure to the PRU Data Ram
pypruss.pru_write_memory(0, 0, self.data)
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.
def start(PWM_freq=1e7, PWM_duty_cycle=50, clock_divider=2):
GPIO.setup("P8_30", GPIO.OUT) #SPI CS for AWG
GPIO.output("P8_30", GPIO.HIGH) #Set CS high initally - i.e. disabled
GPIO.setup("P9_23",
GPIO.OUT) #AFG External trigger. NB check JP1 setting too!
GPIO.setup(
"P9_24", GPIO.OUT
) #What is this for? Possibly old code for the old SPI non bit banged bus?
PWM.start(
"P8_34", PWM_duty_cycle, PWM_freq
) # setup ADC master clock 13e6 = 25khz ~ NCO sees 50MHz clock - connects to J10 on AFG
# NCO removed P8_46 because of a device tree conflict with SPI_overlay_PRU1
# PWM.start("P8_46",50,50e6) # 100e5
pypruss.modprobe() # This only has to be called once pr boot
def __init__(self):
pypruss.modprobe(100)
print 'Initializing PRU'
pypruss.init()
print 'successfully initialized!'
if pypruss.open(0):
print 'PRU open failed'
return 1
pypruss.pruintc_init()
self.pruData = pypruss.map_prumem(pypruss.PRUSS0_PRU0_DATARAM)
pypruss.exec_program(0, "./hcsr04.bin")
def __init__(self):
pru_hz = 200*1000*1000 # The PRU has a speed of 200 MHz
self.s_pr_inst = 1.0/pru_hz # I take it every instruction is a single cycle instruction
self.s_pr_inst_2 = 2.0*(1.0/pru_hz) # I take it every instruction is a single cycle instruction
self.inst_pr_loop = 16 # This is the minimum number of instructions needed to step.
self.inst_pr_delay = 2 # Every loop adds two instructions: i-- and i != 0
self.sec_to_inst_dev = (self.s_pr_inst*2)
self.pru_data = [] # This holds all data for one move (x,y,z,e1,e2)
self.ddr_used = Queue.Queue(30) # List of data lengths currently in DDR for execution
self.ddr_reserved = 0
self.ddr_mem_used = 0
self.clear_events = []
self.ddr_lock = Lock()
self.debug = 0
self.i = 0
pypruss.modprobe(0x40000) # This only has to be called once pr boot
self.ddr_addr = pypruss.ddr_addr()
self.ddr_size = pypruss.ddr_size()
print "The DDR memory reserved for the PRU is "+hex(self.ddr_size)+" and has addr "+hex(self.ddr_addr)
ddr_offset = self.ddr_addr-0x10000000 # The Python mmap function cannot accept unsigned longs.
ddr_filelen = self.ddr_size+0x10000000
self.DDR_START = 0x10000000
self.DDR_END = 0x10000000+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
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, [self.ddr_addr, self.ddr_nr_events]) # Put the ddr address in the first region
pypruss.exec_program(0, "../firmware/firmware_pru_0.bin") # Load firmware "ddr_write.bin" on PRU 0
self.t = Thread(target=self._wait_for_events) # Make the thread
self.running = True
self.t.start()
logging.debug("PRU initialized")
def init(pru_bin):
pypruss.modprobe(1024)
ddr_addr = pypruss.ddr_addr()
ddr_size = pypruss.ddr_size()
print "DDR memory address is 0x%x and the size is 0x%x"%(ddr_addr, ddr_size)
fifo = Fifo(ddr_addr, ddr_size)
pypruss.init()
pypruss.open(0)
pypruss.pruintc_init()
pru_init = [ddr_addr, len(axes)]
for step_addr, step_pin, dir_addr, dir_pin in axes:
pru_init += [step_addr+0x194, 1 << step_pin,
dir_addr+0x194, 1 << dir_pin,
0, 0]
pypruss.pru_write_memory(0,0,pru_init)
pypruss.exec_program(0, pru_bin)
return fifo
def ready_pruss_for_burst(self, CR=None):
""" Arms the ADC for sample collection. This removes some GPIO control
from the BBB, and replaces it with PRUIN/OUT control.
"""
# Initialize variables
if CR is None:
CR = self.conversion_rate
else:
self.conversion_rate = CR
if CR == 0:
raise ValueError("CR currently set to 0 (DEFAULT), indicating that"
+ "user forgot to preset the sample/conversion rate."
+ "prior to calling this function.")
CR_BITECODE = int(round(1.0 / CR * F_CLK)) # Converts user CR input to Hex.
# 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
# init PRU Registers
pypruss.exec_program(0, INIT0) # Cleaning the registers
pypruss.exec_program(1, INIT1) # Cleaning the registers
pypruss.pru_write_memory(0, 0x0000, [0x0, ] * 0x0800) # clearing pru0 ram
pypruss.pru_write_memory(0, 0x0800, [0x0, ] * 0x0800) # clearing pru1 ram
pypruss.pru_write_memory(0, 0x4000, [0x0, ] * 300) # clearing ack bit from pru1
pypruss.pru_write_memory(0, PRU0_CR_Mem_Offset, [CR_BITECODE, ]) # Setting conversion
pypruss.exec_program(1, ADS7865_ClkAndSamplePRU) # Load firmware on PRU1
# end readying process by arming the PRUs
boot.arm()
self.arm_status = 'armed'
self.modified = False
def init():
import pypruss
import mmap
import Adafruit_BBIO.GPIO as GPIO
print "> pypruss init"
with open("/dev/mem", "r+b") as f: # Open the memory device
ddr_mem = mmap.mmap(f.fileno(), DDR_FILELEN, offset=DDR_BASEADDR) #
data = "".join(map(chr,
[0, 0, 0, 0])) # Make the data, it needs to be a string
ddr_mem[
DDR_OFFSET:DDR_OFFSET +
4] = data # Write the data to the DDR memory, four bytes should suffice
ddr_mem.close() # Close the memory
f.close() # Close the file
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
GPIO.setup('P9_15', GPIO.OUT)
GPIO.setup('P9_23', GPIO.OUT)
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.")
#print lines
#f = open('out.txt'), 'w')
speed = [line.strip() for line in cmd.stdout]
print lines[0] #need a file with a number in it for this to work
print speed[0]
percentChange = (
(float(speed[0]) - float(lines[0])) /
float(lines[0])) * 100 ##Calculate the new percent changed
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
from __future__ import print_function import pypruss import os #on PRU0 # wait for input on PRU0 to go high. # when it goes high, send interrupt to PRU1. #on PRU1 # wait for interrupt from PRU0 # generate square wave pypruss.modprobe() pypruss.init() # Init the PRU pypruss.open(0) # Open PRU event 0 which is PRU0_ARM_INTERRUPT pypruss.open(1) # also PRU1 pypruss.pruintc_init() pypruss.exec_program(0, "./PRU0toPRU1.bin") pypruss.exec_program(1, "./PRU1toPRU0.bin") pypruss.wait_for_event(0) # wait for an interrupt from PRU0. currently not sent, use CtrlC
import pypruss
import os
print "This example toggles pin P8.12 as fast as it can, 5ns pr cycle."
print "It muxes the pin to mode 6 and does not stop, so use Ctrl-c to end the script."
#P8.12 = gpio_num = 44
gpio_num = 44
#os.system("echo 6 > /sys/kernel/debug/omap_mux/gpmc_ad12")
open("/sys/class/gpio/export", "w").write(str(gpio_num))
open("/sys/class/gpio/gpio%d/direction" % gpio_num, "w").write("out")
open("/sys/class/gpio/gpio%d/value" % gpio_num, "w").write("1")
pypruss.modprobe(1000)
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, "./speed_test.bin") # Load firmware "blinkled.bin" on PRU 0
pypruss.wait_for_event(
0) # Wait for event 0 which is connected to PRU0_ARM_INTERRUPT
def __init__( self ):
pypruss.modprobe() # This only has to be called once per 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
''' blinkled.py - test script for the PyPRUSS library It blinks the user leds ten times''' import pypruss 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, "./blinkled.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.
from __future__ import print_function
import pypruss
print("Running modprobe")
pypruss.modprobe(1000)
print("modprobe ok")
pypruss.init()
print("init ok")
pypruss.open(0)
print("open ok")
pypruss.pruintc_init()
print("intc ok")
print("ddr addr is " + hex(pypruss.ddr_addr()))
print("ddr size is " + hex(pypruss.ddr_size()))
pypruss.exit()
print("exit ok")
pypruss.modunprobe()
print("modunprobe ok")
frame = frame[:PAYLOAD_LEN]
len_byte = struct.pack('B', len(frame))
self.ddr_mem[self.frames_ptr] = len_byte
frame_offset = self.frames_ptr + 1
self.ddr_mem[frame_offset:frame_offset + len(frame)] = \
frame
produce = (produce + 1) % TX_RING_BUFFER_LEN
self.frames_ptr = \
self.frames_base + (produce * FRAME_SIZE)
self.ddr_mem[self.struct_start:self.struct_start +
RING_BUFFER_CONSUME_OFFSET] = \
struct.pack('L', produce)
pypruss.modprobe()
sock = socket.socket(family=socket.AF_INET, type=socket.SOCK_DGRAM)
try:
sock.bind(('localhost', UDP_PORTS[0]))
except OSError as e:
print(e)
sys.exit(-1)
f = open("/dev/mem", "r+b")
shared_mem = mmap.mmap(f.fileno(), SHARED_FILELEN, offset=SHARED_OFFSET)
if TARGET_PRU_NO == 1:
pypruss.init()
def memread(self, offset, length):
begin = self.ddr_start + offset
return struct.unpack('l'*length,
self.ddr_mem[begin:begin+4*length])
def write(self, data):
self.back += self.memwrite(self.back, data, 'l')
if self.back >= self.fifo_size:
self.back = 8
self.memwrite(4, [self.back])
def front(self):
return struct.unpack('L',
self.ddr_mem[self.ddr_start:self.ddr_start+4])[0]
pypruss.modprobe(1024)
ddr_addr = pypruss.ddr_addr()
ddr_size = pypruss.ddr_size()
print "DDR memory address is 0x%x and the size is 0x%x"%(ddr_addr, ddr_size)
fifo = Fifo(ddr_addr, ddr_size)
pypruss.init()
pypruss.open(0)
pypruss.pruintc_init()
pypruss.pru_write_memory(0,0,[ddr_addr])
pypruss.exec_program(0, "./division.bin")
fifo.write([int(i) for i in sys.argv[1:3]])
fifo.write([0,0])
