def main():
# Set up shared data
shm = SharedMemory(IPC_PRIVATE, size=SHARED_MEMORY_SIZE, flags=IPC_CREAT)
mutex = Semaphore(IPC_PRIVATE, initial_value=1,
flags=IPC_CREAT | IPC_EXCL)
empty = Semaphore(IPC_PRIVATE, initial_value=BUF_SIZE,
flags=IPC_CREAT | IPC_EXCL)
full = Semaphore(IPC_PRIVATE, flags=IPC_CREAT | IPC_EXCL)
print('Forking producer')
producer_id = fork()
if not producer_id:
producer(shm, mutex, empty, full)
print('Forking consumer')
consumer_id = fork()
if not consumer_id:
consumer(shm, mutex, empty, full)
# Wait for children
wait()
wait()
# Clean up.
shm.detach()
shm.remove()
mutex.remove()
empty.remove()
full.remove()
def __init__(self, name, robot_name, pid, struct_name=None, n_data=1):
self._name = name
self._robot_name = robot_name
self._struct_name = struct_name
self._data_type = None
self._struct_type = None
self._semaphore = None
fields = self.read_format(n_data=n_data)
self._struct_type = type(name, (CStruct, ), {'_fields_': fields})
try:
key = get_semaphore_key(self.shmemory_name, pid)
# weird bug - only smMiscSimSensors finds a different key
if 'smMiscSimSensors' in self.shmemory_name:
key = key + 1
SharedMemory.__init__(self, key, size=self.size)
except ExistentialError:
raise Exception('Cannot access shared memory {}'.format(
self.shmemory_name))
self._semaphore = get_semaphore(self.semaphore_name, pid)
def start(self):
""" Start shared memory client """
self.shared_memory = SharedMemory(key=self.key)
self.buffer = memoryview(self.shared_memory)
self.size = self.shared_memory.size
logger.info('Started FrameBufferClient - key=%s, size=%d', \
self.key, self.size)
def start(self):
""" Start shared memory server """
self.shared_memory = SharedMemory(key=None,
flags=IPC_CREX,
size=self.size)
self.buffer = memoryview(self.shared_memory)
self.key = self.shared_memory.key
logger.info('Started FrameBufferServer - key=%s, size=%d', self.key,
self.size)
class FrameBufferClient:
def __init__(self, key: str):
self.buffer = None
self.key = key
self.shared_memory = None
self.size = None
self._hasher = pyhash.t1ha0()
def __enter__(self):
self.start()
return self
def __exit__(self, exc_type, exc_value, exc_traceback):
self.stop()
def start(self):
""" Start shared memory client """
self.shared_memory = SharedMemory(key=self.key)
self.buffer = memoryview(self.shared_memory)
self.size = self.shared_memory.size
logger.info('Started FrameBufferClient - key=%s, size=%d', \
self.key, self.size)
def stop(self):
""" Stop shared memory client """
self.shared_memory.detach()
logger.info('Stopped FrameBufferClient - key=%s, size=%d', \
self.key, self.size)
def set_key(self, key):
""" Set shared memory key (must be done before __enter__/start) """
self.key = key
def write(self, offset: int, data: bytes) -> str:
""" Returns `checksum` """
bytes_to_back = min(len(data), self.size - offset)
bytes_to_front = len(data) - bytes_to_back
self.buffer[offset:offset + bytes_to_back] = data[0:bytes_to_back]
if bytes_to_front > 0:
self.buffer[0:bytes_to_front] = data[bytes_to_back:]
_hash = base64.b64encode(
self._hasher(data).to_bytes(8, sys.byteorder)).decode()
return _hash
def read(self, offset: int, size: int, checksum: str) -> bytes:
""" Raises `FrameBufferTimeout` on invalid checksum """
bytes_from_back = min(size, self.size - offset)
bytes_from_front = size - bytes_from_back
data = bytes(self.buffer[offset:offset + bytes_from_back])
if bytes_from_front > 0:
data += bytes(self.buffer[0:bytes_from_front])
_hash = base64.b64encode(
self._hasher(data).to_bytes(8, sys.byteorder)).decode()
if _hash != checksum:
raise FrameBufferTimeout(
"Invalid checksum - buffer already reused")
return data
class FlyARData(object):
def __init__(self):
self._haveSharedMemKeys = False
self._rollMem = None
self._roll = 0
self._pitchMem = None
self._pitch = 0
self._yawMem = None
self._yaw = 0
def update(self):
'''
Updates the object with the latest from shared memory. Then call the
respective properties to get updated values
'''
if not self._haveSharedMemKeys:
# Get the shared memory keys from the file
with open('/var/tmpflyar/raw_shared_memory_keys.flyar', 'r') as f:
for line in f:
self._haveSharedMemKeys = True
values = line.strip().split(',')
self._rollMem = SharedMemory(int(values[0]))
self._pitchMem = SharedMemory(int(values[1]))
self._yawMem = SharedMemory(int(values[2]))
# Get the latest data from shared memory
self._roll = float(self._rollMem.read())
self._pitch = float(self._pitchMem.read())
self._yaw = float(self._yawMem.read())
@property
def roll(self):
return self._roll
@roll.setter
def roll(self, value):
self._roll = value
@property
def pitch(self):
return self._pitch
@pitch.setter
def pitch(self, value):
self._pitch = value
@property
def yaw(self):
return self._yaw
@yaw.setter
def yaw(self, value):
self._yaw = value
def zpixmap_shm_to_image(shm: sysv_ipc.SharedMemory, size: int, width: int,
height: int) -> np.ndarray:
out = np.frombuffer(shm.read(size), "<B").copy()
out.shape = (height, width, 4)
out[:, :, 3] = 0xFF # Convert BGRX to BGRA
return out
def Init():
Log.info("Attaching commondata shm")
if (CommonData.publicshm == None):
try:
CommonData.publicshm = SharedMemory(Config.PUBLIC_SHMKEY,
size=PUBLICSHM_SIZE)
except ExistentialError:
Log.error("time daemon not started")
raise Exception("Initialization failed: publicshm not created")
def Init():
if (UCache.uidshm == None):
try:
Log.info("Attaching to UCACHE shared memory")
UCache.uidshm = SharedMemory(Config.Config.GetInt("UCACHE_SHMKEY", 3696), size = UCache.UIDSHM_SIZE)
except ExistentialError:
Log.info("Creating UCACHE shared memory")
# not implemented!
raise Exception("Not implemented: Init UCache SHM")
Log.info("UCache initialization finished")
class FrameBufferServer:
def __init__(self, size: int):
self.buffer = None
self.key = None
self.shared_memory = None
self.size = size
self.offset = 0
def __enter__(self):
self.start()
return self
def __exit__(self, exc_type, exc_value, exc_traceback):
self.stop()
def start(self):
""" Start shared memory server """
self.shared_memory = SharedMemory(key=None,
flags=IPC_CREX,
size=self.size)
self.buffer = memoryview(self.shared_memory)
self.key = self.shared_memory.key
logger.info('Started FrameBufferServer - key=%s, size=%d', self.key,
self.size)
def stop(self):
""" Stop shared memory server """
self.shared_memory.detach()
self.shared_memory.remove()
logger.info('Stopped FrameBufferServer - key=%s, size=%d', self.key,
self.size)
def get_key(self) -> str:
""" Return client key for shared memory access """
return self.key
def allocate(self, size: int) -> int:
""" Allocates a chunk of data and returns offset """
offset = self.offset
self.offset = (self.offset + size) % self.size
return offset
def run(self):
time.sleep(3)
shared_mem = SharedMemory(6789,
flags=sysv_ipc.IPC_CREAT,
size=sysv_ipc.PAGE_SIZE,
init_character='\0')
try:
while self.work:
for i in range(
len(stations)
): # convert position to integer then string and fill with 4 zero to align values
shared_mem.write(
' '.join(
str(pos).split(".")[0].zfill(4)
for pos in stations[i].params["position"]) + ' ',
i * 15)
else:
print(shared_mem.read(45))
shared_mem.remove()
except:
shared_mem.remove()
def __start_torcs(self):
if self.torcs_process:
subprocess.call('rm -rf /tmp/.X*', shell=True)
self.torcs_process.kill()
self.disp_process.kill()
else:
self.torcs_logpoller = ProcessLogPoller(self.logdir)
self.torcs_logpoller.start()
color_depth = 24
screen_res = '{}x{}x{}'.format(self.screen_w, self.screen_h,
color_depth)
self.disp_process = subprocess.Popen(
['Xvfb', self.disp_name, '-ac', '-screen', '0', screen_res],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
self.logger.info('Xvfb pid:{}, display:{}', self.disp_process.pid,
self.disp_name)
torcs_bin = os.path.join(self.torcs_dir, 'lib/torcs/torcs-bin')
torcs_lib = os.path.join(self.torcs_dir, 'lib/torcs/lib')
torcs_data = os.path.join(self.torcs_dir, 'share/games/torcs/')
self.torcs_process = Popen([
torcs_bin, '-port',
str(self.port), '-nofuel', '-nodamage', '-nolaptime', '-cmdFreq',
'25', '-h',
str(self.screen_h), '-w',
str(self.screen_w)
],
env={
'LD_LIBRARY_PATH': torcs_lib,
'DISPLAY': self.disp_name
},
cwd=torcs_data,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
self.torcs_logpoller.set_process(self.torcs_process)
for cmd in self.LAUNCH_SEQ:
time.sleep(0.8)
subprocess.call(['xdotool', 'key', cmd],
env={'DISPLAY': self.disp_name})
self.shared_memory = SharedMemory(self.port)
self.logger.info('Started torcs pid:{}, port:{}',
self.torcs_process.pid, self.port)
def update(self):
'''
Updates the object with the latest from shared memory. Then call the
respective properties to get updated values
'''
if not self._haveSharedMemKeys:
# Get the shared memory keys from the file
with open('/var/tmpflyar/raw_shared_memory_keys.flyar', 'r') as f:
for line in f:
self._haveSharedMemKeys = True
values = line.strip().split(',')
self._rollMem = SharedMemory(int(values[0]))
self._pitchMem = SharedMemory(int(values[1]))
self._yawMem = SharedMemory(int(values[2]))
# Get the latest data from shared memory
self._roll = float(self._rollMem.read())
self._pitch = float(self._pitchMem.read())
self._yaw = float(self._yawMem.read())
class Bitmap():
def __init__(self):
self.shm = SharedMemory(None, flags = IPC_EXCL|IPC_CREAT,
mode= 0o600, size = bitmap_size, init_character = b'\x00')
# to show we are alive
self.shm.write('\x01')
# print(self.bytes())
# self.shm.attach()
def get_key(self):
return self.shm.key
def get_id(self):
return self.shm.id
def get_size(self):
return bitmap_size
def bytes(self):
buffer = self.shm.read(bitmap_size)
n = 0
for i in range(bitmap_size):
if buffer[i] != 0:
n += 1
return n
def has_new_bits(self):
ret = 0
buffer = self.shm.read(bitmap_size)
for i in range(bitmap_size):
if buffer[i] and buffer[i] & virgin_bits[i]:
virgin_bits[i] &= ~buffer[i]
if virgin_bits[i] == 0xff:
ret = 2
elif ret < 1:
ret = 1
return ret
def release(self):
self.shm.remove()
import logging
logging.basicConfig(filename='/var/tmpflyar/flyar.log', filemode='w', level=logging.INFO)
from sysv_ipc import SharedMemory, IPC_CREX
from time import time
from smclear import padString
import gc
from os import system
# Open the serial connection. The Pi sometimes like to switch back and forth between ttyACM0 and ttyACM1, so try 0. If it fails, fall back to 1.
try:
ser = Serial("/dev/ttyACM0", 115200)
except SerialException:
ser = Serial("/dev/ttyACM1", 115200)
# Set up the necessary shared memory locations
rollMem = SharedMemory(None, IPC_CREX)
pitchMem = SharedMemory(None, IPC_CREX)
yawMem = SharedMemory(None, IPC_CREX)
# Store the shared memory locations to a file
with open('/var/tmpflyar/raw_shared_memory_keys.flyar', 'wb') as f:
sharedMemoryKeys = '{},{},{}\n'.format(rollMem.key, pitchMem.key, yawMem.key)
logging.info('[ARDUINO-READER] Storing the following shared memory keys to /var/tmpflyar/raw_shared_memory_keys.flyar: {}'.format(sharedMemoryKeys))
f.write(str.encode(sharedMemoryKeys))
while True:
# Send a '1' byte to the Arduino to indicate that we want data
ser.write(b'1')
# Now that the Arduino should now be sending back data, read it in
data = ser.readline().decode('utf-8')
from struct import pack,unpack
from sys import argv, stdin
if len(argv) != 3:
print "%s PID|prog instrument.js"
exit()
def on_message(msg, data):
try:
bb = msg['payload']
print bb
byte = unpack( 'B', shm.read(1, bb%0x10000) )[0]
shm.write( pack('B', (byte+1)%0x100), bb%0x10000 )
except Exception as e:
print msg
JS = open( argv[2] ).read()
SHM_KEY = 0x20137
shm = SharedMemory(SHM_KEY)
device = frida.get_device('local')
for p in device.enumerate_processes():
if argv[1] in [str(p.pid), p.name]:
target = p.pid
session = device.attach(target)
script = session.create_script(JS)
script.on('message', on_message)
script.load()
stdin.read()
previousTime = None
xAccelMem = None
yAccelMem = None
zAccelMem = None
rollMem = None
pitchMem = None
yawMem = None
rollDegMemFrom = None
pitchDegMemFrom = None
yawDegMemFrom = None
# Get the shared memory keys from the config file living in /var/tmpflyar
with open('/var/tmpflyar/raw_shared_memory_keys.flyar', 'r') as f:
for line in f:
values = line.strip().split(',')
xAccelMem = SharedMemory(int(values[0]))
yAccelMem = SharedMemory(int(values[1]))
zAccelMem = SharedMemory(int(values[2]))
rollMem = SharedMemory(int(values[3]))
pitchMem = SharedMemory(int(values[4]))
yawMem = SharedMemory(int(values[5]))
rollDegMemFrom = SharedMemory(int(values[6]))
pitchDegMemFrom = SharedMemory(int(values[7]))
yawDegMemFrom = SharedMemory(int(values[8]))
# Get shared memory locations for the actual data we'll need
xPosMem = SharedMemory(None, IPC_CREX)
yPosMem = SharedMemory(None, IPC_CREX)
zPosMem = SharedMemory(None, IPC_CREX)
rollDegMemTo = SharedMemory(None, IPC_CREX)
pitchDegMemTo = SharedMemory(None, IPC_CREX)
from sysv_ipc import SharedMemory
from os import system
roll = None
pitch = None
yaw = None
with open('/var/tmpflyar/raw_shared_memory_keys.flyar', 'r') as f:
for line in f:
values = line.strip().split(',')
roll = SharedMemory(int(values[2]))
pitch = SharedMemory(int(values[1]))
yaw = SharedMemory(int(values[0]))
print("Roll: {}".format(roll.read().strip()))
print("Pitch: {}".format(pitch.read().strip()))
print("Yaw: {}".format(yaw.read().strip()))
import logging
logging.basicConfig(filename='/var/tmpflyar/flyar.log', filemode='w', level=logging.INFO)
from sense_hat import SenseHat
from sysv_ipc import SharedMemory, IPC_CREX
from time import time
from smclear import padString
import gc
sense = SenseHat()
# Set up the necessary shared memory locations
rollMem = SharedMemory(None, IPC_CREX)
pitchMem = SharedMemory(None, IPC_CREX)
yawMem = SharedMemory(None, IPC_CREX)
currentTime = time()
# Store the shared memory locations to a file
with open('/var/tmpflyar/raw_shared_memory_keys.flyar', 'wb') as f:
sharedMemoryKeys = '{},{},{}\n'.format(rollMem.key, pitchMem.key, yawMem.key)
logging.info(str(currentTime) + ':[SENSE-READER] Storing the following shared memory keys to /var/tmpflyar/raw_shared_memory_keys.flyar: {}'.format(sharedMemoryKeys))
f.write(str.encode(sharedMemoryKeys))
while True:
# Process the data and store it in shared memory
orien = sense.get_orientation_degrees()
rollMem.write(padString("{0:.4f}".format(orien['roll'])).encode())
pitchMem.write(padString("{0:.4f}".format(orien['pitch'])).encode())
yawMem.write(padString("{0:.4f}".format(orien['yaw'])).encode())
gc.collect()
def __init__(self):
self.shm = SharedMemory(None, flags = IPC_EXCL|IPC_CREAT,
mode= 0o600, size = bitmap_size, init_character = b'\x00')
# to show we are alive
self.shm.write('\x01')
#!usr/bin/env python # encoding: utf-8 # Archivo de lectura de la memoria compartida. from sysv_ipc import SharedMemory from numpy import frombuffer, float32 from subprocess import call shm_key = 0x1234; # Vinvculamos la memoria compartida a una instancia. mem = SharedMemory(shm_key) # Leemos la memoria compartida. memory_value = mem.read() # Convertimos la lectura de bytes a numpy array. y = frombuffer(memory_value, dtype=float32) print(y) # Desvinculamos la instancia. mem.detach() # Removemos la memoria. mem.remove()
