@tigerpython/robotics-libraries 1.4.0

package/microbit/mbxgo.py

@@ -0,0 +1,173 @@
+from microbit import *
+
+_speed = 50
+_XGOInit = False
+_TX = pin14
+_RX = pin13
+
+
+def checkInit(func):
+    def wrapper(*args, **kwargs):
+        global _XGOInit
+        if not _XGOInit:
+            init_xgo_serial(_TX, _RX)
+        return func(*args, **kwargs)
+    return wrapper
+
+
+def _map(speed, in_min, in_max, out_min, out_max):
+    return (speed - in_min) * (out_max - out_min) // (in_max - in_min) + out_min
+
+
+@checkInit
+def _move(direction, speed):
+    move_buffer = bytearray(9)
+    move_buffer[0] = 0x55
+    move_buffer[1] = 0x00
+    move_buffer[2] = 0x09
+    move_buffer[3] = 0x00
+    move_buffer[7] = 0x00
+    move_buffer[8] = 0xAA
+
+    speed = max(0, min(100, speed))
+
+    if direction == 0:
+        move_buffer[4] = 0x30
+        move_buffer[5] = _map(speed, 0, 100, 128, 255)
+    elif direction == 1:
+        move_buffer[4] = 0x30
+        move_buffer[5] = _map(speed, 0, 100, 128, 0)
+    elif direction == 2:
+        move_buffer[4] = 0x31
+        move_buffer[5] = _map(speed, 0, 100, 128, 0)
+    elif direction == 3:
+        move_buffer[4] = 0x31
+        move_buffer[5] = _map(speed, 0, 100, 128, 255)
+
+    move_buffer[6] = ~(0x09 + 0x00 + move_buffer[4] + move_buffer[5]) & 0xFF
+
+    uart.write(move_buffer)
+
+
+@checkInit
+def clampX(milimeters=50):
+    clampBuffer = bytearray(9)
+    clampBuffer[0] = 0x55
+    clampBuffer[1] = 0x00
+    clampBuffer[2] = 0x09
+    clampBuffer[3] = 0x00
+    clampBuffer[4] = 0x73
+    clampBuffer[7] = 0x00
+    clampBuffer[8] = 0xAA
+
+    clampBuffer[5] = milimeters
+    clampBuffer[6] = ~(0x09 + 0x00 + 0x73 + clampBuffer[5]) & 0xFF
+
+    uart.write(clampBuffer)
+    sleep(1000)
+
+
+@checkInit
+def clampZ(milimeters=50):
+    clampBuffer = bytearray(9)
+    clampBuffer[0] = 0x55
+    clampBuffer[1] = 0x00
+    clampBuffer[2] = 0x09
+    clampBuffer[3] = 0x00
+    clampBuffer[4] = 0x74
+    clampBuffer[7] = 0x00
+    clampBuffer[8] = 0xAA
+
+    clampBuffer[5] = milimeters
+    clampBuffer[6] = ~(0x09 + 0x00 + 0x74 + clampBuffer[5]) & 0xFF
+
+    uart.write(clampBuffer)
+    sleep(1000)
+
+
+@checkInit
+def clamp(force):
+    clampBuffer = bytearray(9)
+    clampBuffer[0] = 0x55
+    clampBuffer[1] = 0x00
+    clampBuffer[2] = 0x09
+    clampBuffer[3] = 0x00
+    clampBuffer[4] = 0x71
+    clampBuffer[7] = 0x00
+    clampBuffer[8] = 0xAA
+
+    clampBuffer[5] = force
+    clampBuffer[6] = ~(0x09 + 0x00 + 0x71 + clampBuffer[5]) & 0xFF
+
+    uart.write(clampBuffer)
+    sleep(1000)
+
+
+def init_xgo_serial(tx_pin, rx_pin, baudrate=115200):
+    global _XGOInit
+    uart.init(baudrate=baudrate, tx=tx_pin, rx=rx_pin)
+    init_action()
+    _XGOInit = True
+
+
+def init_action():
+    commands_buffer = bytearray(9)
+    commands_buffer[0] = 0x55
+    commands_buffer[1] = 0x00
+    commands_buffer[2] = 0x09
+    commands_buffer[3] = 0x00
+    commands_buffer[4] = 0x3E
+    commands_buffer[5] = 0xFF
+    commands_buffer[6] = ~(0x09 + 0x00 + 0x3E + 0xFF) & 0xFF
+    commands_buffer[7] = 0x00
+    commands_buffer[8] = 0xAA
+
+    uart.write(commands_buffer)
+    sleep(2000)
+
+
+@checkInit
+def action(id):
+    commands_buffer = bytearray(9)
+    commands_buffer[0] = 0x55
+    commands_buffer[1] = 0x00
+    commands_buffer[2] = 0x09
+    commands_buffer[3] = 0x00
+    commands_buffer[4] = 0x3E
+    commands_buffer[5] = id
+    commands_buffer[6] = ~(0x09 + 0x00 + 0x3E + id) & 0xFF
+    commands_buffer[7] = 0x00
+    commands_buffer[8] = 0xAA
+
+    uart.write(commands_buffer)
+    sleep(2000)
+
+
+def changeInit(tx, rx):
+    global _TX
+    global _RX
+    _TX = tx
+    _RX = rx
+    init_xgo_serial(_TX, _RX)
+
+
+@checkInit
+def setSpeed(speed):
+    global _speed
+    _speed = speed
+
+
+def forward():
+    _move(0, _speed)
+
+
+def backward():
+    _move(1, _speed)
+
+
+def left():
+    _move(2, _speed)
+
+
+def right():
+    _move(3, _speed)

package/microbit/min/controller.py

@@ -0,0 +1,42 @@
+_B=False
+_A=1.
+from microbit import run_every,pin13,pin14,pin15,pin16,pin8,pin1,pin2,pin12,button_a,button_b,sleep
+class _Controller_Button:
+	def __init__(A,pin):B=pin;A._pin=B;A.previous_state=0;A._press_count=0;A._pressed_before=_B;B.set_pull(B.PULL_UP)
+	def _f3(A):
+		B=1-A._pin.read_digital()
+		if B==1 and A.previous_state==0:A._press_count+=1;A._pressed_before=True
+		A.previous_state=B
+	def is_pressed(A):return _B if A._pin.read_digital()else True
+	def was_pressed(A):B=A._pressed_before;A._pressed_before=_B;return B
+	def get_presses(A):B=A._press_count;A._press_count=0;return B
+class _Controller_Analog_Stick:
+	def __init__(A,pinX,pinY,pinZ):A.pin_x=pinX;A.pin_y=pinY;A.button_z=_Controller_Button(pinZ);A.dead_zone=.01;A.center_x=0;A.center_y=0;A.min_x=-1;A.max_x=1;A.min_y=-1;A.max_y=1
+	def calibrate(A,dead_zone,center_x=.0,center_y=.0,x_min=-_A,x_max=_A,y_min=-_A,y_max=_A):A.dead_zone=min(.2,max(.01,dead_zone));A.center_x=min(.4,max(-.4,center_x));A.center_y=min(.5,max(-.5,center_y));A.min_x=min(-.5,max(-_A,x_min));A.max_x=min(_A,max(.5,x_max));A.min_y=min(-.5,max(-_A,y_min));A.max_y=min(_A,max(.5,y_max))
+	def _f5(C,value,center,v_min,v_max):
+		B=center;A=value-_A-B
+		if abs(A)-C.dead_zone/2.>.0:
+			if A<.0:A=A/abs(v_min-B)
+			else:A=A/abs(v_max-B)
+		A=min(_A,max(-_A,A));A=.0 if abs(A)<=C.dead_zone else A;return A
+	def get_x(A):B=A.pin_x.read_analog()/512.;C=A._f5(B,A.center_x,A.min_x,A.max_x);return C
+	def get_y(A):B=A.pin_y.read_analog()/512.;C=A._f5(B,A.center_y,A.min_y,A.max_y);return C
+	def get_z(A):return 1 if A.button_z.is_pressed()else 0
+	def is_pressed(A):return A.button_z.is_pressed()
+	def was_pressed(A):return A.button_z.was_pressed()
+	def get_presses(A):return A.button_z.get_presses()
+def vibrate(state):pin12.write_digital(state)
+joystick=_Controller_Analog_Stick(pin1,pin2,pin8)
+button_z=joystick.button_z
+button_c=_Controller_Button(pin13)
+button_green=button_c
+button_d=_Controller_Button(pin14)
+button_yellow=button_d
+button_e=_Controller_Button(pin15)
+button_red=button_e
+button_f=_Controller_Button(pin16)
+button_blue=button_f
+trigger_left=button_a
+trigger_right=button_b
+def _f1():global button_c;global button_d;global button_e;global button_f;global joystick;button_c._f3();button_d._f3();button_e._f3();button_f._f3();joystick.button_z._f3()
+run_every(_f1,days=0,h=0,min=0,s=0,ms=33)

package/microbit/min/huskylens.py

@@ -0,0 +1,145 @@
+_E='Invalid model_id. Must be number in range [0,4]'
+_D='Error: ID must be in range from 1 to 255.'
+_C=None
+_B=True
+_A=False
+from microbit import i2c,sleep,running_time
+import math
+_g1=['FaceRecognition','ObjectTracking','ObjectRecognition','LineTracking','ColorRecognition','TagRecognition','ObjectClassification','QRRecognition','BarcodeRecognition']
+class Request_Command:KNOCK=44;ALGORITHM=45;ALL=32;BLOCKS=33;BLOCKS_LEARNED=36;BLOCKS_OF_ID=39;ARROWS=34;ARROWS_LEARNED=37;ARROWS_OF_ID=40;LEARNED=35;ALL_OF_ID=38;LEARN=54;FORGET=55;CUSTOM_LABEL=47;CUSTOM_TEXT=52;CLEAR_TEXT=53;SAVE_MODEL=50;LOAD_MODEL=51;SAVE_PHOTO=48;SAVE_SCREENSHOT=57;IS_PRO=59;VERSION=60
+class Return_Code:ANY=1;OK=46;BUSY=61;INFO=41;BLOCK=42;ARROW=43;IS_PRO=59;NEED_PRO=62
+class Algorithm:FACE_RECOGNITION=0;OBJECT_TRACKING=1;OBJECT_RECOGNITION=2;LINE_TRACKING=3;COLOR_RECOGNITION=4;TAG_RECOGNITION=5;OBJECT_CLASSIFICATION=6;QR_RECOGNITION=7;BARCODE_RECOGNITION=8
+class Block:
+	def __init__(A,x,y,width,height,id):A.x=x;A.y=y;A.width=width;A.height=height;A.id=id
+	def _f2(A):return'Block: ID_'+str(A.id)+' Pos: ('+str(A.x)+' '+str(A.y)+') Size: ('+str(A.width)+' '+str(A.height)+')'
+class Arrow:
+	def __init__(A,x_tail,y_tail,x_head,y_head,id):A.x_tail=x_tail;A.y_tail=y_tail;A.x_head=x_head;A.y_head=y_head;A.id=id
+	def get_direction(A):
+		C=A.x_head-A.x_tail;D=A.y_head-A.y_tail;B=90-math.degrees(math.atan2(D,C))
+		if B<0:B=B+360
+		return int(B)
+	def _f2(A):return'Arrow: ID_'+str(A.id)+' ('+str(A.x_tail)+' '+str(A.y_tail)+')->('+str(A.x_head)+' '+str(A.y_head)+')'
+def byte_checksum(byte_list):return sum(byte_list)&255
+def hexify(byte_array):
+	A=byte_array
+	if len(A)==0:return''
+	return'0x'+''.join('{:02x}'.format(A)for A in A)
+class Huskylens:
+	I2C_ADDR=50
+	def __init__(A):A.learned_slot_count=0;A.id_slots={};A.id_names={};A.algorithm=Algorithm.OBJECT_TRACKING;A.clear_texts();A.pro_enabled=A.is_pro()
+	def initialize(A):
+		B=_A
+		for E in range(5):
+			A.knock();B,F=A.get_response(Return_Code.OK)
+			if B:break
+		if B>0:
+			C=A.clear_texts();D=A.set_algorithm(Algorithm.OBJECT_TRACKING)
+			if C and D:print('Initialization successful!');return _B
+			else:print("Initialization Failed. Couldn't change Algorithm");return _A
+		else:print('Initialization Failed. Please check connection to Huskylens.');return _A
+	def send_request(D,command,data=_C):
+		B=data;A=bytearray(b'U\xaa\x11\x00\x00');A[3]=0 if B is _C else len(B);A[4]=command
+		if B:
+			for C in B:A.append(C)
+		A.append(byte_checksum(A));i2c.write(Huskylens.I2C_ADDR,A);sleep(50)
+	def get_response(K,return_code=Return_Code.ANY,timeout=500):
+		C=return_code;A=bytearray(b'U\x00\x00\x00\x00');I=running_time()
+		while running_time()-I<timeout:
+			D=i2c.read(Huskylens.I2C_ADDR,1)[0]
+			if D==85:break
+		if D!=85:return-1,[]
+		for J in range(4):A[J+1]=i2c.read(Huskylens.I2C_ADDR,1)[0]
+		if A[0:3]!=b'U\xaa\x11':return-2,[]
+		E=A[3];F=A[4];B=[]
+		if E>0:G=i2c.read(Huskylens.I2C_ADDR,E+1);B=G[0:-1];H=G[-1]
+		else:H=ord(i2c.read(Huskylens.I2C_ADDR,1))
+		if H!=byte_checksum(list(A)+B):return-3,[]
+		if C==Return_Code.ANY or F==C:return F,B
+		else:return 0,B
+	def knock(A):A.send_request(Request_Command.KNOCK)
+	def set_algorithm(B,algorithm):
+		A=algorithm
+		if(A==Algorithm.QR_RECOGNITION or A==Algorithm.BARCODE_RECOGNITION)and not B.pro_enabled:raise RuntimeError('Error: Huskylens PRO version is required for algorithm ',_g1[A]);return _A
+		D=[A,0];B.send_request(Request_Command.ALGORITHM,D);C,E=B.get_response(Return_Code.OK)
+		if C>0:print('Current Algorithm:',_g1[A]);B.algorithm=A
+		return _B if C>0 else _A
+	def get_all(A):return A._f7(Request_Command.ALL)
+	def get_all_learned(A):return A._f7(Request_Command.LEARNED)
+	def get_all_with_id(A,id):
+		if id<=0 or id>255:raise RuntimeError(_D)
+		return A._f7(Request_Command.ALL_OF_ID,id)
+	def get_one(A):B=A._f7(Request_Command.ALL);return A._f8(B)
+	def get_one_learned(A):B=A._f7(Request_Command.LEARNED);return A._f8(B)
+	def get_one_with_id(A,id):
+		if id<=0 or id>255:raise RuntimeError(_D)
+		B=A._f7(Request_Command.ALL_OF_ID,id);return A._f8(B)
+	def attach_label(A,id,name):
+		B=name
+		if A.algorithm==Algorithm.OBJECT_TRACKING or A.algorithm==Algorithm.LINE_TRACKING:C=A._f6(1,B)
+		elif A.algorithm==Algorithm.FACE_RECOGNITION or A.algorithm==Algorithm.TAG_RECOGNITION or A.algorithm==Algorithm.OBJECT_CLASSIFICATION or A.algorithm==Algorithm.OBJECT_RECOGNITION:
+			D=A.id_slots.get(id)
+			if D==_C:raise RuntimeError("Can't attach a name to an unlearned ID number")
+			A.id_names[id]=B;C=_B
+			for E in D:F=A._f6(E,B);C=C and F>0
+		else:A.id_names[id]=B;C=A._f6(id,B)
+		return _B if C>0 else _A
+	def clear_labels(A):
+		A.id_names.clear()
+		for B in range(10):A._f6(B,'')
+	def add_text(E,text,position_x,position_y):
+		C=position_y;B=position_x;D=bytes(text,'utf-8')
+		if len(D)>19:raise RuntimeError('Custom Text must be less than 20 bytes long.')
+		if B>300 or B<0 or C<35 or C>240:raise RuntimeError("Custom Text can't be placed outside of screen pixel size.")
+		A=[len(D)];A.append(255 if B>255 else 0);A.append(B%255);A.append(240-C);A.extend(list(D));E.send_request(Request_Command.CUSTOM_TEXT,A);F,G=E.get_response(Return_Code.OK);return _B if F>0 else _A
+	def clear_texts(A):A.send_request(Request_Command.CLEAR_TEXT);B,C=A.get_response(Return_Code.OK);return _B if B>0 else _A
+	def learn(A,id,name=_C):
+		if id<=0 or id>255:raise RuntimeError('Parameter ID for learned item must be in range [0,255]')
+		if A.algorithm==Algorithm.OBJECT_TRACKING or A.algorithm==Algorithm.LINE_TRACKING:id=1
+		C=500
+		if A.algorithm==Algorithm.OBJECT_CLASSIFICATION:C=1000
+		A.send_request(Request_Command.LEARN,[id,0]);B,E=A.get_response(Return_Code.OK,C)
+		if B>0:
+			A.learned_slot_count+=1
+			if not id in A.id_slots:A.id_slots[id]=[A.learned_slot_count]
+			else:A.id_slots[id].append(A.learned_slot_count)
+			D=A.id_names.get(id)
+			if D!=_C:B=A.attach_label(A.learned_slot_count,D)
+			elif name!=_C:B=A.attach_label(id,name)
+		return _B if B>0 else _A
+	def forget(A):
+		A.send_request(Request_Command.FORGET);B,C=A.get_response(Return_Code.OK)
+		if B:A.learned_slot_count=0;A.id_slots.clear()
+		return _B if B else _A
+	def save_photo(A):A.send_request(Request_Command.SAVE_PHOTO);B,C=A.get_response(Return_Code.OK,1000);return _B if B>0 else _A
+	def save_screenshot(A):A.send_request(Request_Command.SAVE_SCREENSHOT);B,C=A.get_response(Return_Code.OK,1000);return _B if B>0 else _A
+	def save_model(B,model_id):
+		A=model_id
+		if A<0 or A>4:raise RuntimeError(_E)
+		B.send_request(Request_Command.SAVE_MODEL,[A,0]);C,D=B.get_response(Return_Code.OK,1000);print('Model saving: Check Huskylens screen for Result!\n\tModel name:',_g1[B.algorithm]+'_Backup_'+str(A)+'.conf');return _B if C>0 else _A
+	def load_model(B,model_id):
+		A=model_id
+		if A<0 or A>4:raise RuntimeError(_E)
+		B.send_request(Request_Command.LOAD_MODEL,[A,0]);C,D=B.get_response(Return_Code.OK,1000);print('Model Loading: Check Huskylens screen for Result!');return _B if C>0 else _A
+	def is_pro(A):A.send_request(Request_Command.IS_PRO);B,C=A.get_response(Return_Code.IS_PRO);return bool(C[0])if B>0 else _A
+	def _f6(C,id,name):
+		A=bytes(name,'utf-8')
+		if len(A)>19:raise RuntimeError('Custom Name must be less than 20 bytes long.')
+		B=[id,len(A)+1];B.extend(list(A));B.append(0);C.send_request(Request_Command.CUSTOM_LABEL,B);D,E=C.get_response(Return_Code.OK);return _B if D>0 else _A
+	def _f7(B,request_command,id=-1):
+		I=_C if id<0 else[id,0];B.send_request(request_command,I);G,H=B.get_response(Return_Code.INFO)
+		if not G:raise RuntimeError('Failed to request results. Got answer:'+str(G))
+		J=H[0]+H[1]*255;C=0;D=[]
+		while C<J:
+			E,A=B.get_response(Return_Code.ANY)
+			if E==Return_Code.BLOCK and B.algorithm!=3:K=A[0]+A[1]*255;L=240-A[2]+A[3]*255;M=A[4]+A[5]*255;N=A[6]+A[7]*255;F=A[8];O=Block(K,L,M,N,F);D.append(O);C+=1
+			elif E==Return_Code.ARROW:P=A[0]+A[1]*255;Q=240-A[2]+A[3]*255;R=A[4]+A[5]*255;S=240-A[6]+A[7]*255;F=A[8];T=Arrow(P,Q,R,S,F);D.append(T);C+=1
+			elif E==0:return[]
+		return D
+	def _f8(E,results):
+		C=_C;D=440
+		for A in results:
+			B=0
+			if E.algorithm==Algorithm.LINE_TRACKING:B=abs(A.x_tail+(A.x_tail-A.x_head)//2-160)+abs(A.y_tail+(A.y_tail-A.y_head)//2-120)
+			else:B=abs(A.x-160)+abs(A.y-120)
+			if B<D:C,D=A,B
+		return C

package/microbit/min/mbalarm.py

@@ -0,0 +1,6 @@
+import music
+_g1=['c6:1','r','c6,1','r','r','r']
+def setAlarm(on):
+	if on:music.play(_g1,wait=False,loop=True)
+	else:music.stop()
+def beep():music.pitch(2000,200,wait=False)

package/microbit/min/mbbitbot.py

@@ -0,0 +1,40 @@
+from microbit import*
+from neopixel import*
+from utime import ticks_us,sleep_us
+_g1=200
+_g2=12
+_g3=NeoPixel(pin13,_g2)
+_g4=0
+_g5=0
+def w(leftforward,leftbackward,rightforward,rightbackward):
+	if leftforward>0 or rightforward>0:pin16.write_analog(leftforward+_g4);pin8.write_analog(leftbackward);pin14.write_analog(rightforward-_g4);pin12.write_analog(rightbackward)
+	elif leftbackward>0 or rightbackward>0:pin16.write_analog(leftforward);pin8.write_analog(leftbackward+_g4);pin14.write_analog(rightforward);pin12.write_analog(rightbackward-_g4)
+	elif leftforward==0 and rightforward==0 and leftbackward==0 and rightbackward==0:pin16.write_analog(0);pin8.write_analog(0);pin14.write_analog(0);pin12.write_analog(0)
+def forward():w(_g1,0,_g1,0)
+def backward():w(0,_g1,0,_g1)
+def stop():w(0,0,0,0)
+def right():w(0,_g1,_g1,0)
+def left():w(_g1,0,0,_g1)
+def set_led(pos,red,green,blue):_g3[pos]=red,green,blue;_g3.show()
+def fill(red,green,blue):
+	for i in range(_g2):_g3[i]=red,green,blue
+	_g3.show()
+def getDistance():
+	pin15.write_digital(1);sleep_us(10);pin15.write_digital(0);pin15.set_pull(pin15.NO_PULL)
+	while pin15.read_digital()==0:0
+	start=ticks_us()
+	while pin15.read_digital()==1:0
+	end=ticks_us();echo=end-start;distance=int(.01715*echo);return distance
+def calibrate(offset,differential=0):global _g4;global _g5;global _g8;_g5=max(min(int(offset),50),-50);_g4=max(min(int(differential),50),-50);_g8=max(min(arcScaling,50),-50);setSpeed(_g1/1023*100)
+def setSpeed(percent):global _g1;speed=percent/100*1023;speed+=_g5/100*1023;speed=min(max(speed,0),1023);_g1=speed
+def getLine(bit):
+	mask=1<<bit;value=0
+	try:value=i2c.read(28,1)[0]
+	except OSError:pass
+	if value&mask>0:return 1
+	else:return 0
+def getLight(index):
+	if index==0:return pin1.read_analog()
+	elif index==1:return pin2.read_analog()
+def leftArc(radius):speed=_g1;inner_wheel_speed=speed*(radius/(radius+1));w(inner_wheel_speed,0,speed,0)
+def rightArc(radius):speed=_g1;inner_wheel_speed=speed*(radius/(radius+1));w(speed,0,inner_wheel_speed,0)

package/microbit/min/mbglow.py

@@ -0,0 +1,29 @@
+from microbit import*
+_g1=0
+_g2=0
+_g3=0
+_g4=50
+_g5=True
+_g6=False
+def makeGlow():global _g6;display.set_pixel(2,2,9);_g6=True
+def clear():display.clear()
+def forward():_f1(1)
+def back():_f1(-1)
+def right(angle):global _g3;_g3=(_g3+angle)%360
+def left(angle):right(-angle)
+def setPos(x,y):global _g1,_g2;_g1=x;_g2=y;_f2()
+def getPos():return _g1,_g2
+def setSpeed(speed):global _g4;_g4=speed
+def showTrace(enable):global _g5;_g5=enable
+def isLit():return display.get_pixel(_g1+2,4-(_g2+2))==9
+def _f1(s):
+	global _g1,_g2;sleep(2000-_g4*20);d=_g3//45
+	if d in[1,2,3]:_g1+=s
+	if d in[5,6,7]:_g1-=s
+	if d in[0,1,7]:_g2+=s
+	if d in[3,4,5]:_g2-=s
+	_f2()
+def _f2():
+	if not _g6:print('Use "makeGlow()" to create a Glow.');raise Exception('Glow not initialized.')
+	if not _g5:display.clear()
+	if-2<=_g1<=2 and-2<=_g2<=2:display.set_pixel(_g1+2,4-(_g2+2),9)

package/microbit/min/mbled.py

@@ -0,0 +1,18 @@
+from neopixel import*
+import gc
+from microbit import pin2
+_g1=24
+_g2=NeoPixel(pin2,_g1)
+def fill(red,green,blue):
+	for i in range(_g1):_g2[i]=red,green,blue
+	_g2.show()
+def set_led(pos,red,green,blue):_g2[pos]=red,green,blue;_g2.show()
+def clear():_g2.clear()
+def shift_by(amount):
+	shifted_copy=[None]*_g1
+	for n in range(0,_g1):next_i=(n+amount)%_g1;shifted_copy[n]=_g2[next_i]
+	for n in range(0,_g1):_g2[n]=shifted_copy[n]
+	_g2.show()
+def lerp_RGB(r1,g1,b1,r2,g2,b2,percent):
+	if percent<.0 or percent>1e2:raise RuntimeError("Argument 'percent' must be between 0 and 100.")
+	red=max(0,min(255,round(r1+(r2-r1)*(percent/1e2))));green=max(0,min(255,round(g1+(g2-g1)*(percent/1e2))));blue=max(0,min(255,round(b1+(b2-b1)*(percent/1e2))));return red,green,blue

package/microbit/min/mbmarsrover.py

@@ -0,0 +1,62 @@
+from microbit import*
+from neopixel import*
+import utime
+_g1=[0,9,11,13,15]
+_g2=[0,0,0,0,0]
+_g3=False
+_g4=4
+_g5=NeoPixel(pin2,_g4)
+_g6=50
+_g7=40
+_g8=40
+_g9=0
+_g10=0
+_g11=0
+_g12=500
+_g13=29.1
+def _f1(dirL,powerL,dirR,powerR):pinsL=pin1,pin12;pinsR=pin8,pin0;pinsL[dirL].write_analog(powerL);pinsL[1-dirL].write_analog(0);pinsR[dirR].write_analog(powerR);pinsR[1-dirR].write_analog(0)
+def _f2(side,direction,power):
+	if side==0:pins=pin1,pin12
+	elif side==1:pins=pin8,pin0
+	pins[direction].write_analog(power);pins[1-direction].write_analog(0)
+def _f3(r):
+	outerSpeed=_g6;rCm=int(r*100);threshold=outerSpeed-max(rCm+20,40)
+	if threshold<=0:outerSpeed=min(max(rCm+40,40),100)
+	reducedSpeed=0
+	if rCm>=4:flattening=(100-outerSpeed)//2;reducedSpeed=(rCm*10-35)/(rCm*(11+(_g11-4)/10)+90+flattening);reducedSpeed=reducedSpeed*outerSpeed
+	innerByte=_f6(int(reducedSpeed),0);outerByte=_f6(int(outerSpeed),0);return innerByte,outerByte
+def _f4():global _g3;_g3=True;i2cData=bytearray(2);i2cData[0]=0;i2cData[1]=16;i2c.write(64,i2cData);i2cData[0]=254;i2cData[1]=101;i2c.write(64,i2cData);i2cData[0]=0;i2cData[1]=129;i2c.write(64,i2cData)
+def _f5(pin,value,timeout):
+	start_time=utime.ticks_us()
+	while pin.read_digital()!=value:
+		if utime.ticks_diff(utime.ticks_us(),start_time)>timeout:return 0
+	start_time=utime.ticks_us()
+	while pin.read_digital()==value:
+		if utime.ticks_diff(utime.ticks_us(),start_time)>timeout:return 0
+	return utime.ticks_diff(utime.ticks_us(),start_time)
+def calibrate(offset,differential=0,arcScaling=0):global _g10;global _g9;global _g11;_g9=max(min(int(offset),500),-50);_g10=max(min(int(differential),150),-150);_g11=max(min(arcScaling,50),-15);setSpeed(_g6)
+def setSpeed(speed):
+	global _g6;global _g7;global _g8;_g6=int(min(max(speed,0),100));powerValue=_f6(_g6,_g9);boost=round((1-_g6/100)*abs(_g10))if _g6>0 else 0;reduction=round(_g6/100*abs(_g10))
+	if _g10>0:_g7=powerValue-reduction;_g8=powerValue+boost
+	else:_g7=powerValue+boost;_g8=powerValue-reduction
+def _f6(speed,offset):analogValue=int(speed*1023/100)+offset;return min(max(analogValue,0),1023)
+def stop():_f1(0,0,0,0)
+def forward():_f1(0,_g7,0,_g8)
+def backward():_f1(1,_g7,1,_g8)
+def setServo(servoNum,angle):
+	global _g1,_g3
+	if _g3==False:_f4()
+	offsetNum=servoNum;servoNum=_g1[servoNum];i2cData=bytearray(2);start=0;angle=max(min(angle,90),-90);stop=396+(angle+_g2[offsetNum])*223/90;i2cData[0]=6+servoNum*4+2;i2cData[1]=int(stop)+255;i2c.write(64,i2cData);i2cData[0]=6+servoNum*4+3;i2cData[1]=int(stop)>>8;i2c.write(64,i2cData)
+def clearServos():setServo(0,0);setServo(1,0);setServo(2,0);setServo(3,0);setServo(4,0);sleep(500)
+def steer(angle):angle=max(min(angle,45),-45);setServo(1,angle);setServo(2,-angle);setServo(3,-angle);setServo(4,angle);sleep(500)
+def setLED(pos,red,green,blue):_g5[pos]=red,green,blue;_g5.show()
+def fill(red,green,blue):
+	for i in range(_g4):_g5[i]=red,green,blue
+	_g5.show()
+def getDistance():
+	trig=pin13;echo=pin13;d=10;trig.set_pull(trig.NO_PULL)
+	for _ in range(10):
+		trig.write_digital(0);utime.sleep_us(2);trig.write_digital(1);utime.sleep_us(10);trig.write_digital(0);duration=_f5(echo,1,_g12*_g13)
+		if duration>0:d=duration;break
+	return round(d/_g13)
+def calibrateServo(pos,angleDifferential):global _g2;angleDifferential=max(min(angleDifferential,90),-90);_g2[pos]=angleDifferential;clearServos()

package/microbit/min/mbminibit.py

@@ -0,0 +1,50 @@
+from microbit import*
+from neopixel import*
+import utime
+_g1=4
+_g2=NeoPixel(pin13,_g1)
+_g3=50
+_g4=90
+_g5=90
+_g6=0
+_g7=0
+_g8=0
+_g9=500
+_g10=29.1
+def _f1(dirL,powerL,dirR,powerR):pin8.write_analog(powerL if dirL==1 else 0);pin12.write_analog(0 if dirL==1 else powerL);pin16.write_analog(0 if dirR==1 else powerR);pin14.write_analog(powerR if dirR==1 else 0)
+def _f2(pin,value,timeout):
+	start_time=utime.ticks_us()
+	while pin.read_digital()!=value:
+		if utime.ticks_diff(utime.ticks_us(),start_time)>timeout:return 0
+	start_time=utime.ticks_us()
+	while pin.read_digital()==value:
+		if utime.ticks_diff(utime.ticks_us(),start_time)>timeout:return 0
+	return utime.ticks_diff(utime.ticks_us(),start_time)
+def _f3(r):
+	outerSpeed=_g3
+	if r>0:innerSpeed=outerSpeed*max(.2,min(1,1-r/100))
+	else:innerSpeed=0
+	innerByte=_f4(int(innerSpeed),0);outerByte=_f4(int(outerSpeed),0);return innerByte,outerByte
+def _f4(speed,offset):analogValue=int(speed*255/100)+offset;return min(max(analogValue,0),255)
+def calibrate(offset,differential=0,arcScaling=0):global _g7;global _g6;global _g8;_g6=max(min(int(offset),100),-10);_g7=max(min(int(differential),150),-150);_g8=max(min(arcScaling,50),-15);setSpeed(_g3)
+def setSpeed(speed):
+	global _g3;global _g4;global _g5;_g3=int(min(max(speed,0),100));powerByte=_f4(_g3,_g6);boost=round((1-_g3/100)*abs(_g7))if _g3>0 else 0;reduction=round(_g3/100*abs(_g7))
+	if _g7>0:_g4=powerByte-reduction;_g5=powerByte+boost
+	else:_g4=powerByte+boost;_g5=powerByte-reduction
+def stop():_f1(0,0,0,0)
+def forward():_f1(0,_g4,0,_g5)
+def backward():_f1(1,_g4,1,_g5)
+def left():_f1(1,_g4,0,_g5)
+def right():_f1(0,_g4,1,_g5)
+def rightArc(radius):inner,outer=_f3(radius);_f1(0,outer,0,inner)
+def leftArc(radius):inner,outer=_f3(radius);_f1(0,inner,0,outer)
+def setLED(pos,red,green,blue):_g2[pos]=red,green,blue;_g2.show()
+def fill(red,green,blue):
+	for i in range(_g1):_g2[i]=red,green,blue
+	_g2.show()
+def getDistance():
+	trig=pin15;echo=pin15;d=10;trig.set_pull(trig.NO_PULL)
+	for _ in range(10):
+		trig.write_digital(0);utime.sleep_us(2);trig.write_digital(1);utime.sleep_us(10);trig.write_digital(0);duration=_f2(echo,1,_g9*_g10)
+		if duration>0:d=duration;break
+	return round(d/_g10)

package/microbit/min/mbrobot.py

@@ -0,0 +1,82 @@
+from microbit import i2c,pin1,pin2,pin8,pin12,pin13,pin14,pin15,sleep
+import gc,machine,music,neopixel
+_g1=50
+_g2=40
+_g3=40
+_g4=bytearray(5)
+_g5=bytearray(2)
+_g6=bytes(b'\x00\x0b\x0b\x0c\x0c\r\r\r\x0e\x0e\x0f\x0f\x0f\x10\x10\x11\x11\x11\x12\x12\x13\x13\x13\x14\x14\x15\x15\x15\x16\x16\x17\x17\x17\x18\x19\x1a\x1b\x1b\x1c\x1d\x1e\x1f !"##$%&\'()*++,-./0123468:<?ADFILOSVZ^bgkpu{\x81\x87\x8d\x94\x9b\xa3\xab\xb4\xbd\xc6\xd0\xdb\xe6\xf2\xff')
+_g7=0
+_g8=0
+_g9=0
+_g10=neopixel.NeoPixel(pin15,4)
+np_rgb_pixels=_g10
+_g11=['c5:1','r','c5:1','r:3']
+_g12='Please connect to Maqueen robot and switch it on.'
+def _f1(dirL,powerL,dirR,powerR):
+	global _g4;_g4[1]=dirL;_g4[2]=powerL;_g4[3]=dirR;_g4[4]=powerR
+	try:i2c.write(16,_g4)
+	except:raise RuntimeError(_g12)
+def _f2(side,dir,power):
+	global _g4;_g4[1+side]=dir;_g4[2+side]=power
+	try:i2c.write(16,_g4)
+	except:raise RuntimeError(_g12)
+def _f3(speed,offset):return min(_g6[speed]+offset,255)
+def _f4(r):
+	A=_g1;B=int(r*100);D=A-max(B+20,40)
+	if D<=0:A=min(max(B+40,40),100)
+	C=0
+	if B>=4:E=(100-A)//2;C=(B*10-35)/(B*(11+(_g9-4)/10)+90+E);C=C*A
+	F=_f3(int(C),0);G=_f3(int(A),0);return F,G
+def calibrate(offset,differential=0,arcScaling=0):global _g8;global _g7;global _g9;_g7=max(min(int(offset),50),-10);_g8=max(min(int(differential),150),-150);_g9=max(min(arcScaling,50),-15);setSpeed(_g1)
+def setSpeed(speed):
+	global _g1;global _g2;global _g3;_g1=int(min(max(speed,0),100));A=_f3(_g1,_g7);B=round((1-_g1/100)*abs(_g8))if _g1>0 else 0;C=round(_g1/100*abs(_g8))
+	if _g8>0:_g2=A-C;_g3=A+B
+	else:_g2=A+B;_g3=A-C
+def resetSpeed():setSpeed(50)
+def stop():_f1(0,0,0,0)
+def forward():_f1(0,_g2,0,_g3)
+def backward():_f1(1,_g2,1,_g3)
+def left():_f1(1,_g2,0,_g3)
+def right():_f1(0,_g2,1,_g3)
+def rightArc(radius):A,B=_f4(radius);_f1(0,B,0,A)
+def leftArc(radius):A,B=_f4(radius);_f1(0,A,0,B)
+class Motor:
+	def __init__(A,side):A._side=side
+	def rotate(B,speed):A=speed;C=int(min(max(abs(A),0),100));D=_f3(C,_g7);E=0 if A>0 else 1;_f2(B._side,E,D)
+def setServo(servo,angle):
+	B=angle;A=servo;global _g5
+	if A=='S1'or A=='P0':_g5[0]=20
+	elif A=='S2'or A=='P1':_g5[0]=21
+	else:raise ValueError("Unknown Servo. Please use 'S1' or 'S2'.")
+	if B<0 or B>180:raise ValueError('Invalid angle. Must be between 0 and 180')
+	_g5[1]=B
+	try:i2c.write(16,_g5)
+	except:raise RuntimeError(_g12)
+class IRSensor:
+	def __init__(A,pin):A._pin=pin
+	def read_digital(A):return A._pin.read_digital()
+	def read_analog(A):raise NameError('Maqueen Lite does not support reading analog sensor values.')
+def getDistance():pin1.write_digital(1);pin1.write_digital(0);A=machine.time_pulse_us(pin2,1,50000);B=(A>>6)+(A>>10)+(A>>11)+(A>>12)+1;return max(min(B,500),0)if B>0 else 255
+def setLED(state,stateR=None):B=state;A=stateR;A=A if A!=None else B;pin8.write_digital(B);pin12.write_digital(A)
+def setLEDLeft(state):pin8.write_digital(state)
+def setLEDRight(state):pin12.write_digital(state)
+def fillRGB(red,green,blue):
+	for A in range(4):_g10[A]=red,green,blue
+	_g10.show()
+setRGB=fillRGB
+def clearRGB():_g10.clear()
+def posRGB(position,red,green,blue):
+	A=position
+	if A<0 or A>3:raise ValueError('invalid RGB-LED position. Must be 0,1,2 or 3.')
+	_g10[A]=red,green,blue;_g10.show()
+def setAlarm(state):
+	if state:music.play(_g11,wait=False,loop=True)
+	else:music.stop()
+def beep():music.pitch(440,200,wait=False)
+pin2.set_pull(pin2.NO_PULL)
+delay=sleep
+irLeft=IRSensor(pin13)
+irRight=IRSensor(pin14)
+motL=Motor(0)
+motR=Motor(2)