• Analizuj aktywność portu szeregowego

    Serial Port Monitor może połączyć się z portem COM, nawet jeśli jest już otwarty przez jakąś aplikację i natychmiast rozpocząć jego monitorowanie. Wszystkie dane przechodzące przez monitorowany port COM zostaną wyświetlone w naszym programie monitorującym. Ponieważ wszystko jest rejestrowane w czasie rzeczywistym, będziesz w stanie natychmiast wykryć problemy. Aby porównać dane, istnieje funkcja zsynchronizowanego wyboru tych samych IRP w różnych widokach.

    Dodatkowo możesz przekierować wszystkie dane z monitoringu do określonego pliku lub skopiować wszystkie zarejestrowane dane do schowka. Serial Port Monitor daje możliwość przechwytywania i rejestrowania wszystkich kodów sterujących we/wy portu szeregowego (IOCTL), monitorowania wszystkich ich danych i parametrów. Możesz zapisać dowolną sesję monitorowania i w razie potrzeby załadować ją następnym razem.

  • Monitoruj wiele portów w ramach tej samej sesji

    Monitor portu szeregowego ma unikalny funkcjonalność monitorowanie wielu portów COM jednocześnie. Teraz możesz zbierać dane dotyczące interakcji aplikacji z co najmniej dwoma portami i równolegle z wieloma urządzeniami w ramach tej samej sesji. Otrzymane i wysłane dane z monitoringu będą prezentowane (rejestrowane) w osobnym logu w kolejności ich otrzymywania, co znacznie upraszcza analizę.

  • Różne opcje przeglądania otrzymanych danych

    Możesz przeglądać dane monitoringu jednocześnie w 4 trybach: tabeli, linii, zrzutu lub terminala, z których każdy oferuje inny sposób prezentacji zarejestrowanych danych szeregowych. Serial Port Monitor pozwala wybrać filtry monitorowania, oszczędzając w ten sposób czas i umożliwiając monitorowanie tylko interesujących zdarzeń. W ustawieniach możesz wybrać dane do wyświetlenia: binarne, ASCII, skonfigurować port. Dowolne ustawienia wyświetlania można zastosować bezpośrednio w bieżącym procesie monitorowania.

  • Emuluj transfer danych do urządzenia szeregowego

    Możesz wysłać dane do różne formaty(ciągowe, binarne, ósemkowe, dziesiętne, szesnastkowe, mieszane) do monitorowanego portu szeregowego, tak jakby były wysyłane bezpośrednio przez kontrolowaną aplikację przy użyciu funkcji trybu terminala monitora portu szeregowego. W ten sposób można monitorować odpowiedź sterowanego urządzenia szeregowego na niektóre specjalne polecenia i dane.

  • Pełna obsługa protokołu danych Modbus (RTU i ASCII)

    Za pomocą nowych filtrów Serial Port Monitor będziesz mógł deszyfrować i analizować dane Modbus. Program pomoże nie tylko nawiązać połączenie pomiędzy urządzeniami RS485/422/232, ale także przeprowadzić efektywną analizę przekazywanych danych.

  • Odtwórz i porównaj sesje monitorowania

    Serial Port Monitor zapewnia unikalną możliwość odtworzenia sesji z aplikacji do portu dla najlepsza analiza trwające procesy. Będziesz mógł obserwować reakcję portu szeregowego na przejście tych samych danych, zwiększając w ten sposób skuteczność monitoringu. Masz również możliwość porównywania wielu sesji monitorowania i automatycznego śledzenia różnic między nimi.

Dziś wirusy komputerowe dosłownie zalał świat i swobodnie wędrował po Internecie, więc jeśli chodzi o porty, większość użytkowników często myśli o portach logicznych, które w technologiach sieciowych takich jak TCP/IP czy UDP służą do organizowania kanałów komunikacji, a zapomina o portach fizycznych do podłączania urządzeń zewnętrznych. Jednak nawet do podłączenia drukarek coraz częściej używa się myszy i klawiatur szybkie porty USB a coraz rzadziej - stary dobry COM i LPT (porty szeregowe i równoległe). Jednak te ostatnie są dostępne nawet w najnowocześniejszych komputerach i być może nadszedł czas, aby użyć ich w innym celu (powiedzmy, aby sterować jednym lub drugim wyspecjalizowanym urządzeniem).

Aby śledzić wymianę między komputerem a jakimś urządzeniem, potrzebne są programy analizujące porty.

Oczywiście w sprzedaży dostępne są również specjalne urządzenia (sondy) do monitorowania sygnałów analogowych i cyfrowych (m.in. analizatory USB, LPT i COM), jednak jak każdy profesjonalny sprzęt, są dość drogie.

Sterowanie portem szeregowym komputera (COM)

Jeden z programów do analizy portów seryjnych napisał Valery Kovtun (http://valery-us4leh.narod.ru/). Dzięki za świetne narzędzie!

Program nazywa się Com Port Visual Control (http://valery-us4leh.narod.ru/ComVC.html), jest dystrybuowany bezpłatnie i przeznaczony jest do wizualnej kontroli, dokumentowania wymiany danych oraz badania procesów zachodzących w transceiverze UART podczas działania aplikacji korzystających z portu COM komputer osobisty. Ten program działa w Środowisko Windows 9x/Me/NT/2000/XP i wykonuje ciągły podgląd (monitoring) wszystkich rejestrów układu UART. Sterownik ma format 8x8 (osiem rejestrów po osiem bitów każdy) i dla każdego rejestru niezależnie wyświetla: aktualny stan (jednocześnie w formacie dziesiętnym i szesnastkowym) oraz stan logiczny. Dodatkowo program może zapisywać wartości do rejestrów (również w formacie dziesiętnym i szesnastkowym) i odpowiednio zarządzać stanem logicznym. Ponadto monitoruje zmiany w rejestrach i utrzymuje protokół (LOG) zgodnie z poleceniami transceivera układu UART, a także przechowuje protokół odbieranych i przesyłanych danych na poziomie kodów maszynowych. Po zakończeniu pracy program przegląda i zapisuje pliki LOG i może je wyszukiwać w celu uzyskania niezbędnych informacji.

Com Port Visual Control ma wbudowany nadajnik-odbiornik dla standardowe ustawienia tryby portów: bity danych, bity stopu, prędkość, parzystość, kontrola błędów, możliwość odbierania i przesyłania danych tekstowych i poleceń modemowych, a także wskaźnik monitorowania stanu aktywnego poleceń UART (obsługiwanych jest 17 podstawowych poleceń). Dodatkowo porty komputera są monitorowane z jednoczesnym wyświetlaniem grupy rejestrów i bitów statusu oraz utrzymywany jest protokół zmiany danych w rejestrze bazowym.

Wśród takich programów są darmowe narzędzie ComLite32 firmy Realtime Communications (RTCOMM, http://www.rtcomm.com/), napisany dla systemu Windows 95 i jego płatnej wersji premium, ComLab32 (http://www.rtcard.com/comlab32.html).

Programy te są potężnymi analizatorami komunikacji w czasie rzeczywistym, które pozwalają zbadać wymianę przez port COM i zrozumieć, jak działa dane urządzenie, nawet jeśli nie ma na to dokumentacji. Program posiada wygodny i intuicyjny przejrzysty interfejs, ułatwiając monitorowanie wymiany, zarządzanie portami I/O oraz dostarczanie szczegółowej dokumentacji online.

Programy ComLite32 i ComLab32 współpracują z portami RS-232, RS-422, RS-485 i RTX485 (ostatni port jest tylko do odczytu) i umożliwiają komunikację z tymi portami w obu kierunkach. Wymagania systemowe Programy ComLite32 są minimalne: tylko 8 MB RAM, 6 MB miejsca na dysku oraz co najmniej jedno urządzenie współpracujące z portem szeregowym (w tym modemy PCMCIA do laptopów).

Na koniec chciałbym zwrócić uwagę na programy Advanced Serial Port Monitor i Advanced Serial Data Logger firmy AGG Software (http://www.aggsoft.ru). Zaawansowany rejestrator danych szeregowych przetwarza dane otrzymane przez RS-232 i przesyła je do plik Excel, Access lub inną aplikację Windows. Program zapewnia możliwość zbierania danych z dowolnego urządzenia w czasie rzeczywistym, a także odbierania i przesyłania danych przez interfejs RS-232 lub przez interfejs RS-485, jeśli dostępny jest konwerter sprzętowy. Zaawansowany Serial Data Logger zbiera dane z portu szeregowego, przetwarza je zgodnie z potrzebami użytkownika, wydobywa bloki danych ze strumienia ogólnego, a następnie przesyła dane do dowolnej aplikacji Windows lub DOS - poprzez naciśnięcie odpowiednich klawiszy w aplikacji okno. Dane są przesyłane przez DDE (Dynamic Data Exchange), ODBC, OLE itp. Rozwiązanie to może być stosowane w systemach automatycznego zbierania danych lub systemach analizy połączeń PBX.

Zaawansowany rejestrator danych szeregowych może również wysyłać żądania i polecenia przez port szeregowy, aby bezpośrednio sterować urządzeniami za pomocą protokołu ASCII (domyślnie) lub MODBUS. W ten sposób program Advanced Serial Data Logger staje się serwerem we/wy. Jeśli chodzi o zarządzanie i ustawienia, są one bardzo proste i intuicyjne. Dodatkowe programowanie do akwizycji danych nie jest wymagane.

Ponadto Advanced Serial Data Logger może pracować jako usługa pod Windows NT/2000/XP/2003, która uruchamia się przy starcie systemu i zapisuje dane z portu szeregowego do pliku na dysku lub w innych określonych lokalizacjach jeszcze przed logowaniem użytkownika do systemu (i będzie nadal działać po zakończeniu sesji użytkownika).

Program ma możliwość uruchamiania wielu kopii na tym samym komputerze, dzięki czemu jednocześnie może być rejestrowanych wiele portów.

Jeśli chodzi o program Advanced Serial Port Monitor, może być przydatny zarówno dla początkujących użytkowników, jak i profesjonalistów.

Zaawansowany monitor portu szeregowego może służyć zarówno do monitorowania transmisji danych przez inne aplikacje, jak i do wysyłania i odbierania danych przez port szeregowy komputera (RS-232). Program zapewnia różne drogi zapisywanie danych do pliku lub wizualizacja ich na ekranie monitora.

Dzięki temu można współpracować z dowolnymi urządzeniami pracującymi po interfejsie RS-232 lub RS-485 (RS-422) z odpowiednim konwerterem. Będziesz obserwować wymianę danych między dowolną aplikacją Windows i urządzenia zewnętrzne podłączony do portu szeregowego. Może to być urządzenie pomiarowe, domowe radio lub inny komputer podłączony za pomocą kabla z-modem lub modemu zerowego.

Zaawansowany monitor portu szeregowego obsługuje pracę w pełnym dupleksie, co oznacza, że ​​można monitorować wymianę w obu kierunkach bez korzystania z innych programów i bez przerywania innych aplikacji. Wszystkie informacje przechodzące przez port szeregowy są wyświetlane na ekranie w specjalnym oknie i można je zapisać do pliku. Wszystkie wyświetlane parametry można zmieniać podczas pracy. Jednocześnie program obsługuje dwa tryby - automatyczny i ręczny, czyli można wysyłać dane, naciskając przycisk „Wyślij” lub zostaną one wysłane automatycznie w określonym odstępie czasu (od 10 do 10 000 ms).

Za pomocą dodatkowych modułów można nie tylko odbierać dane czy wysyłać polecenia, ale także emulować pracę niektórych określone urządzenia, a w trybie obserwatora (przechwytującego) - wystarczy monitorować wymianę danych między urządzeniem zewnętrznym podłączonym do portu szeregowego a niektórymi Aplikacja Windows. Wreszcie, Advanced Serial Port Monitor ma własny wbudowany język skryptowy, za pomocą którego można uruchamiać program z gotowymi opcjami i akcjami, a także wykonywać polecenia z modułów.

Komputerowe sterowanie portem równoległym (LPT)

Valery Kovtun ma kolejny przydatny program komunikacyjny - LPT 3D Hard Analyzer. Program jest graficznym analizatorem-oscyloskopem pamięci przeznaczonym do przechwytywania sygnałów cyfrowych i protokołów urządzeń podłączonych do portu równoległego komputera w systemie Windows 95/98/Me/NT/2000/XP.

LPT 3D Hard Analyzer działa przez port LPT i pozwala na analizę pięciu linii wejściowych (kanałów) i 12 kanałów wyjściowych (czyli sterowania sygnały cyfrowe z komputera) w trybie SPP lub manipulować czterema wyjściami i 14 Parametry wejściowe w trybie EPP. Tryb dwukierunkowego portu równoległego EPP jest dostępny na prawie wszystkich komputerach wydanych po 1993 roku. Czasami jednak nie jest on domyślnie włączony w BIOS-ie (należy to sprawdzić i, jeśli to możliwe, włączyć).

Pracując w trybie oscyloskopu program zapamiętuje wszystkie 17 wykresów (linii), głębokość (wyświetlana długość wykresu w czasie) jest ograniczona jedynie wolną pamięcią komputera (oraz biorąc pod uwagę plik stronicowania w OC Windows, będzie to kilkaset megabajtów). Istnieje również opcja automatycznego zapisywania każdego Nowa strona w formacie graficznym.

Analizator-oscyloskop LPT 3D Hard Analyzer buduje wykresy zmian danych w postaci dwuwymiarowej i trójwymiarowej, a także pokazuje dwa niezależne diagramy: oscyloskop 17-kanałowy (bit na kanał) oraz wykres rejestrów portów (wejście, wyjście, kontrola). Istnieje regulacja szybkości analizy i wyświetlana jest łączna liczba cykli dla całego okresu przebiegu wykresu. Istnieje również możliwość zaprogramowania ilości cykli z możliwością kopiowania wykresów do pamięci (głębokość kreślenia ograniczona jest jedynie dostępnymi Baran komputer). Program posiada narzędzia do oszczędzania zasobów systemowych podczas odczytu danych z szybkich urządzeń podłączonych do portu LPT i synchronizowanych z nim przez ten program (czyli może być używany na stosunkowo słabych komputerach). Po wyłączeniu trybu wyświetlania graficznego grafika kopiowana jest tylko do pamięci komputera - w efekcie szybkość działania programu wzrasta dziesięciokrotnie. Po zakończeniu analizy wykres jest oglądany w taki sam sposób, jak gdyby został przełączony do trybu wyświetlania graficznego. Przewijanie wykresów odbywa się płynnie i strona po stronie ( kliknij prawym przyciskiem myszy myszy). Istnieje elastyczne ustawienie szybkości i kroku przewijania, a także możliwość automatycznego skompresowania całego wykresu na jednej stronie. Migawki stanu wybranej strony wykresu można przechowywać w Formaty BMP i WMF (metaplik Windows) lub ustaw automatyczne zapisywanie do osobnego pliku dla każdej nowej strony. Do przeglądania pakiet posiada wbudowaną przeglądarkę plików graficznych.

Moduł kontroli portów oparty jest na kodzie rdzenia innego programu Valery'ego Kovtun'a - XP LPT, który wykorzystuje sterownik I/O LPT WDMIO.

Program XP LPT jest przeznaczony do sterowania portami równoległymi komputera z systemem Windows 9x/2000/XP i ma następujące funkcje:

  • wykonuje automatyczną rejestrację sterownika w systemie Windows XP jako administrator systemu;
  • wskazówki automatyczne sprawdzenie ustanowione porty;
  • dokonuje jednoczesnego odczytu danych, rejestrów kontrolnych i statusowych wybranego portu LPT;
  • wyświetla zawartość rejestrów jednocześnie w różnych formatach (dziesiętnym i szesnastkowym), co eliminuje konieczność przeliczania.

Ten program jest dostępny źródło, opis, a także przykłady tworzenia programów do sterowania urządzeniami zewnętrznymi poprzez port równoległy w oparciu o to rozwiązanie.

Jak już wspomnieliśmy, program działa poprzez sterownik wejścia-wyjścia LPT WDMIO i jest przeznaczony specjalnie do szkolenia i debugowania własnych programów do sterowania urządzeniami zewnętrznymi przez port równoległy w środowisku Windows.

Valery Kovtun stworzył również program PortControl, który służy do sterowania portem równoległym za pomocą 17-bitowego analizatora protokołu komunikacyjnego dla urządzeń korzystających z portu LPT komputera. Program jest napisany dla rodziny systemów operacyjnych Windows i posiada następujące cechy:

  • istnieją trzy niezależne kanały, za pomocą których można wprowadzić adres portu (rejestr), automatycznie odczytać dane z portu, zapisywać dane do portu w formacie dziesiętnym i szesnastkowym, a także wyświetlać dane w formatach bite, word i Dword;
  • wyświetlany jest stan każdego z 17 bitów portu LPT i sterowane są bity wyjściowe;
  • dostępnych dziewięć programowalnych banków portów/pamięci danych;
  • istnieje 17-kanałowy analizator-oscyloskop stanu logicznego każdego bitu z możliwością ustawienia szybkości analizy (w czasie), synchronizacja dowolnym z 17 bitów - wg. wysoki poziom(1) i niski (0), a także licznik przesyłanych danych dla każdego bitu i wiele innych funkcji ułatwiających sprawdzanie i dostrajanie urządzenia cyfrowe podłączony do komputera.

Program ten może być wykorzystywany zarówno jako cyfrowy oscyloskop wielokanałowy, jak i do sterowania urządzeniami zewnętrznymi za pośrednictwem komputera.

Programy do analizy i zarządzania portami mogą mieć różne zastosowania. Po pierwsze, można je wykorzystać do szczegółowe sprawdzenie i testowanie wydajności portu równoległego komputera, na przykład w celu sprawdzenia wydajności portu LPT i systemu jako całości za pomocą trybu Test out. Ponadto wygodnie jest obserwować wszystkie operacje w czasie za pomocą wbudowanego 17-kanałowego analizatora-oscyloskopu z możliwością elastycznego dostosowania do określonego rodzaju pomiaru.

Do analizy szybkich magistral cyfrowej transmisji danych podłączonych do komputera różnych urządzeń radioelektronicznych i mikroukładów zaleca się komputer o częstotliwości procesora co najmniej 300 MHz. Ale w przypadku urządzeń o niskiej prędkości więcej niż słabe komputery pod Kontrola systemu Windows 95.

Po drugie, programy analizujące mogą być używane do sterowania, analizowania, konfigurowania, opracowywania, testowania i naprawy cyfrowych elektronicznych obwodów radiowych ( poszczególne moduły, bloki, magistrale sterujące, protokoły sterowania syntezatorami częstotliwości, elementy sterujące wskaźniki cyfrowe, programiści ROM itp.), czyli tam, gdzie są powszechnie używane mikroukłady cyfrowe, które tworzą sygnały sterujące i jakoś na nie reagują.

Po trzecie, programy analizujące porty można po prostu wykorzystać do odczytu protokołów wymiany. A synchronizując magistralę danych i sygnały sterujące urządzeń do przechowywania informacji i identyfikacji, można nawet odczytywać sygnały serwisowe i/lub hasła dostępu zakodowane w sekwencjach zer i jedynek. Ogólnie rzecz biorąc, programy te mają na celu umożliwienie radioamatorowi, inżynierowi elektronikowi lub inżynierowi projektu. Wizualne studium protokołów działania radioelektronicznych urządzeń może być również przydatne przy opracowywaniu własnych oprogramowanie kontrolowane przez różne kontrolery.

Po czwarte, programy analizujące będą bardzo przydatne do naprawy sprzętu biurowego w taki czy inny sposób przy użyciu portu równoległego komputera - różnych drukarek, skanerów, kas fiskalnych i innych urządzeń.

Po piąte, wymienione programy przydadzą się początkującym programistom. Na przykład, jeśli zdecydujesz się napisać mały program aby sterować niektórymi urządzeniami zewnętrznymi przez port równoległy, bardzo wygodnie będzie wizualnie obserwować algorytm swojego programu w wielofunkcyjnym interfejsie PortControl. Dzięki temu będziesz w stanie wykryć i wyeliminować popełnione błędy na czas bez użycia urządzenia pomiarowe na wyjściu portu i bez ingerencji w obwody sterowanego urządzenia.

I wreszcie, dla portu równoległego, Valery Kovtun sugeruje: przydatny program PinRegistrator, przeznaczony do monitorowania i rejestrowania stanu logicznego bitów portu LPT. Program został napisany pod Windows 95/98/Me i automatycznie lub ręcznie rejestruje stan portu równoległego.

Sterowanie portem USB komputera

Wspomniana firma AGG Software posiada programy przeznaczone do analizy i monitorowania portów USB, magistral, kontrolerów i urządzeń. Na przykład Advanced USB Monitor (http://www.aggsoft.ru/usb-monitor/index.htm) umożliwia przechwytywanie, analizowanie, przeglądanie i przetwarzanie ruchu USB w celu wydajnego debugowania i testowania urządzeń USB. Obsługiwane są urządzenia spełniające wszystkie specyfikacje: UHCI- (stare Urządzenia USB 1.x urządzenia działające z prędkością do 1,5 Mb/s), OHCI- (urządzenia nowej generacji USB 1.x działające z prędkością do 12 Mb/s) i wreszcie urządzenia USB 2.0 EHCI (działające z prędkością do 480 Mb/s). Zaawansowany monitor USB umożliwia rozszerzenie zestawu narzędzi laboratoryjnych zarówno dla twórców urządzeń USB, jak i zaawansowanych użytkowników.

Zaawansowany monitor USB może wyświetlać przesyłane pakiety danych w czytelny sposób, dekodować deskryptory, wykrywać błędy pakietów i mierzyć wydajność urządzenia. Podczas przechwytywania pakiety danych mogą być wyświetlane w czasie rzeczywistym, co pozwala monitorować stan urządzeń. Pakiety danych są zapisywane w porządku chronologicznym i zawierają pełna informacja o adresach i punktach końcowych. To bardzo ułatwia identyfikację, filtrowanie i wyszukiwanie pakietów. Program zapewnia kilka poziomów szczegółowości podczas wyświetlania danych. Szybkie dekodowanie ruchu USB umożliwia pracę nawet z takimi szybkie urządzenia jak dyski USB lub aparaty USB. Ponadto przechwytywanie, monitorowanie i rejestrowanie przechwyconych danych odbywa się w czasie rzeczywistym. Zaawansowany monitor USB umożliwia przeglądanie ruchu w miarę jego występowania, jednocześnie dla szeregu urządzeń USB, z wieloma otwartymi oknami monitorowania w tym samym czasie.

Używanie sterownika jądra przechwytywania z obsługą WDM, WMI, Power Management i PNP pozwala osiągnąć pełną zgodność z system operacyjny i urządzenia USB dla maksymalnej wydajności.

Program daje również możliwość pomiaru wydajności dowolnego urządzenia USB. Zaawansowany monitor USB z łatwością nawiguje po topologii urządzeń USB i uzyskuje szczegółowe Specyfikacja o urządzeniach takich jak dyski USB (interfejsy, punkty końcowe, informacje z rejestru, informacje o klasach i nie tylko). Na koniec badania możesz otrzymać gotowy raport o podłączonych urządzeniach i ruchu USB, a na koniec badania wydrukować go na drukarce. Ponadto program posiada zaawansowane funkcje eksportu danych do Formaty PDF, XML lub Microsoft Word, co pozwala nie ograniczać procesu przetwarzania danych tylko do tego jednego programu.

Oscyloskopy USB (http://www.usb-osc.narod.ru/) działają na tej samej zasadzie, co opisane powyżej analizatory-oscyloskopy dla portu równoległego. Oscyloskop USB jest przeznaczony przede wszystkim dla radioamatorów, którzy z natury swojej pracy stają przed koniecznością analizowania sygnałów analogowych o niskiej częstotliwości, rejestrowania długotrwałych wolno zmieniających się procesów, a także badania sygnałów binarnych z różne urządzenia. Ponadto oscyloskop USB może być używany jako prosty dwukanałowy woltomierz do napięć w zakresie +/-20 V, licznik częstotliwości dla częstotliwości sygnału do 50 kHz lub sonda z alarmem dźwiękowym.

Tak więc oscyloskop USB zapewnia następujące tryby pracy:

  • oscyloskop dwukanałowy (pomiary znacznikowe, synchronizacja, pomiary napięcia i częstotliwości sygnału, filtrowanie itp.);
  • dwukanałowy analizator widma (pomiary znaczników, różne funkcje okien, filtrowanie itp.);
  • rejestrator dwukanałowy (pomiary znacznikowe, rejestracja sygnału przez kilkadziesiąt godzin itp.);
  • 8/16-kanałowy analizator stanów logicznych (pomiary znaczników, synchronizacja, pomijanie zadanej liczby impulsów, wyszukiwanie podanej kombinacji logicznej, dekodowanie interfejsów UART, SPI, I2C, 1-Wire itp.);
  • 8-kanałowy generator logiczny (ustawianie tablicy sygnałów lub bezpośrednie konstruowanie wykresów czasowych za pomocą myszki itp.).

Dodatkowo oscyloskop USB umożliwia zapisanie wyników wszystkich pomiarów w postaci rysunku wektorowego lub rastrowego w celu późniejszego importu do innych programów lub zapisania w pliku do późniejszej analizy. Wyniki wszystkich pomiarów można wydrukować, skopiować do schowka, a także ustawić zdarzenia i opatrzyć je komentarzem dźwiękowym. Można obliczyć różne filtry cyfrowe oraz przeprowadzić filtrowanie analogowe i wygładzanie taktowania oscyloskopu. Urządzenie umożliwia wyświetlanie statystyk dla wszystkich kanałów analizatora stanów logicznych i generatora.

Jednak oscyloskopy USB to już nie tylko programy, ale urządzenia wykonane w formie jednostek zewnętrznych z interfejsem USB i towarzyszące im usługodawcy. moduły oprogramowania. Oznacza to, że jest to cały uniwersalny kompleks pomiarowy, składający się z przystawki przełączającej i komputera. Nawiasem mówiąc, możesz zaktualizować oprogramowanie takiego urządzenia za pośrednictwem magistrali USB, co pozwala uzupełnić możliwości urządzenia o dowolne niestandardowe funkcje.

Takie urządzenia produkuje ukraińska firma Da-Labs (http://www.da-labs.com/) i Rosyjska firma„Trade-M” (http://motor-master.ru/index.htm/). Cena zestawu rosyjskiej firmy to 1850 rubli. z wyłączeniem dostawy.

Tak więc, uzbrojeni w niezbędne narzędzia, mamy teraz możliwość samodzielnego pisania programów sterujących dla różnych urządzeń zewnętrznych za pomocą dowolnych portów naszego komputera.

Programiści uwielbiają porty szeregowe za łatwość ich konserwacji i użytkowania.

I oczywiście pisanie do konsoli programu terminalowego jest w porządku, ale chcę mieć własną aplikację, która po naciśnięciu klawisza na ekranie wykonuje potrzebne akcje ;)

W tym artykule opiszę jak pracować z portem com w języku C++.

Rozwiązanie jest proste, ale z jakiegoś powodu nie znaleziono działającego przykładu. Dla sim zapisuję to tutaj.

Oczywiście możesz skorzystać z rozwiązań wieloplatformowych, takich jak QSerial - biblioteka w Qt, prawdopodobnie będę, ale w przyszłości. Teraz mówimy o „czystym” systemie Windows C++. Napiszemy do studio wizualne. Mam 2010, chociaż nie odgrywa to żadnej roli...

Utwórz nowy projekt konsoli Win32.

Dołącz pliki nagłówkowe:

#włączać #włączać używając standardowej przestrzeni nazw;

Deklarujemy obsługę portu com:

UCHWYT hSerial;

Robię to globalnie, więc nie muszę się martwić o wskaźniki podczas przekazywania go do funkcji.

int _tmain(int argc, _TCHAR* argv) (

Nie znoszę programowania w stylu Windows. Nazywali wszystko po swojemu i siedzą radując się ...

Teraz magia deklarowania ciągu znaków z nazwą portu. Rzecz w tym, że nie jest w stanie przekształcić samego char.

LPCTSTR nazwa_portu = L"COM1";

Praca z portami szeregowymi w systemie Windows działa jak z plikiem. Otwarcie pierwszego port COM do pisania/odczytu:

HSerial = ::CreateFile(sPortName,GENERIC_READ | GENERIC_WRITE,0,0,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0);

Sprawdzenie funkcjonalności:

If(hSerial==INVALID_HANDLE_VALUE) ( if(GetLastError()==ERROR_FILE_NOT_FOUND) ( cout<< "serial port does not exist.\n"; } cout << "some other error occurred.\n"; }

Teraz musisz skonfigurować parametry połączenia:

DCB dcbSerialParams = (0); dcbSerialParams.DCBlength=sizeof(dcbSerialParams); if (! GetCommState(hSerial, &dcbSerialParams)) ( cout<< "getting state error\n"; } dcbSerialParams.BaudRate=CBR_9600; dcbSerialParams.ByteSize=8; dcbSerialParams.StopBits=ONESTOPBIT; dcbSerialParams.Parity=NOPARITY; if(!SetCommState(hSerial, &dcbSerialParams)) { cout << "error setting serial port state\n"; }

Na msdn zaleca się najpierw uzyskać parametry, a następnie je zmienić. Ciągle się uczymy, więc robimy to, co prosiliśmy.

Teraz zadeklarujmy ciąg znaków, który przekażemy oraz niezbędne do tego zmienne:

Char data = "Witaj z C++"; // ciąg znaków do przekazania DWORD dwSize = sizeof(data); // rozmiar tego łańcucha DWORD dwBytesWritten; // tutaj będzie liczba faktycznie przesłanych bajtów

Wysyłanie ciągu. Przypomnę, że przykład jest najprostszy, więc nie robię żadnych specjalnych kontroli:

BOOL iRet = WriteFile(hSerial,data,dwSize,&dwBytesWritten,NULL);

Zdecydowałem się również wyświetlić rozmiar ciągu i liczbę bajtów wysłanych do kontroli:

Cout<< dwSize << " Bytes in string. " << dwBytesWritten << " Bytes sended. " << endl;

Na końcu programu wykonujemy nieskończoną pętlę odczytu danych:

While(1) ( ReadCOM(); ) zwraca 0; )

Teraz funkcja odczytu:

Void ReadCOM() ( DWORD iSize; char sReceivedChar; while (true) ( ​​ReadFile(hSerial, &sReceivedChar, 1, &iSize, 0); // uzyskaj 1 bajt, jeśli (iSize > 0) // wypisz cout, jeśli coś zostanie odebrane<< sReceivedChar; } }

To właściwie cały przykład.

O tym, jak pięknie reprezentować dane przesyłane przez Arduin do Seriala. Moim zdaniem chłopaki zaproponowali bardzo piękne rozwiązanie, które z jednej strony wygląda na dość proste, a z drugiej pozwala uzyskać doskonały wynik przy minimalnym wysiłku.

W komentarzach do artykułu żałowano, że takie rozwiązanie nie zadziała pod Firefoksem, a wyrażono pomysł, że „w oparciu o to można jeszcze napisać prosty serwer WWW z wyjściem html”. Ten pomysł mnie „zahaczył”, szybkie wyszukiwanie w google nie dało gotowego rozwiązania, a pomysł sam postanowiłem zrealizować. A oto, co z tego wyszło.

Ostrzeżenie! Proponowanego rozwiązania nie należy w żadnym wypadku uznać za kompletne. W przeciwieństwie do Projektora Seryjnego Amperki jest to koncepcja, demonstracja możliwego podejścia, działający prototyp i nic więcej.

Jakiś czas temu zrobiłem projekt, w którym wykorzystałem wbudowane akcelerometry w smartfonie z Androidem do sterowania serwami podłączonymi do Arduino. Następnie do tych celów wykorzystałem warstwę skryptową dla projektów Android (SL4A) oraz RemoteSensors. Okazuje się, że standardowa biblioteka Pythona zawiera pakiet BaseHTTPServer, za pomocą którego podniesienie usługi sieciowej w pythonie jest zadaniem w kilku linijkach kodu.

Nie było pod ręką żadnych czujników dla Arduino, więc jako źródła wyświetlanych informacji użyłem wewnętrznego termometru wbudowanego w Arduino Uno. O ile rozumiem, nie jest bardzo dokładny i wcale nie jest przeznaczony do pomiaru temperatury otoczenia, ale wystarczy do prototypowania.

Po krótkim googlowaniu oto szkic dla arduino:

// źródło: https://code.google.com/p/tinkerit/wiki/SecretThermometer długi readTemp() ( długi wynik; // Odczytaj czujnik temperatury względem odniesienia 1.1V ADMUX = _BV(REFS1) | _BV(REFS0) | _BV(MUX3); delay(2); // Czekaj, aż Vref rozliczy ADCSRA |= _BV(ADSC); // Konwertuj while (bit_is_set(ADCSRA,ADSC)); wynik = ADCL; wynik |= ADCH<<8; result = (result - 125) * 1075; return result; } void setup() { Serial.begin(115200); } int count = 0; void loop() { String s = String(count++, DEC) + ": " + String(readTemp(), DEC); Serial.println(s) delay(1000); }
Ten szkic otwiera port COM, ustawia go na 115200 bodów, a następnie zapisuje do niego bieżącą wartość wbudowanego termometru co sekundę. (Nie pytaj mnie w jakich jednostkach jest podana temperatura - dla opisywanego zadania nie ma to znaczenia). Ponieważ wartość nie zmienia się zbyt aktywnie, dla lepszej widoczności zmian danych, przed temperaturą wyświetlany jest numer linii.

Aby sprawdzić, czy serwer sieciowy poda tylko całe linie, a nie ich części, jak czyta z portu COM, linia
Serial.println(s)
został zastąpiony przez
for(int i=0; i< s.length(); i++){ Serial.print(s.charAt(i)); delay(200); } Serial.println("");
tych. utworzony ciąg nie jest wysyłany do portu szeregowego w całości, ale znak po znaku, z przerwami 200 ms.

Na początek napisano bardzo prosty prototyp serwera WWW (poniżej jest zdemontowany na części):
# -*- kodowanie: utf-8 -*- #-- na podstawie: https://raw.githubusercontent.com/Jonty/RemoteSensors/master/remoteSensors.py SERIAL_PORT_NAME = "COM6" SERIAL_PORT_SPEED = 115200 WEB_SERVER_PORT = 8000 czas importu , BaseHTTPServer, urlparse import serial ser = Brak def main(): global ser httpd = BaseHTTPServer.HTTPServer(("", WEB_SERVER_PORT), Handler) #-- obejście dla uzyskania adresu IP, pod którym obsługujące importowane gniazdo s = socket.socket( socket.AF_INET, socket.SOCK_DGRAM) s.connect(("google.co.uk", 80)) sData = s.getsockname() print "Udostępnianie w "%s:%s"" % (sData, WEB_SERVER_PORT) ser = serial.Serial(SERIAL_PORT_NAME, SERIAL_PORT_SPEED, timeout=0) httpd.serve_forever() class Handler(BaseHTTPServer.BaseHTTPRequestHandler): # Wyłącz rejestrowanie wyszukiwań DNS def address_string(self): return str(self.client_address) def do_GET(self): self.send_response(200) self.send_header("Typ treści", "application/x-javascript; charset=utf-8") self.end_headers() try: while True: new_serial_line = get_full_line_from_serial() jeśli new_serial_line nie jest Brak: self.wfile.write(new_serial_line) self.wfile.write("\n") self.wfile.flush() z wyjątkiem socket.error, e: print "Klient odłączony.\n" capture = "" def get_full_line_from_serial(): """ zwraca pełną linię z serialu lub Brak Używa zmiennych globalnych "ser" i "captured" """ global capture part = ser.readline() if part: capture += part parts = przechwycone.split("\n", 1); if len(parts) == 2: capture = części zwracają części zwracane Brak if __name__ == "__main__": main()
Podzielmy scenariusz kawałek po kawałku.

Ponieważ jest to prototyp, wszystkie główne parametry operacji (nazwa portu COM, jego szybkość, a także numer portu TCP, na którym będzie działał serwer WWW) są wskazane bezpośrednio w tekście źródłowym:
SERIAL_PORT_NAME="COM6" SERIAL_PORT_SPEED=115200 WEB_SERVER_PORT=8000
Oczywiście możesz zaaranżować odczytywanie tych parametrów z wiersza poleceń. Na przykład za pomocą modułu argparse odbywa się to bardzo szybko, prosto i elastycznie.

W takim przypadku użytkownicy systemu Windows muszą znaleźć w menedżerze urządzeń nazwę portu COM, do którego podłączony jest Arduin. U mnie był to „COM6”. Użytkownicy innych systemów operacyjnych muszą korzystać z narzędzi swojego systemu operacyjnego. Nie mam żadnego doświadczenia z MacOS i nie pracowałem też z portami COM w Linuksie, ale tam najprawdopodobniej będzie to coś w rodzaju "/dev/ttySn".

Dalej jest definicja zmiennej globalnej, do której będzie powiązana instancja klasy Serial, która w pythonie odpowiada za pracę z portem COM:
ser = Brak
W kolejce
httpd = BaseHTTPServer.HTTPServer(("", WEB_SERVER_PORT), Program obsługi)
tworzony jest serwer WWW, który będzie nasłuchiwał żądań na określonym porcie WEB_SERVER_PORT. A te żądania będą obsługiwane przez instancję klasy Handler, opisaną poniżej.

Poniższe wiersze to mały "hack", aby wyświetlić adres IP, na którym faktycznie działa działający serwer sieciowy:
#-- obejście w celu uzyskania adresu IP, pod którym obsługuje importowane gniazdo s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) s.connect(("google.co.uk", 80)) sData = s.getsockname() print "Udostępniam w "%s:%s"" % (sData, WEB_SERVER_PORT)
O ile rozumiem, nie ma innego sposobu na znalezienie tego adresu IP. A bez tej wiedzy, jak uzyskamy dostęp do naszego serwera z przeglądarki?

Dlatego musisz otworzyć gniazdo i połączyć się ze stroną Google, aby wydobyć informacje o własnym adresie IP z atrybutów tego gniazda.

Nieco niżej otwiera się port COM i faktycznie uruchamia się serwer WWW:
ser = serial.Serial(SERIAL_PORT_NAME, SERIAL_PORT_SPEED, timeout=0) httpd.serve_forever()
Po nim następuje opis klasy odpowiedzialnej za przetwarzanie żądań odebranych przez działający serwer WWW:
class Handler(BaseHTTPServer.BaseHTTPRequestHandler):
Jest to spadkobierca klasy wbudowanej w moduł BaseHTTPServer, w której wystarczy nadpisać tylko metodę do_GET

Ponieważ jest to wciąż prototyp, serwer będzie „zadowolony” z każdego żądania - niezależnie od tego, jaki URL zostanie od niego zażądany, przekaże klientowi wszystkie dane odczytane z portu COM. Dlatego w Handler.do_GET natychmiast odpowiada kodem sukcesu i niezbędnymi nagłówkami:
self.send_response(200) self.send_header("Typ treści", "aplikacja/x-javascript; charset=utf-8") self.end_headers()
po czym uruchamiana jest nieskończona pętla, w której następuje próba odczytania całej linii z portu COM i jeśli ta próba się powiodła, przesłania ją do klienta WWW:
while True: new_serial_line = get_full_line_from_serial() jeśli new_serial_line nie jest None: self.wfile.write(new_serial_line) self.wfile.write("\n") self.wfile.flush()
W projekcie, który był podstawą, ta nieskończona pętla została „zawinięta” na próbę… z wyjątkiem bloku, za pomocą którego miała ostrożnie poradzić sobie z przerwaniem połączenia. Być może w systemie Android (dla niego opracowano projekt bazowy) działa to dobrze, ale nie działało to dla mnie pod Windows XP - gdy połączenie zostało zerwane, wystąpił inny wyjątek, którego nigdy nie nauczyłem się przechwytywać. Ale na szczęście nie przeszkodziło to serwerowi sieciowemu w normalnej pracy i akceptowaniu następujących żądań.

Funkcja pobierania całego ciągu z portu COM działa na tej samej zasadzie, co twórcy Serial Projector:

  • istnieje jakiś globalny bufor, który przechowuje wszystko, co jest odczytywane z portu COM
  • za każdym razem, gdy funkcja jest wywoływana, próbuje coś odczytać z portu COM
  • jeśli jej się uda, to
    • dodaje to, co właśnie zostało odczytane, do określonego globalnego bufora
    • próbuje podzielić bufor globalny na co najwyżej dwie części za pomocą znaku końca linii
    • jeśli się powiedzie, zwraca pierwszą część do procedury wywołującej i używa drugiej części jako nowej wartości bufora globalnego
  • jeśli nie ma nowych danych w porcie COM lub nie znaleziono znaku końca wiersza, funkcja zwraca Brak:
capture = "" def get_full_line_from_serial(): """ zwraca pełną linię z serialu lub Brak Używa zmiennych globalnych "ser" i "captured" """ global capture part = ser.readline() if part: capture += part parts = przechwycone.split("\n", 1); if len(parts) == 2: capture = części zwracają części zwracane Brak
W rezultacie wyszło tak:

Widać, że w przeglądarce pojawiają się linie, które są odczytywane z portu COM. Nie rozumiem nic z frontendu internetowego: JavaScript, Ajax, CSS i DOM to dla mnie ciemny las. Ale wydaje mi się, że programistom tworzącym interfejsy internetowe powinno to wystarczyć, aby przekonwertować ten wynik w ten sam piękny obraz, który produkuje Amperka Serial Projector. Moim zdaniem zadaniem jest stworzenie skryptu javascript, który uzyskuje dostęp do serwera WWW, odczytuje z niego strumień i wyprowadza ostatnią odczytaną linię we właściwe miejsce na stronie.

Na wszelki wypadek postanowiłem zachować ostrożność i spróbować samemu dokonać pierwszego przybliżenia. Niezbyt głębokie wyszukiwanie w Google sugerowało, że w rzeczywistości przynajmniej do takich celów używano WebSockets lub Server-Sent Events. Znalazłem to, co wydawało mi się dobrym wykorzystaniem zdarzeń wysyłanych przez serwer i zdecydowałem się na użycie tej technologii.

Notatka! Nie wydaje się to być najlepszym rozwiązaniem, ponieważ ta technologia nie działała w Internet Explorerze 8, ani w przeglądarce wbudowanej w Androida 2.3.5. Ale działało to przynajmniej w Firefoksie 39.0, więc nie „kopałem” dalej.

Z punktu widzenia skryptu pythonowego zmiany w obszarze Zdarzenia wysłane przez serwer są zupełnie niewielkie:

  • konieczne jest zastąpienie rodzaju danych przekazanych klientowi:
    linia
    self.send_header("Typ treści", "aplikacja/x-javascript; charset=utf-8")
    zastąpione przez
    self.send_header("Typ treści", "tekst/strumień zdarzeń")
  • a także przed linią odczytaną z portu COM, wstaw prefiks "data:" i dodaj jeszcze jeden znak nowej linii:
    linie
    self.wfile.write(new_serial_line) self.wfile.write("\n")
    zastąpione przez
    self.wfile.write("data: " + nowa_linia_seryjna) self.wfile.write("\n\n")

Wszystko inne pewnie mogłoby pozostać bez zmian, ale…

Najpierw utworzyłem plik index.html o następującej zawartości:

nagłówek


Najciekawsza w nim jest linia
który tworzy miejsce do wyprowadzenia następnej linii z portu COM i skryptu javascript

który faktycznie odczytuje strumień z serwera WWW i wysyła odczytane informacje do określonej lokalizacji.

Zamierzałem otworzyć ten plik w przeglądarce, na przykład z dysku lub innego serwera WWW, ale to nie zadziałało: podczas otwierania strony z dysku skrypt javascript raz uzyskał dostęp do działającego serwera WWW Pythona i natychmiast się rozłączył. Nie rozumiałem, dlaczego tak się dzieje i zasugerowałem, że może to być jakiś rodzaj ochrony przeglądarki przed różnymi atakami. Pewnie nie podoba mu się, że sama strona jest otwierana z jednego źródła, a skrypt odczytuje dane z innego źródła.

Dlatego zdecydowano się zmienić serwer WWW Pythona tak, aby obsługiwał również tę stronę html. Wtedy okazałoby się, że zarówno strona, jak i strumień są odczytywane z tego samego źródła. Nie wiem, czy moje założenie o bezpieczeństwie okazało się słuszne, czy coś innego, ale przy tej implementacji wszystko działało tak, jak powinno.

Oczywiście wystarczy zmienić klasę obsługi żądań Handler:
class Handler(BaseHTTPServer.BaseHTTPRequestHandler): # Wyłącz rejestrowanie wyszukiwań DNS def address_string(self): return str(self.client_address) def do_GET(self): if self.path == "/" lub self.path == "/index .html": self.process_index() elif self.path == "/get_serial": self.process_get_serial() else: self.process_unknown() def process_index(self): self.send_response(200) self.send_header("Zawartość -type", "text/html; charset=utf-8") self.end_headers() self.wfile.write(open("index.html").read()) self.wfile.write("\n\ n") self.wfile.flush() def process_get_serial(self): self.send_response(200) self.send_header("Typ treści", "tekst/strumień zdarzeń") self.end_headers() try: while True: new_serial_line = get_full_line_from_serial() jeśli new_serial_line nie jest Brak: self.wfile.write("data: " + nowa_linia_serialowa) self.wfile.write("\n\n") self.wfile.flush() z wyjątkiem socket.error, e : print "Klient odłączony.\n" def process_unknown(self): self.send_response(404)
Ta opcja zakłada, że ​​serwer WWW odpowie tylko na dwa żądania: "/index.html" (podając kod HTML strony) i "/get_serial" (podając niekończący się strumień ciągów odczytywanych z portu COM). Na wszystkie inne prośby odpowiemy kodem 404.

Ponieważ index.html jest obsługiwany przez serwer WWW Pythona, można go nieco zmodyfikować, określając względny zamiast bezwzględnego adresu strumienia ciągu z portu COM:
strunowy
var source = new EventSource("http://192.168.1.207:8000/")
zastąpione przez
var source = new EventSource("/get_serial")
W rezultacie wyszło tak:

Tutaj postanowiłem się zatrzymać. Wydaje mi się, że piękne zaprojektowanie strony powinno być już dość proste. Ale nie jestem biegły w HTML czy CSS, więc niech zrobi to ktoś inny. Zobaczyłem swoje zadanie w pokazaniu, że stworzenie usługi internetowej, która wysyła dane z portu COM, wydaje się wcale nie jest trudne.

Powtarzam raz jeszcze: przedstawiony kod nie jest kompletnym rozwiązaniem, które można „wprowadzić do produkcji”. To tylko prototyp, który pokazuje fundamentalne podejście do rozwiązania problemu.

Nad czym jeszcze można pracować:

  • po pierwsze, odczytywanie danych z portu COM w skrypcie pythona odbywa się bardzo "niezdarnie" - w rzeczywistości trwa ciągłe odpytywanie "czy jest coś świeżego?". Takie podejście oczywiście ładuje procesor i jeden rdzeń w moim komputerze jest zajęty w 100%.
    Jako rozwiązanie można użyć odczytu blokującego z limitem czasu. W tym celu wystarczy podać niezerową wartość (w sekundach) jako limit czasu przy otwieraniu portu COM, na przykład:
    ser = serial.Serial(SERIAL_PORT_NAME, SERIAL_PORT_SPEED, timeout=0,03)
    Dodatkowo w opisie modułu pySerial znajdują się trzy przykłady tworzenia mostu: "TCP/IP - most szeregowy", "Single-port TCP/IP - serial bridge (RFC 2217)" oraz "Wieloportowy TCP /IP - most szeregowy (RFC 2217)" - możesz zobaczyć, jak profesjonaliści rozwiązują takie problemy.
  • po drugie, tylko jeden klient może odbierać dane. Dopóki strona nie zostanie zamknięta na pierwszym kliencie, nie możesz połączyć się z tym serwerem i uzyskać wartości na drugim komputerze. Z jednej strony to chyba prawda: jest tylko jeden port COM, a konsumentów jest kilku - który z nich powinien podać linię odczytu? Jeśli uważasz, że odpowiedź na to pytanie powinna brzmieć „wszyscy”, oto moje przemyślenia na ten temat. Wydaje mi się, że problemu nie da się rozwiązać tylko za pomocą „uczciwego” wielowątkowego serwera WWW (na przykład jakiegoś Tornado lub Flaska), który może obsługiwać żądania od kilku klientów WWW jednocześnie. Ponieważ nie można otworzyć portu COM z każdego wątku i z niego odczytać - w takim przypadku dane z portu COM trafią tylko do jednego wątku/procesu. Dlatego moim zdaniem konieczne jest rozbicie części serwerowej na dwie części:
    • serwer zmq współpracujący z portem COM, odczytuje z niego linie i wysyła je przez gniazdo PUB do wszystkich zainteresowanych odbiorców
    • serwer WWW python zamiast łączenia się z portem COM łączy się z serwerem zmq i odbiera z niego dane
    Jeśli nie znasz biblioteki ZMQ (ZeroMQ), możesz zamiast tego użyć zwykłych gniazd TCP / IP lub UDP, ale zdecydowanie polecam zapoznanie się z ZMQ, ponieważ ta biblioteka bardzo ułatwia rozwiązywanie takich problemów. Wydaje mi się, że przy pomocy ZMQ rozwiązanie zmieści się maksymalnie w 20 liniach. (Nie mogę się oprzeć pisaniu: nawet jeśli nie planujesz rozwiązać opisywanego zadania, ale Twoja praca jest związana z programowaniem wielowątkowym / wieloprocesowym z wymianą danych między wątkami / procesami, przyjrzyj się bliżej tej bibliotece - może o tym mówisz od tak dawna marzyłeś)
  • przepływ danych nadal jest jednokierunkowy - od portu COM do przeglądarki internetowej. Nie można jeszcze wysyłać danych z przeglądarki do Arduino. Wydaje mi się, że to zadanie również nie jest bardzo trudne i w przeciwieństwie do poprzedniego można je rozwiązać tylko
    • korzystanie z serwera wielowątkowego
    • dopracowanie metody Handler.do_GET tak, aby akceptowała żądania GET z parametrami i wysyłała wartości niektórych z nich na port COM
    Moim zdaniem, jeśli chcesz napisać pełnoprawny analog internetowego monitora portu szeregowego wbudowanego w Arduino IDE, nie jest to takie trudne. Osobiście dla siebie widzę trudność tylko w tworzeniu normalnego frontendu.
  • nie ma jeszcze możliwości ustawienia nazwy portu COM i parametrów jego działania przez przeglądarkę. Z jednej strony wydaje się to logiczne: skąd użytkownik po drugiej stronie naszej planety może wiedzieć, do którego portu COM i z jaką prędkością podłączone jest arduino? Ale serwer WWW Pythona działający na tym samym komputerze wie na pewno. Ale jeśli nadal pożądane jest umożliwienie użytkownikowi zmiany nazwy portu COM lub parametrów jego działania, to znowu można to łatwo rozwiązać, dopracowując metodę Handler.do_GET
  • Python jest wymagany do uruchomienia serwera. Na ogół nie jest to trudne, ale jeśli z jakiegoś powodu nie można tego zrobić lub nie chcesz, z pomocą może przyjść pyInstaller. Dzięki niemu skrypt Pythona można skompilować w jeden plik wykonywalny (w przypadku Windows - w .exe), który łatwo skopiować na komputer, do którego podłączone jest arduino.
    Być może najlepszym rozwiązaniem byłoby w tym przypadku użycie języka Go. O ile mi wiadomo, lepiej rozwiązuje problem tworzenia pliku do „dystrybucji”.
Podsumowując: może pojawić się pytanie: „czy nie łatwiej rozwiązać ten problem przez jakąś gotową chmurę?”. Dlaczego nie opublikować danych, które można odczytać z portu COM w chmurze, a klienci mają po prostu dostęp do odpowiedniej usługi w chmurze? Prawdopodobnie takie rozwiązanie również ma prawo istnieć, ale przed zastosowaniem takiego rozwiązania należy odpowiedzieć na następujące pytania:
  • Czy istnieją gotowe serwisy internetowe, które pozwalają mi publikować dane z potrzebną szybkością/częstotliwością? Czy są wśród nich darmowe, czy jesteś gotów zapłacić odpowiednie pieniądze?
  • czy jesteś gotowy na to, że w przypadku upadku chmury lub połączenia z nią zostaniesz bez danych
  • Nie przeszkadza Ci, że aby przenieść dane z jednego pomieszczenia do drugiego, dwukrotnie przepłyną ocean lub pół kontynentu?

Więc dotarliśmy do portu COM. Ale dzięki niemu wszystko nie jest tak proste, jak w przypadku LPT, a jego pełne wykorzystanie będzie wymagało znacznie więcej wysiłku. Głównym problemem jest jego główna zaleta - transfer danych w postaci szeregowej. Jeśli w LPT bajt danych jest przesyłany przez 8 linii, po jednym bicie, a stan każdej linii można łatwo sprawdzić, to w porcie COM bajty danych są przesyłane bit po bicie wzdłuż jednej linii (oczywiście w stosunku do masy ) i zobacz, co jest przesyłane z samych diod LED nie zadziała. W tym celu potrzebne jest specjalne urządzenie - konwerter strumienia danych szeregowych na równoległy, tzw. USART (uniwersalny synchroniczny/asynchroniczny nadajnik odbiorczy). Na przykład znajduje się w płycie głównej komputera wyposażonego w port COM, w każdym poważniejszym mikrokontrolerze.

Mam nadzieję, że nadal jesteś zniechęcony do opanowania portu COM. Nie wszystko jest takie ponure. Niektóre wyniki można uzyskać bez USART. Sformułujmy zadanie, które realizujemy na początkowym etapie pracy z portem COM:


"Chcę aby dioda była podłączona do komputera przez port COM. Uruchamiam program. Wykonuję jakąś akcję w tym programie, dioda się zapala, robię coś innego - dioda gaśnie."


Zadanie jest dość specyficzne (biorąc pod uwagę, że USART nie jest używany) i jest czysto „samodzielnie wykonane”, ale jest całkiem wykonalne i wykonalne. Zacznijmy go wdrażać.


1. Port COM

Ponownie bierzemy jednostkę systemową twojego komputera i patrzymy na tył. Zauważamy tam złącze 9-pinowe - to jest port COM. W rzeczywistości może ich być kilka (do 4). Mój komputer ma dwa porty COM (patrz zdjęcie).


2. Rozszerzenie portu COM


3. Sprzęt

Będziemy też musieli „majstrować” przy części sprzętowej, w tym sensie, że będzie to trudniejsze niż z pierwszym urządzeniem dla portu LPT. Faktem jest, że protokół RS-232, za pośrednictwem którego w porcie COM wymieniane są dane, ma nieco inny stosunek stanu logicznego - napięcia. Jeśli zwykle jest to logiczne 0 0 V, logiczne 1 +5 V, to w RS-232 stosunek ten jest następujący: logiczne 0 +12 V, logiczne 1 -12 V.

I na przykład po otrzymaniu -12 V nie jest od razu jasne, co zrobić z tym napięciem. Zwykle poziomy RS-232 są konwertowane na TTL (0,5 V). Najłatwiejszą opcją są diody Zenera. Ale proponuję zrobić ten konwerter na specjalnym mikroukładzie. Nazywa się MAX232.

Zobaczmy teraz, jakie sygnały z portu COM widzimy na diodach LED? W rzeczywistości w porcie COM znajduje się aż 6 niezależnych linii, którymi zainteresuje się twórca urządzeń interfejsowych. Dwa z nich nie są jeszcze dla nas dostępne - szeregowe linie danych. Ale pozostałe 4 mają za zadanie kontrolować i wskazywać proces przesyłania danych, a my będziemy mogli je „przenieść” do własnych potrzeb. Dwa z nich są przeznaczone do sterowania przez urządzenie zewnętrzne i na razie nie będziemy ich dotykać, ale teraz użyjemy dwóch pozostałych linii. Nazywają się:

  • RTS- Wniosek o przeniesienie. Linia interakcji wskazująca, że ​​komputer jest gotowy do odbioru danych.
  • DTR- Komputer jest gotowy. Linia interakcji, która wskazuje, że komputer jest włączony i gotowy do komunikacji.

Teraz trochę mijamy ich cel, a podłączone do nich diody LED albo zgasną, albo zapalą się, w zależności od działań w naszym własnym programie.

Zbierzmy więc schemat, który pozwoli nam przeprowadzić zamierzone działania.

A oto jego praktyczna realizacja. Myślę, że wybaczycie mi, że zrobiłem to w tak głupiej wersji płytki stykowej, bo nie chcę robić płytki do tak „wysoce wydajnego” układu.


4. Część oprogramowania

Tutaj wszystko jest szybsze. Stwórzmy aplikację Windows w Microsoft Visual C++ 6.0 opartą na MFC do zarządzania dwoma liniami komunikacyjnymi portu COM. Aby to zrobić, utwórz nowy projekt MFC i nadaj mu nazwę, na przykład TestCOM. Następnie wybierz opcję budowania na podstawie dialogu.

Daj wygląd okna dialogowego naszego programu, jak na ryc. poniżej, a mianowicie dodaj cztery przyciski, po dwa dla każdej z linii. Jeden z nich, odpowiednio, jest niezbędny, aby „spłacić” linię, drugi, aby „ustawić” ją na jeden.

Klasa CTestCOMDlg: public CDialog ( // Konstrukcja public: CTestCOMDlg(CWnd* pParent = NULL); // standardowy konstruktor HANDLE hFile;

Aby nasz program mógł zarządzać liniami portu COM należy go najpierw otworzyć. Napiszmy kod odpowiedzialny za otwarcie portu podczas ładowania programu.

HFile = CreateFile ("COM2", GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL); if(hFile==INVALID_HANDLE_VALUE) ( MessageBox("Nie udało się otworzyć portu!", "Błąd", MB_ICONERROR); ) else ( MessageBox("Port otwarty pomyślnie", "OK", MB_OK); )

Korzystanie ze standardowej funkcji Win API Utwórz plik() otwórz port COM COM2. Następnie sprawdzamy sukces otwarcia z wyjściem komunikatu informacyjnego. Tutaj trzeba zrobić ważną uwagę: COM2 jest w moim komputerze, a na twoim komputerze mógłbyś podłączyć go do innego portu COM. W związku z tym jego nazwę należy zmienić na używany port. Aby zobaczyć, które numery portów są obecne na twoim komputerze, możesz to zrobić: Start -> Ustawienia -> Panel sterowania -> System -> Sprzęt -> Menedżer urządzeń -> Porty (COM i LPT).

Wreszcie funkcja CTestCOMDlg::OnInitDialog() znajduje się w pliku TestCOMDlg.cpp, nasza klasa okna dialogowego powinna mieć postać:

BOOL CTestCOMDlg::OnInitDialog() ( CDialog::OnInitDialog(); // Dodaj pozycję menu "Informacje..." do menu systemowego. // IDM_ABOUTBOX musi znajdować się w zakresie poleceń systemowych. ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX); ASSERT(IDM_ABOUTBOX AppendMenu(MF_SEPARATOR); pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu); ) ) // Ustaw ikonę dla tego okna dialogowego. Framework robi to automatycznie // gdy główne okno aplikacji nie jest oknem dialogowym SetIcon(m_hIcon, TRUE); // Ustaw dużą ikonę SetIcon(m_hIcon, FALSE); // Ustaw małą ikonę // DO ZROBIENIA: Dodaj tutaj dodatkową inicjalizację hFile = CreateFile("COM2", GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0,NULL); if(hFile==INVALID_HANDLE_VALUE) ( MessageBox("Nie udało się otworzyć portu!", "Błąd", MB_ICONERROR); ) else ( MessageBox("Port otwarty pomyślnie", "Ok", MB_OK); ) return TRUE; // return TRUE, chyba że ustawisz fokus na kontrolkę )

Teraz dodajmy obsługę przycisków sterujących linii. Nadałem im odpowiednie nazwy: funkcja ustawiająca linię DTR na 1 to OnDTR1(), 0 to OnDTR0(). Dla linii RTS odpowiednio w podobny sposób. Przypomnę, że handler jest tworzony po dwukrotnym kliknięciu przycisku. W rezultacie te cztery funkcje powinny przybrać postać:

Void CTestCOMDlg::OnDTR1() ( // TODO: Dodaj tutaj kod obsługi powiadomień sterujących EscapeCommFunction(hFile, 6); ) void CTestCOMDlg::OnDTR0() ( // TODO: Dodaj tutaj swój kod obsługi powiadomień sterujących EscapeCommFunction(hFile, 5); ) void CTestCOMDlg::OnRTS1() ( // TODO: Dodaj tutaj kod obsługi powiadomień kontrolnych EscapeCommFunction(hFile, 4); ) void CTestCOMDlg::OnRTS0() ( // TODO: Dodaj tutaj swój kod obsługi powiadomień kontrolnych EscapeCommFunction(hFile, 3); )

Pozwólcie, że wyjaśnię trochę, jak działają. Jak widać, wewnątrz zawierają wywołanie tej samej funkcji Win API Funkcja EscapeComm() z dwiema opcjami. Pierwszy z nich to uchwyt (HANDLE) do otwartego portu, drugi to specjalny kod akcji odpowiadający wymaganemu stanowi linii.

Wszystko, kompiluj, uruchamiaj. Jeśli wszystko jest w porządku, powinieneś zobaczyć komunikat o pomyślnym otwarciu portu. Dalej, naciskając odpowiednie przyciski, mrugamy diodami podłączonymi do portu COM.

© Iwanow Dmitrij
grudzień 2006