• Elemezze a soros port tevékenységét

    A Serial Port Monitor képes csatlakozni egy COM-porthoz, még akkor is, ha azt valamelyik alkalmazás már megnyitotta, és azonnal elkezdheti figyelni. A felügyelt COM porton áthaladó összes adat megjelenik felügyeleti programunkban. Mivel minden valós időben rögzítésre kerül, azonnal észreveheti a problémákat. Az adatok összehasonlításához ugyanazon IRP-k szinkronizált kiválasztásának funkciója van különböző nézetekben.

    Ezenkívül az összes megfigyelési adatot átirányíthatja egy megadott fájlba, vagy átmásolhatja az összes rögzített adatot a vágólapra. A Serial Port Monitor lehetővé teszi az összes soros port bemeneti/kimeneti vezérlőkódjának (IOCTL) lehallgatását és rögzítését, valamint azok összes adatának és paraméterének figyelését. Bármely megfigyelési munkamenetet menthet, és ha szükséges, legközelebb betöltheti.

  • Több port figyelése ugyanazon a munkameneten belül

    A soros port monitor egyedülálló funkcionalitás több COM port egyidejű felügyelete. Mostantól adatokat gyűjthet arról, hogy az alkalmazások hogyan működnek együtt két vagy több porttal és párhuzamosan több eszközzel egy munkameneten belül. A fogadott és elküldött monitoring adatok a beérkezés sorrendjében külön naplóban kerülnek bemutatásra (rögzítésre), ami nagyban leegyszerűsíti az elemzést.

  • Különböző lehetőségek a fogadott adatok megtekintésére

    Egyszerre 4 módban tekintheti meg a megfigyelési adatokat: táblázat, sor, dump vagy terminál, amelyek mindegyike más-más módot kínál a rögzített soros adatok megjelenítésére. A Serial Port Monitor lehetővé teszi a megfigyelési szűrők kiválasztását, így időt takaríthat meg, és csak az érdeklődésre számot tartó eseményeket figyelheti. A beállításokban kiválaszthatja a megjelenítendő adatokat: bináris, ASCII, beállíthatja a portot. Bármely megjelenítési beállítás közvetlenül alkalmazható az aktuális megfigyelési folyamatban.

  • Emulálja az adatátvitelt soros eszközre

    Adatokat küldhet a címre különféle formátumok(karakterlánc, bináris, oktális, decimális, hexadecimális, vegyes) a felügyelt soros portra, mintha közvetlenül a vezérelt alkalmazás küldte volna őket a Soros Port Monitor Terminal Mode szolgáltatással. Ily módon figyelemmel kísérheti a vezérelt soros eszköz válaszát néhány speciális parancsra és adatra.

  • A Modbus adatprotokoll teljes támogatása (RTU és ASCII)

    Az új Serial Port Monitor szűrők segítségével képes lesz a Modbus adatok visszafejtésére és elemzésére. A program nemcsak az RS485/422/232-es eszközök közötti kapcsolat létrehozásában, hanem az átadott adatok hatékony elemzésében is segít.

  • Ismételje meg és hasonlítsa össze a megfigyelési munkameneteket

    A Serial Port Monitor egyedülálló lehetőséget biztosít egy munkamenet visszajátszására egy alkalmazásból a portra legjobb elemzés folyamatban lévő folyamatok. Megfigyelheti a soros port reakcióját ugyanazon adatok áthaladására, ezáltal növelve a monitorozás hatékonyságát. Lehetősége van több megfigyelési munkamenet összehasonlítására is, és automatikusan nyomon követheti a köztük lévő különbséget.

Ma számítógépes vírusok szó szerint elárasztották a világot, és szabadon barangolnak az interneten, így a portokról a legtöbb felhasználó gyakran a logikai portokra gondol, amelyeket a hálózati technológiákban, például a TCP / IP vagy az UDP kommunikációs csatornák szervezésére használnak, és elfelejtik a fizikai portokat. külső eszközök csatlakoztatásához. Azonban még a nyomtatók csatlakoztatására is egyre gyakrabban használnak egereket és billentyűzeteket nagy sebességű USB portokés egyre ritkábban - a jó öreg COM és LPT (soros és párhuzamos portok). Ez utóbbiak azonban a legmodernebb számítógépekben is elérhetőek, és talán eljött az idő, hogy más célra is használjuk őket (mondjuk egyik vagy másik speciális eszköz vezérlésére).

A számítógép és bizonyos eszközök közötti csere nyomon követéséhez portelemző programokra van szükség.

Természetesen kaphatók speciális eszközök (szondák) is az analóg és digitális jelek figyelésére (beleértve az USB, LPT és COM analizátorokat), azonban mint minden professzionális felszerelés elég drágák.

Számítógép soros port vezérlése (COM)

Az egyik soros port elemző programot Valery Kovtun írta (http://valery-us4leh.narod.ru/). Köszönöm a remek eszközt!

Az ingyenesen terjesztett program a Com Port Visual Control (http://valery-us4leh.narod.ru/ComVC.html) névre hallgat, és vizuális vezérlésre, adatcsere dokumentálására és az UART adó-vevőben zajló folyamatok tanulmányozására szolgál. a COM -portot használó alkalmazások működése során személyi számítógép. Ez a program ben működik Windows környezet 9x/Me/NT/2000/XP, és az UART chip összes regiszterének folyamatos megtekintését (monitorozását) végzi. A vezérlő 8x8-as formátumú (nyolc, nyolc bites regiszter), és minden egyes regiszternél önállóan megjeleníti: az aktuális állapotot (egyidejűleg decimális és hexadecimális formátumban), valamint a logikai állapotot. Ezenkívül a program képes értékeket írni a regiszterekbe (tizedes és hexadecimális formátumban is), és ennek megfelelően kezelni a logikai állapotot. Ezen kívül figyeli a regiszterek változásait és az UART chip adó-vevőjének parancsai szerint protokollt (LOG) tart fenn, valamint gépi kódok szintjén protokollt vezet a vett és továbbított adatokról. Munka végeztével a program megtekinti és elmenti a LOG fájlokat, és megkeresi a szükséges információkat.

A Com Port Visual Control beépített adó-vevővel rendelkezik standard beállítás port módok: adatbitek, stopbitek, sebesség, paritás, hibakezelés, szöveges adatok és modemparancsok fogadásának és továbbításának képessége, valamint az UART parancsok aktív állapotának felügyeletére szolgáló jelző (17 alapparancs támogatott). Ezen túlmenően a számítógép-portokat a regiszterek és állapotbitek egyidejű megjelenítésével figyelik, és protokollt tartanak fenn az alapregiszterben lévő adatok megváltoztatásához.

Az ilyen programok közé tartozik ingyenes segédprogram ComLite32 a Realtime Communications (RTCOMM, http://www.rtcomm.com/) cégtől, Windows 95-höz írt, és prémium fizetős verziója, a ComLab32 (http://www.rtcard.com/comlab32.html).

Ezek a programok hatékony valós idejű kommunikációelemzők, amelyek lehetővé teszik a COM-porton keresztüli adatcsere felfedezését, és annak megértését, hogyan működik egy adott eszköz, még akkor is, ha nincs hozzá dokumentáció. A program kényelmes és intuitív tiszta felület, amely megkönnyíti a központ monitorozását, az I / O portok kezelését és a részletes online dokumentáció biztosítását.

A ComLite32 és ComLab32 programok RS-232, RS-422, RS-485 és RTX485 portokkal működnek (az utolsó port csak olvasható), és lehetővé teszik a kommunikációt ezekkel a portokkal mindkét irányban. Rendszerkövetelmények A ComLite32 programok minimálisak: csak 8 MB RAM, 6 MB lemez területés legalább egy soros porttal működő eszköz (beleértve a laptop PCMCIA modemeket).

És végül szeretném megjegyezni az AGG Software (http://www.aggsoft.ru) Advanced Serial Port Monitor és Advanced Serial Data Logger programjait. Az Advanced Serial Data Logger feldolgozza az RS-232-n keresztül kapott adatokat, és továbbítja azokat Excel fájl, Access vagy más Windows-alkalmazás. A program lehetőséget biztosít bármely eszközről valós idejű adatgyűjtésre, valamint adatok fogadására és továbbítására az RS-232 interfészen, illetve az RS-485 interfészen keresztül, ha rendelkezésre áll hardveres átalakító. Az Advanced Serial Data Logger adatokat gyűjt a soros portról, a felhasználó igényeinek megfelelően feldolgozza, adatblokkokat von ki az általános adatfolyamból, majd az adatokat bármely Windows vagy DOS alkalmazásba továbbítja - az alkalmazás megfelelő billentyűinek megnyomásával ablak. Az adatok átvitele DDE-n (Dynamic Data Exchange), ODBC-n, OLE-n stb. Ez a megoldás automatizált adatgyűjtő rendszerekben vagy alközponti híváselemző rendszerekben használható.

Az Advanced Serial Data Logger kéréseket és parancsokat is tud küldeni soros porton keresztül az eszközöknek közvetlenül az ASCII (alapértelmezett) vagy MODBUS protokollon keresztül történő vezérléséhez. Így az Advanced Serial Data Logger program I/O szerverré válik. Ami a kezelést és a beállításokat illeti, nagyon egyszerűek és intuitívak. Az adatgyűjtéshez nincs szükség további programozásra.

Ezenkívül az Advanced Serial Data Logger szolgáltatásként működhet Windows NT/2000/XP/2003 alatt, amely a rendszerindításkor elindul, és adatokat ír a soros portról egy lemezen lévő fájlba vagy más megadott helyre még a felhasználó bejelentkezése előtt. a rendszerbe (és a felhasználói munkamenet vége után is tovább fog működni).

A program képes több példányt futtatni ugyanazon a számítógépen, így több portot lehet egyszerre naplózni.

Ami az Advanced Serial Port Monitor programot illeti, kezdő felhasználók és szakemberek számára egyaránt hasznos lehet.

Az Advanced Serial Port Monitor használható más alkalmazások adatátvitelének figyelésére, valamint adatok küldésére és fogadására a számítógép soros portján (RS-232) keresztül. A program biztosítja különböző módokon adatok fájlba mentése vagy megjelenítése a monitor képernyőjén.

Így minden olyan eszközzel dolgozhat, amely az RS-232 vagy RS-485 (RS-422) interfészen keresztül működik a megfelelő átalakítóval. Megfigyelheti az adatcserét bármely Windows-alkalmazás és külső eszközök csatlakozik a soros porthoz. Ez lehet egy mérőeszköz, vagy egy otthoni rádió, vagy egy másik számítógép, amely z-modem vagy nullmodemkábellel csatlakozik.

Az Advanced Serial Port Monitor támogatja a teljes duplex működést, azaz mindkét irányban figyelheti a cserét anélkül, hogy más programok használata és más alkalmazások megszakítása nélkül történik. A soros porton áthaladó összes információ egy speciális ablakban jelenik meg a képernyőn, és fájlba írható. Az összes megjelenített paraméter megváltoztatható működés közben. Ugyanakkor a program két módot támogat - automatikus és kézi, vagyis a "Küldés" gomb megnyomásával küldhet adatokat, vagy bizonyos időközönként (10 és 10 000 ms között) automatikusan elküldésre kerülnek.

További modulok segítségével nem csak adatokat fogadhat, vagy parancsokat küldhet, hanem egyesek munkáját emulálhatja is konkrét eszközök megfigyelő (elfogó) módban - csak figyelje az adatcserét a soros portra csatlakoztatott külső eszköz és néhány Windows alkalmazás. És végül az Advanced Serial Port Monitor saját beépített szkriptnyelvvel rendelkezik, amellyel előre beállított opciókkal és műveletekkel futtatható a program, valamint modulokból származó parancsok is végrehajthatók.

Számítógépes párhuzamos port vezérlés (LPT)

Valery Kovtunnak van egy másik hasznos kommunikációs programja - az LPT 3D Hard Analyzer. A program egy grafikus tárolóelemző-oszcilloszkóp, amelyet a számítógép párhuzamos portjához csatlakoztatott eszközök digitális jeleinek és protokolljainak rögzítésére terveztek Windows 95/98/Me/NT/2000/XP rendszerben.

Az LPT 3D Hard Analyzer az LPT porton keresztül működik, és lehetővé teszi öt bemeneti vonal (csatorna) és 12 kimeneti csatorna (azaz vezérlés) elemzését. digitális jelek számítógépről) SPP módban, vagy kezeljen négy kimenetet és 14 bemeneti paraméterek EPP módban. A kétirányú EPP párhuzamos port mód szinte minden 1993 után kiadott számítógépen elérhető. Néha azonban alapértelmezés szerint nincs engedélyezve a BIOS-ban (ezt ellenőrizni kell, és ha lehetséges, engedélyezni kell).

Oszcilloszkóp módban a program mind a 17 grafikont (vonalat) megjegyzi, a mélységet (a grafikon időben megjelenített hosszát) csak a számítógép szabad memóriája korlátozza (és figyelembe véve a lapozófájlt OC Windowsban, ez több száz megabájt lesz). Lehetőség van mindegyik automatikus mentésére is új oldal grafikus formátumban.

Analizátor-oszcilloszkóp LPT 3D Hard Analyzer kétdimenziós és háromdimenziós formában ábrázolja az adatok változásait, és két független diagramot is mutat: egy 17 csatornás oszcilloszkópot (csatornánként bit) és a portregiszterek grafikonját (bemenet, kimenet, vezérlés) . Az elemzés sebessége módosítható, és megjelenik a ciklusok teljes száma a grafikon előrehaladásának teljes időtartamára vonatkozóan. A ciklusok számát programozhatja a grafikonok memóriába másolásának lehetőségével is (a nyomtatási mélységet csak a rendelkezésre álló RAM számítógép). A program olyan eszközökkel rendelkezik, amelyek segítségével megtakaríthatja a rendszer erőforrásait, miközben az LPT portra csatlakoztatott és ezzel a programmal szinkronizált nagy sebességű eszközökről olvas adatokat (vagyis viszonylag gyenge számítógépeken használható). A grafikus megjelenítési mód kikapcsolásakor a grafika csak a számítógép memóriájába másolódik – ennek eredményeként a program sebessége tízszeresére nő. Az elemzés végén a grafikont ugyanúgy tekintjük meg, mintha grafikus megjelenítési módba kapcsolnánk. A grafikonok görgetése gördülékenyen és oldalanként történik ( Jobb klikk egerek). Rugalmasan beállíthatja a sebességet és a görgetési lépést, valamint lehetőség van a teljes diagram egy oldalon belüli automatikus tömörítésére. A kiválasztott grafikonoldal állapotáról pillanatfelvételek tárolhatók BMP formátumokés WMF (Windows metafile), vagy állítsa be az automatikus mentést külön fájlba minden új oldalhoz. A csomag megtekintéséhez beépített böngésző grafikus fájlokat tartalmaz.

A portvezérlő modul Valery Kovtun egy másik programjának - XP LPT - alapkódján alapul, amely az LPT WDMIO I/O illesztőprogramot használja.

Az XP LPT program a Windows 9x/2000/XP rendszerű számítógépek párhuzamos portjainak vezérlésére szolgál, és a következő funkciókkal rendelkezik:

  • rendszergazdaként végrehajtja az illesztőprogram automatikus regisztrációját a Windows XP rendszerben;
  • vezet automatikus ellenőrzés kiépített kikötők;
  • a kiválasztott LPT port adatainak, vezérlő- és állapotregisztereinek egyidejű kiolvasását végzi;
  • a regiszterek tartalmát egyszerre jeleníti meg különböző formátumokban (tizedes és hexadecimális), ami feleslegessé teszi az újraszámítást.

Ez a program elérhető forrás, leírása, valamint példák külső eszközök párhuzamos porton keresztül történő vezérlésére szolgáló programok létrehozására ezen megoldás alapján.

Mint már említettük, a program az LPT WDMIO I / O illesztőprogramon keresztül működik, és kifejezetten saját készítésű programok betanítására és hibakeresésére készült, külső eszközök párhuzamos porton keresztül történő vezérlésére Windows környezetben.

Valerij Kovtun létrehozta a PortControl programot is, amely a számítógép LPT portját használó eszközök kommunikációs protokolljának 17 bites elemzőjével párhuzamos port vezérlésére szolgál. A program a Windows operációs rendszer családhoz készült, és a következő funkciókkal rendelkezik:

  • három független csatorna használható a port címének megadására (regiszter), a portról automatikus adatolvasásra, a portra decimális és hexadecimális formátumban történő adatírásra, valamint a bites, word és Dword formátumú adatok megjelenítésére;
  • az LPT port mind a 17 bitjének állapota megjelenik, és a kimeneti bitek vezérlésre kerülnek;
  • kilenc programozható port/adat memóriabank áll rendelkezésre;
  • az egyes bitek logikai állapotának 17 csatornás elemző-oszcilloszkópja működik az elemzési sebesség beállításának lehetőségével (időben), szinkronizálás a 17 bit bármelyikével - a magas szint(1) és alacsony (0), valamint az egyes bitekhez továbbított adatok számlálója és sok más funkció az egyszerű ellenőrzés és hangolás érdekében digitális eszközök számítógéphez csatlakoztatva.

Ez a program digitális többcsatornás oszcilloszkópként és külső eszközök számítógépen keresztüli vezérlésére egyaránt használható.

A kikötőelemző és -kezelő programok rendelkezhetnek különféle alkalmazások. Először is meg lehet őket szokni részletes ellenőrzésés a számítógép párhuzamos portja teljesítményének tesztelése, például az LPT port és a rendszer egészének teljesítményének ellenőrzése a Kipróbálás mód használatával. Ezenkívül kényelmes az összes művelet időben történő megfigyelése a beépített 17 csatornás analizátor-oszcilloszkóp segítségével, amely rugalmas beállítási lehetőséggel rendelkezik egy bizonyos típusú méréshez.

A különféle rádióelektronikai eszközök és mikroáramkörök számítógépéhez csatlakoztatott nagy sebességű digitális adatátviteli buszok elemzéséhez legalább 300 MHz processzorfrekvenciájú számítógép javasolt. De a kis sebességű készülékeknél több mint gyenge számítógépek alatt Windows vezérlés 95.

Másodszor, az elemző programok használhatók digitális rádióelektronikai áramkörök vezérlésére, elemzésére, konfigurálására, fejlesztésére, tesztelésére és javítására. egyedi modulok, blokkok, vezérlőbuszok, frekvenciaszintetizátor vezérlőprotokollok, vezérlőelemek digitális indikátorok, ROM programozók stb.), vagyis ahol széles körben használják digitális mikroáramkörök, amelyek vezérlőjeleket képeznek és valahogy reagálnak rájuk.

Harmadszor, a portelemző programok egyszerűen használhatók a csereprotokollok olvasására. Az adatbusz és az információtároló és azonosító eszközök vezérlőjeleinek szinkronizálásával pedig akár nullák és egyesek sorozataiba kódolt szervizjelek és/vagy hozzáférési jelszavak is olvashatók. Általában ezek a programok a rádióamatőrök, elektronikai mérnökök vagy tervezőmérnökök számára készültek. A rádióelektronikai eszközök működési protokolljainak vizuális tanulmányozása a saját fejlesztése során is hasznos lehet szoftver különböző vezérlők vezérlik.

Negyedszer, az elemző programok nagyon hasznosak lesznek olyan irodai berendezések javításához, amelyek valamilyen módon használják a számítógép párhuzamos portját - különféle nyomtatók, szkennerek, pénztárgépek és egyéb eszközök.

Ötödször, a felsorolt ​​programok hasznosak lesznek a kezdő programozók számára. Például ha úgy döntesz, hogy írsz kis program bizonyos külső eszközök párhuzamos porton keresztül történő vezérléséhez nagyon kényelmes lesz, ha vizuálisan megfigyelheti programja algoritmusát a PortControl többfunkciós felületén. Ennek eredményeként időben felismerheti és kiküszöbölheti az elkövetett hibákat, használat nélkül mérőműszerek a port kimenetén és anélkül, hogy zavarná a vezérelt eszköz áramkörét.

És végül a párhuzamos porthoz Valerij Kovtun javasolja hasznos program PinRegistrator, amelyet az LPT port bitjeinek logikai állapotának figyelésére és regisztrálására terveztek. A program Windows 95/98/Me alatt készült, és automatikusan vagy manuálisan naplózza a párhuzamos port állapotát.

Számítógépes USB port vezérlés

A fent említett AGG Software cég USB portok, buszok, vezérlők és eszközök elemzésére és figyelésére tervezett programokkal rendelkezik. Például az Advanced USB Monitor (http://www.aggsoft.ru/usb-monitor/index.htm) lehetővé teszi az USB-forgalom rögzítését, elemzését, megtekintését és feldolgozását az USB-eszközök hatékony hibakeresése és tesztelése érdekében. Az összes specifikációnak megfelelő eszközök támogatottak: UHCI- (old USB-eszközök 1,5 Mbps-ig működő 1.x eszközök, OHCI- (legfeljebb 12 Mbps sebességgel működő következő generációs USB 1.x eszközök) és végül USB 2.0 EHCI eszközök (480 Mbps-ig üzemelnek). Az Advanced USB Monitor lehetővé teszi a laboratóriumi eszközkészlet bővítését mind az USB-eszközök fejlesztői, mind a haladó felhasználók számára.

A fejlett USB-monitor képes olvasható módon megjeleníteni a továbbított adatcsomagokat, dekódolni a leírókat, észlelni a csomaghibákat, és mérni tudja az eszköz teljesítményét. A rögzítés során az adatcsomagok valós időben jeleníthetők meg, lehetővé téve az eszközök állapotának nyomon követését. Az adatcsomagok időrendi sorrendben kerülnek mentésre és tartalmazzák teljes körű információ címekről és végpontokról. Ez nagyon egyszerűvé teszi a csomagok azonosítását, szűrését és keresését. A program több szintű részletességet biztosít az adatok megjelenítése során. Az USB-forgalom gyors dekódolása lehetővé teszi az ilyenekkel való munkát is nagy sebességű készülékek mint az USB-meghajtók vagy az USB-kamerák. Ezenkívül a rögzített adatok rögzítése, monitorozása és rögzítése valós időben történik. Az Advanced USB Monitor segítségével megtekintheti a forgalmat, ahogyan az előfordul, és egyidejűleg számos USB-eszköz esetében, egyszerre több megfigyelési ablakkal.

A WDM, WMI, Power Management és PNP támogatásával rendelkező rögzítő kernel illesztőprogram használatával teljes kompatibilitást érhet el operációs rendszerés USB-eszközök a maximális teljesítmény érdekében.

A program lehetővé teszi bármely USB-eszköz teljesítményének mérését is. A fejlett USB-monitor könnyedén navigál az USB-eszközök topológiájában, és részletes információkat kap technikai információ olyan eszközökről, mint például az USB-meghajtók (interfészek, végpontok, regisztrációs adatok, osztályinformációk és egyebek). A tanulmány végén kész jelentést kaphat a csatlakoztatott eszközökről és az USB forgalomról, majd a tanulmány végén kinyomtathatja nyomtatón. Ezenkívül a program fejlett funkciókkal rendelkezik az adatok exportálásához PDF formátumok, XML ill Microsoft Word, amely lehetővé teszi, hogy az adatok utófeldolgozási folyamatát ne korlátozzuk csak erre az egy programra.

Az USB oszcilloszkópok (http://www.usb-osc.narod.ru/) ugyanazon az elven működnek, mint a párhuzamos porthoz fent leírt analizátorok-oszcilloszkópok. Az USB oszcilloszkóp elsősorban rádióamatőrök számára készült, akik munkájuk természeténél fogva szembesülnek azzal az igénysel, hogy alacsony frekvenciájú analóg jeleket elemezzenek, hosszú távon lassan változó folyamatokat regisztráljanak, és bináris jeleket is vizsgáljanak. különféle eszközök. Ezenkívül az USB oszcilloszkóp használható egyszerű kétcsatornás voltmérőként a +/-20 V tartományba eső feszültségekhez, frekvenciaszámlálóként 50 kHz-ig terjedő jelfrekvenciákhoz, vagy hangjelzéssel rendelkező szondaként.

Tehát az USB oszcilloszkóp a következő működési módokat biztosítja:

  • kétcsatornás oszcilloszkóp (markermérés, szinkronizálás, jelfeszültség és frekvencia mérés, szűrés stb.);
  • kétcsatornás spektrumanalizátor (markermérés, különféle ablakfunkciók, szűrés stb.);
  • kétcsatornás rögzítő (marker mérések, több tíz órás jelrögzítés stb.);
  • 8/16 csatornás logikai elemző (marker mérések, szinkronizálás, adott számú impulzus kihagyása, adott logikai kombináció keresése, interfészek dekódolása UART, SPI, I2C, 1-Wire stb.);
  • 8 csatornás logikai generátor (jeltáblázat beállítása vagy időzítési diagramok közvetlen készítése egérrel stb.).

Ezenkívül az USB oszcilloszkóp lehetővé teszi az összes mérés eredményének vektor vagy raszteres rajz formájában történő elmentését, hogy később más programokba importálhassa, vagy fájlba mentse későbbi elemzés céljából. Valamennyi mérés eredménye kinyomtatható, vágólapra másolható, események beállíthatók és hangos kommentárral kísérhetők. Különféle digitális szűrők számíthatók, valamint analóg szűrés és oszcilloszkópos időzítési simítás végezhető. A készülék lehetővé teszi a logikai elemző és generátor összes csatornájának statisztikáinak megjelenítését.

Az USB oszcilloszkópok azonban már nem csak programok, hanem külső, USB interfésszel ellátott egységek formájában, szolgáltatók kíséretében készült eszközök. szoftver modulok. Vagyis egy egész univerzális mérőkomplexum, amely egy kapcsolócsatolásból és egy számítógépből áll. Egy ilyen eszköz firmware-jét egyébként USB buszon keresztül frissítheti, ami lehetővé teszi az eszköz képességeinek kiegészítését bármilyen egyedi funkcióval.

Az ilyen eszközöket az ukrán Da-Labs cég gyártja (http://www.da-labs.com/), ill. orosz cég"Trade-M" (http://motor-master.ru/index.htm/). Egy orosz cég készletének ára 1850 rubel. szállítást kivéve.

Így a szükséges eszközökkel felvértezve most lehetőségünk van önállóan vezérlőprogramokat írni különféle külső eszközökhöz számítógépünk bármely portjáról.

A soros portokat a könnyű karbantartás és használat miatt szeretik a fejlesztők.

És persze a terminálprogram konzoljára írni minden jó, de szeretnék egy saját alkalmazást, ami a képernyőn egy billentyű megnyomásával elvégzi a szükséges műveleteket;)

Ebben a cikkben leírom hogyan kell dolgozni a com porttal C++ nyelven.

A megoldás egyszerű, de valamiért nem találtak azonnal működő példát. Sim-hez ide mentem.

Természetesen használhatsz platformközi megoldásokat, mint például a QSerial – egy Qt-beli könyvtár, valószínűleg fogom, de a jövőben. Most a "tiszta" Windowsról beszélünk C++. Írni fogunk vizuális Stúdió. Nekem 2010 van, bár ez nem játszik szerepet...

Hozzon létre egy új konzol Win32 projektet.

Fejlécfájlok hozzáadása:

#beleértve #beleértve névtér használata std;

Egy com port kezelőt deklarálunk:

HANDLE hSerial;

Globálisan csinálom, így nem kell aggódnom a mutatók miatt, amikor függvényeknek adom át.

int _tmain(int argc, _TCHAR* argv) (

Nem bírom a Windows programozási stílust. Mindent a maguk módján hívtak, és ujjongva ülnek ...

Most egy karakterlánc deklarálása a port nevével. Az a baj, hogy magát a chart nem tudja átalakítani.

LPCTSTR sPortName = L"COM1";

A soros portokkal való munka a Windows rendszerben úgy működik, mint egy fájl esetében. Az első megnyitása com port az íráshoz/olvasáshoz:

HSerial = ::Fájl létrehozása(sPortName,ÁLTALÁNOS_OLVASHATÓ | ÁLTALÁNOS_ÍRÁS,0,0,NYITOTT_MEGÉSZÍTŐ,FÁJL_ATTRIBUTE_NORMAL,0);

A funkcionalitás ellenőrzése:

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

Most be kell állítania a csatlakozási paramétereket:

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"; }

Az msdn-en tanácsos először beszerezni a paramétereket, majd módosítani. Még tanulunk, úgyhogy a kérésnek megfelelően csináljuk.

Most deklaráljuk az átadandó karakterláncot és az ehhez szükséges változókat:

Char data = "Üdvözöljük a C++-ból"; // karakterlánc a duplaszó átadásához dwSize = sizeof(data); // ennek a karakterláncnak a mérete DWORD dwBytesWritten; // itt lesz a ténylegesen átvitt bájtok száma

Karakterlánc küldése. Hadd emlékeztesselek arra, hogy a példa a legegyszerűbb, ezért nem teszek különösebb ellenőrzést:

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

Úgy döntöttem, hogy megjelenítem a karakterlánc méretét és a vezérléshez küldött bájtok számát:

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

A program végén végtelen hurkot készítünk az olvasási adatokból:

While(1) ( ReadCOM(); ) return 0; )

Most az olvasási funkció:

Void ReadCOM() ( DWORD iSize; char sReceivedChar; while (true) (ReadFile(hSerial, &sReceivedChar, 1, &iSize, 0); // kap 1 bájtot, ha (iSize > 0) // nyomtat, ha valami érkezik<< sReceivedChar; } }

Valójában ez az egész példa.

Arról, hogyan lehet szépen ábrázolni az Arduin által a Serial-nak küldött adatokat. Véleményem szerint a srácok egy nagyon szép megoldást kínáltak, ami egyrészt meglehetősen egyszerűnek tűnik, másrészt lehetővé teszi, hogy minimális erőfeszítéssel kiváló eredményt érjen el.

A cikkhez fűzött kommentekben sajnálkoztak, hogy Firefox alatt nem működne egy ilyen megoldás, és megfogalmazódott az ötlet, hogy "e dolog alapján még lehet egyszerű webszervert írni html kimenettel". Ez az ötlet „megragadott”, a google gyors keresése nem adott kész megoldást, és úgy döntöttem, magam valósítom meg az ötletet. És íme, mi sült ki belőle.

Figyelem! A javasolt megoldás semmiképpen sem tekinthető teljesnek. Az Amperka soros kivetítőjével ellentétben ez egy koncepció, egy lehetséges megközelítés bemutatása, egy működő prototípus és semmi több.

Nemrég csináltam egy projektet, amelyben egy Android okostelefon beépített gyorsulásmérőit használtam az Arduinohoz csatlakoztatott szervók vezérlésére. Aztán ezekre a célokra a Scripting Layer for Android (SL4A) és a RemoteSensors projekteket használtam. Kiderült, hogy a python szabványos könyvtára tartalmazza a BaseHTTPServer csomagot, amellyel egy webszolgáltatás pythonban történő létrehozása néhány kódsoros feladat.

Nem voltak kéznél szenzorok az Arduino számára, így az Arduino Uno-ba épített belső hőmérőt használtam a megjelenített információk forrásaként. Amennyire én értem, nem túl pontos, és egyáltalán nem a környezeti hőmérséklet mérésére szolgál, de prototípuskészítéshez megteszi.

Rövid guglizás után álljon itt egy vázlat egy arduinóhoz:

// forrás: https://code.google.com/p/tinkerit/wiki/SecretThermometer long readTemp() ( hosszú eredmény; // Hőmérséklet-érzékelő olvasása 1,1 V-os referencia ADMUX = _BV(REFS1) | _BV(REFS0) | _BV(MUX3); delay(2); // Várja meg, amíg a Vref rendezi az ADCSRA-t |= _BV(ADSC); // Konvertálás while (bit_is_set(ADCSRA,ADSC)); eredmény = ADCL; eredmény |= 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); }
Ez a vázlat megnyit egy COM portot, 115200 baudra állítja, majd másodpercenként kiírja rá a beépített hőmérő aktuális értékét. (Ne kérdezzétek milyen mértékegységben adják meg a hőmérsékletet - a leírt feladatnál ez nem fontos). Mivel az érték nem változik túl aktívan, az adatváltozások jobb láthatósága érdekében a sorszám a hőmérséklet előtt jelenik meg.

Annak ellenőrzésére, hogy a webszerver csak egész sorokat ad-e ki, és nem részeit, ahogyan a COM portról olvassa, a sort
Serial.println(s)
váltotta fel
for(int i=0; i< s.length(); i++){ Serial.print(s.charAt(i)); delay(200); } Serial.println("");
azok. a kialakított string nem teljes egészében kerül ki a soros portra, hanem karakterenként, 200 ms-os szünetekkel.

Először is megírták egy webszerver nagyon egyszerű prototípusát (alább részenként szétszerelve):
# -*- kódolás: utf-8 -*- #-- a következő alapján: https://raw.githubusercontent.com/Jonty/RemoteSensors/master/remoteSensors.py SERIAL_PORT_NAME = "COM6" SERIAL_PORT_SPEED = 115200 = 115200 WEB_SER00_0 import idő = WEB_SER00_0 , BaseHTTPServer, urlparse import serial ser = Nincs def main(): global ser httpd = BaseHTTPServer.HTTPServer(("", WEB_SERVER_PORT), Handler) #--megkerülő megoldás az IP-cím megszerzésére, amelyen a kiszolgáló import socket s = socket.socket( socket.AF_INET, socket.SOCK_DGRAM) s.connect(("google.co.uk", 80)) sData = s.getsockname() print "Kiszolgálás itt: "%s:%s"" % (sData, WEB_SERVER_PORT) ser = serial.Serial(SERIAL_PORT_NAME, SERIAL_PORT_SPEED, timeout=0) httpd.serve_forever() class Handler(BaseHTTPServer.BaseHTTPRequestHandler): # DNS-keresések naplózásának letiltása def address_string(self): return str(self.client_Gdress) deself do_Gdress self.send_response(200) self.send_header("Content-type", "application/x-javascript; charset=utf-8") self.end_headers() try: while True: new_serial_line = get_full_line_from_serial() ha nem az új_soros_sor Nincs: self.wfile.write(new_serial_line) self.wfile.write("\n") self.wfile.flush() kivéve a socket.error-t, e: print "Client disconnected.\n" captured = "" def get_full_line_from_serial(): """ teljes sort ad vissza a sorosból captured.split("\n", 1); if len(parts) == 2: captured = részek return parts return None if __name__ == "__main__": main()
Bontsuk darabonként a forgatókönyvet.

Mivel ez egy prototípus, az összes fő működési paraméter (a COM-port neve, sebessége, valamint a TCP-port száma, amelyen a webszerver futni fog) közvetlenül a forrásszövegben szerepel:
SERIAL_PORT_NAME="COM6" SERIAL_PORT_SPEED=115200 WEB_SERVER_PORT=8000
Természetesen ezeket a paramétereket a parancssorból is beolvashatja. Például az argparse modul segítségével ez nagyon gyorsan, egyszerűen és rugalmasan történik.

Ebben az esetben a Windows-felhasználóknak meg kell találniuk az eszközkezelőben annak a COM-portnak a nevét, amelyhez az Arduin csatlakozik. Nekem "COM6" volt. Más operációs rendszerek felhasználóinak az operációs rendszerük eszközeit kell használniuk. Egyáltalán nincs tapasztalatom MacOS-szal, és nem dolgoztam COM-portokkal Linuxon sem, de ott nagy valószínűséggel valami olyasmi lesz, mint a "/dev/ttySn".

Következik egy globális változó meghatározása, amelyhez a Serial osztály egy példánya, amely a pythonban a COM-porttal való együttműködésért felelős, hozzá lesz kötve:
ser = Nincs
Sorban
httpd = BaseHTTPServer.HTTPServer(("", WEB_SZERVER_PORT), Kezelő)
létrejön egy webszerver, amely figyeli a kéréseket a megadott WEB_SERVER_PORT porton. És ezeket a kéréseket a Handler osztály egy példánya fogja kezelni, amelyet alább ismertetünk.

A következő sorok egy kis "hack" annak az IP-címnek a megjelenítéséhez, amelyen a futó webszerver ténylegesen fut:
#-- Megkerülő megoldás az IP-cím megszerzéséhez, amelyen a kiszolgáló import socket s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) s.connect(("google.co.uk", 80)) sData = s.getsockname() print "Kiszolgálás itt: "%s:%s"" % (sData, WEB_SERVER_PORT)
Ha jól értem, nincs más mód ennek az IP-nek a kiderítésére. És ennek ismerete nélkül hogyan fogjuk elérni a szerverünket a böngészőből?

Ezért meg kell nyitnia egy socketet, és csatlakoznia kell a Google webhelyéhez, hogy saját IP-címére vonatkozó információkat nyerjen ki ennek a socketnek az attribútumaiból.

Kicsit lejjebb megnyílik a COM port, és ténylegesen elindul a webszerver:
ser = serial.Serial(SERIAL_PORT_NAME, SERIAL_PORT_SPEED, timeout=0) httpd.serve_forever()
Ezt követi annak az osztálynak a leírása, amely a futó webszerver által kapott kérések feldolgozásáért felelős:
osztálykezelő (BaseHTTPServer.BaseHTTPRequestHandler):
Ez a BaseHTTPServer modulba épített osztály örököse, amelyben elég csak a do_GET metódus felülírása

Mivel ez még egy prototípus, a szerver „örül” minden kérésnek – függetlenül attól, hogy milyen URL-t kérnek tőle, a COM portról beolvasott összes adatot átadja a kliensnek. Ezért a Handler.do_GET-ben azonnal válaszol egy sikerkóddal és a szükséges fejlécekkel:
self.send_response(200) self.send_header("Content-type", "application/x-javascript; charset=utf-8") self.end_headers()
ezután elindul egy végtelen ciklus, amelyben egy egész sort próbálnak kiolvasni a COM portról, és ha ez a próbálkozás sikeres volt, akkor átviszik a webkliensre:
while True: new_serial_line = get_full_line_from_serial() if new_serial_line nem None: self.wfile.write(new_serial_line) self.wfile.write("\n") self.wfile.flush()
Az alapul vett projektben ezt a végtelen hurkot egy try ... blokkba „tekerték” be, aminek segítségével a kapcsolatszakadást óvatosan kellett volna kezelni. Talán Androidban (az alapprojektet erre fejlesztették ki) ez jól működik, de nekem nem jött be Windows XP alatt - amikor a kapcsolat megszakadt, más kivétel történt, amit soha nem tanultam meg lehallgatni. De szerencsére ez nem akadályozta meg a webszerver normális működését és a következő kérések elfogadását.

A teljes karakterlánc COM-portról való lekérése ugyanazon az elven működik, mint a Serial Projector megalkotói:

  • van valami globális puffer, ami mindent eltárol, amit a COM portról olvas
  • minden alkalommal, amikor a függvény meghívásra kerül, megpróbál olvasni valamit a COM portról
  • ha sikerül neki, akkor
    • az éppen olvasottakat hozzáadja a megadott globális pufferhez
    • megpróbálja a globális puffert legfeljebb két részre osztani a sorvégi karakterrel
    • ha ez sikerül, akkor az első részt visszaadja a hívó eljárásnak, és a második részt használja a globális puffer új értékeként
  • ha nincs új adat a COM-porton, vagy nem található a sorvégi karakter, akkor a függvény a None-t adja vissza:
captured = "" def get_full_line_from_serial(): """ teljes sort ad vissza sorosból captured.split("\n", 1); if len(parts) == 2: rögzítve = részek visszaadják a részeket. Nincs
Ennek eredményeként a következőképpen alakult:

Látható, hogy a böngészőben olyan sorok jelennek meg, amelyeket a COM portról olvas be. Nem értek semmit a webes frontendhez: a JavaScript, az Ajax, a CSS és a DOM sötét erdő számomra. De nekem úgy tűnik, hogy a webes felületeket létrehozó programozók számára ennek elégnek kell lennie ahhoz, hogy ezt a kimenetet ugyanolyan gyönyörű képpé alakítsák, mint az Amperka soros kivetítője. Véleményem szerint a feladat egy javascript szkript létrehozása, amely eléri a webszervert, beolvas belőle egy streamet, és az utolsó beolvasott sort a megfelelő helyre írja ki a weboldalon.

Minden esetre úgy döntöttem, hogy eljátszom, és megpróbáltam egyedül elkészíteni az első közelítést. A nem túl mély Google-keresés azt sugallta, hogy valójában ilyen célokra legalábbis a WebSockets vagy a Server-Sent Events alkalmazást használták. Megtaláltam azt, ami számomra jónak tűnt a kiszolgáló által küldött eseményeknek, és úgy döntöttem, hogy ezt a technológiát használom.

Jegyzet! Ez nem tűnik a legjobb megoldásnak, mert ez a technológia sem az Internet Explorer 8-ban, sem az Android 2.3.5-be épített böngészőben nem működött. De legalább Firefox 39.0-ban működött, így nem "ástam" tovább.

A python szkript szempontjából a Szerver által küldött események alatti változtatások teljesen csekélyek:

  • az ügyfélnek adott adattípus cseréje szükséges:
    vonal
    self.send_header("Content-type", "application/x-javascript; charset=utf-8")
    kicserélve
    self.send_header("Tartalomtípus", "Szöveg/eseményfolyam")
  • és a COM portról beolvasott sor elé is illessze be a "data:" előtagot, és adjon hozzá még egy újsor karaktert:
    vonalak
    self.wfile.write(új_soros_sor) self.wfile.write("\n")
    kicserélve
    self.wfile.write("data: " + new_serial_line) self.wfile.write("\n\n")

Minden más valószínűleg változatlan maradhat, de...

Először létrehoztam egy index.html fájlt a következő tartalommal:

fejléc


A legérdekesebb benne a vonal
amely helyet ad a következő sor kimenetének a COM-portról, és egy javascript szkriptet

amely ténylegesen beolvassa a webszerverről érkező adatfolyamot és az olvasott információt a megadott helyre adja ki.

Ezt a fájlt egy böngészőben szándékoztam megnyitni, például lemezről vagy más webszerverről, de ez nem működött: amikor lemezről megnyit egy oldalt, a javascript szkript egyszer hozzáfért a futó Python webszerverhez, és azonnal megszakadt. Nem értettem, miért történik ez, és felvetettem, hogy ez valamiféle böngészővédelem lehet a különféle támadások ellen. Valószínűleg nem szereti, hogy maga az oldal egy forrásból nyílik meg, és a szkript egy másik forrásból olvassa be az adatokat.

Ezért úgy döntöttek, hogy megváltoztatják a Python webszervert, hogy az ezt a html oldalt is kiszolgálja. Akkor kiderülne, hogy az oldalt és a folyamot is ugyanabból a forrásból olvassák. Nem tudom, hogy a biztonsággal kapcsolatos feltételezésem helyesnek bizonyult-e, vagy valami más, de ezzel a megvalósítással minden úgy működött, ahogy kellett.

Természetesen csak a Handler kéréskezelő osztályt kell módosítania:
class Handler(BaseHTTPServer.BaseHTTPRequestHandler): # DNS-keresések naplózásának letiltása def address_string(self): return str(self.client_address) def do_GET(self): if self.path == "/" vagy 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("Content -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("Content-type", "text/event-stream") self.end_headers() try: while True: new_serial_line = get_full_line_from_serial() ha nem az új_soros_sor Nincs: self.wfile.write("data: " + new_serial_line) self.wfile.write("\n\n") self.wfile.flush() kivéve a socket.errort, e : print "Client disconnected.\n" def process_unknown(self): self.send_response(404)
Ez a beállítás feltételezi, hogy a webszerver csak két kérésre válaszol: "/index.html" (az oldal html kódját adja meg) és "/get_serial" (a COM-portról beolvasott karakterláncok végtelen folyamát adja). Minden egyéb kérésre 404-es kóddal válaszolunk.

Mivel az index.html-t a Python webszerver szolgálja ki, kissé módosítható, ha a COM-portból származó string folyam abszolút címe helyett egy relatívt ad meg:
húr
var source = new EventSource("http://192.168.1.207:8000/")
kicserélve
var source = new EventSource("/get_serial")
Ennek eredményeként a következőképpen alakult:

Itt döntöttem úgy, hogy abbahagyom. Nekem úgy tűnik, hogy egy oldalt szépen megtervezni már egészen egyszerűnek kell lennie. De nem vagyok jártas a HTML-ben vagy a CSS-ben, úgyhogy csinálja meg valaki más. Feladatomat abban láttam, hogy megmutassam, hogy egy COM-portról adatokat küldő webszolgáltatás elkészítése, úgy tűnik, egyáltalán nem nehéz.

Még egyszer megismétlem: a bemutatott kód nem egy teljes, „gyártásba állítható” megoldás. Ez csak egy prototípus, amely a probléma megoldásának alapvető megközelítését mutatja be.

Amin még lehet dolgozni:

  • először is, a python szkriptben a COM-portról az adatok beolvasása nagyon "ügyetlenül" történik - sőt, folyamatosan lekérdezik, hogy "van valami friss?". Ez a megközelítés természetesen betölti a processzort, és a számítógépem egyik magja 100%-ban foglalt.
    Megoldásként használható egy időkorlátos blokkoló olvasás. Ehhez elegendő egy nullától eltérő értéket megadni (másodpercben) időtúllépésként egy COM port megnyitásakor, például:
    ser = soros.Sorozat(SERIAL_PORT_NAME, SERIAL_PORT_SPEED, timeout=0,03)
    Ezenkívül a pySerial modul leírásában három példa található híd létrehozására: "TCP/IP - soros híd", "Egyportos TCP/IP - soros híd (RFC 2217)" és "Többportos TCP /IP - soros híd (RFC 2217)" - láthatja, hogyan oldják meg a szakemberek az ilyen problémákat.
  • másodszor, csak egy ügyfél fogadhat adatokat. Amíg az oldal nincs bezárva az első kliensen, nem csatlakozhat ehhez a szerverhez, és nem kaphat le értékeket a második számítógépen. Egyrészt ez valószínűleg helyes: csak egy COM port van, és több fogyasztó is van - melyikük adja meg az olvasási sort? Ha úgy gondolja, hogy erre a kérdésre "mindenki" választ kell adni, akkor itt vannak az én gondolataim az üggyel kapcsolatban. Számomra úgy tűnik, hogy a probléma nem oldható meg csak egy "becsületes" többszálú webszerver (például Tornado vagy Flask) használatával, amely egyszerre több webklienstől is képes kiszolgálni a kéréseket. Mivel nem nyithat meg minden szálból egy COM-portot, és nem olvashat belőlük - ebben az esetben a COM-portról származó adatok csak egy szálhoz/folyamathoz fognak eljutni. Ezért véleményem szerint a szerver részt két részre kell osztani:
    • zmq szerver, amely COM porttal működik, beolvassa belőle a sorokat és elküldi a PUB socketen keresztül minden érdeklődő fogyasztónak
    • python webszerver ahelyett, hogy a COM porthoz csatlakozna, csatlakozik a zmq szerverhez, és adatokat fogad tőle
    Ha nem ismeri a ZMQ (ZeroMQ) könyvtárat, használhatja helyette hagyományos TCP / IP vagy UDP socketeket, de erősen javaslom a ZMQ megismerését, mert ez a könyvtár nagyon egyszerűvé teszi az ilyen problémák megoldását. Nekem úgy tűnik, hogy a ZMQ segítségével maximum 20 sorba fog beleférni a megoldás. (Nem bírom kihagyni az írást: ha nem is tervezed a leírt feladat megoldását, de munkád többszálas/többfolyamatos programozáshoz kapcsolódik szálak/folyamatok közötti adatcserével, nézd meg közelebbről ezt a könyvtárat - talán ez az, amiről oly régóta álmodoztál)
  • az adatáramlás továbbra is egyirányú – a COM porttól a webböngészőig. Még nem küldhet adatokat a böngészőből az Arduino-ba. Számomra úgy tűnik, hogy ez a feladat sem túl nehéz, és az előzővel ellentétben csak megoldható
    • többszálú szerver használatával
    • a Handler.do_GET metódus finomítása úgy, hogy az elfogadja a GET kéréseket paraméterekkel, és elküldi azok bizonyos értékét a COM portra
    Véleményem szerint, ha az Arduino IDE-be épített web-alapú soros port monitor teljes értékű analógját akarja írni, az nem olyan nehéz. Személy szerint magam számára csak egy normális frontend létrehozásában látom a nehézséget.
  • a COM port nevét és működési paramétereit még nem lehet beállítani a böngészőn keresztül. Ez egyrészt logikusnak tűnik: honnan tudhatja egy felhasználó bolygónk másik oldalán, hogy melyik COM porthoz és milyen sebességgel csatlakozik az arduino? De az ugyanazon a számítógépen futó Python webszerver biztosan tudja. De ha továbbra is kívánatos lehetőséget adni a felhasználónak a COM port nevének vagy működési paramétereinek megváltoztatására, akkor ez ismét könnyen megoldható a Handler.do_GET metódus finomításával
  • python szükséges a szerver futtatásához. Ez általában nem nehéz, de ha valamilyen okból ezt nem lehet megtenni, vagy nem akarja, akkor a pyInstaller segíthet. Ezzel a Python szkript egyetlen végrehajtható fájlba fordítható (Windows esetén - .exe-ben), amelyet egyszerűen át lehet másolni arra a számítógépre, amelyhez az arduino csatlakozik.
    Talán a legjobb megoldás a Go nyelv használata ebben az esetben. Amennyire én tudom, jobban megoldja a fájl létrehozását a "terjesztéshez".
Végezetül: felmerülhet a kérdés: „nem egyszerűbb megoldani ezt a problémát valamilyen kész felhőn keresztül?”. Miért nem tesz közzé egy COM-portról olvasható adatokat a felhőben, és a klienseken egyszerűen elérheti a megfelelő szolgáltatást a felhőben? Valószínűleg egy ilyen megoldásnak is van létjogosultsága, de egy ilyen megoldás alkalmazása előtt a következő kérdéseket kell megválaszolni:
  • Vannak kész webszolgáltatások, amelyek lehetővé teszik az adatok közzétételét a szükséges sebességgel / gyakorisággal? Vannak köztük ingyenesek, vagy készen állsz a megfelelő pénzt kifizetni?
  • készen állsz arra, hogy a felhő lezuhanása vagy a hozzá való csatlakozás esetén adat nélkül maradsz
  • Nem zavar, hogy az egyik helyiségből a másikba való adatátvitel érdekében kétszer átkelnek az óceánon vagy egy fél kontinensen?

Így eljutottunk a COM porthoz. De vele nem minden olyan egyszerű, mint az LPT-vel, és teljes körű használata sokkal több erőfeszítést igényel. A fő bökkenő a fő előnye - az adatátvitel soros formában. Ha az LPT-ben egy adatbájt 8 sorban, egy-egy biten keresztül kerül továbbításra, és az egyes sorok állapota könnyen megtekinthető, akkor a COM portban az adatbájtokat bitenként egy vonal mentén továbbítják (természetesen a földhöz viszonyítva ), és nézze meg, hogy a LED-ek által továbbított tartalma önmagában nem fog működni. Ehhez szükség van egy speciális eszközre - a soros adatfolyam párhuzamos átalakítására, az ún. USART (Universal Synchronous/Asynchronous Receiver Transmitter). Pl. egy COM porttal felszerelt számítógép alaplapjába, bármilyen komolyabb mikrokontrollerbe.

Remélem, még mindig nincs kedved a COM-port elsajátításától. Nem minden olyan komor. Néhány eredmény USART nélkül is elérhető. Fogalmazzuk meg a feladatot, amelyet a COM-porttal való munka kezdeti szakaszában hajtunk végre:


"Szeretnék egy LED-et csatlakoztatni a számítógéphez a COM porton keresztül. Elindítom a programot. Ebben a programban csinálok valamit, a LED világít, csinálok valami mást - a LED kialszik."


A feladat meglehetősen specifikus (tekintve, hogy az USART-t nem használják), és tisztán "self-made", de teljesen megvalósítható és működőképes. Kezdjük el a megvalósítást.


1.COM port

Ismét vesszük a számítógép rendszeregységét, és megnézzük a hátulját. Megjegyezzük, hogy van egy 9 tűs csatlakozó - ez a COM port. A valóságban több is lehet (legfeljebb 4). A számítógépemnek két COM portja van (lásd a képet).


2. COM port kiterjesztés


3. Hardver

A hardveres résszel is "büszkélkednünk" kell, abban az értelemben, hogy az LPT porthoz képest nehezebb lesz, mint az első eszközzel. Az a tény, hogy az RS-232 protokollnak, amelyen keresztül adatcsere történik a COM-porton, kissé eltérő logikai állapot - feszültség aránya van. Ha általában logikai 0 0 V, logikai 1 +5 V, akkor az RS-232-ben ez az arány a következő: logikai 0 +12 V, logikai 1 -12 V.

És például, miután -12 V-ot kapott, nem azonnal világos, hogy mit kell tenni ezzel a feszültséggel. Általában az RS-232 szinteket TTL-re (0,5 V) alakítják át. A legegyszerűbb lehetőség a zener diódák. De azt javaslom, hogy ezt az átalakítót egy speciális mikroáramkörre készítsék. MAX232-nek hívják.

Most nézzük, milyen jeleket láthatunk a COM portról a LED-eken? Valójában a COM-portban akár 6 független vonal is található, amelyek érdekesek az interfészeszközök fejlesztői számára. Közülük kettő – soros adatvonal – még nem áll rendelkezésünkre. De a fennmaradó 4 az adatátvitel folyamatának vezérlésére és jelzésére szolgál, és ezeket mi tudjuk majd az igényeinknek megfelelően "átvinni". Kettőt úgy terveztek, hogy külső eszközzel vezérelhető legyen, és egyelőre nem fogunk hozzájuk nyúlni, de most az utolsó két sort használjuk. Úgy hívják őket:

  • RTS- Áthelyezési kérvény. Interakciós vonal, amely azt jelzi, hogy a számítógép készen áll az adatok fogadására.
  • DTR- A számítógép készen áll. Interakciós vonal, amely azt jelzi, hogy a számítógép be van kapcsolva és készen áll a kommunikációra.

Most egy kicsit átlépjük a céljukat, és a hozzájuk kapcsolódó LED-ek vagy kialszanak, vagy világítanak, a saját programunkban lévő műveletek függvényében.

Tehát állítsunk össze egy sémát, amely lehetővé teszi számunkra a tervezett műveletek végrehajtását.

És itt van a gyakorlati megvalósítása. Azt hiszem, megbocsátjátok, hogy ilyen buta kenyérlapos változatban készítettem, mert nem akarok ilyen "nagyon termelékeny" áramkörhöz táblát készíteni.


4. Szoftver rész

Itt minden gyorsabb. Hozzunk létre egy Windows-alkalmazást a Microsoft Visual C++ 6.0-ban MFC-n alapuló COM-port két kommunikációs vonalának kezelésére. Ehhez hozzon létre egy új MFC projektet, és adjon neki nevet, például TestCOM. Ezután a párbeszéd alapján választjuk ki az építés lehetőségét.

Adja meg programunk párbeszédpanelének megjelenését, ahogyan az 1. ábrán látható. alább, nevezetesen adjon hozzá négy gombot, kettőt minden sorhoz. Az egyik a vonal "kifizetéséhez", a másik az egyikre "beállításához" szükséges.

CTestCOMDlg osztály: public CDialog ( // Nyilvános felépítés: CTestCOMDlg(CWnd* pParent = NULL); // szabványos konstruktor HANDLE hFile;

Ahhoz, hogy programunk kezelje a COM port sorait, először meg kell nyitni. Írjuk meg a port megnyitásáért felelős kódot a program betöltésekor.

HFile = CreateFile("COM2", GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0,NULL); if(hFile==INVALID_HANDLE_VALUE) ( MessageBox("Nem sikerült megnyitni a portot!", "Hiba", MB_ICONERROR); ) else ( MessageBox("Port sikeresen megnyitva", "Ok", MB_OK); )

A szabványos Win API funkció használata CreateFile() nyissa meg a COM portot COM2. Ezután egy tájékoztató üzenet kimenetével ellenőrizzük a nyitás sikerességét. Itt egy fontos megjegyzést kell tenni: a COM2 a számítógépemben van, és a számítógépén csatlakoztathatja egy másik COM porthoz. Ennek megfelelően a nevét meg kell változtatni arra, hogy melyik portot használja. Ha látni szeretné, hogy mely portszámok vannak a számítógépén, tegye a következőket: Start -> Beállítások -> Vezérlőpult -> Rendszer -> Hardver -> Eszközkezelő -> Portok (COM és LPT).

Végül a funkció CTestCOMDlg::OnInitDialog() fájlban található TestCOMDlg.cpp, párbeszédosztályunknak a következő formájúnak kell lennie:

BOOL CTestCOMDlg::OnInitDialog() ( CDialog::OnInitDialog(); // Az "About..." menüpont hozzáadása a rendszermenühöz. // Az IDM_ABOUTBOX-nak a rendszer parancstartományában kell lennie. ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX); ASSERT(IDM_ABOUTBOX AppendMenu(MF_SEPARATOR); pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu); ) ) // Állítsa be a párbeszédpanel ikonját. A keretrendszer ezt automatikusan megteszi // ha az alkalmazás főablakja nem párbeszédablak SetIcon(m_hIcon, TRUE); // Nagy ikon beállítása SetIcon(m_hIcon, FALSE); // Kis ikon beállítása // TEENDŐ: Adjon hozzá extra inicializálást ide hFile = CreateFile("COM2", GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0,NULL); if(hFile==INVALID_HANDLE_VALUE) ( MessageBox("Nem sikerült megnyitni a portot!", "Hiba", MB_ICONERROR); ) else ( MessageBox("Port sikeresen megnyílt", "Ok", MB_OK); ) return TRUE; // IGAZ értéket ad vissza, hacsak nem egy vezérlőre állítja a fókuszt)

Most adjunk hozzá vonalvezérlő gombkezelőket. Megadtam nekik a megfelelő neveket: a DTR sort 1-re állító függvény az OnDTR1(), a 0 pedig az OnDTR0(). Az RTS vonalhoz, illetve hasonló módon. Hadd emlékeztesselek arra, hogy a kezelő akkor jön létre, ha duplán kattint a gombra. Ennek eredményeképpen ennek a négy funkciónak a következő formában kell megjelennie:

Void CTestCOMDlg::OnDTR1() ( // TODO: Adja hozzá a vezérlőértesítés kezelő kódját ide EscapeCommFunction(hFile, 6); ) void CTestCOMDlg::OnDTR0() ( // TODO: Adja hozzá a vezérlőértesítés kezelő kódját ide EscapeCommFunction(hFile, 5); ) void CTestCOMDlg::OnRTS1() ( // TODO: Adja hozzá a vezérlőértesítéskezelő kódját ide EscapeCommFunction(hFile, 4); ) void CTestCOMDlg::OnRTS0() ( // TODO: Adja hozzá a vezérlőértesítéskezelő kódját ide EscapeCommFunction(hFile, 3); )

Hadd magyarázzam el egy kicsit, hogyan működnek. Amint láthatja, belül ugyanannak a Win API függvénynek a hívása található EscapeCommFunction() két lehetőséggel. Ezek közül az első egy nyitott porthoz mutató fogantyú (HANDLE), a második pedig egy speciális műveletkód, amely megfelel a vonal kívánt állapotának.

Minden, fordítsd le, futtasd. Ha minden rendben van, egy üzenetet kell látnia a port sikeres megnyitásáról. Továbbá a megfelelő gombok megnyomásával villogtatjuk a COM porthoz csatlakoztatott LED-eket.

© Ivanov Dmitrij
2006. december