🔍Γνώρισε το CLUE

Το Adafruit CLUE είναι ένας μικρός υπολογιστής (ένας μικροελεγκτής) περίπου στο μέγεθος μιας πιστωτικής κάρτας. Είναι γεμάτο gadgets. Δες τι έχει πάνω του:

Μέχρι το τέλος της περιπέτειας θα έχεις χρησιμοποιήσει όλα αυτά. Θα χρειαστείς επίσης:

• Ένα καλώδιο USB που μεταφέρει δεδομένα (κάποια καλώδια κάνουν μόνο φόρτιση, και αυτά δεν θα δουλέψουν!)
• Έναν υπολογιστή με Chrome ή Edge (και Chromebook κάνει μια χαρά)

🐍Python σε 20 λεπτά

Η CircuitPython είναι Python φτιαγμένη για μικροσκοπικές πλακέτες. Αν ξέρεις ήδη Python, ρίξε μια γρήγορη ματιά και προχώρα. Αν όχι, αυτές είναι οι μόνες ιδέες που χρειάζεσαι για όλη την περιπέτεια. Μετά την Εγκατάσταση, δοκίμασέ τες στο REPL (δες την «Επίλυση προβλημάτων») ή μέσα στο code.py.

1. Σχόλια: σημειώσεις για ανθρώπους

Ό,τι γράψεις μετά το # ο υπολογιστής το αγνοεί.

# Αυτό είναι σχόλιο. Το CLUE το προσπερνάει.

2. print(): στείλε ένα μήνυμα

Δείχνει ένα μήνυμα στην κονσόλα Serial (και στην οθόνη του CLUE, μέχρι το πρόγραμμά σου να ζωγραφίσει κάτι άλλο εκεί).

print("Γεια!")
print(2 + 3)      # τυπώνει 5

3. Μεταβλητές: κουτιά με ετικέτα

score = 0          # ένας αριθμός
name = "Robo"      # το κείμενο (ένα "string") μπαίνει σε εισαγωγικά
score = score + 10 # τώρα το score είναι 10
score += 5         # συντόμευση για score = score + 5, τώρα 15
print(name, "έχει", score, "πόντους")

4. Μαθηματικά: η Python είναι αριθμομηχανή

print(7 + 2)    # 9   πρόσθεση
print(7 - 2)    # 5   αφαίρεση
print(7 * 2)    # 14  πολλαπλασιασμός (αστεράκι, όχι x)
print(7 / 2)    # 3.5 διαίρεση
print(7 // 2)   # 3   διαίρεση χωρίς το υπόλοιπο
print(7 % 2)    # 1   ΜΟΝΟ το υπόλοιπο
print(2 ** 3)   # 8   δύναμη: 2 x 2 x 2
print(round(3.7))  # 4

Το % είναι πολύ χρήσιμο: n % 2 == 0 σημαίνει «το n είναι ζυγός», και το angle % 360 κρατάει μια γωνία από 0 έως 359.

5. True / False και if

Η εσοχή μετράει! Οι γραμμές που είναι πιο μέσα κατά 4 κενά ανήκουν στο if.

temperature = 30
if temperature > 25:
    print("Καύσωνας!")
elif temperature > 15:
    print("Ωραία.")
else:
    print("Μπρρρ!")

Συγκρίσεις: > μεγαλύτερο, < μικρότερο, >= μεγαλύτερο ή ίσο, == ίσο (δύο ίσον!), != διαφορετικό. Συνδύασε ελέγχους με and (και), or (ή), not (όχι), για παράδειγμα if a > 0 and b > 0:.

6. Βρόχοι: κάν' το ξανά

for i in range(3):        # τρέχει 3 φορές: i = 0, 1, 2
    print("Ζήτω!", i)

for i in range(10, 0, -2):  # ξεκίνα από 10, σταμάτα πριν το 0, βήμα -2
    print(i)                # 10 8 6 4 2

count = 0
while count < 3:          # επανάλαβε ΟΣΟ αυτό είναι True
    count += 1
print("μέτρησα ως το", count)

while True:               # τρέχει ΓΙΑ ΠΑΝΤΑ...
    print("Δεν σταματάω ποτέ!")
    break                 # ...εκτός αν βγεις με break

Σχεδόν κάθε πρόγραμμα για το CLUE έχει έναν βρόχο while True:, ώστε να ελέγχει συνέχεια τα κουμπιά και τους αισθητήρες.

7. Λίστες (πίνακες / arrays!): πολλά πράγματα σε ένα κουτί

Στο Scratch λέγονται λίστες, στο MakeCode πίνακες (arrays) και στην Python λίστες (lists). Μια λίστα κρατάει πράγματα με σειρά, μέσα σε αγκύλες [ ].

pets = ["cat", "dog", "hamster"]

print(pets[0])        # cat      (η μέτρηση ξεκινάει από το 0!)
print(pets[2])        # hamster
print(pets[-1])       # hamster  (-1 = το ΤΕΛΕΥΤΑΙΟ)
print(len(pets))      # 3        (πόσα στοιχεία έχει)

pets[1] = "parrot"    # άλλαξε ένα στοιχείο
pets.append("fish")   # πρόσθεσε στο τέλος
pets.insert(0, "frog")  # πρόσθεσε στη θέση 0
pets.remove("cat")    # βγάλε ένα στοιχείο με βάση την τιμή του
last = pets.pop()     # βγάλε το τελευταίο (και κράτα το)
print(pets, last)     # ['frog', 'parrot', 'hamster'] fish

if "frog" in pets:    # υπάρχει στη λίστα;
    print("Κουάξ!")

Βρόχος πάνω σε μια λίστα

scores = [12, 45, 7, 30]

for s in scores:               # το s γίνεται κάθε στοιχείο με τη σειρά
    print("σκορ:", s)

for i in range(len(scores)):   # όταν χρειάζεσαι και τη θέση
    print("παίκτης", i, "έφερε", scores[i])

print(sum(scores), max(scores), min(scores))  # 94 45 7
print(sorted(scores))          # [7, 12, 30, 45]
print(scores[1:3])             # [45, 7]  ένα «κομμάτι» (slice): στοιχεία 1 και 2

Φτιάχνοντας μια λίστα λίγο-λίγο

evens = []                # ξεκίνα με άδεια λίστα
for n in range(1, 11):
    if n % 2 == 0:
        evens.append(n)
print(evens)              # [2, 4, 6, 8, 10]

Λίστες μέσα σε λίστες: ένα πλέγμα

Τέλειο για ταμπλό παιχνιδιών και λαβυρίνθους. grid[γραμμή][στήλη]:

grid = [
    [0, 1, 0],
    [1, 1, 1],
    [0, 1, 0],
]
print(grid[1][2])         # γραμμή 1, στήλη 2 -> 1
grid[0][0] = 9
for row in grid:
    print(row)

8. Tuples (πλειάδες): λίστες που δεν αλλάζουν ποτέ

Παρενθέσεις ( ) αντί για αγκύλες. Μπορείς να τις διαβάσεις αλλά όχι να τις αλλάξεις. Το CLUE τις χρησιμοποιεί συνέχεια: τα χρώματα και οι μετρήσεις των αισθητήρων είναι tuples.

purple = (255, 0, 255)     # πόσο κόκκινο, πράσινο, μπλε
print(purple[0])           # 255
x, y, z = (1, 2, 3)        # "ξεπακετάρουμε" ένα tuple σε 3 μεταβλητές
# purple[0] = 100          # ΛΑΘΟΣ! τα tuples δεν αλλάζουν

9. Strings: παιχνίδι με κείμενο

word = "clue"
print(word.upper())        # CLUE
print(len(word))           # 4 γράμματα
print(word[0])             # c  (τα strings δουλεύουν σαν λίστες από γράμματα!)
print("Hi " + word + "!")  # Hi clue!  (το + κολλάει κείμενα μαζί)
print("ha" * 3)            # hahaha

age = 12
print("Είμαι " + str(age))  # το str() κάνει έναν αριθμό κείμενο
print(int("7") + 1)         # το int() κάνει κείμενο αριθμό: 8

10. import: δανείσου υπερδυνάμεις

import time              # εργαλεία ρολογιού
time.sleep(0.5)          # περίμενε μισό δευτερόλεπτο

import random            # εργαλεία για ζάρια και τύχη
print(random.randint(1, 6))          # τυχαίος ακέραιος από 1 έως 6
print(random.choice(["rock", "paper", "scissors"]))  # διάλεξε από μια λίστα

from adafruit_clue import clue   # δανειζόμαστε ΟΛΕΣ τις δυνάμεις του CLUE

11. Συναρτήσεις: οι δικές σου εντολές

def cheer(name):
    print("Πάμε", name, "πάμε!")

cheer("Robo")   # Πάμε Robo πάμε!

def double(n):
    return n * 2      # το return δίνει πίσω μια απάντηση

print(double(4))      # 8

def average(numbers):             # συναρτήσεις + λίστες = δύναμη!
    return sum(numbers) / len(numbers)

print(average([10, 20, 30]))      # 20.0

Το print δείχνει κάτι· το return δίνει την απάντηση πίσω στον κώδικα που κάλεσε τη συνάρτηση.

12. f-strings: ανακάτεψε κείμενο και αριθμούς

temp = 21.5678
print(f"Θερμοκρασία: {temp:.1f} C")   # Θερμοκρασία: 21.6 C  (.1f = 1 δεκαδικό ψηφίο)

13. Μπόνους: λεξικά (dictionaries), λίστες με ταμπελάκια

Μια λίστα βρίσκει πράγματα με βάση τη θέση. Ένα λεξικό τα βρίσκει με βάση ένα όνομα (ένα «κλειδί»), με άγκιστρα { }.

colors = {"red": (255, 0, 0), "green": (0, 255, 0), "blue": (0, 0, 255)}
print(colors["green"])      # (0, 255, 0)
colors["pink"] = (255, 0, 128)   # πρόσθεσε νέο κλειδί

for name in colors:
    print(name, colors[name])   # προσοχή: στο CLUE η σειρά μπορεί να βγει ανακατεμένη!

Σε αντίθεση με τη λίστα, ένα λεξικό στο CLUE δεν υπόσχεται να κρατήσει τη σειρά. Όταν η σειρά μετράει, χρησιμοποίησε λίστα.

🔬 Μίνι project: μια λίστα με αληθινές μετρήσεις

Μόλις στήσεις το CLUE σου (στο επόμενο επίπεδο), δοκίμασε αυτό. Μαζεύει 10 μετρήσεις θερμοκρασίας σε μια λίστα και μετά κάνει μαθηματικά με αυτές.

import time
from adafruit_clue import clue

readings = []
for i in range(10):
    readings.append(clue.temperature)
    time.sleep(0.2)

print("όλες:", [round(t, 1) for t in readings])
print(f"χαμηλότερη {min(readings):.1f}  υψηλότερη {max(readings):.1f}")
print(f"μέσος όρος {sum(readings) / len(readings):.2f}")

Η γραμμή με το [round(t, 1) for t in readings] είναι μια έξυπνη συντόμευση που φτιάχνει μια νέα λίστα με κάθε μέτρηση στρογγυλεμένη. Δεν χρειάζεται να γράφεις τέτοιες ακόμα!

🛠️Εγκατάσταση: ζωντάνεψε το CLUE σου

Αυτό το κάνουμε μόνο μία φορά. Έχει 3 μέρη: (A) εγκατάσταση της CircuitPython, (B) προσθήκη των βιβλιοθηκών, (Γ) σύνδεση με τον editor κώδικα.

Μέρος A: Εγκατάσταση της CircuitPython

1. Πήγαινε στο circuitpython.org/board/clue_nrf52840_express και κατέβασε το πιο πρόσφατο σταθερό αρχείο .UF2 (όχι κάποιο "Absolute Newest" ή beta).
2. Σύνδεσε το CLUE στον υπολογιστή με το καλώδιο USB δεδομένων.
3. Κάνε διπλό κλικ στο μικρό κουμπί Reset (γρήγορα: κλικ-κλικ!). Το NeoPixel γίνεται πράσινο και στον υπολογιστή σου εμφανίζεται ένας νέος δίσκος με όνομα CLUEBOOT (ο δίσκος «εκκίνησης» της πλακέτας).
4. Σύρε το αρχείο .UF2 πάνω στο CLUEBOOT. Το φωτάκι αναβοσβήνει, το CLUEBOOT εξαφανίζεται και εμφανίζεται ένας νέος δίσκος με όνομα CIRCUITPY (εδώ θα ζει ο κώδικάς σου). 🎉

Κοίτα μέσα στο CIRCUITPY. Θα δεις το code.py (το πρόγραμμά σου), έναν φάκελο lib (για τις βιβλιοθήκες) και το boot_out.txt. Άνοιξε το boot_out.txt: η πρώτη γραμμή σου λέει την έκδοση της CircuitPython, για παράδειγμα Adafruit CircuitPython 10.0.0. Θυμήσου αυτόν τον πρώτο αριθμό!

Μέρος B: Πρόσθεσε τις βιβλιοθήκες

Μια βιβλιοθήκη (library) είναι κώδικας που έγραψε κάποιος άλλος και μπορείς να τον δανειστείς. Η βιβλιοθήκη adafruit_clue μάς δίνει εύκολες εντολές όπως το clue.temperature. Χρειάζεται όμως και μερικές βοηθητικές βιβλιοθήκες.

1. Πήγαινε στο circuitpython.org/libraries και κατέβασε το Bundle με τον ίδιο πρώτο αριθμό. Για παράδειγμα, αν το boot_out.txt γράφει CircuitPython 10.3.1, διάλεξε το bundle για 10.x.
2. Αποσυμπίεσέ το. Άνοιξε τον φάκελο lib μέσα στο bundle. Είναι τεράστιος, αλλά χρειαζόμαστε μόνο λίγα πράγματα.
3. Αντέγραψε αυτά στον φάκελο lib του CIRCUITPY (κάποια είναι φάκελοι, κάποια είναι αρχεία που τελειώνουν σε .mpy):

pip install circup
circup install adafruit_clue

Μέρος Γ: Σύνδεση με τον editor κώδικα

1. Άνοιξε το code.circuitpython.org σε Chrome ή Edge.
2. Εμφανίζεται ένα κουτί που ρωτάει πώς θα συνδεθείς. Πάτα USB.
3. Βήμα 1: πάτα Connect to Device (Σύνδεση με συσκευή). Ο Chrome δείχνει μια λίστα: διάλεξε CLUE nRF52840 Express - CircuitPython CDC control (COM…) και πάτα Connect.
4. Βήμα 2: πάτα Select New Folder (Επιλογή φακέλου), διάλεξε τον δίσκο CIRCUITPY και πάτα Select Folder. Ο Chrome ρωτάει "Allow this site to edit files?" (Να επιτρέπεται η επεξεργασία αρχείων;): πάτα Allow και μετά OK.
5. Ένα κουτί Device Info δείχνει την πλακέτα και την έκδοσή της. Αν γράφει "Update available … alpha", αγνόησέ το (alpha = δοκιμαστική, ημιτελής έκδοση) και πάτα Close.
6. Ο editor ξεκινάει με ένα άδειο [New Document]. Πάτα Open (Άνοιγμα) και κάνε διπλό κλικ στο code.py. Αυτό είναι το αρχείο που τρέχει αυτόματα το CLUE.
7. Πάτα Serial (κάτω αριστερά) για να ανοίξει η κονσόλα στα δεξιά. Εκεί εμφανίζονται τα μηνύματα του print(). Έχει κουμπιά Halt (σταματάει το πρόγραμμα), Restart (επανεκκίνηση), Clear (καθάρισμα) και Plotter (ζωντανά γραφήματα!).

Το πρώτο σου πρόγραμμα

Σβήσε ό,τι υπάρχει στο code.py, γράψε αυτό και πάτα Save + Run:

from adafruit_clue import clue

print("Γεια από το CLUE μου!")
print("Εδώ μέσα έχει", round(clue.temperature, 1), "βαθμούς Κελσίου (λίγο παραπάνω, δες την Αποστολή 11)")

Κοίτα στην κονσόλα Serial. Τύπωσε τη θερμοκρασία; Μόλις διάβασες έναν αισθητήρα! 🎉

Ας βάλουμε λέξεις στην οθόνη. Το simple_text_display σού δίνει έναν τίτλο και γραμμές με αριθμούς 0, 1, 2…

from adafruit_clue import clue

screen = clue.simple_text_display(title="CLUE QUEST", text_scale=2,
                                  colors=((255, 0, 255), (0, 255, 255), (255, 255, 0)))

screen[0].text = "Hello, world!"
screen[1].text = "My name is"
screen[2].text = "Sam"
screen.show()          # δεν εμφανίζεται τίποτα μέχρι να καλέσεις το show()!

while True:            # κράτα το πρόγραμμα να τρέχει για να μένει το κείμενο
    pass               # "pass" σημαίνει "μην κάνεις τίποτα"

Τα χρώματα γράφονται ως (κόκκινο, πράσινο, μπλε), το καθένα από 0 έως 255. (255, 0, 255) = όλο το κόκκινο + όλο το μπλε = ματζέντα. Ο τίτλος μένει πάντα λευκός, γιατί το colors= αλλάζει μόνο τις γραμμές. Για να τον αλλάξεις, βάλε title_color=(255, 255, 0).

import displayio
import terminalio
from adafruit_display_text import label
from adafruit_clue import clue

group = displayio.Group()                 # ένα "στρώμα" για να ζωγραφίσουμε

# φόντο: ένα bitmap 240x240 γεμάτο με ένα χρώμα
bg = displayio.Bitmap(240, 240, 1)
palette = displayio.Palette(1)
palette[0] = 0x220044                     # σκούρο μωβ (χρώμα σε hex)
group.append(displayio.TileGrid(bg, pixel_shader=palette))

big = label.Label(terminalio.FONT, text="WOW", color=0x22D3EE, scale=6, x=65, y=120)
group.append(big)

clue.display.root_group = group           # δείξε το στρώμα μας

while True:
    pass

Το CLUE έχει τρία είδη φώτων: το NeoPixel (όποιο χρώμα θες), το κόκκινο LED (ανοιχτό/κλειστό) και δύο λευκά LED (ανοιχτά/κλειστά, πάρα πολύ φωτεινά).

import time
from adafruit_clue import clue

clue.pixel.brightness = 0.2    # 0.0 = σβηστό, 1.0 = ΤΥΦΛΩΝΕΙ

rainbow = [(255, 0, 0), (255, 128, 0), (255, 255, 0),
           (0, 255, 0), (0, 0, 255), (128, 0, 255)]

while True:
    for color in rainbow:
        clue.pixel.fill(color)   # βάλε χρώμα στο NeoPixel
        clue.red_led = True      # κόκκινο LED αναμμένο
        time.sleep(0.3)
        clue.red_led = False     # κόκκινο LED σβηστό
        time.sleep(0.1)

Και τα λευκά LED θέλουν μόνο μία γραμμή:

from adafruit_clue import clue

clue.white_leds = True    # φακός ΑΝΑΜΜΕΝΟΣ (με False σβήνει)

while True:
    pass

Το clue.button_a είναι True όσο κρατάς πατημένο το A, αλλιώς είναι False. Το ίδιο και για το B.

from adafruit_clue import clue

while True:
    if clue.button_a and clue.button_b:
        clue.pixel.fill((0, 255, 0))      # και τα δύο = πράσινο
    elif clue.button_a:
        clue.pixel.fill((255, 0, 0))      # A = κόκκινο
    elif clue.button_b:
        clue.pixel.fill((0, 0, 255))      # B = μπλε
    else:
        clue.pixel.fill((0, 0, 0))        # τίποτα = σβηστό

Μετράμε πατήματα

Αν απλώς κάναμε count = count + 1 όσο είναι πατημένο το A, θα μετρούσε εκατοντάδες φορές σε κάθε πάτημα! Αντί γι' αυτό, θυμόμαστε αν το κουμπί ήταν ήδη πατημένο και μετράμε μόνο τη στιγμή που πατιέται.

from adafruit_clue import clue

screen = clue.simple_text_display(title="Clicker", text_scale=3)
count = 0
was_down = False

while True:
    down = clue.button_a
    if down and not was_down:     # ΜΟΛΙΣ πατήθηκε
        count = count + 1
    was_down = down

    if clue.button_b:             # το B μηδενίζει
        count = 0

    screen[0].text = str(count)   # το str() κάνει έναν αριθμό κείμενο
    screen.show()

Το clue.play_tone(frequency, seconds) παίζει μια νότα (συχνότητα, δευτερόλεπτα). Μεγαλύτερη συχνότητα σημαίνει πιο ψιλή νότα. Το 262 είναι το μεσαίο Ντο.

import time
from adafruit_clue import clue

C, D, E, F, G, A = 262, 294, 330, 349, 392, 440   # Ντο, Ρε, Μι, Φα, Σολ, Λα

# Twinkle Twinkle Little Star: (νότα, διάρκεια)
song = [(C, 0.4), (C, 0.4), (G, 0.4), (G, 0.4), (A, 0.4), (A, 0.4), (G, 0.8),
        (F, 0.4), (F, 0.4), (E, 0.4), (E, 0.4), (D, 0.4), (D, 0.4), (C, 0.8)]

for note, length in song:     # ξεπακετάρουμε κάθε ζευγάρι (νότα, διάρκεια)
    clue.play_tone(note, length)
    time.sleep(0.05)          # μικρό κενό ανάμεσα στις νότες

Υπάρχουν επίσης τα clue.start_tone(freq) και clue.stop_tone() για νότες που κρατάνε όσο θέλεις. Θα τα χρησιμοποιήσεις στην επόμενη αποστολή. Το play_tone περιμένει να τελειώσει η νότα πριν τρέξει η επόμενη γραμμή· το start_tone ξεκινάει τη νότα και προχωράει αμέσως.

Τα χρυσά «πατάκια» με τα νούμερα 0, 1 και 2 στην κάτω άκρη είναι αισθητήρες αφής. Το σώμα σου έχει ένα μικροσκοπικό ηλεκτρικό φορτίο, και το CLUE μπορεί να το νιώσει!

from adafruit_clue import clue

clue.pixel.brightness = 0.2

while True:
    if clue.touch_0:
        clue.start_tone(262)          # Ντο
        clue.pixel.fill((255, 0, 0))
    elif clue.touch_1:
        clue.start_tone(330)          # Μι
        clue.pixel.fill((0, 255, 0))
    elif clue.touch_2:
        clue.start_tone(392)          # Σολ
        clue.pixel.fill((0, 0, 255))
    else:
        clue.stop_tone()
        clue.pixel.fill((0, 0, 0))

Χέρια μακριά όσο ξεκινάει! Το CLUE μαθαίνει το «κανονικό» επίπεδο κάθε πατακιού όταν ξεκινάει το πρόγραμμα. Αν ένα πατάκι μοιάζει κολλημένο, ξανατρέξε το πρόγραμμα χωρίς να ακουμπάς τίποτα.

Το επιταχυνσιόμετρο μετράει σπρωξίματα και τραβήγματα, ακόμα και τη βαρύτητα! Το clue.acceleration δίνει 3 αριθμούς (x, y, z). Όταν η πλακέτα είναι ξαπλωμένη με την οθόνη προς τα πάνω, το z είναι περίπου -9,5 έως -9,8 (λίγο διαφορετικό σε κάθε πλακέτα): αυτή είναι η βαρύτητα που τραβάει προς τα κάτω. Γύρνα την ανάποδα και γίνεται +9,8!

import time
from adafruit_clue import clue

while True:
    x, y, z = clue.acceleration
    print(f"x={x:.1f}  y={y:.1f}  z={z:.1f}")
    time.sleep(0.2)

Γείρε την πλακέτα και δες τους αριθμούς να αλλάζουν. Γείρε τη δεξιά-αριστερά: αυτό είναι το x. Γείρε τη μπρος-πίσω: αυτό είναι το y.

Μαγική Μπάλα 8

Το clue.shake() είναι True όταν κουνάς την πλακέτα. Η προεπιλογή για το shake_threshold είναι 30 (δυνατό κούνημα)· εμείς βάζουμε 20 για να πιάνει και ένα απαλό κούνημα. Μεγάλωσέ το αν ενεργοποιείται πολύ εύκολα, μίκρυνέ το αν πρέπει να την κουνάς πάρα πολύ δυνατά, αλλά όχι κάτω από 10.

import random
from adafruit_clue import clue

answers = ["Yes!", "No way", "Maybe...", "Ask again", "Definitely", "Nope"]
screen = clue.simple_text_display(title="Magic 8-Ball", text_scale=3)
screen[1].text = "Shake me!"
screen.show()

while True:
    if clue.shake(shake_threshold=20):
        screen[1].text = random.choice(answers)
        screen.show()
        clue.play_tone(880, 0.1)

Το γυροσκόπιο μετράει πόσο γρήγορα γυρίζει η πλακέτα, σε μοίρες ανά δευτερόλεπτο. Όταν είναι ακίνητη, δείχνει κοντά στο 0.

from adafruit_clue import clue

screen = clue.simple_text_display(title="Spin-o-meter", text_scale=2)

while True:
    x, y, z = clue.gyro
    screen[0].text = f"x: {x:6.0f}"
    screen[1].text = f"y: {y:6.0f}"
    screen[2].text = f"z: {z:6.0f}"
    if abs(z) > 200:              # το abs() αγνοεί το πρόσημο μείον
        screen[4].text = "WHEEE!"
    else:
        screen[4].text = ""
    screen.show()

Το :6.0f σημαίνει χωρίς δεκαδικά και πλάτος τουλάχιστον 6 χαρακτήρες, για να στοιχίζονται οι αριθμοί. Μπορείς να χρησιμοποιήσεις και τις γραμμές 3, 4, 5…: κάθε γραμμή είναι 13 × text_scale pixel πιο κάτω, οπότε με μεγάλα γράμματα η οθόνη τελειώνει πιο γρήγορα.

Ξάπλωσε το CLUE στο τραπέζι και γύρνα το σαν δίσκο βινυλίου. Αυτός είναι ο άξονας z!

Το μαγνητόμετρο νιώθει μαγνητικά πεδία (σε μικροτέσλα). Η Γη είναι ένας γιγάντιος μαγνήτης, και ένα μαγνητάκι ψυγείου είναι ένας μικροσκοπικός.

import math
from adafruit_clue import clue

screen = clue.simple_text_display(title="Magnet Hunter", text_scale=2)

while True:
    x, y, z = clue.magnetic
    strength = math.sqrt(x*x + y*y + z*z)    # συνολική δύναμη μαγνήτη
    screen[0].text = f"Power: {strength:.0f}"
    if strength > 150:
        screen[2].text = "MAGNET NEARBY!"
        clue.pixel.fill((255, 0, 0))
    else:
        screen[2].text = ""
        clue.pixel.fill((0, 0, 0))
    screen.show()

Φέρε κοντά έναν μαγνήτη και δες τη δύναμη να πετάγεται. Μόνο το πεδίο της Γης είναι συνήθως γύρω στο 25 έως 65.

Πρόχειρη πυξίδα

Με την πλακέτα ξαπλωμένη, το atan2(y, x) μετατρέπει τις τιμές x και y σε γωνία, και το % 360 την κρατάει από 0 έως 359.

import math
from adafruit_clue import clue

screen = clue.simple_text_display(title="Compass", text_scale=3)

while True:
    x, y, z = clue.magnetic
    heading = math.degrees(math.atan2(y, x)) % 360
    screen[1].text = f"{heading:.0f} deg"
    screen.show()

Η γωνία μετριέται από τον άξονα x της πλακέτας, όχι από την οθόνη. Γύρνα την πλακέτα μέχρι να δείξει περίπου 0: τώρα ο άξονας x δείχνει προς τον μαγνητικό βορρά. Δες προς τα πού ανεβαίνει ο αριθμός πριν εμπιστευτείς τα N/E/S/W.

Ο μικρός μαύρος αισθητήρας στην κορυφή της πλακέτας ρίχνει αόρατο υπέρυθρο φως και βλέπει πώς αυτό αναπηδάει πίσω. Έτσι παίρνουμε εγγύτητα (0 = μακριά, 255 = το ακουμπάς) και χειρονομίες (κουνήματα του χεριού!).

Θερεμίν εγγύτητας

from adafruit_clue import clue

while True:
    p = clue.proximity
    if p > 10:
        clue.start_tone(200 + p * 5)   # χέρι πιο κοντά = πιο ψιλή νότα
    else:
        clue.stop_tone()

Ανιχνευτής κινήσεων

Το clue.gesture δίνει 0 = τίποτα, 1 = πάνω, 2 = κάτω, 3 = αριστερά, 4 = δεξιά. Κούνα το χέρι σου περίπου 5 με 10 εκατοστά πάνω από τον αισθητήρα.

from adafruit_clue import clue

names = ["", "UP", "DOWN", "LEFT", "RIGHT"]
screen = clue.simple_text_display(title="Swipe!", text_scale=4)

while True:
    g = clue.gesture
    if g != 0:
        screen[1].text = names[g]    # με τον αριθμό διαλέγουμε από τη λίστα
        screen.show()

Ο ίδιος αισθητήρας βλέπει και χρώματα! Το clue.color δίνει 4 αριθμούς: κόκκινο, πράσινο, μπλε, clear (clear = συνολική φωτεινότητα). Άναψε τα λευκά LED για να βλέπει καλύτερα.

import time
from adafruit_clue import clue

clue.white_leds = True
clue.pixel.brightness = 0.3
screen = clue.simple_text_display(title="Color Copycat", text_scale=2)

while True:
    r, g, b, c = clue.color
    screen[0].text = f"R {r}"
    screen[1].text = f"G {g}"
    screen[2].text = f"B {b}"
    screen.show()

    biggest = max(r, g, b, 1)            # το 1 μας γλιτώνει από διαίρεση με το μηδέν
    # κλιμάκωση ώστε το πιο δυνατό χρώμα να γίνει 255
    clue.pixel.fill((r * 255 // biggest, g * 255 // biggest, b * 255 // biggest))
    time.sleep(0.1)

Κράτα ένα πολύχρωμο τουβλάκι LEGO, ένα χαρτάκι post-it ή το καπάκι ενός μαρκαδόρου ακριβώς πάνω από τον αισθητήρα. Το NeoPixel το αντιγράφει!

Η πρώτη μέτρηση αφού ανάψουν τα λευκά LED είναι 0 (ο αισθητήρας θέλει περίπου μισό δευτερόλεπτο για την πρώτη του «φωτογραφία»· σε πρόγραμμα που διαβάζει μόνο μία φορά, διάβασε, κάνε time.sleep(0.5) και ξαναδιάβασε), και οι αριθμοί μπορεί να είναι εκατοντάδες ή χιλιάδες, όχι μόνο 0 έως 255. Δεν πειράζει: μετράει μόνο ποιος είναι ο μεγαλύτερος. (Το // κάνει διαίρεση και πετάει τα δεκαδικά.)

Τέσσερις αισθητήρες αέρα σε ένα πρόγραμμα:

• clue.temperature: βαθμοί Κελσίου
• clue.humidity: % νερού στον αέρα
• clue.pressure: ατμοσφαιρική πίεση σε hPa (όταν η πίεση πέφτει, συχνά έρχεται βροχή!)
• clue.altitude: υψόμετρο σε μέτρα, υπολογισμένο από την πίεση

import time
from adafruit_clue import clue

# Βρες τη σημερινή πίεση στο επίπεδο της θάλασσας για την πόλη σου σε ένα site καιρού
# και βάλ' τη εδώ για να είναι πιο ακριβές το υψόμετρο.
clue.sea_level_pressure = 1013.25
TEMP_OFFSET = 5      # μέτρησε το δικό σου: ένδειξη CLUE μείον αληθινό θερμόμετρο

screen = clue.simple_text_display(title="Weather Station", text_scale=2,
                                  colors=((255, 80, 80), (80, 180, 255), (255, 255, 0), (80, 255, 120)))

while True:
    temp_c = clue.temperature - TEMP_OFFSET
    temp_f = temp_c * 9 / 5 + 32
    screen[0].text = f"{temp_c:.1f}C / {temp_f:.0f}F"
    screen[1].text = f"Humid {clue.humidity:.0f}%"
    screen[2].text = f"{clue.pressure:.0f} hPa"
    screen[3].text = f"Alt {clue.altitude:.0f} m"
    screen.show()
    time.sleep(1)

Το μικρόφωνο εδώ δεν μπορεί να ηχογραφήσει λέξεις, αλλά μετράει πόσο δυνατός είναι ο ήχος. Το clue.sound_level δίνει έναν αριθμό, και το clue.loud_sound() είναι True όταν ο ήχος είναι πιο δυνατός από ένα όριο.

Μετρητής θορύβου

import time
from adafruit_clue import clue

while True:
    level = clue.sound_level
    print((level,))          # το κόμμα το κάνει tuple, για να το ζωγραφίσει ο Plotter!
    time.sleep(0.05)

Φως με παλαμάκι

import time
from adafruit_clue import clue

light_on = False

while True:
    if clue.loud_sound(sound_threshold=500):
        light_on = not light_on          # αλλάζει True ↔ False
        clue.white_leds = light_on
        time.sleep(0.5)                  # αγνόησε την ηχώ από το ίδιο παλαμάκι

Πολύ ευαίσθητο; Μεγάλωσε το sound_threshold. Δεν σε ακούει; Μίκρυνέ το. Σε ήσυχο δωμάτιο ο αριθμός είναι συνήθως 5 έως 30. Όταν μιλάτε ανεβαίνει, και με ένα παλαμάκι ανεβαίνει πολύ περισσότερο. Τρέξε τον μετρητή θορύβου, χτύπα παλαμάκια και διάλεξε ένα όριο ανάμεσα στον πιο δυνατό κανονικό θόρυβο και στο παλαμάκι σου.

Ώρα να συνδυάσεις δυνάμεις: οθόνη + NeoPixel + κουμπιά + ηχείο + χρόνος + τύχη (random). Περίμενε το πράσινο και μετά πάτα το A όσο πιο γρήγορα μπορείς. Αν πατήσεις πολύ νωρίς, χάνεις!

import time
import random
from adafruit_clue import clue

clue.pixel.brightness = 0.3
screen = clue.simple_text_display(title="REACTION RACE", text_scale=2)
best = None                      # None = "δεν υπάρχει σκορ ακόμα"

def show(line0, line1="", line2=""):
    screen[0].text = line0
    screen[1].text = line1
    screen[2].text = line2
    screen.show()

while True:
    best_text = "Best: --" if best is None else f"Best: {best} ms"
    show("Press A", "to start", best_text)
    while not clue.button_a:     # περίμενε το A
        pass
    while clue.button_a:         # περίμενε να αφήσεις το A
        pass

    show("Get ready...", "wait for GREEN")
    clue.pixel.fill((255, 0, 0))
    wait = random.uniform(1.5, 4.0)
    start_wait = time.monotonic()
    cheated = False
    while time.monotonic() - start_wait < wait:
        if clue.button_a:        # πατήθηκε πολύ νωρίς!
            cheated = True
            break

    if cheated:
        clue.pixel.fill((255, 0, 255))
        clue.play_tone(150, 0.6)
        show("TOO EARLY!", "Try again")
        time.sleep(2)
        continue                 # πήδα πίσω στην αρχή του βρόχου

    clue.pixel.fill((0, 255, 0))
    clue.play_tone(1000, 0.05)
    go = time.monotonic()
    while not clue.button_a:
        pass
    ms = int((time.monotonic() - go) * 1000)
    clue.pixel.fill((0, 0, 0))

    if best is None or ms < best:
        best = ms
        clue.play_tone(523, 0.1)
        clue.play_tone(784, 0.2)
        show(f"{ms} ms", "NEW RECORD!")
    else:
        show(f"{ms} ms", "Nice try!")
    time.sleep(2)
    while clue.button_a:
        pass

Καινούργια πράγματα εδώ: το time.monotonic() είναι ένα χρονόμετρο που μετράει δευτερόλεπτα από τη στιγμή που ξεκίνησε η πλακέτα, το break σε βγάζει έξω από έναν βρόχο, το continue πηδάει στον επόμενο γύρο, και το None σημαίνει «τίποτα ακόμα».

Όλες οι δυνάμεις του CLUE σε μία σελίδα

Ξεκίνα πάντα με from adafruit_clue import clue.

Κι άλλες περιπέτειες

• Εργαστήριο Οθόνης: πώς δουλεύει η οθόνη, σχήματα και κίνηση
• Picture Maker: φωτογραφίες και GIF στο CLUE σου
• Οδηγός Adafruit CLUE: το επίσημο εγχειρίδιο (στα αγγλικά)
• Τεκμηρίωση της βιβλιοθήκης adafruit_clue: κάθε εντολή εξηγημένη (στα αγγλικά)
• Projects με CLUE στο Adafruit Learn: ένα σωρό ιδέες για projects
• Η CircuitPython στο GitHub: ο πηγαίος κώδικας της ίδιας της CircuitPython