# Programming with MicroPython: KOI

### Import KOI Library

Import KOI library to make use of its functions.

```
from futureKOI import KOI
```

### KOI Basic Operations

#### Initiate KOI

```
koi = KOI(tx='P2',rx='P12',id=1)
```

Initiates the KOI port.

* tx: Tx Pin, use P2 for Robotbit Edu.
* rx: Rx Pin, use P12 for Robotbit Edu.

#### Set KOI Camera Orientation

```
# available modes
# 0,2

koi.screen_mode(mode, cmd='K6')
```

Sets the KOI camera orientation.

* mode: 0 for front, 2 for back

#### Display text

```
koi.text(x, y, delay, text, cmd="K4")
```

Displays a text on the KOI screen.

* x: X coordinate of the text.
* y: Y coordinate of the text.
* delay: Duration of the text in ms.
* text: The string to be displayed.

#### KOI Screen Capture

```
koi.screen_save(pic , cmd="K2")
```

Captures the screen and save to SD card.

* pic: Filename on the SD card in jpg format.

#### KOI Displays JPG

```
koi.screen_show(pic, cmd="K1")
```

Displays a jpg on the screen.

* pic: Filename on the SD card in jpg format.

### Face Detection

#### Load Face Yolo

```
koi.face_yolo_load(cmd="K30")
```

Loads the face yolo model.

#### Single Face Detection

```
x = koi.face_detect(cmd="K31")
```

Runs the single face detection.

#### Obtain Face Coordinates

```
koi.get_re(cmd="K31")[0]  #x
koi.get_re(cmd="K31")[1]  #y
```

Returns the X or Y coordinate of the face detected.

#### Multi Face Detection

```
koi.face_count(cmd="K32")
```

Runs the multi face detection.

#### Obtain Number of Faces

```
koi.get_re(cmd="K32")[0]
```

Returns the number of faces detected.

### Face Detection Sample Program

```
from future import *
from futureKOI import KOI

screen.sync = 0
koi = KOI(tx='P2',rx='P12',id=1)
koi.screen_mode(2, cmd='K6')
koi.face_yolo_load(cmd='K30')
while True:
if koi.face_detect(cmd='K31'):
    screen.fill((0, 0, 0))
    screen.text("Face detected:",5,10,1,(255, 255, 255))
    screen.text("X:",5,20,2,(255, 255, 255))
    screen.text((koi.get_re(cmd='K31')[0]),5,40,3,(255, 255, 255))
    screen.text("Y:",5,70,2,(255, 255, 255))
    screen.text((koi.get_re(cmd='K31')[1]),5,90,3,(255, 255, 255))
    screen.refresh()
else:
    screen.fill((0, 0, 0))
    screen.text("No face",5,10,1,(255, 255, 255))
    screen.refresh()
sleep(0.5)
```

### Machine Learning Image Classifier

#### Initiate Image Classifier

```
koi.init_cls()
```

Starts image classifier mode.

#### Save the Classifier Model

```
koi.cls_save_model(model,cmd="K43")
```

Saves the model to the SD Card.

* model: The filename on the SD card.

#### Load a Classifier Model

```
koi.cls_load_model(model="abc.json",cmd="K44")
```

Loads the model from the SD Card.

* model: The filename on the SD card.

#### Classifier Add Tag

```
koi.cls_add_tag(tag,cmd="K41")
```

Add an image tag.

* tag: Name of the tag.

#### Run Image Classifier

```
koi.cls_run(cmd="K42")
```

Returns the tag for the classified object.

### KOI Classifier Model Training Sample Program

```
from future import *
from futureKOI import KOI

items = []
i = 0

items.append('rock')
items.append('paper')
items.append('scissors')
i = 0
koi = KOI(tx='P2',rx='P12',id=1)
koi.init_cls()                                                      # init classifier
koi.screen_mode(2, cmd='K6')    
screen.sync = 0
while True:
screen.fill((0, 0, 0))
if sensor.btnValue("a") and sensor.btnValue("b"):
    koi.cls_save_model(model="model.json",cmd='K43')                # saves the classifier model
    buzzer.melody(1)
else:
    if sensor.btnValue("a"):
    sleep(0.2)
    if not sensor.btnValue("b"):
        koi.cls_add_tag(id=(items[int((i % 3 + 1) - 1)]),cmd='K41') # classifier add tag
        buzzer.melody(4)
    else:
    if sensor.btnValue("b"):
        sleep(0.2)
        buzzer.tone(440,0.2)
        if not sensor.btnValue("a"):
        i += 1
screen.text("Now training:",0,10,1,(255, 255, 255))
screen.text((items[int((i % 3 + 1) - 1)]),0,30,2,(255, 255, 255))
screen.text("Press A to add tag",0,60,1,(255, 255, 255))
screen.text("Press B for next tag",0,80,1,(255, 255, 255))
screen.text("Press A+B to save",0,100,1,(255, 255, 255))
screen.refresh()
```

### KOI Image Classification Sample Program

```
from future import *
from futureKOI import KOI

koi = KOI(tx='P2',rx='P12',id=1)
koi.screen_mode(2, cmd='K6')
koi.init_cls()
koi.cls_load_model(model="model.json",cmd='K44')                    # loads the classifier model
while True:
if sensor.btnValue("a"):
    screen.clear()
    screen.text((koi.cls_run(cmd='K42')),5,10,2,(255, 255, 255))    # displays the classified tag
    screen.refresh()
```

### Colour Blob and Line Tracking

#### Calibrate a Colour to Track

```
koi.color_cali(name ,cmd="K16")
```

Calibrates a colour to track.

* name: The name for this colour.

#### Tracks a Colour Blob

```
koi.color_tracking(name="name", cmd="K15")
# returns [cx,cy,w,h,name]
```

Returns a list containing the values of the colour blob.

* name: the name of the colour to track.

#### Obtain Colour Blob Values

```
koi.get_re(cmd="K15")[0] #cx
koi.get_re(cmd="K15")[1] #cy
koi.get_re(cmd="K15")[2] #w
koi.get_re(cmd="K15")[3] #h
```

Returns the specific value of the colour blob.

### Blob Detection Sample Program

```
from future import *
from futureKOI import KOI

koi.screen_mode(2, cmd='K6')
koi = KOI(tx='P2',rx='P12',id=1)
while True:
if sensor.btnValue("a"):
    koi.color_cali(name="red" ,cmd='K16')
    sleep(0.3)
if sensor.btnValue("b"):
    if koi.color_tracking(name="red", cmd='K15'):
    screen.clear()
    screen.text((koi.get_re(cmd='K15')[0]),5,10,1,(255, 255, 255))
    screen.text((koi.get_re(cmd='K15')[1]),5,20,1,(255, 255, 255))
    screen.text((koi.get_re(cmd='K15')[2]),5,30,1,(255, 255, 255))
    screen.text((koi.get_re(cmd='K15')[3]),5,40,1,(255, 255, 255))
    screen.refresh()
    sleep(0.3)
```

#### Tracks a line

```
koi.line_tracking(name ,cmd="K12")
# returns [x1, y1, x2, y2, name]
```

Returns a list containing the values of the line.

* name: the name of the colour to track.

#### Obtain Line Values

```
koi.get_re(cmd="K12")[0] #x1
koi.get_re(cmd="K12")[1] #y1
koi.get_re(cmd="K12")[2] #x2
koi.get_re(cmd="K12")[3] #y2
```

Returns the specific value of the line.

### Line Detection Sample Program

```
from future import *
from futureKOI import KOI

koi.screen_mode(2, cmd='K6')
koi = KOI(tx='P2',rx='P12',id=1)
while True:
if sensor.btnValue("a"):
    koi.color_cali(name="red" ,cmd='K16')
    sleep(0.3)
if sensor.btnValue("b"):
    if koi.line_tracking(name="red" ,cmd='K12'):
    screen.clear()
    screen.text((koi.get_re(cmd='K12')[0]),5,10,1,(255, 255, 255))
    screen.text((koi.get_re(cmd='K12')[1]),5,20,1,(255, 255, 255))
    screen.text((koi.get_re(cmd='K12')[2]),5,30,1,(255, 255, 255))
    screen.text((koi.get_re(cmd='K12')[3]),5,40,1,(255, 255, 255))
    screen.refresh()
    sleep(0.3)
```

### Shape Detection

#### Circle Detection

```
koi.circle_detect(threshold, cmd="K10")
```

Runs the circle detection.

* threshold: The threshold for circle, typical value is about 2000, adjust to achieve best results.

#### Obtain Circle Values

```
koi.get_re(cmd="K10")[0] #cx
koi.get_re(cmd="K10")[1] #cy
koi.get_re(cmd="K10")[2] #r
```

Returns the specific value of the circle.

#### Rectangle Detection

```
 koi.rectangle_detect(th=4000,cmd="K11")
```

Runs the rectangle detection.

* threshold: The threshold for rectangle, typical value is about 1000, adjust to achieve best results.

#### Obtain Rectangle Values

```
koi.get_re(cmd="K11")[0]
koi.get_re(cmd="K11")[1]
koi.get_re(cmd="K11")[2]
koi.get_re(cmd="K11")[3]
```

Returns the specific value of the rectangle.

### Shape Detection Sample Program

```
from futureKOI import KOI
from future import *

koi.screen_mode(2, cmd='K6')
koi = KOI(tx='P2',rx='P12',id=1)
while True:
if sensor.btnValue("a"):
    if koi.circle_detect(th=4000, cmd='K10'):
    screen.clear()
    screen.text((koi.get_re(cmd='K10')[0]),5,10,1,(255, 255, 255))
    screen.text((koi.get_re(cmd='K10')[0]),5,20,1,(255, 255, 255))
    screen.text((koi.get_re(cmd='K10')[0]),5,30,1,(255, 255, 255))
    screen.refresh()
    sleep(0.3)
if sensor.btnValue("b"):
    if koi.rectangle_detect(th=4000,cmd='K11'):
    screen.clear()
    screen.text((koi.get_re(cmd='K11')[0]),5,10,1,(255, 255, 255))
    screen.text((koi.get_re(cmd='K11')[1]),5,20,1,(255, 255, 255))
    screen.text((koi.get_re(cmd='K11')[2]),5,30,1,(255, 255, 255))
    screen.text((koi.get_re(cmd='K11')[3]),5,40,1,(255, 255, 255))
    screen.refresh()
    sleep(0.3)
```

### Code Scanner

#### QR Code Scanner

```
koi.scan_qrcode(cmd="K20")
```

Returns the QR Code data.

#### Barcode Scanner

```
koi.scan_barcode(cmd="K22")
```

Returns the Barcode data.

#### Apriltag Scanner

```
koi.scan_Apriltag(cmd="K23")
```

Runs the scanner for Apriltag.

#### Obtains Apriltag data

```
koi.get_re(cmd="K23")[0] #id
koi.get_re(cmd="K23")[1] #cx
koi.get_re(cmd="K23")[2] #cy
koi.get_re(cmd="K23")[3] #w
koi.get_re(cmd="K23")[4] #h
```

Returns the specific data of the Apriltag.

### Code Scanner Sample Program

```
from future import *
from futureKOI import KOI

koi = KOI(tx='P2',rx='P12',id=1)
koi.screen_mode(2, cmd='K6')
while True:
if sensor.btnValue("a"):
    screen.clear()
    screen.text((koi.scan_qrcode(cmd='K20')),5,10,2,(255, 255, 255))
if sensor.btnValue("b"):
    screen.clear()
    screen.text((koi.scan_barcode(cmd='K22')),5,10,2,(255, 255, 255))
```

### Wifi Connection

#### Connect to Wifi

```
koi.connect_wifi(router ,pwd ,cmd="K50")
```

Connects to a Wifi network.

* router: The SSID.
* pwd: The password.

#### Displays IP Address

```
koi.get_ip(cmd="K54")
```

Displays the IP Address.

### BaiduAI

#### BaiduAI Face Recognition

```
koi.baiduAI_face_detect(cmd="K75")
# returns [face token, age, sex, mask, emotion]
```

Returns a list of values from the BaiduAI Face Recognition.

#### BaiduAI Face Token

```
koi.get_re(cmd="K75")[0]
```

Returns the face token.

#### BaiduAI Add Face to Group

```
koi.baiduAI_face_add(face_token="token" ,groupName="group" ,faceName="name" ,cmd="K76")
```

Adds the face token to a group.

* face\_token: The token to be added.
* groupName: The group name.
* faceName: The name of the person.

#### BaiduAI Search Face in Group

```
koi.baiduAI_face_search(face_token="token" ,groupName="group" ,cmd="K77")[0]
```

Searches the face in a group and returns the person name.

* face\_token: The token to be searched.
* groupName: The group name.

#### BaiduAi Text to Speech

```
koi.baiduAI_tts(text ,cmd="K78")
```

Generates a speech using BaiduAI.

-text: The text to be spoken.

### Wifi and Baidu TTS Sample Program

```
from future import *
from futureKOI import KOI

koi = KOI(tx='P2',rx='P12',id=1)
koi.screen_mode(2, cmd='K6')
koi.connect_wifi(router="apname" ,pwd="password" ,cmd='K50')
while True:
if sensor.btnValue("a"):
    koi.baiduAI_tts(txt='"hello"' ,cmd='K78')
    sleep(0.2)
if sensor.btnValue("b"):
    screen.clear()
    screen.text((koi.get_ip(cmd='K54')),5,10,1,(255, 255, 255))
    screen.refresh()
    sleep(0.2)
```

### Audio

#### Record Wav File

```
koi.audio_record(name)
```

Record and saves the wav file to the SD card.

* name: The file name in wav format.

#### Play Wav File

```
koi.audio_play(name)
```

Plays a wav file from the SD card.

* name: The file name in wav format.

#### Calibrate Ambient Noise

```
koi.audio_noisetap()
```

Calibrates the ambient noise for speech recognition.

#### Speech Recognition Add Tag

```
koi.speech_add_tag(tag)
```

Adds a speech tag.

* tag: The tag name.

#### Get Speech Recognition Tag

```
koi.speech_run(cmd="K65")
```

Runs the speech recognition and returns the tag.

#### Save Speech Model

```
koi.speech_save_model(file)
```

Saves the speech model to the SD card.

* file: The filename.

#### Load Speech Model

```
koi.speech_load_model(file)
```

Loads a speech model.

* file: The filename.

### Speech Recognition Training Sample Program

```
from future import *
from futureKOI import KOI

items = []
i = 0


items.append('rock')
items.append('paper')
items.append('scissors')
i = 0
koi = KOI(tx='P2',rx='P12',id=1)
koi.audio_noisetap()
koi.screen_mode(2, cmd='K6')
screen.sync = 0
while True:
screen.fill((0, 0, 0))
if sensor.btnValue("a") and sensor.btnValue("b"):
    buzzer.melody(1)
    koi.speech_save_model("speech.json")
else:
    if sensor.btnValue("a"):
    sleep(0.2)
    if not sensor.btnValue("b"):
        koi.speech_add_tag((items[int((i % 3 + 1) - 1)]))
    else:
    if sensor.btnValue("b"):
        sleep(0.2)
        buzzer.tone(440,0.2)
        if not sensor.btnValue("a"):
        i += 1
screen.text("Now training:",0,10,1,(255, 255, 255))
screen.text((items[int((i % 3 + 1) - 1)]),0,30,2,(255, 255, 255))
screen.text("Press A to add tag",0,60,1,(255, 255, 255))
screen.text("Press B for next tag",0,80,1,(255, 255, 255))
screen.text("Press A+B to save",0,100,1,(255, 255, 255))
screen.refresh()
```

### Speech Recognition Sample Program

```
from future import *
from futureKOI import KOI


koi = KOI(tx='P2',rx='P12',id=1)
koi.audio_noisetap()
koi.speech_load_model("speech.json")
while True:
if sensor.btnValue("a"):
    screen.clear()
    screen.text((koi.speech_run(cmd='K65')),5,10,2,(255, 255, 255))
    screen.refresh()
```

### Miscellaneous

#### Reset KOI

```
koi.reset(cmd='k99')
```

Resets the KOI.

#### Stop Classifier and Face Yolo

```
koi.stop_kpu(cmd='k98')
```

Stops the KPU from running Classifier and Face Yolo.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://sharinghub-eng.kittenbot.hk/main-controllers/futureboard/futureboard-micropython-programming-tutorial/programming-with-micropython-koi.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.