Funkcje programu sterującego - opisanie rzeczy.

Całość programu sterującego rozpoczyna się od zaimportowania biblioteki - właściwie jednej z najpopularniejszych bibliotek pod platformę BeagleBone Black - mianowicie Adafruit-BBIO. Sposób instalacji tej biblioteki na platformie opisano dokładnie TUTAJ. Niemniej, żeby nie było Wam tak łatwo - sami sobie znajdźcie obraz Debiana na którym to działa :) W każdym bądź razie jak już to Zrobicie...
Było co innego, ale będzie czerstwo i nudno gdyż zostałem zaszczuty czymś o "obowiązkach domowych" - typical... :-D

No dość już ględzenia o nieczym!!!

Można za pomocą instrukcji opisanej w powyższym linku ustawiać i kontrolować zachowanie portów naszego Beagle'a.

Z innej beczki. Inna sprawa, że w Kanadzie można mieć Rysia domowego (normalnie ruchy jak kot - bo to jest kot :/):

A w Polsce...

Za to takie szczenię dobrze ułożone będzie na długooooo Waszym best frendem.

Aby program mógł w pełni funkcjonować potrzebne jest zdefiniowanie kilku stałych sterujących poszczególnymi fazami "wykonywania się" programu. Oto one:

PIN_SPEED_CH1_Right: Określa, że ​​pin 14, portu rozszerzeń (P9) steruje prędkością prawego koła przedniego;

PIN_SPEED_CH2_Left: Określa, że ​​pin 16, portu rozszerzeń (P9) steruje prędkością lewego koła przedniego;

PIN_SPEED_CH3_Right: Określa, że ​​pin 19 portu rozszerzeń (P8) steruje prędkością prawego koła tylnego;

PIN_SPEED_CH4_Left: Określa, że ​​pin 13 portu rozszerzeń (P8) steruje prędkością lewego koła tylnego.

PIN_DIR_CH1_LEFT:  Określa, że pin 27 portu rozszerzeń (P9) steruje kierunkiem obrotu prawego koła przedniego;

PIN_DIR_CH2_LEFT:  Określa, że pin 30 portu rozszerzeń (P9) steruje kierunkiem obrotu lewego koła przedniego;

PIN_DIR_CH3_LEFT: Określa, że pin 17 portu rozszerzeń (P8) steruje kierunkiem obrotu prawego koła tylnego;

PIN_DIR_CH4_LEFT:  Określa, że pin 15 portu rozszerzeń (P8) steruje kierunkiem obrotu lewego koła tylnego.

MAX_SPEED: Jest to stała przechowująca aktualną maksymalną prędkość jaką można ustawić dla platformy (czyli jak ustawię ją na 100% [100] to platforma powinna się poruszać jakieś 1 może 1,5 km/h).

MIN_SPEED:  Jest to stała przechowująca minimalną prędkość jaką można ustawić dla platformy (czyli jak ustawię ją na 23% - 25% platforma powinna się praktycznie nie poruszać). Metodą prób i błędów ustaliłem, że w zasadzie na wartościach ustawionych poniżej 23 - 25 nie ruszymy platformą z miejsca :) - uważajcie więc, żeby nie spalić kontrolera i silniczków.

CHANGE_RATE: Jest to stała określająca wartość z jaką, czy też o jaką zwiększamy lub zmniejszamy prędkość (wartość ta to oczywiście % wypełnienia naszego sygnału podawanego z BBB do kontrolera silniczków). Domyślnie jest 5 ale można poeksperymentować z innymi mniejszymi lub większymi :).

STOP_SPEED: Jest to wartość jaką ustawiamy na wyjściu kiedy chcemy aby robot się zatrzymał.

FORWARD_DIR: Wartość definiująca kiedy robot ma jechać do przodu (jazda do przodu).

REVERSE_DIR: Wartość definiująca kiedy robot ma jechać do tyłu (jazda do tyłu).

Tak wygląda zdefiniowanie stałych sterujących w programie. Teraz należałoby zdefiniować zmienne globalne dla bieżącego kierunku.

Zmienne te będą śledziły, aktualną prędkość i kierunek naszego robota.

Pierwsza z tych definicji jest o tyle ważna, że inicjowane są definiowane są w niej piny na portach rozszerzeń które chcemy używać do kontroli naszej maszyny.

Inna sprawa, że sporo się nakombinowałem zanim znalazłem odpowiedni obraz Debiana, który ma wszystko ustawione prawidłowo ale nie będę tu teraz o tym pisał.

Ważne jest to, że używając funkcji PWM.start() dla odpowiednio: PIN_SPEED_CH1_Right; PIN_SPEED_CH2_Left; PIN_SPEED_CH3_Right oraz PIN_SPEED_CH4_Left - inicjujemy po prostu przypisane do tych stałych pinouty PWM, naszego BeagleBone Black.

W dokładnie taki sam sposób użyjemy funkcji zmiennej GPIO.setup() dla pinów PIN_DIR_CH1_Right; PIN_DIR_CH2_Left; PIN_DIR_CH3_Right oraz PIN_DIR_CH4_Left do inicjalizacji pinów cyfrowych Input/Output naszego komputera (to one będą zbierały sygnał z enkoderów i na jego podstawie program "podejmie decyzje" jak kręcić nimi dalej).

Dodatkowo w programie została założona funkcja init_rover(), którą jak Zobaczycie będziemy wywoływali przed wywołaniem każdej innej funkcji w tym programie.

W następnym poście (bo teraz już mi się nie chce), omówię pozostałe funkcje i pokrótce ich działanie.

A na koniec coś dla wszystkich zadufanych w technologii, wszechwiedzących, badających sedno wszystkiego i wszystkich, drążących prawdę w poszukiwaniu prawdy, która... jest szara jak szynszyla i rozczarowuje:

"Gdy
już nakarmię swoje ego
galaktyk
i harmonii pyłem
i Głos usłyszę ten
dlaczego
na ziemi
między wami byłem

to skłonię przed Nim
czoło dumne
podam
swą duszę pełną strachu
i
po raz drugi jeszcze umrę
by zostać
na wszechświata dachu"

Ryszard Szociński

Program sterujący "układu jezdnego" :->

Kurde ale trzeba być durniem, żeby pisać blog, który czyta może z pięć osób - porażka...

Dziś przetestowałem układ jezdny. Na razie daleko temu jest do autonomicznego robota ale przy dobrych wiatrach wszystko się może uda... jakoś.

W moim ostatnim poście, próbowałem pokazać Wam drodzy czytelnicy jak można połączyć platformę BeagleBone Black z podwoziem produkowanym przez DAGU, czyli - Rover'em 5.

Do połączenia i sterowania silnikami DC użyłem dedykowanej do tego zestawu elektroniki czyli kontrolera silników DAGU.

Cóż jeszcze - wykonałem krótki test, prostym programikiem napisanym w Pythonie i pomęczyłem się z niedziałającymi obrazami systemu Debian, który w tym komputerku "siedzi" i jego konfiguracją - sporo tego było - niemal miesiąc ślęczenia praktycznie w miejscu i związanej z tym frustracji :(

Jeśli ktoś mnie teraz zapyta czy przyszedł czas na udanie się do "WC dla personelu" to - nie będzie w błędzie. Otóż podczas pisania tego tekstu chorowałem na tak zwaną "jelitówkę" i generalnie oprócz osłabienia, przesiadywałem głównie w "Świątyni dumania", więc miałem sporo czasu na myślenie :-D Pomiędzy posiedzeniami tam gdzie "Król chadza bez korony", wykorzystywałem swój wolny czas (a taki wolny czas jest cenny), bowiem pozwoliło na dalsze prace nad platformą i ostateczne poprawki w napisanym kodzie programu sterującego w Pythonie, oraz programu, który przetestuje moje założenia i mniej więcej jak będzie wyglądało sterowanie robotem.

Zastanawiam się tylko czy nie być "rasowym Cebulakiem" i udostępnić kod pospólstwu i tak chyba zrobię :-)

Każdy wie, że każda maszyna cyfrowa (w tym komputer robota) nie umie nic bez oprogramowania. Należy więc zdefiniować podstawowe ruchy maszyny jak np.: jazda do przodu, do tyłu, skręcanie w prawo i lewo, przyśpieszanie, zwalnianie itd. itp. Oczywiście założyłem, że zmęczę to wszystko w Pythonie, bowiem jest bardzo dużo ciekawych przykładów po sieci i zawsze czegoś nowego się dowiem. :)

W tej części przedstawiam moduł sterujący robotem. Plik dla przykładu nazwałem: rover_beaglebone_v2.py.
Wersja 2 bo przymiarki i kombinacje z tym jak to uruchomić już od nieomal wakacji uskuteczniałem, no i skutkiem tych "prac koncepcyjno - studialnych" => (ale suchar :/) - powstały w sumie trzy wersje tego programu różnie działające, mniej lub bardziej zadawalające mnie. Ta ostatnia "v2" (nie mylić z niemieckimi rakietami do zabijania von Brauna) to efekt właśnie posiedzeń na "batyskafie" w towarzystwie kolegów rotawirusów :)

Oczywiście dokładnie też postaram się opisać co i jak działa ale to może już nie w tym poście... tylko w następnym - bo tak i już ha ha :)

Kod programu:

1. import Adafruit_BBIO.PWM as PWM
2. import Adafruit_BBIO.GPIO as GPIO
3. import time
4. 
   
5. PIN_SPEED_CH1_Right = "P9_14"
6. PIN_SPEED_CH2_Left = "P9_16"
7. PIN_SPEED_CH3_Right = "P8_19"
8. PIN_SPEED_CH4_Left = "P8_13"
9. PIN_DIR_CH1_Right = "P9_27"
10. PIN_DIR_CH2_Left = "P9_30"
11. PIN_DIR_CH3_Right = "P8_17"
12. PIN_DIR_CH4_Left = "P8_15"
13. MAX_SPEED = 100
14. MIN_SPEED = 23
15. CHANGE_RATE = 5
16. STOP_SPEED = 0
17. FORWARD_DIR = 1
18. REVERSE_DIR = 0
19. 
    
20. current_speed_CH1_Right = STOP_SPEED
21. current_speed_CH2_Left = STOP_SPEED
22. current_speed_CH3_Right = STOP_SPEED
23. current_speed_CH4_Left = STOP_SPEED
24. current_dir_CH1_Right = FORWARD_DIR
25. current_dir_CH2_Left = FORWARD_DIR
26. current_dir_CH3_Right = FORWARD_DIR
27. current_dir_CH4_Left = FORWARD_DIR
28. 
    
29. #zainicjowanie ruchu podwozia ROVER ustawienie stanu pinów
30. def init_rover():
31. PWM.start(PIN_SPEED_CH1_Right, 0)
32. PWM.start(PIN_SPEED_CH2_Left, 0)
33. PWM.start(PIN_SPEED_CH3_Right, 0)
34. PWM.start(PIN_SPEED_CH4_Left, 0)
35. GPIO.setup(PIN_DIR_CH1_Right, GPIO.OUT)
36. GPIO.setup(PIN_DIR_CH2_Left, GPIO.OUT)
37. GPIO.setup(PIN_DIR_CH3_Right, GPIO.OUT)
38. GPIO.setup(PIN_DIR_CH4_Left, GPIO.OUT)
39. 
    
40. def stop_rover():
41. all_stop()
42. 
    
43. #funkcja pomocnicza - sprawdza utrzymanie predkosci obrotowej kol
44. 
    
45. def check_speed(speed):
46. if speed < MIN_SPEED and speed != STOP_SPEED:
47. speed = MIN_SPEED
48. if speed > MAX_SPEED:
49. speed = MAX_SPEED
50. return speed
51. 
    
52. def fastest_speed_front(): 
53. global current_speed_CH1_Right, current_speed_CH2_Left
54. ret_speed_front = current_speed_CH1_Right
55. if current_speed_CH2_Left > current_speed_CH1_Right:
56. ret_speed_front = current_speed_CH2_Left
57. return ret_speed_front
58. 
    
59. def fastest_speed_rear():
60. global current_speed_CH3_Right, current_speed_CH4_Left
61. ret_speed_rear = current_speed_CH3_Right
62. if current_speed_CH4_Left > current_speed_CH3_Right:
63. ret_speed_rear = current_speed_CH4_Left
64. return ret_speed_rear
65. 
    
66. def slowest_speed_front():
67. global current_speed_CH1_Right, current_speed_CH2_Left
68. ret_speed_front = current_speed_CH1_Right
69. if current_speed_CH2_Left < current_speed_CH1_Right:
70. ret_speed_front = current_speed_CH2_Left
71. return ret_speed_front
72. 
    
73. def slowest_speed_rear():
74. global current_speed_right_CH3_Right, current_speed_CH4_Left
75. ret_speed_rear = current_speed_CH3_Right
76. if current_speed_CH4_Left < current_speed_CH3_Right:
77. ret_speed_rear = current_speed_CH4_Left
78. return ret_speed_rear
79. 
    
80. #set speed - ustaw predkosci kol
81. def set_right_speed_wheel_front(speed): #prawa gasienica kolo przednie
82. global current_speed_CH1_Right, current_speed_CH2_Left
83. new_speed = check_speed(speed)
84. PWM.set_duty_cycle(PIN_SPEED_CH1_Right,new_speed)
85. current_speed_CH1_Right = new_speed
86. 
    
87. def set_right_speed_wheel_rear(speed): #prawa gasienica kolo tylne
88. global current_speed_CH3_Right, current_speed_CH4_Left
89. new_speed = check_speed(speed)
90. PWM.set_duty_cycle(PIN_SPEED_CH3_Right,new_speed)
91. current_speed_CH3_Right = new_speed
92. 
    
93. def set_left_speed_wheel_front(speed): #lewa gasienica kolo przednie
94. global current_speed_CH1_Right, current_speed_CH2_Left
95. new_speed = check_speed(speed)
96. PWM.set_duty_cycle(PIN_SPEED_CH2_Left,new_speed)
97. current_speed_CH2_Left = new_speed
98. 
    
99. def set_left_speed_wheel_rear(speed): #lewa gasienica kolo tylne
100. global current_speed_CH3_Right, current_speed_CH4_Left
101. new_speed = check_speed(speed)
102. PWM.set_duty_cycle(PIN_SPEED_CH4_Left,new_speed)
103. current_speed_CH4_left = new_speed
104. 
     
105. def set_speed(speed):
106. set_right_speed_wheel_front(speed)
107. set_right_speed_wheel_rear(speed)
108. set_left_speed_wheel_front(speed)
109. set_left_speed_wheel_rear(speed)
110.     
111. #Increase speed - Zwekszenie predkosci
112. def increase_right_speed_wheel_front(): #prawa gasienica kolo przednie
113. global current_speed_CH1_Right, current_speed_CH2_Left
114. set_right_speed_wheel_front(current_speed_CH1_Right + CHANGE_RATE)
115. 
     
116. def increase_right_speed_wheel_rear(): #prawa gasienica kolo tylne
117. global current_speed_CH3_Right, current_speed_CH4_Left
118. set_right_speed_wheel_rear(current_speed_CH3_Right + CHANGE_RATE)
119. 
     
120. def increase_left_speed_wheel_front(): #lewa gasienica kolo przednie
121. global current_speed_CH1_Right, current_speed_CH2_Left
122. set_left_speed_wheel_front(current_speed_CH2_Left + CHANGE_RATE)
123. 
     
124. def increase_left_speed_wheel_rear(): #lewa gasienica kolo tylne
125. global current_speed_CH3_Right, current_speed_CH4_Left
126. set_left_speed_wheel_rear(current_speed_CH4_Left + CHANGE_RATE)
127. 
     
128. def increase_speed():
129. increase_right_speed_wheel_front()
130. increase_right_speed_wheel_rear()
131. increase_left_speed_wheel_front()
132. increase_left_speed_wheel_rear()
133. 
     
134. #Decrease speed - Zmniejszenie predkosci
135. def decrease_right_speed_wheel_front(): #prawa gasienica kolo przednie
136. global current_speed_CH1_Right, current_speed_CH2_Left
137. set_right_speed_wheel_front(current_speed_CH1_Right - CHANGE_RATE)
138. 
     
139. def decrease_right_speed_wheel_rear(): #prawa gasienica kolo tylne
140. global current_speed_CH3_Right, current_speed_CH4_Left
141. set_right_speed_wheel_rear(current_speed_CH3_Right - CHANGE_RATE)
142. 
     
143. def decrease_left_speed_wheel_front(): #lewa gasienica kolo przednie
144. global current_speed_CH1_Right, current_speed_CH2_Left
145. set_left_speed_wheel_front(current_speed_CH2_Left - CHANGE_RATE)
146. 
     
147. def decrease_left_speed_wheel_rear(): #lewa gasienica kolo tylne
148. global current_speed_CH3_Right, current_speed_CH4_Left
149. set_left_speed_wheel_rear(current_speed_CH4_Left - CHANGE_RATE)
150. 
     
151. def decrease_speed():
152. decrease_right_speed_wheel_front()
153. decrease_right_speed_wheel_rear()
154. decrease_left_speed_wheel_front()
155. decrease_left_speed_wheel_rear()
156. 
     
157. #Set direction forward - Ustawianie kierunku do przodu
158. def forward_right_dir_wheel_front(): #naprzod przednie kolo prawe
159. global current_dir_CH1_Right, current_dir_CH2_Left
160. if current_dir_CH1_Right == REVERSE_DIR:
161. all_stop()
162. GPIO.output(PIN_DIR_CH1_Right, GPIO.HIGH) #LOW
163. current_dir_CH1_Right = FORWARD_DIR
164. 
     
165. def forward_right_dir_wheel_rear(): #naprzod tylne kolo prawe
166. global current_dir_CH3_Right, current_dir_CH4_Left
167. if current_dir_CH3_Right == REVERSE_DIR:
168. all_stop()
169. GPIO.output(PIN_DIR_CH3_Right, GPIO.LOW)
170. current_dir_CH3_Right = FORWARD_DIR
171. 
     
172. def forward_left_dir_wheel_front(): #naprzod przenie kolo lewe
173. global current_dir_CH1_Right, current_dir_CH2_Left
174. if current_dir_CH2_Left == REVERSE_DIR:
175. all_stop()
176. GPIO.output(PIN_DIR_CH2_Left, GPIO.HIGH)
177. current_dir_CH2_Left = FORWARD_DIR
178. 
     
179. def forward_left_dir_wheel_rear(): #naprzod tylne kolo lewe
180. global current_dir_CH3_Right, current_dir_CH4_Left
181. if current_dir_CH4_Left == REVERSE_DIR:
182. all_stop()
183. GPIO.output(PIN_DIR_CH4_Left, GPIO.LOW)
184. current_dir_CH4_Left = FORWARD_DIR
185. 
     
186. def forward_dir():
187. forward_right_dir_wheel_front()
188. forward_right_dir_wheel_rear()
189. forward_left_dir_wheel_front()
190. forward_left_dir_wheel_rear()
192. #Set reverse direction - Ustawienie kierunku do tylu
193. def reverse_right_dir_wheel_front(): #wstecz przednie kolo prawe
194. global current_dir_CH1_Right, current_dir_CH2_Left
195. if current_dir_CH1_Right == FORWARD_DIR:
196. all_stop()
197. GPIO.output(PIN_DIR_CH2_Left, GPIO.LOW) # HIGH
198. current_dir_CH1_Right = REVERSE_DIR
199. 
     
200. def reverse_right_dir_wheel_rear(): #wstecz tylne kolo prawe
201. global current_dir_CH3_Right, current_dir_CH4_Left
202. if current_dir_CH3_Right == FORWARD_DIR:
203. all_stop()
204. GPIO.output(PIN_DIR_CH4_Left, GPIO.HIGH)
205. current_dir_CH3_Right = REVERSE_DIR
206. 
     
207. def reverse_left_dir_wheel_front(): #wstecz przednie kolo lewe
208. global current_dir_CH1_Right, current_dir_CH2_Left
209. if current_dir_CH2_Left == FORWARD_DIR:
210. all_stop()
211. GPIO.output(PIN_DIR_CH1_Right, GPIO.LOW) # HIGH
212. current_dir_CH2_Left = REVERSE_DIR
213. 
     
214. def reverse_left_dir_wheel_rear(): #wstecz tylne kolo lewe
215. global current_dir_CH3_Right, current_dir_CH4_Left
216. if current_dir_CH4_Left == FORWARD_DIR:
217. all_stop()
218. GPIO.output(PIN_DIR_CH3_Right, GPIO.HIGH) #or HIGH
219. current_dir_CH4_Left = REVERSE_DIR
220. 
     
221. def reverse_dir():
222. reverse_right_dir_wheel_front()
223. reverse_right_dir_wheel_rear()
224. reverse_left_dir_wheel_front()
225. reverse_left_dir_wheel_rear()
226. 
     
227. #Stop rover - Zatrzymanie rovera
228. def stop_left_wheel_front():
229. set_left_speed_wheel_front(STOP_SPEED)
230. 
     
231. def stop_left_wheel_rear():
232. set_left_speed_wheel_rear(STOP_SPEED)
233. 
     
234. def stop_right_whell_front():
235. set_right_speed_wheel_front(STOP_SPEED)
236. 
     
237. def stop_right_wheel_rear():
238. set_right_speed_wheel_rear(STOP_SPEED)
239. 
     
240. def all_stop():
241. stop_left_wheel_front()
242. stop_left_wheel_rear()
243. stop_right_whell_front()
244. stop_right_wheel_rear()
245. 
     
246. #Full speed - Cala naprzod
247. def full_speed_left_wheel_front():
248. set_left_speed_wheel_front(MAX_SPEED)
249. 
     
250. def full_speed_left_wheel_rear():
251. set_left_speed_wheel_rear(MAX_SPEED)
252. 
     
253. def full_speed_right_wheel_front():
254. set_right_speed_wheel_front(MAX_SPEED)
255. 
     
256. def full_speed_right_wheel_rear():
257. set_right_speed_wheel_rear(MAX_SPEED)
258. 
     
259. def all_full_speed():
260. full_speed_left_wheel_front()
261. full_speed_left_wheel_rear()
262. full_speed_right_wheel_front()
263. full_speed_right_wheel_rear()
264. 
     
265. #Spin rover - Obracanie rovera - skrecanie - zawracanie
266. def spin_right(speed):
267. all_stop()
268. forward_dir()
269. forward_right_dir_wheel_front()
270. forward_right_dir_wheel_rear()
271. reverse_left_dir_wheel_front()
272. reverse_left_dir_wheel_rear()
273. set_right_speed_wheel_front(speed)
274. set_right_speed_wheel_rear(speed)
275. set_left_speed_wheel_front(speed)
276. set_left_speed_wheel_rear(speed)
277. 
     
278. def spin_left(speed):
279. all_stop()
280. forward_dir()
281. forward_left_dir_wheel_front()
282. forward_left_dir_wheel_rear()
283. reverse_right_dir_wheel_front()
284. reverse_right_dir_wheel_rear()
285. set_right_speed_wheel_front(speed)
286. set_right_speed_wheel_rear(speed)
287. set_left_speed_wheel_front(speed)
288. set_left_speed_wheel_rear(speed)

Rozumiecie??? :-D Widzicie??? :-D
No to jak rozumiecie i widzicie to wszystko po kolei wyjaśnię:)
Do kontroli pinów z tak zwanych przeze mnie "hederów" P8 i P9 BBB, używam biblioteki Adafruit BBIO omówionej parę postów wcześniej.
Ale ponieważ już nie chce mi się pisać więcej to resztę omówię przy okazji następnego postu.
Łostańcie z Bogiem.

Testy połączeń platformy, o linuxie i trochę konfigurowania stuffu :)

Okej na początek fotka 
Czas na sprawdzenie teorii w praktyce i pierwszy test układu jezdnego

Dla celów testowych umieszczamy nasze podwozie na czymś co spowoduję niestykanie się rolek napędowych z powierzchnią i demontujemy gąsienice.

Na razie przecież nie chcemy, aby nasza platforma odjechała, tym bardziej, że póki co mamy komputer BeagleBone Black podpięty do komputera przez UART.

Później się będę zastanawiał jak rozwiążę zdalne przesyłanie oprogramowania i ewentualnych modyfikacji do platformy. Na razie szczerze mówiąc nie mam pojęcia jak to zrobić - ale nie pali się:)

Dobra czas na kod. Na początek napisałem prosty skrypt "na cztery koła" nazywając go np. test.py - wy możecie sobie go nazwać jak wam się żywnie podoba:

import Adafruit_BBIO.PWM as PWM

import time
pin1 = "P9_14"

pin2 = "P9_16"
pin3 = "P8_19"

pin4 = "P8_13"

PWM.start(pin1,0)

PWM.start(pin2,0)

PWM.start(pin3,0)

PWM.start(pin4,0)
PWM.set_duty_cycle(pin1, 100)

PWM.set_duty_cycle(pin2, 100)

PWM.set_duty_cycle(pin3, 100)

PWM.set_duty_cycle(pin4, 100)
time.sleep(60)

PWM.stop(pin1)

PWM.stop(pin2)

PWM.stop(pin3)

PWM.stop(pin4)
PWM.cleanup()

Jeśli wszystko jest prawidłowo połączone i zasilane, to koła powinny obracać się parami "ku sobie" przez czas jaki założymy w zmiennej time.sleep() w moim przypadku to np. 60, czyli minuta czasu :)
Pliki programów moim zdaniem najlepiej umiejscowić sobie w następującym katalogu:
/var/lib/cloud9/nazwa_katalogu - ta ostatnia to wg życzenia.
Narzędzie Cloud9 będzie wtedy łatwo znajdowało nasze programy i nie trzeba będzie się kopać po plikach i katalogach. Oczywiście, jak kto jest bardziej biegły w temacie to może to sobie zrobić w inny sposób. Ja zrobiłam jak umiałem :)
Oczywiście pliki te warto sobie co jakiś czas kopiować na PC np. za pomocą programu WinScp, aby w razie jakiejś awarii, konieczności instalacji wszystkiego od nowa mieć kopię zapasową swojej pracy:)

Do poprawnej pracy potrzebujemy jeszcze biblioteki Adarfuit PWM, którą można zainstalować stosując instrukcje zamieszczone tutaj:

https://github.com/adafruit/adafruit-beaglebone-io-python

lub tutaj:

https://learn.adafruit.com/setting-up-io-python-library-on-beaglebone-black/installation-on-ubuntu

Adafruit BBIO jest to taki zestaw narzędzi napisanych w Pythonie i ciągle aktualizowanych, które służą do obsługi i dostępu do konfiguracji  pinów  GPIO, PWM, ADC oraz UART w tej platformie.

Nie wiem dokładnie jak funkcjonują wszystkie te narzędzia więc proszę, jeśli ktoś to czyta nie pytajcie mnie o to. Generalnie konfiguracja standardowa, powinna się znaleźć w każdym aktualnym obrazie Debiana wspierającym tą platformę.

Ja osobiście zalecam używanie jak najbardziej aktualnego obrazu Debiana dla tej płytki dostępnego na przykład na Beaglebone.org w zakładce "Latest Software Images".

Do tego obrazu zaleca się instalację jądra w wersji 4.14.x, po to aby włączyć kontrolę nad konfiguracją GPIO i PWM z poziomu innego użytkownika niż /root - ot choćby to to aby móc swobodnie korzystać z platformy programistycznej Cloud9 "wszytej" w ten obraz, która korzysta jedynie z uprawnień standardowego usera.

Na dzień dzisiejszy ja osobiście używam takiego kernela:

root@beaglebone:~# uname -a

Linux beaglebone 4.4.91-ti-r136 #1 SMP Thu Nov 2 02:28:07 UTC 2017 armv7l GNU/Linux

Wziętego stąd:

https://rcn-ee.net/rootfs/bb.org/testing/

Jakkolwiek Developerzy zalecają na dzień dzisiejszy Debiana w wersji 9,2 "Stretch" iot z (2017-10-29), ja mam wersję z nieco nowszym kernelem i wszystko działa bez zarzutu - przynajmniej na razie :)

Myliłby się jednak ten kto by sądził, że poszło to wszystko tak pięknie, ładnie i zgrabnie. Zanim udało się odpalić ten prosty programik - test, co jest powyżej, dobry miesiąc testowałem razem z developerami wskazane przez nich różne testy, polecenia i konfiguracje obrazów, zanim pojawił się obraz, który działa sensownie i stabilnie.

Nie będę wszystkiego tu opisywał szczegółowo, bo uczciwie mówiąc nie jestem jakimś Linux'owym guru, ale koniec końców udało się i wszystko działa.

W tym miejscu chciałbym podziękować panom z github.com - Drew Fustini'emu i  Robertowi C Nelson'owi za pomoc i wyjaśnienie zawiłości oraz wskazanie co i jak zrobić :)

Co jeszcze? Aha, nowe wersje Adafruit_BBIO mogą być kompatybilne wstecznie ale, jak ktoś chce to niech testuje już we własnym zakresie:)

Poniżej przedstawiam film z jednego z pierwszych testów platformy:

To tyle na dziś. Trzymta się ludziska :)