Powrót do korzeni... mikrokomputer CA80, kolejny tydzień pandemmi Covid19 i prace nad moim komputerkiem....

Witam. Tym razem mało pisaniny a więcej dokumentacji zdjęciowej. CA80 dostał między innymi obudowę ze skrzynki elektrycznej z tłoczywa ABS, jako klawiszy użyłem klawiszy mechanicznych kupionych na sztuki (Kailh White Box) o sile nacisku 55g (jakby to miało jakiekolwiek znaczenie dla pisania na tym komputerku), co tam jeszcze? - wykonałem podłączenie złącza magnetofonowego DIN 3pin oraz przycisku RESET, który działa następująco:

W technice cyfrowej i ogólnie elektronice (zwłaszcza tam, gdzie mamy do czynienia z poziomami TTL , a tu w tym komputerku takowymi operujemy) wyróżniamy dwa stany logiczne „0” – bardzo bliskie 0V oraz „1” – mniej więcej większe od połowy zasilania +5V. Jest jeszcze „trzeci stan”, czyli brak jakichkolwiek stanów, stan wysokiej impedancji, czy jak niektórzy nazywają stan nieustalony.

Nóżka (pin) 26 mikroprocesora ZILOG Z80 (na schemacie na str.55 MIK-09) służy właśnie do wprowadzania procesora w stan „RESET” sprzętowy, sygnałem aktywującym jest tu poziom niski „L”, czyli „0” logiczne. Tak więc podanie masy (połączenia masy z pinem RESET procesora (noga 26) spowoduje wprowadzenie procesora właśnie w stan RESETU, z którego wychodzi podczas powrotu tego sygnału do stanu wysokiego „H” (przez podanie na powrót „1” logicznej "High", co zapewnia rezystor R9).

Więc kiedy procesor normalnie pracuje to znaczy bez takiej modyfikacji w postaci dołączenia przycisku „RESET” na pin 26 procesora Z80 mamy tam stale stan wysoki (jedynkę logiczną) wymuszony przez rezystor R9, drugim końcem podłączony do zasilania +5V.

Zamontowany w obudowie przycisk RESET'u

Rezystor R9 oraz kondestator C5 tworzą prymitywny układ reseto/startu bo: w momencie podania zasilania na wszystkie układy CA80 mogą powstać liczne stany nieustalone (im większy system tym jest ich potencjalnie więcej), dlatego na bardzo krótką chwilę ładujący się poprzez rezystor R9 kondensator C5 wymusza na nóżce 26 procesora stan niski „L” wprowadzając go na krótko w stan resetu sprzętowego.

No i tak trochę z pomocą Bożą i kolegi z forum dobrnąłem do miejsca gdzie musiałem wykonać dodatkowy przycisk RESET podłączony pomiędzy masę zasilania a tą nóżkę rezystora R9, która jest wspólna również dla wejścia resetu procesora (pin 26) i kondensatora C5. Po prostu przycisk RESET kondensator C5, tak aby na nodze 26 procesora wymusić stan „L” - wysoki, czyli podać „0” logiczne, w praktyce masę GND.

 Sposób podłączenia końcówki przycisku RESET do nóżki rezystora R9.

Sposób podłączenia końcówki przycisku RESET do masy (GND).

Kolejnym etapem pracy było założenie gniazda magnetofonu ale to już kosmetyka i nie pokazuję tutaj jak to zrobiłem oraz zarobienie przewodów wtyku zasilania.

Duże ukłony i wyrazy uznania należą się w tym momencie żonie, która dzielnie zapletła mi te "warkoczyki" z przewodów, które docelowo trafią drugimi końcami do złącza zasilacza. Poniżej krótka galeria zdjęć montowanego wtyku:

I to tyle w tym poście.

CDN.

Powrót do korzeni... mikrokomputer CA80, dlaczego nie oglądać YT!

Witam

Normalny człowiek podczas pandemii koronawirusa siedzi grzecznie z żonką w domeczku, liczy kolekcję znaczków lub kopie w ogródeczku jakieś roślinki... ale nieeeee taki czub jak ja musi odgrzewać stare kotlety i znajdować w otmętach internetu różne dziwne rzeczy, lub...

Regularnie jeżdżą na rowerku po dzielnicy i mają koło dupy nakazy i zakazy bo i tak nie ma tu gdzie mieszkam nikogo w nocy a nawet jak ktoś przechodzi to i tak rzadko...

Tak też się stało i ze mną bo szukając pomysłu na zabicie czymś czasu trafiłem na YT na film dotyczący uruchomienia komputera statku APOLLO, który 50 lat temu zabrał w kosmos i pozwolił wylądować człowiekowi na księżycu.
Przeto, że w Polsce mogę pomarzyć o zdobyciu modułów do AGC (Apollo Gudance Computer), trafiłem po jakimś czasie na YouTube'owy kanał pana Adama Śmiałka "Towary Modne", w którym omawiał on "kryzysowy komputer" CA80, jako coś co miało mieć znamiona komputera i było tanie i dostępne dla każdego i do samodzielnego złożenia i w ogóle "cud mjut".

Pan Adam z właściwą sobie "krakoską" manierą, stwierdza, że nie będzie nikomu czynił wykładu z asseblera niemniej w jakiś sposób kupił moją uwagę tą charakterystyczną postawą. Zobaczcie zresztą sami:

Problem w tym, że ani nie było tanie - moich rodziców nie było stać nawet na taki komputerek, a co dopiero na sprzęt potrzebny do jego złożenia - ani nie było ogólnodostępne bo jakoś nie pamiętam z czasów krakowskiej giełdy elektroniczej (a bywałem tam nieomal co tydzień), żeby coś takiego było dostępne lub rzuciło mi się w oczy.

Nawet w czasach legendarnego w Krakowie sklepu BAJTEK zlokalizowanego z boku budynku "KORONY" (nie, nie tej kieleckiej, tylko krakowskiego budynku klubu KORONA), coś takiego nie obiło się o moje oczy, a też kilkanaście razy tam zaglądałem z ojcen w tamtych czasach.

Również w czasach legendarnych zestawów, produkowanych przez krakowski TELPOD z serii "Młody elektronik" nigdy jakoś nie trafiłem na zestawy "MIK'a".

No cóż może byłem za mały, żeby móc coś wiedzieć, albo po prostu dostępność tego komputerka i tak była znikoma, tym bardziej, że już wtedy można było kupić sobie PC'ta Olivetti na procku bodaj 8080 lub lepszym za całkiem grube pieniądze lub nawet ZX Spectrum opartego w sumie o ten sam ZILOG co MIK (a może się mylę)...

Tak czy siak zakładów UNITRA Telpod w Krakowie już nie ma (są ale w śladowej ilości). W ich budynku powstał "luksusowy akademik" z saunami siłowniami, wodotryskami i chuj wie czym jeszcze. No bo dzisiaj nowoczesny student ma prawa i on musi mieć godne warunki do imprezowania, chillu i uniesień sexualnych, byle tylko nie robić tego do czego służy studiowanie.

Główna brama wejściowa na teren zakładu "Telpod" w latach 90-tych.Kadr z filmu Upadek Telpodu. Warto zwrócić uwagę na ilość osób opuszczających bramy zakładu.

Potem wychodzą stada kretynów z "dupomami" (nie mylić z dyplomami) nie umiejących czytać i pisać poprawnie co paradoksalnie ma kluczowe znaczenie w programowaniu i innych dziedzinach naukowych....

... za daleko wybiegam...
Ja się zresztą nie znam na tym i jestem tylko sfrustrowanym, zgrzybiałym 40 latkiem i w ogóle nie mam pojęcia o elektronice i informatyce i nie pracuję w TOP Korpolandzie więc po co w ogóle zabieram tu głos...

Budynek Wydziału Mikroukładów Hybrydowych Grubowarstwowych - ul. Lipowa 4e.Ilustracja z książki "Krakowskie Zakłady Elektroniczne UNITRA Telpod". Obecnie w tym małym budynku stołówki mieści się "Turbo nowoczesna, trendy shit" knajpa dla nowoczesnej i postępowej laickiej młodzieży i korpodupków znających biegle pięć języków w tym chiński i będących top "menedżment" sraka na porcelicie.

Stanisław Gardynik też obecnie zajmuje się czym innym (a szkoda) a mnie pozostało nadrabianie "skakania w gumę" tyle, że 30 lat z okładem później.
(Szanowni postgimnazjaliści i inni niedorozwinięci nadpobudliwi sexualnie młodzi ludzie "skakanie w gumę" to nie jest odmiana gangbangu tylko gra sprawnościowa, polegająca na sprawnym przeskoczeniu długiej gumy trzymanej lub owiniętej wzdłuż nóg lub bioder dwóch innych osób w taki sposób alby jej nie zaczepić - były jeszcze inne prawidła tej gry ale nie będę robił z tego oddzielnego zagadnienia).

Gra w gumę - lada '70 - '90 XX wieku - mój Boże jak to brzmi...

Tak pogrążony dołującymi myślami o pokoleniu obecnych tępawych 20 to i 30 latków (pokoleniu IKEŁY) poszukałem na portalach aukcyjnych czy może ktoś posiada takie coś jak może jakiś używany, ba nawet zniszczony CA80.
No i ku mojemu wielkiemu zaskoczeniu znalazłem. Okazało się, że jeszcze nie wszystko stracone i jakiś człowiek postanowił przywrócić ten jeden z pierwszych polskich zestawów DIY do życia.
Wykonał on na podstawie dokumentacji z 1991 roku dokładną płytkę drukowaną, dziś powiedzielibyśmy płytę główną tego komputera w wersji nowszej czyli MIK290.
No to kupiłem i przystąpiłem do montowania... aaa chwilka jeszcze kilka słów o CA80:

"Mikrokomputer CA80 (bo na swoje czasy na 100% był „mikro”), to pełnowartościowy system procesorowy pracujący pierwotnie pod kontrolą 8-mio bitowego procesora U880 (klon Z80A firmy Zilog), którego głównym przeznaczeniem była nauka programowania mikrokomputerów, ale także elektroniki cyfrowej w ogóle. Został on wymyślony na początku lat 90-tych przez polskiego inżyniera Stanisława Gardynika. Sprzedawany w zestawach do samodzielnego montażu i wspomagany obszerną literaturą autorstwa jego twórcy, która zgromadzona była w kilkunastu dosyć obszernych zeszytach o nazwie „MIK”. Zeszyty te opisywały zarówno podstawy elektroniki, jak i sposób montażu komputerka, jego uruchomienie oraz oprogramowanie. W miarę rozwoju przedsięwzięcia fani doczekali się kilku, może nawet kilkunastu programów użytkowych wraz z adekwatną adaptacją hardware’u."

Źródło: http://elserw.pl/category/ca80/

Dobra. Nie ma co tu więcej pisać. Po nadejściu przesyłki zawierającej płytkę PCB, przystąpiłem do montażu i jednoczesnego gromadzenia potrzebnych elementów. Ponieważ z różnych moich starych projektów pozostały mi najróżniejsze elementy dyskretne użyłem ich do budowy mojego komputera. zastosowałem 1% rezystory Vishay DALE stosowane w systemach audio oraz precyzyjne podstawki ze złoconymi końcówkami. Jako kondensatory blokujące użyłem również wysokiej klasy kondensatorów Vishay. Mogłem to zmontować starych na ruskich częściach tylko po co.
Zdjęcia przedstawiają wstępne fazy przed i po montażu PCB i kolorowe elementy czyli masę rezystorów, zwłaszcza przy wyjściu klawiatury i wyświetlacza (ten ostatni opiszę kiedy indziej).

Przed:

Płytka PCB a pod nią spis elementów i ich zamienników.

Po:

Jako układy I/O zastosowano w tym projekcie popularne programowalne układy z serii 8255 (u mnie to układy jeszcze Czechosłowackie TESLA), oraz całą masę pamięci do wyboru do koloru i choć dzisiaj mamy np. NVRAM'y i inne nowsze to ja zdecydowałem się zadziałać ortodoksyjnie i zastosować klasyczne Intel'owskie EPROM'y z serii 27128 o pojemności 16kB każdy.
Złącze klawiatury i wyświetlacza to też klasyka i zastosowanie złącza typu CANON w tym wypadku produkcji Hartig'a.
Nie jest tak mocne jak to z przed 30 lat, produkowane przez zakłady ELTRA i już po kilku wyjęciach i wpięciach łapie luzy ale innego nie miałem (musiałem kupić na tym TME).
Wyświetlacz... wyświetlacz to już kolejna bajka na dobranoc dla tych którym w ogóle chce się czytać te wypociny....
Pozdrawiam.

Woltomierz Meratronik V628 - czyszczenie i gadanie w zasadzie o niczym...

Najlepszy blog podróżniczy jaki znam - kolejna podroz.pl

kolejnapodroz.pl

I cóż powiedzieć - ja pracując nieomal dwadzieścia lat "na państwowym" mam całkiem podobne odczucia jak ten pan.

W świacie fejmu i celebrytów klepiących gówno za hajsy, za takimi jak my nawet najohydniejsza dziwka z ulicy nie raczy spojrzeć (sam się czasem zastanawiam jakim cudem żona wytrzymuje ze mną - technologicznym nędzarzem 24h/dobę ;) ).

Niestety za pensję podstawową plus współmałżnka na permanentnym bezrobociu, nadal nie jest się w stanie w Polsce przeżyć, a co dopiero godnie funkcjonować, o podróżach nie wspominając.

Owszem są "pińcet plusy" i inne beneficje (for the masses), ale trzeba mieć do tego dzieci a nie wszystkich pomimo rozdawania rządowych zapomóg na dzieci stać a dwa, one (te programy socjalne) spowodowały jedynie drastyczny wzrost cen produktów i usług, w tym także turystycznych (no niestety "onion rulez" i każdy "Janusz biznesu" chce skorzystać na tym, że ludzie mają w końcu nieco  większy "hajc").

Tak czy siak poczytajcie sobie Blog pana Sieczkowskiego dopóki jeszcze jest.

Ja nadmienię tylko, że dzięki niemu dowiedziałem się o letnim i zimowym pociągu z Muszyny do Popradu, bo przecież w mediach głównego nurtu nikt o tym nie mówi - nawet lokalnie ciężko z tym bywa.

Za to bicia piany, "elektromobilności", "kolejach dużych prędkości" - give me a break :):) i tego wyświechtanego frazesu "innowacyjność" aż do wyrzygu.

Z drugiej strony też nie lepiej bo od słowa "kon(pro)stytucja" i widoku bandy retardów i nieudaczników zaskoczonych oderwaniem ryja od koryta zbiera mnie na wymioty.

A kim jest sam autor? Jak sam o sobie pisze:

Dariusz Sieczkowski - nierób i nieudacznik, niedoszły przedsiębiorca, niedoszły naukowiec, dawniej leksykograf, pasożyt społeczny, posiadacz bezwartościowej wiedzy i bezwartościowych umiejętności, mistrz autopromocji. Dostarczyciel wiedzy i pomysłów dla tych, którzy mają możliwość ich realizacji oraz zarabiania na nich. Inwalida przez dolegliwości spowodowane wieloletnim wolontariatem przy komputerze.

Poprzez swoją twórczość udowadniam, że marzenia się nie spełniają, a hasła typu "chcieć, to móc" to tylko bzdury dla naiwnych. W świecie, w którym wartość człowieka wyznacza liczba fanów i lajków, znajduję się na samym dnie.

No cóż polecam i pozdrawiam.
Cześć.

RIDEN RD6006 - zasilacz/przetwornica

Lot Dronem Tarot T960 nad zabytkową cerkwią w Gładyszowie.

Lot Dronem Tarot T960 nad zabytkową cerkwią w Gładyszowie.

Zmierzch: Ofensywa ideologii gender

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.