# Python API for Codey
## `led` — Onboard RGB LED
**Function**
`led.show(r, g, b)`\
Set the displayed color of the RGB LED, parameters：
* *r* refers to the value of red component, parameter range is `0 ~ 255`，0 with no red component and 255 the highest red component.
* *g* refers to the value of green component, parameter range is `0 ~ 255`，0 with no green component and 255 the highest green component.
* *b* refers to the value of blue component, parameter range is `0 ~ 255`，0 with no blue component and 255 the highest blue component.
`led.set_red(val)`\
Set the red color value of the RGB LED, parameters：
* *val* refers to the value of red component, parameter range is `0 ~ 255`，0 with no red component and 255 the highest red component.
`led.set_green(val)`\
Set the green color value of the RGB LED, parameters：
* *val* refers to the value of green component, parameter range is `0 ~ 255`，0 with no green component and 255 the highest green component.
`led.set_blue(val)`\
Set the blue color value of the RGB LED, parameters：
* *val* refers to the value of blue component, parameter range is `0 ~ 255`，0 with no blue component and 255 the highest blue component.
`led.off()`\
Turn off the RGB LED.
**Sample Code:**
```
import codey
import time
codey.led.show(255,255,255)
time.sleep(2)
codey.led.off()
time.sleep(2)
while True:
codey.led.set_red(255)
time.sleep(1)
codey.led.set_green(255)
time.sleep(1)
codey.led.set_blue(255)
time.sleep(1)
codey.led.off()
time.sleep(1)
```
## `display` — Face Panel
**Face Panel Introduction**
As shown in the figure above, the face panel has the upper left corner as the coordinate 0 point, and the direction of x and y is indicated by the arrow. About parameters displayed, take above figure as an example. The upper three of the first column data are lit and the data is converted to `11100000`, that is, hexadecimal 0xe0.The second column verse is converted to `00001101`, that is, In hexadecimal 0x0d. All the lattices in the above figure are converted to `e00d0000000000000000000000000000`.
**Function**
`display.show_image(image, pos_x = 0, pos_y = 0, time_s = None)`\
Display custom dot matrix graphics as image parameters, parameters：
* *image* string data, each column of the dot matrix has 8 display points, which is 1 byte of data, converted to a hexadecimal string. Therefore, 16 columns of lattices need to be represented by 32 string data.
* *pos\_x* displays the offset of the x-axis of the graph on the panel. The parameter range is `-15 ~ 15`, It starts from the 0 position as default if this parameter is not set.
* *pos\_y* displays the offset of the graph on the y-axis of the panel. The parameter range is `-7 ~ 7`, It starts from the 0 position as default if this parameter is not set.
* *time\_s* displays the time in seconds (in seconds). If this parameter is not set, the display remains unchanged until there is a clear screen or resetting the panel operation.
`display.show(var, pos_x = 0, pos_y = 0, wait = True)`\
Display data in full-type data parameters, parameters：
* *var* full type, where the display of numeric and time types is treated specially, and the time format display needs to satisfy: `[x]x:[x]x` format (regular expression `d?d:dd?`)
* *pos\_x* displays the offset of the data on the x-axis of the panel. The parameter range is `-15 ~ 15`. It starts from the 0 position as default if this parameter is not set.
* *pos\_y* displays the offset of the data on the y-axis of the panel. The parameter range is `-7 ~ 7`. It starts from the 0 position as default if this parameter is not set.
* *wait* sets whether to block the display, where True: means blocking until the display is complete, False: means display but not blocking.
`display.set_pixel(pos_x, pos_y, status)`\
Set the brightness and deactivation status of a single pixel of the panel, Parameters：
* *pos\_x* The coordinates of the x-axis for the pixel on the panel. The parameter range is `0 ~ 15`.
* *pos\_y* The coordinates of the y-axis for the pixel on the panel. The parameter range is `0 ~ 7`.
* *status* Boolean value，where `True` indicates that the pixel is lit, and `False`: indicates that the pixel is off.
`display.get_pixel(pos_x, pos_y)`\
Get the current on and off states of a single pixel on the panel. The return value is a Boolean value, where `True`: indicates that the pixel is lit, and `False`: indicates that the pixel is off, parameter：
* *pos\_x* The coordinates of the x-axis for the pixel on the panel. The parameter range is `0 ~ 15`.
* *pos\_y* The coordinates of the y-axis for the pixel on the panel. The parameter range is `0 ~ 7`.
`display.toggle_pixel(pos_x, pos_y)`\
Toggle the current on and off states of a single pixel on the panel, parameter：
* *pos\_x* The coordinates of the x-axis for the pixel on the panel. The parameter range is `0 ~ 15`.
* *pos\_y* The coordinates of the y-axis for the pixel on the panel. The parameter range is `0 ~ 7`.
`display.clear()`\
Turn off all the LED lights on the display.
**Sample Code:**
```
import codey
import time
codey.display.show("ffffff")
codey.display.show("123")
time.sleep(1)
codey.display.show("12345", 3, 1)
codey.display.set_pixel(1, 1, True)
image = "ffffffffff000000000000000000000000"
codey.display.show_image(image, pos_x = 3, pos_y = 4)
time.sleep(1)
codey.display.clear()
print("[1, 1]:", codey.display.get_pixel(1, 1))
codey.display.show("12:28")
while True:
codey.display.toggle_pixel(7, 2)
codey.display.toggle_pixel(7, 4)
time.sleep(1)
```
## `speaker` — Onboard Speaker
**Function**
`speaker.stop_sounds()`\
Stop all sounds.
`speaker.play_melody(file_name)`\
Playing an audio file, the function will not block when playing, but if it is called continuously, the next playback will stop the previous playback, Parameters：
* *file\_name* String type, the audio file name of the wav format burned in Codey Rocky flash. When inputting, the format suffix `.wav` can also be omitted.
The optional sound file has:
```
hello.wav ： hello
hi.wav ： hi
bye.wav ： bye
yeah.wav ： yeah
wow.wav ： wow
laugh.wav ： laugh
hum.wav ： hum
sad.wav ： sad
sigh.wav ： sigh
annoyed.wav ： annoyed
angry.wav ： angry
surprised.wav ： scared
yummy.wav ： pettish
curious.wav ： curious
embarrassed.wav ： embarrassed
ready.wav ： ready
sprint.wav ： sprint
sleepy.wav ： snore
meow.wav ： meow
start.wav ： start
switch.wav ： switch
beeps.wav ： beeps
buzzing.wav ： buzz
exhaust.wav ： air-out
explosion.wav ： explosion
gotcha.wav ： gotcha
hurt.wav ： painful
jump.wav ： jump
laser.wav ： laser
level up.wav ： level-up
low energy.wav ： low-energy
metal clash.wav ： metal-clash
prompt tone.wav ： prompt-tone
right.wav ： right
wrong.wav ： wrong
ring.wav ： ringtone
score.wav ： score
shot.wav ： shot
step_1.wav ： step_1
step_2.wav ： step_2
wake.wav ： activate
warning.wav ： warning
```
`speaker.play_melody_until_done(file_name)`\
The audio file is played until it stops, and the function blocks playback, that is, the next instruction cannot be executed until the sound is played, parameter：
* *file\_name* String type, the audio file name of the wav format burned in Codey Rocky flash. When inputting, the format name `.wav` can also be omitted. For specific optional parameters, see `play_melody`.
`speaker.play_note(note_num, beat = None)`\
Play note, digital note definitions please refer to: [scratch digital note description](https://en.scratch-wiki.info/wiki/Play_Note_\()*for*()*Beats*(block)), prameters：
* *note\_num* numeric value, range of values `48 - 72`, or string type, such as `C4`.
* *beat* value data, indicates the number of beats, the default value is always playing.\
notes and frequency is as follows:
```
['C2','65'], ['D2','73'], ['E2','82'], ['F2','87'],
['G2','98'], ['A2','110'], ['B2','123'], ['C3','131'],
['D3','147'], ['E3','165'], ['F3','175'], ['G3','196'],
['A3','220'], ['B3','247'], ['C4','262'], ['D4','294'],
['E4','330'], ['F4','349'], ['G4','392'], ['A4','440'],
['B4','494'], ['C5','523'], ['D5','587'], ['E5','659'],
['F5','698'], ['G5','784'], ['A5','880'], ['B5','988'],
['C6','1047'], ['D6','1175'], ['E6','1319'], ['F6','1397'],
['G6','1568'], ['A6','1760'], ['B6','1976'], ['C7','2093'],
['D7','2349'], ['E7','2637'], ['F7','2794'], ['G7','3136'],
['A7','3520'], ['B7','3951'], ['C8','4186'], ['D8','4699'],
```
`speaker.play_tone(frequency, time = None)`\
Play the setting frequency sound, parameters：
* *frequency* Numerical data, the frequency of sound which is played, and its value range is `0 ~ 5000`.
* *time* Numerical data, indicating the playback time (in `milliseconds - ms`) and its value range is `0 ~ the value range limit`.
`speaker.rest(number)`\
Stop the beat, parameters：
* *number* Numerical data, the number of paused beats, its value range is `0 ~ the value range limit`.
**Constant**
`speaker.volume`\
Numerical data, the property value of the volume, you can modify or read this value. Modify this value to control the volume. Its value range is `0 ~ 100`.
`speaker.tempo`\
Numerical data, indicating the nature of the playback speed, in `bmp` (beat per minute), which is the length of each beat.Its value range is `6 ~ 600`. The default value is 60, which means that the duration of one beat is 1 second. The beats of the `rest` and `play_note` functions are affected by this constant.
**Sample Code:**
```
import codey
import time
codey.speaker.play_melody("hello", True)
codey.display.show("hello")
codey.display.clear()
codey.speaker.play_note(48, 1)
codey.speaker.rest(1)
codey.display.show("note")
codey.display.clear()
codey.speaker.play_note("C4", 1)
codey.speaker.rest(1)
codey.display.show("C4")
codey.display.clear()
codey.speaker.play_tone(1000, 2)
codey.speaker.rest(1)
codey.display.show("tone")
codey.display.clear()
print("tempo:", end = "")
print(codey.speaker.tempo)
codey.speaker.play_note("C4", 1)
codey.speaker.rest(1)
codey.speaker.tempo = 120
codey.speaker.volume = 20
codey.speaker.play_note("C4", 1)
codey.speaker.rest(1)
```
## `sound_sensor` — Onboard Sound Sensor
**Function**
`sound_sensor.get_loudness()`\
Get the sound intensity detected by the sound sensor, and the return value is the volume. The value range is `0 ~ 100`.
**Sample Code:**
```
import codey
while True:
codey.display.show(codey.sound_sensor.get_loudness())
```
## `light_sensor` — Onboard Light Sensor
**Function**
`light_sensor.get_value()`\
Get the light intensity detected by the light sensor, and the return value is the intensity value of visible light. The value range is `0 ~ 100`.
**Sample Code:**
```
import codey
while True:
codey.display.show(codey.light_sensor.get_value())
```
## `potentiometer` — Onboard Potentiometer
**Function**
`potentiometer.get_value()`\
Get the current value of the potentiometer knob. The value range is `0 ~ 100`.
**Sample Code:**
```
import codey
while True:
codey.display.show(codey.potentiometer.get_value())
```
## `button_a` — Onboard Button A
**Function**
`button_a.is_pressed()`\
Get the current state of button A. The result returned is `True`: the button is pressed, or the `False`: button is not pressed.
**Sample Code:**
```
import codey
def loop():
while True:
if codey.button_a.is_pressed():
print("button A is pressed")
loop()
```
## `button_b` — Onboard Button B
**Function**
`button_b.is_pressed()`\
Get the current state of button B. The result returned is `True`: the button is pressed, or the `False`: button is not pressed.
**Sample Code:**
```
import codey
def loop():
while True:
if codey.button_b.is_pressed():
print("button B is pressed")
loop()
```
## `button_c` — Onboard Button C
**Function**
`button_c.is_pressed()`\
Get the current state of button C. The result returned is `True`: the button is pressed, or the `False`: button is not pressed.
**Sample Code:**
```
import codey
def loop():
while True:
if codey.button_c.is_pressed():
print("button C is pressed")
loop()
```
## `motion_sensor` — Onboard Motion Sensor
**Motion Sensor Introduction**
As shown in the picture above, the direction of the roll and pitch are based on the right-handed screw rule.
Both roll and pitch are `0°` when the Codey is horizontally placed.
* Roll range: `-90° ~ 90°`
* Pitch range: `-180 ° ~ 180 °`
**Function**
`motion_sensor.get_roll()`\
Get the roll of the Euler angle, the returned data range is `-90 ~ 90`.
`motion_sensor.get_pitch()`\
Get the pitch of the Euler angle, the returned data range is `-180 ~ 180`.
`motion_sensor.get_yaw()`\
Get the yaw of the Euler angle, The returned data range is `0 ~ 360`. Since the Codey onboard sensor is a six-axis sensor, there is no electronic compass. So in fact the yaw angle is just the integral of the Z-axis angular velocity. It has accumulated errors. If you want to get a true yaw angle, this API is not suitable for use.
`motion_sensor.get_rotation(axis)`\
Get the angle at which the Codey rotates on the three axes, and the counterclockwise direction is the positive direction, parameter：
* *axis* String type, with `x`, `y`, `z` representing the axis defined by Codey.
`motion_sensor.reset_rotation(axis = "all")`\
The current angle of initial rotation around the three axes is 0, and the `get_rotation()` will start at 0, parameter:
* *axis* string type, with `x`, `y`, `z` representing the axis defined by Codey, and `all` representing all three axes. This is also the default value for this function.
`motion_sensor.is_shaked()`\
Check if the Codey is shaken, the return value is a Boolean value, where `True` means that Codey is shaken, and `False` means that Codey is not shaken.
`motion_sensor.get_shake_strength()`\
If the Codey is shaken, this function can obtain the intensity of the shaking. The value of the return value range is `0 ~ 100`. The larger the value, the greater the intensity of the shaking.
`motion_sensor.is_tilted_left()`\
Check if Codey is tilted to the left, and the return value is a Boolean value, where `True` means that Codey is tilted to the left, and `False` means that Codey is not tilted to the left.
`motion_sensor.is_tilted_right()`\
Check if Codey is tilted to the right, and the return value is a Boolean value, where `True` means that Codey is tilted to the right, and `False` means that Codey is not tilted to the right.
`motion_sensor.is_ears_up()`\
Check if the ear of Codey is up, the return value is a Boolean value, where `True` means that the ear of Codey is facing up, and `False` means that the ear of Codey is not facing up.
`motion_sensor.is_ears_down()`\
Check if the ear of Codey is down, the return value is a Boolean value, where `True` means that the ear of Codey is facing down, and `False` means that the ear of Codey is not facing down.
`motion_sensor.is_display_up()`\
Check if the face panel of Codey is up, the return value is a Boolean value, where `True` means that the panel of Codey is facing up, and `False` means that the panel of Codey is not facing up.
`motion_sensor.is_display_down()` Check if the face panel of Codey is down, the return value is a Boolean value, where `True` means that the panel of Codey is facing down, and `False` means that the panel of Codey is not facing down.
`motion_sensor.is_upright()`\
Check if Codey is upright, the return value is a Boolean value, where `True` means that Codey is upright, and `False` means that Codey is not upright.
`motion_sensor.get_acceleration(axis)`\
Get the acceleration values of the three axes in `m/s^2`, Parameters：
* *axis* String type, with `x`, `y`, `z` representing the axis defined by Codey.
`motion_sensor.get_gyroscope(axis)`\
Get the angular velocity values of the three axes in `°/sec`, Parameters：
* *axis* String type, with `x`, `y`, `z` representing the axis defined by Codey。
**Sample Code 1:**
```
import codey
import time
while True:
roll = codey.motion_sensor.get_roll()
pitch = codey.motion_sensor.get_pitch()
yaw = codey.motion_sensor.get_yaw()
print("roll:", end = "")
print(roll, end = "")
print(" ,pitch:", end = "")
print(pitch, end = "")
print(" ,yaw:", end = "")
print(yaw)
time.sleep(0.05)
```
**Sample Code 2:**
```
import codey
while True:
if codey.motion_sensor.is_shaked():
print("shake_strength:", end = "")
print(codey.motion_sensor.get_shake_strength())
```
**Sample Code 3:**
```
import codey
while True:
if codey.motion_sensor.is_tilted_left():
print("tilted_left")
if codey.motion_sensor.is_tilted_right():
print("tilted_right")
if codey.motion_sensor.is_ears_up():
print("ears_up")
if codey.motion_sensor.is_ears_down():
print("ears_down")
if codey.motion_sensor.is_display_up():
print("display_up")
if codey.motion_sensor.is_display_down():
print("display_down")
if codey.motion_sensor.is_upright():
print("upright")
```
## `ir` — Onboard Infrared Transceiver
**Function**
`ir.receive()`\
Returns the string information received by the infrared receiver, so the data sent by the infrared sender must end with `\n`. If it is a remote control command that receives the NEC encoding protocol, use another function `receive_remote_code()`.
`ir.receive_remote_code()`\
Get the date from infrared remote controller. The data contains two parts: address and content, so it returns a list data which length 2. The first parameter is the address code, and the latter parameter is the data code.
`ir.send(str)`\
Send infrared string, parameters：
* *str* The string data to be emitted, the function send will add the `\n` terminator at the end of the string automatically.
`ir.start_learning()`\
Start infrared learning and only support remote control commands that learn the standard NEC protocol.
`ir.stop_learning()`\
Stop infrared learning.
`ir.save_learned_result(index)`\
Save the learned infrared coding result to the corresponding area, parameters：
* *index* the value range is 0 \~ 15, a total of 16 storage areas.
`ir.send_learned_result(index = 1)`\
Send infrared learning saved infrared code, the learning result of the area with index = 1 is set as default, parameters：
* *index* The index value range is `0 ~ 15`, a total of 16 storage areas.
`ir.learn(time = 3)`\
Infrared learning `time` seconds, after calling this API will save the infrared information learned in `time` seconds. Default saved to the area with index = 1, parameter：
* *time* learning time, in `seconds`.
**Sample Code 1:**
```
import codey
import event
@event.start
def start_cb():
print("start event succeeded")
while True:
codey.display.show(codey.ir.receive_remote_code()[1])
```
**Sample Code 2:**
```
import codey
import event
@event.button_a_pressed
def button_a_cb():
print("button a event succeeded")
codey.ir.learn()
codey.led.show(0, 100, 0)
@event.button_b_pressed
def button_a_cb():
print("button b event succeeded")
while True:
codey.ir.send_learned_result()
@event.button_c_pressed
def button_c_cb():
print("button b event succeeded")
while True:
codey.display.show(codey.ir.receive())
```
## `wifi` — Onboard Wi-Fi
**Function**
`wifi.start(ssid = "wifi_ssid", password = "password", mode = codey.wifi.STA)`\
Start wifi connection, the API will not block process, API exit does not mean that wifi is connected, you need to call `wifi.is_connected()` to judge, Parameter：
* *ssid* string type, Wi-Fi account.
* *password* string type, Wi-Fi password.
* *mode* starts the Wi-Fi mode.
`wifi.is_connected()`\
Check if Wi-Fi is connected, the return value is Boolean, where `True` means that wifi has established a connection, `False` means that wifi has not yet established a connection.
**Constant**
`wifi.STA`\
The Wi-Fi station mode, that is, the wireless adapter mode. In this mode, wifi can be connected to the router.
`wifi.AP`\
Wireless access point mode, the general wireless routing / bridge works in this mode. In this mode, it allows other wireless devices to access.
`wifi.APSTA`\
The Wi-Fi AP and STA modes coexist.
**Sample Code:**
```
import codey
codey.wifi.start('makeblock', 'password', codey.wifi.STA)
codey.led.show(0,0,0)
while True:
if codey.wifi.is_connected():
codey.led.show(0,0,255)
else:
codey.led.show(0,0,0)
```
## `battery` — Built-in Lithium Battery
**Function**
`battery.get_voltage()`\
Get the current battery voltage, the return value is a floating point data. The unit is `V`.
`battery.get_percentage()`\
Get the percentage of remaining battery power. The return value is an integer. The data range is `0 ~ 100`, where 100 means there is still 100% of the remaining battery.
**Sample Code:**
```
import codey
while True:
print("vol" + str(codey.battery.get_voltage()))
print("percentage" + str(codey.battery.get_percentage()))
```
## `codey_timer` — Counter
**Function**
`codey.get_timer()`\
Gets the current value of the timer (the timer runs from the time the user script starts), the return value is a floating point data. The unit is `seconds`.
`codey.reset_timer()`\
Initialize the value of the timer.
**Sample Code:**
```
import codey
codey.reset_timer()
while True:
print("time:", end = "")
print(codey.get_timer())
```
## `codey_broadcast` — Broadcast Module
**Function**
`codey.broadcast(str)`\
A broadcast can be sent to the serial port, Bluetooth, and its own event monitoring unit, Parameter：
* *str* The content of the broadcast.
**Sample Code:**
```
import codey
import event
@event.button_a_pressed
def button_a_cb():
print("button a event succeeded")
codey.broadcast("hello")
@event.received("hello")
def received_cb():
print("received message: hello")
```
## `codey_external_module_detect` — External Module Access Detection
**Function**
`codey.has_neuron_connected()`\
Check whether there is any neuron module connected to Codey, and the return value is a Boolean value, where `True` indicates that the neuron module is connected to Codey (including the connecting of the Rocky), and `False` indicates that there is no neuron module connected to the Codey.
`codey.is_rocky_connected()`\
Check if the Rocky is connected to the Codey, the return value is a Boolean value, where `True` means that there is a Rocky connected to the Codey, and `False` means no Rocky connected to Codey.
**Sample Code:**
```
import codey
import time
while True:
if codey.is_rocky_connected():
print("rocky is in")
else:
print("rocky is out")
time.sleep(1)
```
## `codey_script_control` — Script/Thread Control
**Function**
`codey.stop_this_script()`\
Stop the current script, consistent with the scratch stop script feature.
`codey.stop_other_scripts()`\
Stop other scripts, consistent with the scratch stop other scripts feature.
`codey.stop_this_script()`\
Stop all scripts, consistent with the scratch stop all scripts.
**Sample Code:**
```
import codey
import time
import event
@event.start
def start_cb():
while True:
print("start cb executing...")
time.sleep(1)
print("stop this script")
codey.stop_this_script()
@event.button_a_pressed
def button_a_cb():
codey.stop_other_scripts()
while True:
print("button a event")
@event.button_b_pressed
def button_b_cb():
codey.stop_other_scripts()
while True:
print("button b event")
@event.button_c_pressed
def button_c_cb():
codey.stop_all_scripts()
```
## `event` — Event Processing Unit
**Event Processing Unit Introduction**
The way user events are used currently supports two ways of writing. One is registration：
```
import codey
import time
import event
def start_cb():
while True:
codey.led.show(255, 0, 0)
time.sleep(1)
codey.led.show(0, 0, 0)
time.sleep(1)
event.start(start_cb)
```
The other is to use a decorator, such as：
```
import codey
import time
import event
@event.start
def start_callback():
while True:
codey.led.show(255, 0, 0)
time.sleep(1)
codey.led.show(0, 0, 0)
time.sleep(1)
```
**Function**
`event.start(callback)`\
Startup event.
`event.shaked(callback)`\
Codey was shaken event.
`event.received(callback, msgstr)`\
Broadcast reception detection event. In addition to the callback parameter, the parameter：
* *msgstr* string type, the string to be matched. The event will be triggered when the received string matches the matching string.
`event.button_a_pressed(callback)`\
Button A pressed event.
`event.button_b_pressed(callback)`\
Button B pressed event.
`event.button_c_pressed(callback)`\
Button C pressed event.
`event.tilted_left(callback)`\
Codey left-tilted event.
`event.tilted_right(callback)`\
Codey right-tilted event.
`event.ears_up(callback)`\
Codey ears-up event.
`event.ears_down(callback)`\
Codey ears-down event.
`event.ir_received(callback, ir_str)`\
Infrared string reception detection event. In addition to the callback parameter, the parameter：
* *ir\_str* string type, the string to be matched. The event will be triggered when the received string matches the matching string.
`event.greater_than(callback, threshold, type_str)`\
The threshold comparison event, which will be triggered when the threshold is exceeded. In addition to the callback parameter, the parameter：
* *threshold* value data, set the threshold for triggering.
* *type\_str* string data, currently only supports `sound_sensor`: volume sensor, `timer`: timer.
`event.less_than(callback, threshold, type_str)`\
Threshold comparison event, triggered below the threshold, in addition to the callback parameter, the parameter：
* *threshold* value data, set the threshold for triggering
* *type\_str* string data, currently only supports `light_sensor`: light sensor.
**Sample Code:**
```
import codey
import event
@event.button_a_pressed
def button_a_cb():
print("button a event triggered")
@event.button_b_pressed
def button_b_cb():
print("button b event triggered")
@event.button_c_pressed
def button_c_cb():
print("button c event triggered")
@event.greater_than(20, "sound_sensor")
def sound_sensor_cb():
print("sound sensor greater event triggered")
@event.greater_than(5, "timer")
def timer_cb():
print("timer greater event triggered")
@event.less_than(30, "light_sensor")
def light_sensor_cb():
print("light sensor event triggered")
```
---
# 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://learn.pakronics.com.au/primary/codey-rocky-ai-robot/python-api-reference/python-api-for-codey.md?ask=
```
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.