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 :)

Połączenia elektryczne w platformie

Przyszedł czas na zaprezentowanie jak zrobione są połączenia elektryczne w moim projekcie.

Do zasilania zastosowano akumulator (LiPo) Litowo Polimerowy o pojemności 2500mAh (miliamperogodzin) o napięciu 14,8V, czyli czterocelowy (4S1P).

O zasadach użytkowania i bezpieczeństwa przy pracy z tymi akumulatorami napisano już bardzo wiele, ot choćby porządny materiał na Forbot.pl w dziale Akumulatory LiPo - kompendium.

Ponieważ jestem perfekcjonistą i nie toleruję projektów robionych w pudełkach po butach lub na tekturce, platformę moją wykonałem z gustownej sklejki brzozowej (łatwo się ją tnie i obrabia).

W sklejce powycinałem otwory na wiązki przewodów oraz powierciłem niezbędne otwory na słupki dystansowe - nieco wyższe niż te co izolują płytę główną komputera od obudowy i zwarcia, niemniej spełniające tę samą funkcję. Na sam koniec sklejka została wyrównana papierem ściernym i do akcji wkroczyła moja żona, która jest już na etapie "doktoratu" w zakresie powłok bejcowych i lakierniczo farbiarskich :) To ona dokonała dokładnego i precyzyjnego pobejcowania i polakierowania mojej "dechy" w platformie No co ma być estetycznie) :)

Aby uniknąć odkształceń sklejki, powstałych na skutek lakierowania, wykonałem do niej ramkę z kątownika aluminiowego - takiego jak się stosuje na progi podłogowe lub stopnie schodów - do kupienia w każdym markecie budowlanym.

Teraz tak: zasilanie

Na płytce kontrolera silników mamy dwa wejścia zasilające kontroler: jedno 5V do zasilenia logiki płytki kontrolera i drugie do dostarczenia napięcia w zakresie bodaj 4,5V - 12V do zasilania napędu czyli silniczków DC (wartości 12V doradzam nie przekraczać bo ja przekroczyłem i jeden taki kontroler spaliłem - niedacznik!!!).

Nie używam dostarczanego wraz z podwoziem koszyka na baterie, a sposób zasilania wszystkiego opiszę nieco dalej w poście i opatrzę fotografiami.

Na płytce kontrolera silników Dagu mamy dwa złącza śrubowe ARK (chyba tak się ono nazywa), oznaczone odpowiednio "Vbat" i drugie oznaczone jako "VCC". Należy podłączyć napięcie około 7,2V (tyle wymagają silniczki DAGU) do złącza oznaczonego symbolem "Vbat", z kolei do drugiego złącza "VCC" podpinamy napięcie 5V (można je "pożyczyć" z "hedera" Beagle'a: P9_5 lub P9_6 (napięcie 5V) i P9_1 lub 2 GND (Ground) ).

Ja jednak wykonałem to zupełnie inaczej i czas pokaże czy dobrze.

Ponieważ Beaglebone Black potrzebuje 5V i około 1,5A prądu stałego, takie samo napięcie, jak blok logiki sterownika silników, z kolei do zasilania bloku PWM sterownika silników potrzeba w tym projekcie około 7,2V (tak, jak pisałem powyżej i żeby nie spalić sterownika i silniczków DC), trzeba było jakoś te dwa napięcia doprowadzić z akumulatora.
He tylko jak to zrobić mając 14,8V na wyjściu akumulatora?

Nic bardziej prostego - zastosowałem po prostu dwie przetwornice oparte o układ scalony XL4015 - ja zresztą już wspominałem o niej i o zasilaniu nią BBB, w jednym z wcześniejszych moich postów. A widok jej poniżej:

Te małe przetwornice wydają się idealne do takich zastosowań. Owszem ktoś może powiedzieć że powinienem taki układ wykonać sam! Pytanie tylko po co, skoro kosztowało to na Aliexpress dolara z kawałkiem :-)

Przetwornice te mają potencjometry regulacyjne, którymi ustawiamy pożądany prąd i napięcie zasilanego układu i to w zasadzie tyle.

A jak rozdzielić prąd z akumulatora do zasilenia dwóch przetwornic na raz? Nic bardziej prostszego rozdzielacz:

Ja miałem akurat pełno wtyczek XT60 pozostałych z budowy drona, więc akurat takie pokazuję, niemniej taki rozdzielacz można sobie spokojnie wykonać samemu w domowym zaciszu :)

Poniżej zdjęcia jak to wygląda na gotowo:

Pozostało wszystko odpowiednio połączyć ale to wyjdzie w następnych postach co  i jak.
No dobrze tyle na dzisiaj, bo nie chce mi się już pisać. :)

Cześć.

Podłączenie platformy Beaglebone Black do kontrolera silników.

Zanim zacznę znowu truć o "techikaliach"chciałbym złożyć gorące podziękowania przynajmniej dwóm osobom i na dodatek kobietom, którym w ogóle chce się jeszcze czytać tę radosną twórczość. Pierwsza to oczywiście moja żona z równoległego świata blogowego sztukaspodstrzechy oraz tajemniczej, acz bardzo intrygującej mnie Koreance śledzącej moje poczynania tutaj, Lunie Mae. Albowiem są to chyba jedyne dwie kobiety, które są jeszcze w stanie czytać te posty.

Tak, że dzięki dziewczyny i wielkie pozdrawiam i wielkie puss pussy dla Was. Młuuuaaa. :)

Po podłączeniu sterownika do podwozia, przyszedł czas na podłączenia platformy Beaglebone Black do sterownika silników. Oczywiście ze względu na higienę pracy i żeby niczego nie spalić wszystko to o czym piszę wykonujemy przy odłączonym zasilaniu.

Pierwszą rzeczą, którą wykonałem to wydruk wyprowadzeń pinoutów Beagle'a na podstawie genialnej książki Derrek'a Molloy'a - irlandczyka, inżyniera, nauczyciela i badacza, zwłaszcza elektroniki i systemów wbudowanych.

Aha poniżej link do strony Dereka:

http://derekmolloy.ie/beaglebone/

Dodatkowo "druknąłem" sobie wszystkie możliwe kombinacje tak zwanych MUXów pinów, bo można je sobie dowolnie konfigurować ale to już temat na inny post. Poniżej "MUXy"

P8 HEADER

P9 HEADER

Po zapoznaniu się z dokumentacją poznajdowałem piny PWM czyli te, które chciałem używać jako sterujące silnikami oraz piny GPIO, których chciałem użyć dla ustawienia kierunku obrotu kół.
I w tym miejscu chciałem podziękować z wspaniałe lekcje kolejnemu nauczycielowi - nieee, nie żadnemu pajacowi z doktoratem z "wyższej" uczelni z Polski - broń Boże.
Podziękowania należą się panu Paul'owi Mcwhorter'owi z bloga toptechboy.com, dzięki któremu złapałem jakiego takiego bakcyla na zabawę z tą platformą.
Lekcje bardzo zachęcająco prowadzone dokładnie, krok po kroku a nie po łebkach, wszystko wyjaśnione i poparte przykładem działającego programu i sprzętu.

Niechbym tylko śmiał skorzystać z takiej elektrody.pl, oojjjj - to zaraz byłbym zaszczuty i zakrzyczany przez "znawców" wszystkiego i wszystkich, na zasadzie "nie znasz podstaw, to po co pytasz o takie rzeczy?! Opanuj podstawy!" - i w tym momencie pada litania tego co powinno zdaniem takowego "oświeconego" być nauczone. Zamiast pomocy i konkretnego rozwiązania - wymyślanie koła od początku.
Ewentualnie jest się blokowanym lub wyrzucanym za własne racje i dążenie do nich - no cóż niektórzy z tak zwanych "moderatorów" ze wsi wyszli, ale wieś z nich nigdy nie wyjdzie, choćby nie wiem jaki pozom wiedzy opanowali. :) Czasem trzeba być człowiekiem a nie prostakiem, i jak mawiał mój dawny kolega "na nic będą doktoraty kiedy człowiek chamowaty" :) Znowu za daleko wybiegłem...
Tak czy siak skorzystałem z porad zagranicznych wykładowców i jestem z tego faktu zadowolony, zupełnie inny poziom rozmowy, jeśli sarkazm to tylko w celach wyjaśnienia, nikt nikogo nie blokuje, nie banuje za wpisy i tyle - ogólnie brak cebulactwa, inna kultura pracy...

Do rzeczy. W moim projekcie podłączyłem piny PWM do płytki kontrolera silników następująco:
P9_14 do pierwszego kanału;
P9_16 do drugiego kanału;
P8_19 do kanału 3;
oraz P8_13 do kanału 4 płytki sterownika silników.
Po czym piny "cyfrowe: GPIO podłączyłem w następujący sposób:
P9_27 - GPIO - kanał 1;
P9_30 - GPIO - Kanał 2;
P8_17 - GPIO - kanał 3;
P8_15 - GPIO - kanał 4.
Poniżej pokazuję to na zdjęciach i tak niebieskie przewody to wyjściowy sygnał sterujący PWM (Pulse Wave Modulation), a fioletowe to cyfrowe piny GPIO do sterowania kierunkiem jazdy maszyny.

Jak więc widać każda para pinów PWM / GPIO odpowiada za sterowanie jednym kanałem, czyli jednym silnikiem DC i enkoderem (no tak jakby jedną nogą).
Myślę, że wyjaśni się to dokładniej kiedy przedstawię przykładowy program do testowania połączeń:)

No i pamiętajcie: pan Paul McWhorter, blog toptechboy.com, bardzo fajne lekcje dla początkujących i bardzo fajnie wytłumaczone.
Jeszcze raz gorąco zachęcam do lekcji prowadzonych przez tego człowieka. Krok po kroku a nie po łebkach jak na polskiej uczelni!!!

Cześć.