shudder5305/pupilometer
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Removing older version and temporary tests from repo

Browse Source
This commit is contained in:
Tempest 2025-09-19 20:30:34 +07:00
parent bda937a889
commit b4cfbbe60b
2 changed files with 0 additions and 248 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

118
src/controllerSoftware/run.py
View File

@ -1,118 +0,0 @@
import asyncio
import time
from bleak import BleakScanner, BleakClient
lampAmount = 25
LampArray = {
"Center": [0],
"Up": [1,2,8,9,10,11,12,13,23,24],
"Down": [4,5,6,15,16,17,18,19,20,21],
"Left": [6,3,8,9,19,20,21,22,23,12],
"Right": [2,7,4,11,24,13,14,15,16,17],
"Inner": [1,2,3,4,5,6,7,8],
"Outer": [9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24]
}
colorArray = ["500000","005000","000050"]
colorArrayTest = ["050000","000500"]
def sectionInitializer():
result = [b'\x00\x00\x00'] * lampAmount
return result
def sectionSerializer(section, color):
result = sectionInitializer()
sectionResult = LampArray[section]
for pos in sectionResult:
result[pos] = int(color,16).to_bytes(3,'big')
return result
def posColorByte(pos, section, color):
intColor = int(color, 16)
result = int(intColor * section[pos])
print(result)
return result.to_bytes(3)
async def setOnUserInput(client, chars):
while True:
configZone = input("Input Zone [Up, Down, Left, Right, Inner, Outer]: ")
if configZone not in list(LampArray.keys()):
continue
configColor = input("Input Color [000000]: ")
configColorCenter = input("Input Color for Center Lamp [000000]: ")
await setLampToColor(client, chars, configZone, configColor, configColorCenter)
async def setLampToColor(bleClient, bleChars, section, color, colorCenter):
sectionSerial = sectionSerializer(section, color)
sectionSerial[0] = int(colorCenter,16).to_bytes(3,'big')
for char in bleChars:
lampPos = bleChars.index(char)
value = sectionSerial[lampPos]
print(f"Setting Lamp number {lampPos} to {value}")
await bleClient.write_gatt_char(char.uuid, value)
async def connect_to_ble_device(device_name):
print(f"Scanning for device: {device_name}...")
devices = await BleakScanner.discover()
global services
global client
target_device = None
for device in devices:
if device.name == device_name:
target_device = device
break
if target_device:
print(f"Found device: {target_device.name} ({target_device.address})")
async with BleakClient(target_device.address) as client:
if client.is_connected:
print(f"Connected to {target_device.name}")
# Now you can interact with services and characteristics
# Example: Read a characteristic (replace with actual UUID)
# battery_level = await client.read_gatt_char("00002a19-0000-1000-8000-00805f9b34fb")
# print(f"Battery Level: {int.from_bytes(battery_level, 'little')}%")
else:
print(f"Failed to connect to {target_device.name}")
exit(1)
services = sorted(client.services, key=lambda serv: serv.handle)
print("\n--- Services and Characteristics ---")
for service in services:
print(f"\nService: {service.uuid} (Handle: {service.handle}) - {service.description}")
# Get all characteristics for the current service
characteristics = service.characteristics
# Sort the characteristics by handle
sorted_characteristics = sorted(characteristics, key=lambda char: char.handle)
print("Characteristics sorted by handle:")
for char in sorted_characteristics:
print(f" Characteristic: {char.uuid} (Handle: {char.handle})")
print(f" Description: {char.description}")
print(f" Properties: {char.properties}")
if "read" in char.properties:
try:
await client.write_gatt_char(char.uuid, bytes.fromhex("000005"))
time.sleep(1)
value = await client.read_gatt_char(char.uuid)
print(f" Value: {value.hex()} (raw bytes)")
except Exception as e:
print(f" Could not read characteristic {char.uuid}: {e}")
else:
print(" (Read not supported)")
# for color in colorArray:
# await setLampToColor(client, service.characteristics, Up, color)
# await setLampToColor(client, service.characteristics, Down, color)
# await setLampToColor(client, service.characteristics, Left, color)
# await setLampToColor(client, service.characteristics, Right, color)
# await setLampToColor(client, service.characteristics, Inner, color)
# await setLampToColor(client, service.characteristics, Outer, color)
if service.handle != 1:
await setOnUserInput(client, sorted_characteristics)
else:
print(f"Device '{device_name}' not found.")
if __name__ == "__main__":
# Replace 'YourDeviceName' with the actual name of your BLE device
asyncio.run(connect_to_ble_device("Pupilometer LED Billboard"))

130
src/controllerSoftware/web.py
View File

@ -1,130 +0,0 @@
from flask import Flask, render_template, request, jsonify
# ... (paste the two helper functions here if they are not already present) ...
app = Flask(__name__)
def create_spiral_map(n=5):
"""
Creates a pre-computed spiral mapping for an n x n matrix.
The spiral starts from the center, moves up, then right, and spirals outwards.
Args:
n (int): The size of the square matrix.
Returns:
list of lists: A 2D list where each element is the spiraling address.
"""
if n % 2 == 0:
raise ValueError("Matrix size must be odd for a unique center point.")
spiral_map = [[0] * n for _ in range(n)]
# Starting position and index
r, c = n // 2, n // 2
address = 0
spiral_map[r][c] = address
# Directions: Up, Right, Down, Left
# This is the key change to adjust the spiral path
dr = [-1, 0, 1, 0]
dc = [0, 1, 0, -1]
direction = 0
segment_length = 1
steps = 0
while address < n * n - 1:
for _ in range(segment_length):
address += 1
r += dr[direction]
c += dc[direction]
if 0 <= r < n and 0 <= c < n:
spiral_map[r][c] = address
direction = (direction + 1) % 4
steps += 1
if steps % 2 == 0:
segment_length += 1
return spiral_map
def get_spiral_address(row, col, spiral_map):
"""
Converts a standard (row, col) address to a spiraling address
using a pre-computed map.
Args:
row (int): The row index (0-indexed).
col (int): The column index (0-indexed).
spiral_map (list of lists): The pre-computed spiral map.
Returns:
int: The spiraling address, or -1 if the coordinates are out of bounds.
"""
n = len(spiral_map)
if 0 <= row < n and 0 <= col < n:
return spiral_map[row][col]
else:
return -1
# Pre-compute the spiral map for a 5x5 matrix when the app starts
SPIRAL_MAP_5x5 = create_spiral_map(5)
# Initialize a 5x5 matrix with all lamps off (black color code)
lamp_matrix = [['#000000' for _ in range(5)] for _ in range(5)]
# Define a helper function to convert hex to RGB for template use
def hex_to_rgb(hex_color):
hex_color = hex_color.lstrip('#')
return {
'r': int(hex_color[0:2], 16),
'g': int(hex_color[2:4], 16),
'b': int(hex_color[4:6], 16)
}
app.jinja_env.globals.update(hex_to_rgb=hex_to_rgb)
@app.route('/')
def index():
"""
Renders the main control interface for the RGB lamp matrix.
"""
return render_template('index.html', matrix=lamp_matrix)
@app.route('/set_color', methods=['POST'])
def set_color():
"""
Sets the color for multiple lamps and turns all others black.
"""
data = request.get_json()
lamps_to_update = data.get('lamps', [])
r = data.get('r')
g = data.get('g')
b = data.get('b')
try:
r, g, b = int(r), int(g), int(b)
new_color = '#{:02x}{:02x}{:02x}'.format(r, g, b)
# First, turn all lamps black
for row in range(5):
for col in range(5):
lamp_matrix[row][col] = '#000000'
# Then, apply the new color to the selected lamps
for lamp in lamps_to_update:
row = lamp['row']
col = lamp['col']
if 0 <= row < 5 and 0 <= col < 5:
lamp_matrix[row][col] = new_color
print(get_spiral_address(row, col, SPIRAL_MAP_5x5))
return jsonify(success=True, new_color=new_color)
except (ValueError, TypeError, IndexError):
return jsonify(success=False, message="Invalid data received")
if __name__ == '__main__':
app.run(debug=True,host='0.0.0.0')