├── .gitignore ├── Examples ├── spheroBlink.py ├── spheroCircle.py ├── spheroColors.py ├── spheroRiddle.py ├── spheroSleep.py ├── spheroSquare.py └── spheroStrobo.py ├── README.md └── Tutorials ├── 1. Hello Sphero ├── 1_hello_sphero.py ├── 2_kolory.py ├── 3_kolory_w_petli.py └── 4_zgas_swiatlo.py ├── 2. Poznajemy Sphero ├── 1_rollowanie.py ├── 2_troche_ruchu.py ├── 3_zakrety.py ├── 4_lets_dance.py └── 5_te_kocie_ruchy.py ├── 3. Ćwiczymy ruch ├── 1_bumerang.py ├── 2_bumerang_w_petli.py ├── 3_trojkaty_i_kwadraty.py ├── 4_odkrywamy_kolo_na_nowo.py └── 5_osemka.py ├── 4. Zagadka ├── 01_minitask.py ├── 02_minitask.py ├── 03_minitask.py ├── 04_minitask.py ├── 05_minitask.py ├── 06_minitask.py ├── 07_minitask.py ├── 08_minitask.py ├── 09_minitask.py ├── 10_minitask.py ├── 11_minitask.py └── 12_minitask.py ├── sphero_config.py └── sphero_reset.py /.gitignore: -------------------------------------------------------------------------------- 1 | *.o 2 | *.so 3 | *.pyc 4 | *.pyo 5 | .cache/ 6 | __pycache__/ 7 | build/ 8 | *.egg-info/ 9 | dist/ 10 | -------------------------------------------------------------------------------- /Examples/spheroBlink.py: -------------------------------------------------------------------------------- 1 | from kulka import Kulka 2 | import random 3 | import time 4 | 5 | 6 | ADDR = 'XX:XX:XX:XX:XX:XX' 7 | 8 | 9 | def main(): 10 | with Kulka(ADDR) as kulka: 11 | kulka.set_inactivity_timeout(3600) 12 | blink_rate = 1 13 | 14 | for _ in range(5): 15 | blink_rate = abs(blink_rate - 0.05) 16 | kulka.set_rgb(random.randint(0, 255), random.randint(0, 255), 17 | random.randint(0, 255)) 18 | time.sleep(blink_rate) 19 | kulka.set_rgb(0, 0, 0) 20 | time.sleep(blink_rate) 21 | 22 | main() 23 | -------------------------------------------------------------------------------- /Examples/spheroCircle.py: -------------------------------------------------------------------------------- 1 | from kulka import Kulka 2 | import time 3 | 4 | 5 | ADDR = 'XX:XX:XX:XX:XX:XX' 6 | 7 | 8 | STEPS = 10 9 | SPEED = 0x30 10 | SLEEP_TIME = 0.3 11 | 12 | 13 | def make_a_step(kulka, current_angle): 14 | kulka.roll(SPEED, current_angle) 15 | time.sleep(SLEEP_TIME) 16 | kulka.roll(0, current_angle) 17 | 18 | 19 | def make_a_circle(kulka, steps): 20 | rotate_by = 360 // steps 21 | current_angle = 1 22 | 23 | for _ in range(steps): 24 | make_a_step(kulka, current_angle % 360) 25 | current_angle += rotate_by 26 | 27 | 28 | def main(): 29 | with Kulka(ADDR) as kulka: 30 | make_a_circle(kulka, STEPS) 31 | 32 | 33 | main() 34 | -------------------------------------------------------------------------------- /Examples/spheroColors.py: -------------------------------------------------------------------------------- 1 | from __future__ import print_function 2 | from kulka import Kulka 3 | import time 4 | 5 | 6 | ADDR = 'XX:XX:XX:XX:XX:XX' 7 | 8 | 9 | with Kulka(ADDR) as kulka: 10 | for _ in range(3): 11 | print("Setting color to red") 12 | kulka.set_rgb(255, 0, 0) 13 | time.sleep(0.1) 14 | 15 | print("Setting color to green") 16 | kulka.set_rgb(0, 255, 0) 17 | time.sleep(0.1) 18 | 19 | print("Setting color to blue") 20 | kulka.set_rgb(0, 0, 255) 21 | time.sleep(0.1) 22 | -------------------------------------------------------------------------------- /Examples/spheroRiddle.py: -------------------------------------------------------------------------------- 1 | from __future__ import print_function 2 | from Kulka import Kulka 3 | from textwrap import dedent 4 | from random import randint 5 | 6 | try: 7 | input_ = raw_input 8 | except NameError: 9 | input_ = input 10 | 11 | 12 | ADDR = 'XX:XX:XX:XX:XX:XX' 13 | 14 | 15 | """ 16 | This program is a simple implementation of a game, where the user is 17 | supposed to guess the number in a range 1 to 100, while the program 18 | can give him a hint, whether the number provided is greater, equal 19 | or less to the one provided by the player 20 | 21 | pulse rate means how close is user to guess the number the smaller 22 | the value is, the closer the user is. range: 0-100 23 | """ 24 | 25 | 26 | def show_hint_in_sphero(kulka, pulse_rate): 27 | green_channel = abs(255 - int(pulse_rate * 2.55)) % 255 28 | kulka.set_rgb(0, green_channel, 0) 29 | print("pulse rate: %s" % pulse_rate) 30 | print("color: 10, {}, 10".format(green_channel)) 31 | 32 | 33 | def show_hint(kulka, difference): 34 | if difference > 0: 35 | print("My number is greater!") 36 | else: 37 | print("My number is smaller!") 38 | 39 | pulse_rate = abs(difference) 40 | show_hint_in_sphero(kulka, pulse_rate) 41 | 42 | 43 | def game(kulka): 44 | print(dedent("""\ 45 | Welcome to the SpheroRiddle game! Guess my number! 46 | If you want to have a hint about how close you are, 47 | take a look at the Sphero. The faster it blinks and 48 | the brighter it shines, the closer you are. 49 | -------------------------------------------------- 50 | Type in the number! 51 | """)) 52 | 53 | secret_number = randint(1, 100) 54 | guess = '' 55 | trials = 0 56 | 57 | while True: 58 | guess = input_("> ") 59 | 60 | if guess == 'q' or guess == 'quit': 61 | break 62 | elif guess.isdigit(): 63 | guess = int(guess) 64 | trials += 1 65 | 66 | if secret_number is not guess: 67 | show_hint(kulka, secret_number - int(guess)) 68 | else: 69 | print("Bravo! You've guessed my number in %s trials!" % trials) 70 | break 71 | else: 72 | print("Please input the number or 'q'/'quit' if you want to end " 73 | "the game.") 74 | 75 | 76 | def play_next(): 77 | next_ = input_("Do you want to play another game? (y/n): ") 78 | return next_.lower() in ["y", "yes"] 79 | 80 | 81 | def main(): 82 | with Kulka(ADDR) as kulka: 83 | while True: 84 | game(kulka) 85 | 86 | if not play_next(): 87 | break 88 | 89 | 90 | main() 91 | -------------------------------------------------------------------------------- /Examples/spheroSleep.py: -------------------------------------------------------------------------------- 1 | from kulka import Kulka 2 | 3 | 4 | ADDR = 'XX:XX:XX:XX:XX:XX' 5 | 6 | 7 | with Kulka(ADDR) as kulka: 8 | kulka.sleep() 9 | -------------------------------------------------------------------------------- /Examples/spheroSquare.py: -------------------------------------------------------------------------------- 1 | from __future__ import print_function 2 | from kulka import Kulka 3 | import time 4 | 5 | 6 | ADDR = 'XX:XX:XX:XX:XX:XX' 7 | 8 | 9 | def do_the_dance(kulka): 10 | speed = 0x88 11 | sleep_time = 1 12 | 13 | for angle in [1, 90, 180, 270]: 14 | kulka.roll(speed, angle) 15 | time.sleep(sleep_time) 16 | 17 | kulka.roll(0, 0) 18 | 19 | 20 | def main(): 21 | with Kulka(ADDR) as kulka: 22 | for _ in range(3): 23 | do_the_dance(kulka) 24 | time.sleep(0.1) 25 | 26 | print("The end. Sphero goes to bed.") 27 | kulka.sleep() 28 | -------------------------------------------------------------------------------- /Examples/spheroStrobo.py: -------------------------------------------------------------------------------- 1 | from kulka import Kulka 2 | import time 3 | 4 | 5 | ADDR = 'XX:XX:XX:XX:XX:XX' 6 | 7 | 8 | def main(): 9 | with Kulka(ADDR) as kulka: 10 | blink_rate = 0.001 11 | 12 | for _ in range(10): 13 | kulka.set_rgb(255, 255, 255) 14 | time.sleep(blink_rate) 15 | kulka.set_rgb(0, 0, 0) 16 | time.sleep(blink_rate) 17 | 18 | 19 | main() 20 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Python Sphero Examples & Tutorials 2 | 3 | This repository contains materials for easy learning of programming [Sphero](http://www.gosphero.com/) using [Python language](https://www.python.org/) and the [Sphero Kulka API](https://github.com/karol-szuster/kulka) by [Karol Szuster](https://github.com/karol-szuster). It is designed for a total programming/Python/robotics newbie. 4 | 5 | Directory ```tutorials``` contains a complete guide that introduces each Sphero function step by step with explanation, hints, scaffolding code and microtasks, meanwhile ```examples``` is a place, where fully functional and standalone examples are placed for your experiments. 6 | 7 | ## Configuration 8 | 9 | Make sure that Python is installed on your machine, as well as Python Sphero client module: 10 | ```sh 11 | pip install kulka 12 | ``` 13 | Add Sphero device to the OS (double tap the Orb to wake it up and pair it to your PC via bluetooth). Then, You may use the kulka to connect with the device (knowing it's mac address) in such way: 14 | ```python 15 | from kulka import Kulka 16 | from random import randint 17 | 18 | with Kulka('01:02:03:04:05:06') as kulka: 19 | kulka.set_inactivity_timeout(3600) 20 | kulka.roll(randint(0, 255), randint(0, 359)) 21 | ``` 22 | Should the Sphero be properly paired and the Sphero's device mac correctly set, you can go ahead, run the code and have fun with it! 23 | 24 | ## Usage 25 | 26 | ### Examples 27 | 28 | Run examples with: 29 | ```sh 30 | python spheroCircle.py 31 | ``` 32 | After you've finished games & stuff, tell the Sphero to go to sleep: 33 | ```sh 34 | python spheroSleep.py 35 | ``` 36 | 37 | ### Tutorials 38 | 39 | Basically, each main directory beginning with a number is a group of smaller tasks, that utilize a specific area of Sphero programming. Explore four sections, namely: 40 | * 1. Hello Sphero 41 | * 2. Sphero basics 42 | * 3. Advanced movement 43 | * 4. Sphero guess game 44 | 45 | Each small task is to be done one by one, beginning from the first task. To start the tutorial, open the ```1_.py``` file in Sublime, ekhm I meant some good text editor you surely have. There is a description of each task with microtask listed. You may freely modify each file and run it over and over again using simply ```python sometask.py```. 46 | 47 | Those examples will guide you through communicating with Sphero, modifying its state (colors or backled light), rotating it and rolling. Last task is also a good practice for Python beginners, where a goal is to implement a game of guessing the number, step by step using feature-oriented programming, where each new functionality is added to the old ones in each and only step. 48 | 49 | In order to promote an awesome Polish language, all comments and namings are Polish words ;) A jeżeli rozumiesz co tutaj jest napisane, zapraszam Cię na świetne szkolenia dla początkujących programistów Pythona (i nie tylko) organizowanych przez Geek Girls Carrots, gdzie na żywo prowadzimy uczestników przez te zadania. 50 | 51 | ### Notes 52 | 53 | This software has been tested on Windows and Linux with Sphero1/2 and has code improvements that significantly reduced problems with timeouts and connection drops. Moreover, it is Python 2.x and Python 3.x compatible. There's a known issue with running this code on OS X, that is related to limited compatibility of [bluetooth connector](https://github.com/karulis/pybluez) with this platform. If you would like to try this code on OS X, please checkout our [first release](https://github.com/zdanowiczkonrad/PythonSphero/releases/tag/v1.0.0) using [default Sphero API lib](https://github.com/faulkner/sphero) (beware, it is Python 2.x compatible only). For more sphero-experience check out awesome educational materials on the official Sphero's [Education site](http://www.gosphero.com/education/) that partially inspired the code snippets here. Aw, did I mention that [Sphero](http://www.gosphero.com/) is really cool for playing and learning and (playing and learning)? 54 | 55 | ### License 56 | CC 57 | -------------------------------------------------------------------------------- /Tutorials/1. Hello Sphero/1_hello_sphero.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from __future__ import print_function 3 | from kulka import Kulka 4 | import time 5 | 6 | 7 | """ 8 | Cześć! To Twój pierwszy program Sphero. Uruchom go, wywołując w 9 | konsoli następującą komendę: 10 | 11 | $ python 1_hello_sphero.py 12 | 13 | I zaobseruj co się dzieje z Kuleczką. 14 | """ 15 | 16 | 17 | ADDR = 'XX:XX:XX:XX:XX:XX' 18 | 19 | 20 | with Kulka(ADDR) as kulka: 21 | # nadaj Sphero kolor 22 | kulka.set_rgb(255, 0, 0) 23 | print("czerwono!") 24 | time.sleep(5) 25 | 26 | kulka.set_rgb(0, 255, 0) 27 | print("zielono!") 28 | time.sleep(5) 29 | 30 | kulka.set_rgb(0, 0, 255) 31 | print("niebiesko!") 32 | time.sleep(5) 33 | 34 | print("koniec.") 35 | -------------------------------------------------------------------------------- /Tutorials/1. Hello Sphero/2_kolory.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from __future__ import print_function 3 | from kulka import Kulka 4 | 5 | 6 | """ 7 | Teraz spróbuj ustawić własne trzy kolory Sphero! 8 | """ 9 | 10 | # ustaw swóje trzy ulubione kolory! 11 | # set_rgb(RED,GREEN,BLUE,1) 12 | # RED 0-255 13 | # GREEN 0-255 14 | # BLUE 0-255 15 | # spróbuj różnych kombinacji! 16 | 17 | 18 | ADDR = 'XX:XX:XX:XX:XX:XX' 19 | 20 | 21 | with Kulka(ADDR) as kulka: 22 | kulka.set_rgb(0, 0, 0) 23 | kulka.czekaj(5) 24 | 25 | kulka.set_rgb(0, 0, 0) 26 | kulka.czekaj(5) 27 | 28 | kulka.set_rgb(0, 0, 0) 29 | kulka.czekaj(5) 30 | 31 | print("koniec.") 32 | -------------------------------------------------------------------------------- /Tutorials/1. Hello Sphero/3_kolory_w_petli.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from kulka import Kulka 3 | 4 | """ 5 | Sphero jest zawstydzone! Uruchom ten program i zobacz jak kuleczka 6 | się czerwieni. 7 | """ 8 | 9 | 10 | ADDR = 'XX:XX:XX:XX:XX:XX' 11 | 12 | 13 | with Kulka(ADDR) as kulka: 14 | for czerwony in range(0, 255, 20): 15 | kulka.set_rgb(czerwony, 0, 0) 16 | 17 | print "koniec." 18 | -------------------------------------------------------------------------------- /Tutorials/1. Hello Sphero/4_zgas_swiatlo.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from kulka import Kulka 3 | 4 | 5 | """ 6 | 1. Zmodyfikuj ten program, aby kulka coraz jaśniej świeciła na zielono 7 | 2. A teraz tak, aby kulka świeciła się coraz jaśniej na biało! 8 | 3. Spróbujmy teraz przyspieszyć wygaszanie kulki - 9 | - zobacz co się stanie, jeżeli w range(0,255,20) zastąpisz 20 inną liczbą, 10 | np. 5, 10 lub 50 11 | 4. Odwróćmy teraz kolejność! Niech kulka stopniowo gaśnie, a nie się zapala! 12 | """ 13 | 14 | 15 | ADDR = 'XX:XX:XX:XX:XX:XX' 16 | 17 | 18 | with Kulka(ADDR) as kulka: 19 | for czerwony in range(0, 255, 20): 20 | kulka.set_rgb(czerwony, 0, 0) 21 | 22 | print "koniec." 23 | -------------------------------------------------------------------------------- /Tutorials/2. Poznajemy Sphero/1_rollowanie.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from __future__ import print_function 3 | from kulka import Kulka 4 | import time 5 | 6 | """ 7 | Przyszła pora na coś ciekawszego :) Uruchom ten program oraz 8 | przedyskutujcie, co robi funkcja 9 | 10 | >>> roll(predkosc, obrot) 11 | """ 12 | 13 | 14 | ADDR = 'XX:XX:XX:XX:XX:XX' 15 | PREDKOSC = 0 16 | 17 | 18 | with Kulka(ADDR) as kulka: 19 | # zapal tylnią diodkę, aby było wiadomo gdzie jest "tył" kulki 20 | kulka.set_back_led(255) 21 | 22 | 23 | for obrot in [1, 120, 240, 359, 1]: 24 | kulka.roll(PREDKOSC, obrot) 25 | print("Sphero obrócone do kąta " + str(obrot)) 26 | time.sleep(0.01) 27 | 28 | kulka.roll(0, 0) 29 | 30 | print("koniec.") 31 | -------------------------------------------------------------------------------- /Tutorials/2. Poznajemy Sphero/2_troche_ruchu.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from __future__ import print_function 3 | from kulka import Kulka 4 | import time 5 | 6 | 7 | """ 8 | 1. Uruchom program i zobacz co się stanie 9 | 2. Sprawdź jak zachowuje się kulka dla prędkości od 0 do 255 10 | 3. Sprawdź co się stanie, gdy czas zostanie zwiększony lub zmniejszony 11 | 4. Usuń funkcję stop i zobacz co się dzieje 12 | """ 13 | 14 | 15 | ADDR = 'XX:XX:XX:XX:XX:XX' 16 | PREDKOSC = 50 17 | CZAS = 4 18 | 19 | 20 | with Kulka(ADDR) as kulka: 21 | print("jadę...") 22 | kulka.roll(PREDKOSC, 1) 23 | time.sleep(CZAS) 24 | 25 | print("stop!") 26 | kulka.roll(0, 0) 27 | 28 | print("koniec.") 29 | -------------------------------------------------------------------------------- /Tutorials/2. Poznajemy Sphero/3_zakrety.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from __future__ import print_function 3 | from kulka import Kulka 4 | import time 5 | 6 | 7 | """ 8 | 1. Dodaj kolejny ruch tak, aby Sphero poruszyło się w kształcie litery L 9 | 2. Dodaj jeszcze kilka ruchów 10 | 3. Możesz poeksperymentować z wartościami prędkości i czasu 11 | """ 12 | 13 | 14 | ADDR = 'XX:XX:XX:XX:XX:XX' 15 | PREDKOSC = 50 16 | CZAS = 4 17 | 18 | 19 | with Kulka(ADDR) as kulka: 20 | kulka.roll(PREDKOSC, 1) 21 | time.sleep(CZAS) 22 | 23 | # tutaj dodaj kolejny ruch pod kątem 90 stopni 24 | print("uwaga, zakręt!") 25 | 26 | # pamiętajmy o stop na końcu! 27 | print("stop!") 28 | kulka.roll(0, 0) 29 | 30 | print("koniec.") 31 | -------------------------------------------------------------------------------- /Tutorials/2. Poznajemy Sphero/4_lets_dance.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from __future__ import print_function 3 | from kulka import Kulka 4 | import time 5 | 6 | 7 | """ 8 | Sphero tańczy tak, jak mu zagrasz! 9 | 10 | 1. Uruchom ten program i zobacz co się stanie 11 | 2. Dopisz kolejne dwa "kroki taneczne" - dodaj dwa elementy do listy 12 | KROKI_TANECZNE 13 | """ 14 | 15 | 16 | ADDR = 'XX:XX:XX:XX:XX:XX' 17 | PREDKOSC = 70 18 | CZAS = 1 19 | KROKI_TANECZNE = [22, 235, 120, 230, 350] 20 | 21 | 22 | with Kulka(ADDR) as kulka: 23 | for obrot in KROKI_TANECZNE: 24 | print("jadę pod kątem " + str(obrot)) 25 | kulka.roll(PREDKOSC, obrot) 26 | time.sleep(CZAS) 27 | 28 | print("stop!") 29 | kulka.roll(0, 0) 30 | 31 | print("koniec.") 32 | -------------------------------------------------------------------------------- /Tutorials/2. Poznajemy Sphero/5_te_kocie_ruchy.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from __future__ import print_function 3 | from kulka import Kulka 4 | from random import randint 5 | import time 6 | 7 | """ 8 | 1. Zwróć uwagę na to, jak zmienił się drugi element w liście 9 | KROKI_TANECZNE 10 | 2. Uruchom ten program kilka razy, zobacz w którym kierunku 11 | pojechała kulka oraz porównaj trasę z tym, co zostało wypisane do 12 | konsoli. Spróbuj wytłumaczyć, co robi randint(1,359). 13 | 3. Zmodyfikuj listę kroków tak, aby Sphero zatańczyło w 5 losowych 14 | kierunkach 15 | """ 16 | 17 | 18 | ADDR = 'XX:XX:XX:XX:XX:XX' 19 | PREDKOSC = 70 20 | CZAS = 1 21 | KROKI_TANECZNE = [10, randint(1, 359), 50] 22 | 23 | 24 | with Kulka(ADDR) as kulka: 25 | for obrot in KROKI_TANECZNE: 26 | print("jadę pod kątem " + str(obrot)) 27 | kulka.roll(PREDKOSC, obrot) 28 | time.sleep(CZAS) 29 | 30 | print("stop!") 31 | kulka.roll(0, 0) 32 | 33 | print("koniec.") 34 | -------------------------------------------------------------------------------- /Tutorials/3. Ćwiczymy ruch/1_bumerang.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from __future__ import print_function 3 | from kulka import Kulka 4 | import time 5 | 6 | """ 7 | 1. Przeanalizuj ten program i narysuj na kartce tor, po którym Twoim 8 | zdaniem przejedzie Sphero. 9 | 2. Następnie uruchom go i porównaj wyniki z przypuszczeniami 10 | """ 11 | 12 | 13 | ADDR = 'XX:XX:XX:XX:XX:XX' 14 | PREDKOSC = 60 15 | CZAS = 2 16 | 17 | 18 | with Kulka(ADDR) as kulka: 19 | # bumerang 20 | kulka.roll(PREDKOSC, 1) 21 | time.sleep(CZAS) 22 | 23 | kulka.roll(PREDKOSC, 180) 24 | time.sleep(CZAS) 25 | 26 | print("stop!") 27 | kulka.roll(0, 0) 28 | 29 | print("koniec.") 30 | -------------------------------------------------------------------------------- /Tutorials/3. Ćwiczymy ruch/2_bumerang_w_petli.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from __future__ import print_function 3 | from kulka import Kulka 4 | import time 5 | 6 | 7 | """ 8 | 1. Umieść napisany przez Ciebie kod w pętli, aby Sphero trzykrotnie 9 | przejechało w tę i z powrotem! 10 | 2. Z każdym kolejnym powtórzeniem, zmień prędkość Sphero! 11 | Wykorzystaj do tego listę "PREDKOSCI" 12 | 3. Z każdym kolejnym powtórzeniem, zmień kolor Sphero! Wykorzystaj do 13 | listę kolory. funkcję set_rgb() 14 | 4. Dodaj własny krok z marchewkowym kolorem i prędkością 128 15 | - rozszerz listę PREDKOSCI o 128, oraz dodaj do tablicy kolory 16 | kolejny element z własnym kolorem 17 | """ 18 | 19 | 20 | PREDKOSCI = [100, 40, 80] 21 | CZAS = 2 22 | 23 | KOLORY = [ 24 | [150, 210, 54], 25 | [251, 61, 10], 26 | [70, 51, 211] 27 | ] 28 | 29 | 30 | with Kulka(ADDR) as kulka: 31 | # umieść ten kod w pętli 32 | # ---------------------------------------------------- 33 | # 1. ustaw pierwszy kolor z tablicy KOLORY 34 | kulka.set_rgb(KOLORY[0][0], KOLORY[0][1], KOLORY[0][2]) 35 | 36 | # 2. zatocz się z prędkością 100 37 | kulka.roll(PREDKOSCI[0], 1) 38 | time.sleep(CZAS) 39 | # 3. wielki powrót 40 | kulka.roll(PREDKOSCI[0], 180) 41 | time.sleep(CZAS) 42 | # ---------------------------------------------------- 43 | 44 | print("stop!") 45 | kulka.roll(0, 0) 46 | 47 | print("koniec.") 48 | -------------------------------------------------------------------------------- /Tutorials/3. Ćwiczymy ruch/3_trojkaty_i_kwadraty.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from __future__ import print_function 3 | from kulka import Kulka 4 | import time 5 | 6 | 7 | """ 8 | O ruchu wiadomo już wszystko :) Uruchom ten program i zobacz, 9 | co się stanie. 10 | 1. Zmodyfikuj ten program tak, aby Sphero zakreśliło kształt trójkąta 11 | 2. Zmodyfikuj listę kroków, aby Sphero przejechało drogę 12 | w kształcie kwadraty 13 | 3. Wiesz jak narysować inne wielokąty? Da się w ten sposób narysować 14 | gwiazdę pięcioramienną? 15 | """ 16 | 17 | ADDR = 'XX:XX:XX:XX:XX:XX' 18 | PREDKOSC = 100 19 | CZAS = 1.5 20 | 21 | 22 | with Kulka(ADDR) as kulka: 23 | for obrot in [1, 120, 300]: 24 | kulka.roll(PREDKOSC, obrot) 25 | time.sleep(CZAS) 26 | 27 | print("stop!") 28 | kulka.roll(0, 0) 29 | 30 | print("koniec.") 31 | -------------------------------------------------------------------------------- /Tutorials/3. Ćwiczymy ruch/4_odkrywamy_kolo_na_nowo.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from __future__ import print_function 3 | from kulka import Kulka 4 | import time 5 | 6 | 7 | """ 8 | 1. Zmodyfikuj poprzedni program, aby Sphero przejechało koło. 9 | podrasuj listę "LISTA_OBROTOW". możesz użyć funkcji range(1, 359, 10 | 40), która utworzy listę liczb od 1 do 359 co 40, czyli [1, 41, 81,...] 11 | 2. Utwórz funkcję "jazda(sphero, LISTA_OBROTOW)" i przenieś do jej 12 | definicji pętle for wraz instrukcjami, które powodują że Sphero się 13 | rolluje i czeka. 14 | 3. Zwiększ/zmniejsz CZAS i zobacz jak Sphero robi mniejsze lub większe koło! 15 | """ 16 | 17 | ADDR = 'XX:XX:XX:XX:XX:XX' 18 | PREDKOSC = 70 19 | CZAS = 0.5 20 | 21 | LISTA_OBROTOW = [1, 20, 40, 60] 22 | 23 | 24 | with Kulka(ADDR) as kulka: 25 | for obrot in LISTA_OBROTOW: 26 | print("obrot o kat " + str(obrot)) 27 | kulka.roll(PREDKOSC, obrot) 28 | time.sleep(CZAS) 29 | 30 | # pamiętaj o stop na końcu! 31 | print("stop!") 32 | kulka.roll(0, 0) 33 | 34 | print("koniec.") 35 | -------------------------------------------------------------------------------- /Tutorials/3. Ćwiczymy ruch/5_osemka.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from __future__ import print_function 3 | from kulka import Kulka 4 | import time 5 | 6 | """ 7 | Na podstawie programu, w którym Sphero jeździ w kółko, napisz program, 8 | który toczy Sphero w znak ósemki! podpowiedź: funkcja reversed(lista) 9 | przyjmuje listę i zwraca listę z elementami w odwrotnej kolejności, np. 10 | 11 | >>> reversed([1, 2, 3]) 12 | [3, 2, 1] 13 | """ 14 | 15 | 16 | ADDR = 'XX:XX:XX:XX:XX:XX' 17 | 18 | 19 | def jazda(kulka, lista_obrotow): 20 | predkosc = 70 21 | czas = 0.2 22 | 23 | for obrot in lista_obrotow: 24 | print("obrot o kat " + str(obrot)) 25 | kulka.roll(predkosc, obrot) 26 | time.sleep(czas) 27 | 28 | 29 | with Kulka(ADDR) as kulka: 30 | # wywolaj funkcje jazda 31 | jazda(kulka, range(1, 359, 40)) 32 | print("---") 33 | # wywołaj jeszcze raz tę funkcję, ale z odwróconą listą obrotów 34 | 35 | # pamiętaj o stop na końcu! 36 | print("stop!") 37 | kulka.roll(0, 0) 38 | 39 | print("koniec.") 40 | -------------------------------------------------------------------------------- /Tutorials/4. Zagadka/01_minitask.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from __future__ import print_function 3 | from random import randint 4 | 5 | """ 6 | Ten rozdział rozpocznie serię minitasków celem zaprogramowania gry 7 | w zgadywanie. 8 | 9 | 1. Zacznij od napisania programu, który wylosuje liczbę od 1 do 100 i 10 | ją wydrukuje. Możesz użyć funkcji randint(start,end), która losuje 11 | liczbę od 1 do 100. 12 | """ 13 | # tutaj zapisz wylosowaną liczbę i ją wydrukuj 14 | tajemnicza_liczba = ___ 15 | 16 | # nie zapomnij jej wydrukować! 17 | -------------------------------------------------------------------------------- /Tutorials/4. Zagadka/02_minitask.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from __future__ import print_function 3 | from random import randint 4 | 5 | try: 6 | input = raw_input 7 | except NameError: 8 | pass 9 | 10 | """ 11 | Uruchom ten program i sprawdź co się stanie, gdy wpiszesz dowolną liczbę. 12 | """ 13 | # liczba, którą zna komputer 14 | tajemnicza_liczba = randint(1, 100) 15 | 16 | proba = input("Zgadnij liczbę (pierwsza próba): ") 17 | print("Twój strzał to " + proba) 18 | print("Tajemnicza liczba, którą wylosował komputer to" + str(tajemnicza_liczba)) 19 | -------------------------------------------------------------------------------- /Tutorials/4. Zagadka/03_minitask.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from random import randint 3 | try: 4 | input = raw_input 5 | except NameError: 6 | pass 7 | 8 | """ 9 | Sprawdź, czy liczba, którą podał człowiek (zmienna proba) jest 10 | rowna tajemniczej liczbie, którą wylosował komputer Jeżeli tak, 11 | wypisz "Zwycięstwo!" 12 | """ 13 | # liczba, którą zna komputer 14 | tajemnicza_liczba = randint(1, 100) 15 | 16 | proba = int(input("Zgadnij liczbę (pierwsza próba): ")) 17 | -------------------------------------------------------------------------------- /Tutorials/4. Zagadka/04_minitask.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from __future__ import print_function 3 | from random import randint 4 | try: 5 | input = raw_input 6 | except NameError: 7 | pass 8 | 9 | """ 10 | Kod, który pyta gracza o liczbę, przenieś do funkcji "zgadnij" 11 | """ 12 | # liczba, którą zna komputer 13 | tajemnicza_liczba = randint(1, 100) 14 | 15 | proba = int(input("Zgadnij liczbę (pierwsza próba): ")) 16 | if proba == tajemnicza_liczba: 17 | print("Zwycięstwo!") 18 | 19 | -------------------------------------------------------------------------------- /Tutorials/4. Zagadka/05_minitask.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from __future__ import print_function 3 | from random import randint 4 | try: 5 | input = raw_input 6 | except NameError: 7 | pass 8 | """ 9 | Pozwól graczowi zgadywać 10 razy. Umieść kod zgadywania w pętli, 10 | która wykona się 10 razy 11 | """ 12 | # liczba, którą zna komputer 13 | tajemnicza_liczba = randint(1, 100) 14 | 15 | def zgadnij(): 16 | proba = int(input("Zgadnij liczbę (pierwsza próba): ")) 17 | if proba == tajemnicza_liczba: 18 | print("Zwycięstwo!") 19 | 20 | zgadnij() 21 | -------------------------------------------------------------------------------- /Tutorials/4. Zagadka/06_minitask.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from __future__ import print_function 3 | from random import randint 4 | try: 5 | input = raw_input 6 | except NameError: 7 | pass 8 | """ 9 | Coś tu nie gra! Gracz zgaduje kilka razy, ale widzi zawsze komunikat 10 | "pierwsza próba"... Dodaj do funkcji <> argument "proba" 11 | i wypisuj poprawny komunikat z numerem próby zamiast "pierwsza próba". 12 | """ 13 | # liczba, którą zna komputer 14 | tajemnicza_liczba = randint(1, 100) 15 | 16 | def zgadnij(): 17 | proba = int(input("Zgadnij liczbę (pierwsza próba): ")) 18 | if proba == tajemnicza_liczba: 19 | print("Zwycięstwo!") 20 | 21 | for proba in range(10): 22 | zgadnij() 23 | -------------------------------------------------------------------------------- /Tutorials/4. Zagadka/07_minitask.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from __future__ import print_function 3 | from random import randint 4 | 5 | try: 6 | input_ = raw_input 7 | except NameError: 8 | intput_ = input 9 | 10 | """ 11 | Zmodyfikuj funkcję zgadnij(), aby zwracała True jeżeli użytkownik zgadł, 12 | lub False jeżeli tajemnicza liczba nie została trafiona. 13 | """ 14 | # liczba, którą zna komputer 15 | tajemnicza_liczba = randint(1, 100) 16 | 17 | def zgadnij(numer_proby): 18 | proba = int(input_("Zgadnij liczbę (próba #%s)" % (numer_proby + 1))) 19 | 20 | if proba == tajemnicza_liczba: 21 | print("Zwycięstwo!") 22 | 23 | for proba in range(10): 24 | zgadnij(proba) 25 | -------------------------------------------------------------------------------- /Tutorials/4. Zagadka/08_minitask.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from __future__ import print_function 3 | from random import randint 4 | try: 5 | input = raw_input 6 | except NameError: 7 | pass 8 | """ 9 | Dodaj wewnątrz pętli for warunek sprawdzający, czy użytkownik zgadł. 10 | Jeżeli tak, zakończ pętlę poleceniem "break". Jeżeli jednak gracz nie zgadł za 10 razem, 11 | wypisz "Porażka!" 12 | """ 13 | # liczba, którą zna komputer 14 | tajemnicza_liczba = randint(1, 100) 15 | 16 | def zgadnij(numer_proby): 17 | proba = int(input("Zgadnij liczbę (próba #%s): " % (numer_proby + 1))) 18 | if proba == tajemnicza_liczba: 19 | print("Zwycięstwo!") 20 | return True 21 | else: 22 | return False 23 | 24 | for proba in range(10): 25 | zgadnij(proba) 26 | -------------------------------------------------------------------------------- /Tutorials/4. Zagadka/09_minitask.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from __future__ import print_function 3 | from random import randint 4 | try: 5 | input = raw_input 6 | except NameError: 7 | pass 8 | """ 9 | Czas na podpowiedzi :) Rozszerz funkcję podpowiedz(tajemnicza_liczba, 10 | proba), która będzie podpowiadać graczowi. Jeżeli tajemnicza liczba 11 | jest większa od tej, którą podał gracz, wypisz "większa". Jeżeli 12 | mniejsza, wypisz "mniejsza" 13 | """ 14 | # liczba, którą zna komputer 15 | tajemnicza_liczba = randint(1, 100) 16 | 17 | def podpowiedz(tajemnicza_liczba, proba): 18 | # Tutaj Twoja podpowiedź! 19 | pass 20 | 21 | def zgadnij(numer_proby): 22 | proba = int(input("Zgadnij liczbę (próba #%s): " % (numer_proby + 1))) 23 | if proba == tajemnicza_liczba: 24 | print("Zwycięstwo!") 25 | return True 26 | else: 27 | # nie zapomnij wywołać funkcji podpowiedź() z właściwymi argumentami! 28 | return False 29 | 30 | for proba in range(10): 31 | if zgadnij(proba): 32 | break 33 | else: 34 | print("Porażka!") 35 | -------------------------------------------------------------------------------- /Tutorials/4. Zagadka/10_minitask.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from __future__ import print_function 3 | from random import randint 4 | from kulka import Kulka 5 | import time 6 | 7 | try: 8 | input = raw_input 9 | except NameError: 10 | pass 11 | 12 | """ 13 | Świetnie! Pamiętacie jeszcze o Sphero? 14 | 15 | Dodaj teraz kod, który zaświeci Sphero na zielono i zrobi obrót, 16 | jeżeli gracz zgadnie liczbę, za każdą zaś błędną odpowiedź, 17 | Sphero zamiga 3 razy na pomarańczowo! 18 | Extra task: im strzał jest bliżej wyniku, niech Sphero świeci się jaśniej! 19 | 20 | Podpowiedzi: 21 | zielony: R=0, G=255, B=0 22 | pomarańczowy: R=255, G=120, B=0 23 | Możesz użyć funkcji zrob_kolko(), która wykonuje obrót! 24 | """ 25 | 26 | ADDR = 'XX:XX:XX:XX:XX:XX' 27 | 28 | # liczba, którą zna komputer 29 | tajemnicza_liczba = randint(1, 100) 30 | 31 | def zrob_kolko(kulka): 32 | for obrot in [1, 120, 240, 359, 1]: 33 | kulka.roll(0, obrot) 34 | time.sleep(0.01) 35 | 36 | def podpowiedz(tajemnicza_liczba, proba): 37 | if tajemnicza_liczba > proba: 38 | print(" -> Większa.") 39 | else: 40 | print(" -> Mniejsza.") 41 | 42 | def zgadnij(kulka, numer_proby): 43 | proba = int(input("Zgadnij liczbę (próba #%s): " % (numer_proby + 1))) 44 | if proba == tajemnicza_liczba: 45 | print("Zwycięstwo!") 46 | # tutaj ustaw kolor zwycięstwa! 47 | return True 48 | else: 49 | podpowiedz(tajemnicza_liczba, proba) 50 | # tutaj zamigaj trzy razy! 51 | return False 52 | 53 | with Kulka(ADDR) as kulka: 54 | for proba in range(10): 55 | if zgadnij(kulka, proba): 56 | break 57 | else: 58 | print("Porażka!") 59 | -------------------------------------------------------------------------------- /Tutorials/4. Zagadka/11_minitask.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from __future__ import print_function 3 | from kulka import Kulka 4 | from random import randint 5 | import time 6 | try: 7 | input = raw_input 8 | except NameError: 9 | pass 10 | 11 | """ 12 | Wcale nie jest tak łatwo wygrać! Dodaj funkcję "pociesz()", która 13 | zaświeci Sphero na losowy kolor i wykona dowolną sekwencję ruchów! 14 | Następnie, dodaj ją jeżeli uzytkownikowi nie uda się zgadnąć 15 | liczby :) 16 | """ 17 | 18 | ADDR = 'XX:XX:XX:XX:XX:XX' 19 | 20 | # liczba, którą zna komputer 21 | tajemnicza_liczba = randint(1, 100) 22 | 23 | def zrob_kolko(kulka): 24 | for obrot in [1, 120, 240, 359, 1]: 25 | kulka.roll(0, obrot) 26 | kulka.czekaj(0.00001) 27 | 28 | def podpowiedz(tajemnicza_liczba, proba): 29 | if tajemnicza_liczba > proba: 30 | print(" -> Większa.") 31 | else: 32 | print(" -> Mniejsza.") 33 | 34 | def zgadnij(kulka, numer_proby): 35 | proba = int(input("Zgadnij liczbę (próba #%s): " % (numer_proby + 1))) 36 | if proba == tajemnicza_liczba: 37 | print("Zwycięstwo!") 38 | kulka.set_rgb(0, 255, 0) 39 | zrob_kolko(kulka) 40 | return True 41 | else: 42 | podpowiedz(tajemnicza_liczba, proba) 43 | for _ in range(3): 44 | kulka.set_rgb(255, 120, 0) 45 | time.sleep(0.01) 46 | kulka.set_rgb(0, 0, 0) 47 | time.sleep(0.01) 48 | return False 49 | 50 | with Kulka(ADDR) as kulka: 51 | for proba in range(10): 52 | if zgadnij(kulka, proba): 53 | break 54 | else: 55 | print("Porażka!") 56 | # tutaj wywołaj swoją oryginalną funkcję pociesz()! 57 | -------------------------------------------------------------------------------- /Tutorials/4. Zagadka/12_minitask.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from __future__ import print_function 3 | from kulka import Kulka 4 | from random import randint 5 | import time 6 | try: 7 | input = raw_input 8 | except NameError: 9 | pass 10 | 11 | """ 12 | Teraz możesz do woli przetestować grę i spróbować ograć komputer :) 13 | Jeżeli jest za trudno - zmniejsz zakres losowania tajemniczej liczby, 14 | bądź zwiększ liczbę szans :) 15 | """ 16 | ADDR = 'XX:XX:XX:XX:XX:XX' 17 | 18 | # liczba, którą zna komputer 19 | tajemnicza_liczba = randint(1, 100) 20 | 21 | def pociesz(kulka): 22 | for _ in range(5): 23 | kulka.set_rgb(randint(0, 255), randint(0, 255), randint(0, 255)) 24 | kulka.roll(100, randint(1, 359)) 25 | kulka.czekaj(0.1) 26 | kulka.stop() 27 | 28 | def zrob_kolko(kulka): 29 | for obrot in [1, 120, 240, 359, 1]: 30 | kulka.roll(0, obrot) 31 | time.sleep(0.01) 32 | 33 | def podpowiedz(tajemnicza_liczba, proba): 34 | if tajemnicza_liczba > proba: 35 | print(" -> Większa.") 36 | else: 37 | print(" -> Mniejsza.") 38 | 39 | def zgadnij(kulka, numer_proby): 40 | proba = int(input("Zgadnij liczbę (próba #%s): " % (numer_proby + 1))) 41 | if proba == tajemnicza_liczba: 42 | print("Zwycięstwo!") 43 | kulka.set_rgb(0, 255, 0) 44 | zrob_kolko(kulka) 45 | return True 46 | else: 47 | podpowiedz(tajemnicza_liczba, proba) 48 | for _ in range(3): 49 | kulka.set_rgb(255, 120, 0) 50 | time.sleep(0.01) 51 | kulka.set_rgb(0, 0, 0) 52 | time.sleep(0.01) 53 | return False 54 | 55 | with Kulka(ADDR) as kulka: 56 | for proba in range(10): 57 | if zgadnij(kulka, proba): 58 | break 59 | else: 60 | print("Porażka!") 61 | pociesz(kulka) 62 | -------------------------------------------------------------------------------- /Tutorials/sphero_config.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | # Ten plik ustanawia polaczenie ze Sphero 3 | # oraz definuje zmienna sphero, ktora moze 4 | # byc uzywana do komunikacji 5 | from sphero import core 6 | import time 7 | nazwa_sphero = "/dev/tty.Sphero-WYW-AMP-SPP" 8 | # dla windowsa : "COM-3" 9 | # dla linuxa : sparowac MAC adres z linkiem w /dev/ 10 | # timeout na połączenie 11 | timeout_na_polaczenie = 10 12 | # utwórz Sphero, które będzie używane w kodzie 13 | sphero = core.Sphero(nazwa_sphero) 14 | # nawiąż połączenie 15 | sphero.connect() 16 | # dodaj customową funkcję czekaj w Sphero 17 | sphero.czekaj = time.sleep 18 | print "[i] Sphero skonfigurowane poprawnie. Jeszcze chwilkę..." 19 | time.sleep(timeout_na_polaczenie) 20 | # wyłącz stabilizację 21 | # sphero.set_stabilization(True) 22 | # sphero.set_rotation_rate(0xFF) 23 | sphero.roll(1, 1) 24 | print "[i] Połączono ze Sphero." 25 | 26 | -------------------------------------------------------------------------------- /Tutorials/sphero_reset.py: -------------------------------------------------------------------------------- 1 | from sphero_config import sphero 2 | sphero.stop() 3 | sphero.sleep() --------------------------------------------------------------------------------