Python com port linux

pySerial¶

Overview¶

This module encapsulates the access for the serial port. It provides backends for Python running on Windows, OSX, Linux, BSD (possibly any POSIX compliant system) and IronPython. The module named “serial” automatically selects the appropriate backend.

It is released under a free software license, see LICENSE for more details.

Copyright (C) 2001-2020 Chris Liechti

Other pages (online)

Features¶

• Same class based interface on all supported platforms.
• Access to the port settings through Python properties.
• Support for different byte sizes, stop bits, parity and flow control with RTS/CTS and/or Xon/Xoff.
• Working with or without receive timeout.
• File like API with “read” and “write” (“readline” etc. also supported).
• The files in this package are 100% pure Python.
• The port is set up for binary transmission. No NULL byte stripping, CR-LF translation etc. (which are many times enabled for POSIX.) This makes this module universally useful.
• Compatible with io library
• RFC 2217 client (experimental), server provided in the examples.

Requirements¶

• Python 2.7 or Python 3.4 and newer
• If running on Windows: Windows 7 or newer
• If running on Jython: “Java Communications” (JavaComm) or compatible extension for Java

For older installations (older Python versions or older operating systems), see older versions below.

Installation¶

This installs a package that can be used from Python ( import serial ).

To install for all users on the system, administrator rights (root) may be required.

From PyPI¶

pySerial can be installed from PyPI:

Using the python / python3 executable of the desired version (2.7/3.x).

Developers also may be interested to get the source archive, because it contains examples, tests and the this documentation.

From Conda¶

pySerial can be installed from Conda:

Currently the default conda channel will provide version 3.4 whereas the conda-forge channel provides the current 3.x version.

From source (zip/tar.gz or checkout)В¶

Download the archive from http://pypi.python.org/pypi/pyserial or https://github.com/pyserial/pyserial/releases. Unpack the archive, enter the pyserial-x.y directory and run:

Using the python / python3 executable of the desired version (2.7/3.x).

Packages¶

There are also packaged versions for some Linux distributions:

• Debian/Ubuntu: “python-serial”, “python3-serial”
• Fedora / RHEL / CentOS / EPEL: “pyserial”
• Arch Linux: “python-pyserial”
• Gentoo: “dev-python/pyserial”

Note that some distributions may package an older version of pySerial. These packages are created and maintained by developers working on these distributions.

References¶

Older Versions¶

Older versions are still available on the current download page or the old download page. The last version of pySerial’s 2.x series was 2.7, compatible with Python 2.3 and newer and partially with early Python 3.x versions.

pySerial 1.21 is compatible with Python 2.0 on Windows, Linux and several un*x like systems, MacOSX and Jython.

On Windows, releases older than 2.5 will depend on pywin32 (previously known as win32all). WinXP is supported up to 3.0.1.

© Copyright 2001-2020, Chris Liechti Revision f7e39f06 .

Источник

Работа с ком портом питоне

Продолжаю осваивать питон

Накропал скрипт для лога данных с сенсора в БД

Железка определяется как

Из неприятных минусов — железка перезагружается. Помогите побороть эту бяку.

Когда работает эта программа то перезагружается, а если просто minicom натравить — то не перезагружается?

Где-то эти прекрасные макароны:

и этот тред я уже видел.

а китайская хитрая железяка. перезагружается

Я думаю, что проблема где-то тут. На неё документация есть? Софт с ней какой идёт? Попробуй реверсни и посмотри как с ней работают.

Железка -суровый китайский самопал. Документации нет, софта нет. Населена роботами. Вот она если что. mysku.ru/blog/taobao/40456.html Ребут идет именно по запуску скрипта. Гугл показывает аналогичную проблему с ардуиной, но там хардварное решение -тупо воткнуть конденсатор между пинами

начни с устранения причин перезагрузки.

скорость работы устройство действительно 9600?

вообще если какой тулой вообще посмотреть чё с порта приходит — на какой скорости?

может твой скрипт ненароком просто вычитывает тоны не формата — чисто для себя попробуй посмотреть чё в s = ser.readline() приходит и печатай для себя.

Чтение никак не должно влиять на работу железки. Может у тебя там коротит чего? Питание проверяй. Попробуй конденсатор микрофарад на 100 воткнуть между плюсом и минусом питания, если в железке нет такого. Можно больше.

long — в моём питоне такого нет.

Я бы так написал:

Попробуй выяснить, после какого вызова происходит ресет.

У меня он происходил про открытии порта.

Я не спец по железкам. Но она выдает в csv данные. В виде строки данных через запятую.

По крайней мере я так понял. Если можешь подскажи чем и как посмотреть чем плюется железка.

Я в ардуинке тоже сталкивался. Судя по всему оно на ser.open() ресетится.

Ты уже проверил что с программами типа minicom всё нормально работает и не резетится? И лишь только с твоей программой так.

А если чего-нибудь туда послать, тоже ресетится?

крч у питона же интерактивная среда есть

если вручную подключаешься то всё видимо ок?

попробуй ну просто счётчик числа прочитаных строк воткнуть и посмотреть после скольки рвёться соединение например.

(в порядке мозгового шторма)может вообще там у железки после некоторого обьёма ответа какие буферы сыпятся вот и ресетиться — али ещё какие глюки с «таймингами» и действительно попробуй какой «обычной»(т.е обще используемой в таковых задачах) тулзой посмотреть программно свою железку «по разговарий» с ней может до чего и уговоришь

Проверил. оно ресетится на всем что пробовал: CuteCOM, SerialPlot

Проверил — ресетится оно по открытию порта.

Самый неприятный открытый момент — при чтении порта он сначала отдает кривые данные.

Соответсвенно вижу 2 варианта.

1. бесконечный цикл чтения данных и отбор нужных 2. вызов таки по крону, фильтрация медианой пачки считанных данных.

Сейчас пытаюсь сделать регистрацию на qq (китайский месенджер) чтоб достать продавца

после скольки рвёться соединение например

tsya.ru (я не придираюсь, просто этот сайт поможет)

А железяка дороговата. 157 баксов за такое — перебор если по мне.

А найди аналоги дешевле.

Самому спаять. Там в принципе ничего сложного.

в принципе да, но я вон уже пару дней мучаюсь с тупым подключением готовой железки к компу.

Короче, сделал я чтоб не перезапускался. правда велосипед еще тот.

Скрипт запустил в бесконечный цикл чтения т.е. открытие порта происходит всего 1 раз. а чтобы оно постоянно висело, запустил его через supervisor

Из неприятных минусов — железка перезагружается.

ну так правильно, ты же подключаешся, у меня ардуино так же себя ведет

правильно-неправильно. но мне такое поведение вредно.

Источник

Python & Arduino. Просто, быстро и красиво

Оборудование

Недавно я заполучил очень интересную плату: Arduino SS Micro. Эта плата, внешне напоминающая Digispark Attiny 85, тем не менее является китайской версией Arduino Micro, с выведенным выходом USB.

Подробно рассказывать о ней я не буду, ведь это уже сделал пользователь YouTube с ником iomoio, и его обзор можно посмотреть здесь.

Как мне кажется — это довольно крутое и удобное устройство для небольших домашних проектов, ведь у проводов есть супер-свойство: теряться в самый неподходящий момент.

В качестве управляющего компьютера был использован MacBook Pro с операционной системой macOS Mojave, но не надо закрывать статью, если вы используете Windows или Linux — всё описанное в статье будет работать без изменений на любой операционной системе.

Скетч для Arduino

В качестве примера будет использоваться скетч, включающий и выключающий светодиод, по команде из Serial-порта.

Светодиод в Arduino SS Micro висит на порте SS, и поэтому он автоматически выключается. Не смотря на это, стандартный пример Blink — мигающий светодиод работает.

Если вы будете использовать другую Arduino — не забудьте сменить пин светодиода.

Код для компьютера

Одним из достоинств Python, кроме его кроссплатформенности — наличие гигантского числа библиотек. Нам понадобятся:

• PySerial — библиотека для работы с Serial-портом
• PyQT5 — библиотека для создания графического интерфейса

Установка

Для установки, воспользуемся встроенным менеджером пакетов — pip.

Для удобства создания GUI можно установить программу QTDesigner.

Интерфейс

Поскольку данная программа предназначена скорее, для демонстрации возможностей, пользователь может выбрать порт из предложенных, а так же скорость, с которой будет происходить общение.

Исходный код

Вся работа с устройством происходит благодаря библиотеке PySerial. Но есть несколько нюансов. Например, как узнать, в какой из портов подключено устройство?

На всем прекрасно известном сайте stackoverflow, пользователь с ником Thomas предложил уже готовое решение, которое я и использовал.

Кроме этого необходимо хранить список доступных скоростей:

А теперь соберём вместе дизайн(созданный в QtDesigner и сконвертированный с помощью утилиты pyuic5 в .py файл), функции для сканирования портов и основной код программы.

Основной класс, содержащий в себе всю логику программы

Переменные self.Port и self.Speed — это выпадающие списки, содержащие в себе значения доступных портов и скоростей.

При нажатии на кнопку self.ConnectButton вызывается функция connect, в которой производится попытка подключения к заданному порту с заданной скоростью. Если подключение успешно, то кнопка окрашивается в зелёный цвет, и меняется надпись.

Функция send отправляет в наш порт байтовую строку — заставляющую включить режим мигания.

Таким образом можно управлять различными устройствами, подключёнными к USB.

Данная статья является вводной и обзорной, более полную информацию можно найти например тут:

Источник

Последовательный порт. Да, поможет нам Python!

Давным-давно, когда я сидел под Виндовсом у меня была прога для работы с COM-портом. Это были мои «уши и руки» для доступа к моим микроконтроллерным устройствам. Я очень боялся потерять её, боялся, чтобы её не загрызли вирусы…

Потом я пересел на Линукс, и как все Линукс-новички искал аналоги этой проги. Можно не уточнять, что я их не нашел. Конечно, я тогда расстроился — «Ну как же так! Потребность есть, а проги нет? Что-то не так в мире Линукса. Ведь в мире Виндовса каких-только программ нет! А тут такая фигня — и нет! Да, похоже, правильно говорят: Линукс — это какая-то недоделанная ОСь. Ничего в нем (Линуксе) толкового нет!»

Да-да, именно такие мысли бродили у меня в голове. Иногда они подогревались Виндузятниками, которые «эксперты-по-Линуксу», и мне было очень даже тяжко. Но я, «закусив удила», пер как трактор — только вперед!

Через какое-то время я допер, что в мире Линукса существует программа MiniCom. Прога как прога, как принято говорить — «малость не дотягивает до уровня аналогичных программ для Виндос». Я ее юзал какое-то время, пока опять-таки не допер, что даже и она не очень-то нужна в мире Линукса.

Линукс — более чем самодостаточен. В Линуксе не надо никаких особых программ для работы с последовательным портом, как это принято в мире Виндовс. По этой причине, собственно, нет и не должно быть программ для работы с портом. Они просто не нужны!

В мире Линукса последовательный порт — это файл. (Вообще, Линукс на всё «смотрит» как на файлы. Всё унифицировано.) Ну а с файлами-то мы работать умеем! А раз так, то всякие вычурные программы с бантиками и бубенчиками — это ненужный антураж, который создает видимость «продуманности» программы. Отвлекать юзера от основной цели (назначения программы), уводить его на второстепенные (менее значительные) показатели и ненужную побочную функциональность — это по-Виндовому!

Однако, вернемся к Линуксу. Что я делал, когда мне нужно было принять информацию с устройства и сохранить ее в файле? Я просто в консоли выполнял команду:

Но это прога выполнялась молча, на экран ничего не выводила. Но иногда требуется «мониторить» поток. Тогда команда должна стать составной — дополниться командой tee, которая одну копию потока отправляет в указанный файл, а другую выводит на консоль:

Все предельно просто. Но что же делать, когда требуется какая-то обработка данных в реальном времени? И вот тут у меня не было ничего «красивого», что бы я мог предложить.

В этих случаях я поступал по-Виндовому. Я писал Си-шные программы, которые открывали последовательный порт, считывали из него информационный поток, как-то его обрабатывали, результат работы записывали в файл и при необходимости что-то выдавали на экран. Все это работало. Работало не плохо. Работало надежно. Но какое-то шестое чувство мне подсказывало, что это не совсем тот самый путь, который есть правильный. В Линуксе всё должно быть как-то по другому. Но, как? Я не знал. И продолжал компилировать свои многочисленные программы.

В процессе работы возникали смешные проблемы. Надо сказать, что все эти проги не были предназначены ни для продажи, ни для широкого тиражирования. Эти проги работали в единичных экземплярах и/или только с моим оборудованием. Но каждый раз, даже при незначительных (казалось бы!) изменениях, мне приходилось их заново компилировать и присваивать им версии. Путаница начинала свой разбег по взлетной полосе…

Конечно, можно было пойти по другому пути. Все переменные параметры можно было бы сохранять в конфигурационных файлах. Но, ребята, окститесь! Это ж не коммерческие проги! Я их сам поддерживаю, я сам знаю, что и где в них нужно подкрутить или изменить, чтобы они работали чуть-чуть по другому.

Конфигурационные файлы — это еще один уровень сложности в борьбе с той сложностью, ради которой создается программа. С точки зрения уменьшения сложности, конфигурационные файлы мало-что меняют. Это просто перенос сложностей в другую плоскость (на другой уровень), но это не уменьшение количества сложностей. Наша жизнь и без того сложна, и отчетливо помнить все подробности весьма затруднительно. Поэтому нужно уменьшать количество сложности, а не увеличивать.

Я понимал, что нужно было что-то делать. Как минимум, нужно было что-нибудь почитать по Линуксу и обработке данных. И я погрузился в изучение парадигмы Линукса.

Следует заметить, что Линукс очень силен в обработке статических текстов и текстовых потоков. Обработка текстовой информации — это один из столпов Линукса. Это могучий булыжник в фундаменте Линукса. И тот, кто упускает этот момент, можно утверждать, что он не понимает Линукса.

Отсюда вытекает весьма простая истина, если информационный поток, который идет через последовательный порт, будет в текстовом формате, то все проблемы легко решаются штатными утилитами, входящими в состав любого дистрибутива Линукс.
Я даже выделил эту синтецию жирным, на столько она фундаментальна.

Понимая эту и некоторые другие Линуксовые идеи начинаешь задумываться над вопросом — «Ребята, а зачем нам вообще нужна Винда?» Она и без того мне мозги прочистила так, что я до сих пор иногда мыслю по-Виндовому. А когда я мыслю по-Виндовому, я не понимаю Линукса. Отсюда все мои неудачи и разочарования. К счастью, это происходит всё реже и реже!

Прошло ещё какое-то время, я открыл для себя удобство пользования языка Python. Казалось бы, язык интерпретируемый, а значит по определению — медленный. Однако, ирония в том, что он не абсолютно медленный, а — относительно. Относительно Си-шных программ программы на языке Python исполняются медленнее. Это не открытие. Открытие в том, что для работы с последовательным портом и обработки данных быстродействия Python-ских программ вполне хватает.

А раз так, то зачем нам какие-то специализированные (а к пущему греху еще и графические — прости-хоспади!) проги для работы с последовательным портом? Написать на Python-е для работы с последовательным портом прогу, специализированную под наши требования, — проще пареной репы!

Для работы с последовательным портом существует модуль serial, который инкапсулирует доступ к порту. (В интернете иногда можно встретить название PySerial. Это одно и тоже! Возможно, так назывался этот модуль раньше, но точно я не знаю. Это только мои предположения.) Модуль serial не входит в состав Python – его нужно устанавливать самостоятельно. В Ubuntu это делается с помощью команды:

Заметьте, что название модуля и название пакета не совпадают. Почему? Какая причина?

Всё просто. Дело в том, что название пакета python-serial — это, так сказать, «область имен» в сфере пакетов программ, то есть в это область операционной системы, область репозиториев пакетов, область инсталляции программ — улавливаете?

А название модуля serial — это область работы Питона. Питон понятия не имеет об операционной системе и тем более о каких-то пакетах программ. У Питона свои тараканы — модули. Модули — это в некоторой степени библиотеки.

Вас ведь не смущает, что какая-нибудь программа-инсталлятор имеет одно имя, а устанавливаемая из неё программ — другое. Так и тут: имя пакета — это название коробочки, в которой лежит куча разных файлов. Среди этих файлов вполне может находиться Питоновский модуль, возможно какие-то справочные файлы или файлы конфигурации.

В программную среду Python модуль подключается обычным способом – через команду import:

И опять, название модуля отличается.

Следующая программа позволяет найти в системе все последовательные порты. (Программа взята из книги «Beginning Python Visialization.: Crafting Visual Transformation Scripts» Shai Vaingast, 2009. Стр. 3., и немного переделана для работы Linux-е.

Следующая программа забирает поток данных из последовательного порта и выводит его на экран

Программа имеет бесконечный цикл, поэтому для ее окончания нужно нажать Ctrl-C.

Еще одна программа из книги «Beginning Python Visialization.: Crafting Visual Transformation Scripts» Shai Vaingast, 2009. (cтраница 5). Эта программа забирает поток данных из последовательного порта и сохраняет его в файле. В целях контроля, поток данных выводится на экран.

Имя файла формируется автоматически на основе времени запуска программы. Например, имя файла, созданного 8-го Февраля 2014-го года в 9 часов (утра) 3 минуты и 31-у секунду, будет следующим:

здесь GPS – это префикс файла. По нему можно ориентироваться, какие данные в нем находятся. Программа использовалась для работы с GPS-приёмником, это отразилось на имени создаваемых ею файлов.

Далее следует дата-время, записанные через дефис. Стандарт ISO 8601 предписывает числа в дате писать через черточки, а числа во времени писать через двоеточие. Использование символа двоеточия в именах файлов – это не очень хорошая идея, поэтому числа во времени удобнее написать так же через дефис. Следует обратить внимание, что месяцы, дни, часы, минуты и секунды должны всегда иметь две цифры – незначащий ноль должен присутствовать. Это облегчит поиск и анализ файлов в директории, где подобных файлов может оказаться очень много. Поскольку файловые менеджеры зачастую упорядочивают файлы, то избранная правильная система наименования файлов только облегчат работу с ними.

Суффикс файла csv – говорит о том, что этот файл текстовый, то есть состоит из строк текста. Каждая строка состоит из информационных полей, разделителем которых является символ запятая. В английском это более прозрачно: csv – это Comma Separaterd Values – значения, разделенные запятой.

Однако, давайте перейдем к рассмотрению самой программы:

Здесь имя последовательного порта несколько отличается. У меня GPS-приемник подключен к USB-порту через самодельный переходник USB-UART. Переходник самый обычный, выполнен на микросхеме FTDI232RL.

Со стороны компа я обращаюсь к UART-у, как к виртуальному последовательному порту, который «проброшен» через USB-порт. Поэтому имя файла порта в моем случае будет /dev/ttyUSB0.

В самой последней команде программы запятая нужна для того, чтобы исключить переход на следующую строку. Дело в том, что в сообщениях GPS-приемника, которые состоят из строк, символ перевода на новую строку уже есть. И если в команде опустить запятую, то на экран будут выводится два символа перевода на новую строку – один присутствует в самой строке , а другой – от команды print.

Вот пример текста, который появляется у меня на экране и записывается в файл:

Это текст в формате NMEA (америкосы произносят это как «эн-ем-Иа», ударение на «И»). Я бы не хотел сейчас заострять внимание на его расшифровке. Важно только то, что это, во первых, текстовая информация (а не двоичная), а во вторых, эта информация достаточно хорошо структурирована и может быть легко обработана.

Точно такой же тип текстовой информации я получаю с геологических приборов:

Здесь у меня чередуются два типа пакетов (два типа строк). Пакет типа «M» содержит данные Модуля Магнитного Каротажа (ММК), а пакет типа «E» – данные Модуля Электро-Каротажа (МЭК). Пакет ММК значительно меньше по размеру пакета МЭК. Если пакет ММК состоит из 13 полей, то пакет МЭК содержит более 400.

Каждая запись (каждый пакет) располагается в одной информационной строке, которая заканчивается символом «новая строка». Здесь поля отделяются друг от друга символом пробела. Это не совсем правильно. Это я только сейчас понял, что csv-формат может автоматически «затягиваться» в программы электронных таблиц из офисных пакетов (типа Calc из Libre-Office) без дополнительных телодвижений по указанию символов-разграничителей полей. Да, надо будет как-нибудь переписать программу и заменить символ-разграничитель.

Как видите, ничего сверхсложного и непонятного в работе с последовательным портом — нет. Я предполагаю, что вы немного знакомы с языком Python, поэтому я не слишком подробно прокомментировал действия в программах. Но если что, задавайте вопросы.

А пока на этом всё!

UPDATE 29.10.2015

Небольшая заметка, касающаяся особенности использования модуля serial под Python-3:

UPDATE 01.12.2015

Вопрос: где взять модуль serial для Python-3?

Ответ: Модуль serial для Python-3 я тупо взял из репозитория Debian-8. То есть даже не заморачивался его поисками в интернете.

Команда для инсталляции:

Установка модуля serial для Python-2.x на Ubuntu-10.04 LTS производится очень просто:

Но для Python-3.x модуля serial в репозитории Ubuntu-10.04 LTS нет. Поэтому установка будет производиться несколько сложнее

и скачиваем архивный файл pyserial-2.7.tar.gz

2) Распаковываем полученный архивный файл:

3) Заходим в поддиректорий:

4) Запускаем процесс инсталляции:

После этого можно использовать модуль serial в программах под Python-3.x.

Есть мнение, что можно проинсталлировать модуль вот так:

, но я этого не делал. Поэтому я не могу сказать можно ли так делать или нельзя.

Написал новую статью: «Python, последовательный порт и нуль-модемный кабель»

Написал статью про использование последовательного порта в проектах с микроконтроллером

Share this:

Понравилось это:

Похожее

32 responses to “ Последовательный порт. Да, поможет нам Python! ”

А как обстоят дела у линуха, если нужно при передаче пакета, дёрнуть какой-то ногой , пином общего назначения, для того, чтобы к примеру включить передатчик, а по окончании передачи пакета дёрнуть в обратную сторону ? Нужно перекомпливать ядро линуха ?

Забегаете вперед, уважаемый!

Расскажу и научу это делать, но чуть позже. Пожалейте же пианиста!

Ок 🙂 Я тут просто приобрел БиглБоард ( http://beagleboard.org/Products/BeagleBone%20Black ), и по причине полной отстранённости от Линухов, не смог сделать с ним ничего лучше чем, попросматривать директории, посоздавать файлы, покопаться в исходниках программ обслуживания периферии, ужаснуться от своего непонимания нифигушки в них и отложить плату до лучших времен. А линкс на железе стоимостью в 50 баксов, с таким богатым комплектом периферии, это весьма аппетитная перспектива… Видимо прийдётся таки разбираться. Потому и опрашиваю Вас, Вы уж не серчайте 🙂

Добрая плата, могучий процессор, не запредельная цена, плюс желание двигаться вперед и правильно выбранное направление мысли — это можно только приветствовать!

Исправьте опечатку, должно быть
found = False

Ой! (наверно промазал пальцем при наборе)
Спасибо, WidikK!

А если два ПК соединены нуль-модемным кабелем, как через pySerial отправить с одного ПК на другой хотя бы один символ? Хочется увидеть рабочий пример.

Основная проблема в коммуникации через последовательный порт состоит в непонимании какую роль играет операционная система.

Начну с противоположного — с Виндовса. В ДОС-е/Виндовсе терминалы не являются жизнеобеспечивающим механизмом, поэтому они там не развиты совсем. Соответственно, последовательный порт, на основе которого изначально строились почти все хост-терминальные системы, в ДОС-е был вообще без надобности.

Конечно, через последовательный порт (там он носит название «коммуникационного» — сокращенно «СОМ») использовался для подключения различных периферийных устройств. В основном это были измерительные приборы или какое-то управляющее оборудование для хозяйственной деятельности. Но это точно не была система типа «компьютер + удалённый терминал». Поэтому и средств в операционной системе ДОС/Виндовс для работы с последовательным портом, как с ИНТЕРФЕЙСОМ ДЛЯ ДИСТАНЦИОННОГО ПОДКЛЮЧЕНИЯ К ОПЕРАЦИОННОЙ СИСТЕМЕ — нет. А это значит, в контексте ДОС/Виндовс последовательный порт — это всего лишь ещё одна дырка для передачи данных, управление которой полностью отдано пользователю. Иначе говоря операционная система (ДОС/Виндовс) не вмешивается в работу этой дыры. Максимум, что делает, Виндовс — это как-то пытается управлять доступом к этому ресурсу. ДОС — вообще этот вопрос никак не регулирует.

Соответственно, все управление потоком данных через последовательный порт лежит на совести программ, использующих порт.

Совсем иначе обстоят дела в Линуксе. Линух/Юникс — это изначально хост-терминал ориентированные системы. И как я уже говорил, в древние времена коммуникация с терминалами в основном осуществлялась через последовательные порты. Значительно позже Линукс появился на персональных компах (класс компьютеров IBM PC), но изначально UNIX строился на основе большого мощного компа и множества терминалов.

Через какое-то время на персоналках «заработал» Линукс. Но персональные компы это не мощные вычислительные машины, с множеством терминалов, а автономные вычислительные системы со своими клавиатурами и дисплеями. Таким образом, идея терминала в отношении персонального компа — стала несколько надуманной. Ну, просто терминал не нужен там, где есть встроенные в (аппаратно) систему клавиатура и дисплей. Поскольку в основе Линукса лежит UNIX (система, основанная на терминалах), это не могло не отразиться на специфике Линукса, как операционной системы.

Иначе говоря, последовательный порт в Линуксе это не дырка для передачи данных. Последовательный порт в Линуксе — это мощный механизм, встроенный в операционную систему. Этот механизм отвечает не только за передачу данных туда-сюда, на него возложены также функции безопасности системы — пользователь, не имеющий учётной записи, не должен получить управление системой.

Во времена расцвета UNIX производители оборудования («железа») выпускали целый зоопарк различных устройств. Эти устройства имели сходные характеристики, но та же имели и свои уникальные. Так например, некоторые терминалы не имели клавиш управления курсором. Иные устройства работали только с символами CR (Возврат каретки), а другие только с символами LF (первод строки). Но операционная система должна была уметь работать и с теми, и с другими, и еще бог-знает с какими устройствами! Поэтому в операционной системе была встроена возможность настраивать последовательный порт для работы с тем или иным оборудованием.

Ну, как бы я много сказал. Короче можно сказать, что последовательный порт в ДОС-е/Виндовсе — это всего лишь порт (микросхема), через которую можно передавать и принимать данные. Ну, разве что с минимальной программной обвязкой в виде драйверов у Виндовс, а ДОС-е — это вообще голая вещь. А в отношении Линукса, последовательный порт — это целая система, которая гибко настраивается под потребности пользователя.

Проблема в том, что пользователи знают СОМ-порт от Виндовса, и думают, что в Линуксе последовательный порт — это тоже самое. Нет! В Линуксе последовательный порт — это совершенно другая ипостась! А это значит, методы работы с последовательным портом в Виндовсе и Линуксе существенно отличаются.

Так вот. Подводя итог сказанному, хочу заметить, основная сложность работы с последовательным портом в Линуксе состоит не в передаче данных, а именно в настройке порта.

Пару дней назад на elecrtonix.ru один товарищ задавал вопрос по работе порта под Линуксом и костерил Линукс последними словами за то, что Линукс никак не хотел передавать два символа LF-CR вместо одного символа LF.

Прогу, которая связывает два компа через нуль-модем, я может быть чуть позже напишу. Там, собственно, сложно ничего нет. Если будете писать самостоятельно, обратите внимание на то, что Линуксовые терминалы «заточены» на передачу строк, а не отдельных символов. Передавать отдельные символы — это достаточно накладная процедура. Поэтому рациональнее объединять их в пакет (то есть в строку) и в таком виде отправлять. Тем более, что отдельные символы сами по себе мало что значат. Значат — законченные строки (команды).

А если возникает необходимость передавать отдельные символы (ну, допустим, для игровых программ или наподобие), то терминал нужно перевести в так называемый «неканонический» режим.

В каноническом режиме любой ввод должен заканчиваться нажатием на клавишу Enter. Пока эта клавиша не нажата, обработку строки (то есть редактирование, исправление ошибок) осуществляет терминал. Но как только будет нажата клавиша Enter, строка из терминала будет передана хосту.

В неканоническом режиме каждое нажатие клавиши на клавиатуре вызывает отправление кода в хост. Таким образом хост вынужден постоянно «дёргаться». Как я уже говорил, иногда в жизни для некоторых программ это так и надо делать. Но в основном для работы в командной оболочке (shell) используется канонический режим. Вспомните, для чего (в Линуксе) нужен терминал и всё сразу станет на свои места.

Спасибо за ответ.
Я использую (на обоих ПК) Windows XP SP3, Python 3.4, pySerial 3.0.1.
Использование FIFO буферов включено: по моему предположению этот буфер используется принимающим ПК, когда пишут в порт отправляющего ПК. И потом на принимающем ПК сообщение можно считать из порта.

Что я делаю (на каждом ПК в оболочке IDLE):
import serial
ser = serial.Serial()
ser.port = ‘COM15′ (отправляющий и’COM1′ — принимающий)
ser.dsrdtr = 1 (пробовал и при 0 на обоих ПК)
ser.timeout = 1 (только для принимающего ПК в цикле while True)
ser.open()

И далее:
На отправляющем ПК пишу
ser.write(b’hello’) (или b’hello\n’)
На принимающем
ser.read() или
ser.readline()
присваивал результаты этих команд переменным. Ничего! Только b».
Цель — передать файл с одного ПК на другой при помощи pySerial.

Понятно. Ладно, ждите статью.
Бог даст может быть сегодня чего-нибудь напишу на эту тему.

Добрый вечер. Поставил com0com — симуляция нуль-модемного соединения через виртуальные COM-порты ‘NCNA0’ и ‘CNCB0′ — на них всё работает (переда-приём b’hello’ и т.п.), в двух терминалах IDLE на одном ПК. Очень не хочется об этом думать, но возможно у меня сгорели COM-порты на обоих ПК…

Фёдор, замкните контакт 2 и контакт 3 на разъеме порта. Эти есть контакты TxD и RxD. Такое соединение называется «локальное эхо». Комп (порт) будет получать всё, что передаёт. Таким образом можно легко проверить работоспособность порта.

Вообще говоря, у Вас есть еще одна заморочка, которая не позволит Вам сделать это легко. Я говорю об отсутствии у Вас опыта. Но когда-то же надо его получать!

Спасибо за подсказку про «локальное эхо». Сам бы не догадался, что так можно сделать. Такая простая вещь, а как облегчает жизнь. Оказалось, что действительно на одном ПК не работает COM-порт. И найденный переходник USB-COM, подававший большие надежды, тоже оказался не рабочим.

Спешу напомнить, что в Windows последовательный порт это тоже файл и PySerial на винде работает точно также. Собственно, я эту связку и использую на работе (там Linux не дают ставить). Вы, сами того не зная, нашли кросс-платформенное решение. Это преимущество не Линукса, а скорее языка Python. Хотя да, Линукс шикарен.

Вопрос по реверс инжирингу. Перехватывал запись в файл *.txt последовательность цифр 123456 расположенный на USB флешке. Есть ТСД Оптикон. Пытаюсь сейчас с помощью USBpcap перехватить запись в него слова «Пирог», после открытия в Wiresharke файла *.pcap вижу функции BULK что сильно отличается от write() на флешке. Помогите пожалуйста в расшифровке данных перехвата или дайте пинка в нужном направлении пожалуйста!

Извините, но я не смогу Вам помочь. Думаю, что Вам следует поискать в интернете соответствующие форумы и там задать свой вопрос.

Повторил пример
Но у меня на экран и в файл выводится строка с префиксом b’
не

Почему так и как убрать?

То, что Вы указали версию Питона, это хорошо. Но Вы, к сожалению, не указали какая у Вас операционка, и Вы не уточнили в каком режиме (в программном или в интерактивном) Вы получили такой вывод.

Кроме того мне кажется, что строка, которую Вы получили, заканчивается символом апострофа — точно таким же, какой присутствует в префиксе после символа b. Уточните этот момент, пожалуйста.

У Вас ведь программа лежит в компе в виде файла. Пришлите мне этот файл.

Ну и попробуйте выводить не саму переменную line (или как она в Вашей программе называется?), а выражение line.decode().

К стати, заметьте, что версия программы, опубликованная в статье, написана для Python-2.x, а у Вас — Python-3.x. Версия 2 и версия 3 в некоторых местах сильно отличаются. Иногда даже говорят, что третий Питон — это другой язык. В третьем Питоне в некоторых местах существенно изменена идеология языка.

Здравствуйте
ОС — Windows 7 x64
Режим программный
Символ апострофа в конце строки тоже есть
b’$GPRMC,000028.000,V,0000.00000,N,00000.00000,E,0.0,0.0,071214. N*7D\r\n’
Вот программа
import time, serial

# change these parameters to your GPS parameters
ser = serial.Serial(«COM11»)
ser.baudrate = 115200
fmt = «../GPS-%4d-%02d-%02d-%02d-%02d-%02d.csv»

filename = fmt % time.localtime()[:6]
f = open(filename, ‘w’)
while True:
line = ser.readline()
f.write(str(line) + «\n»)
print (line,)

Попробуйте заменить строку
print (line,)
на
print(line.decode(),)

Отпишитесь, что у Вас получится.

Код
import time, serial

# change these parameters to your GPS parameters
ser = serial.Serial(«COM11»)
ser.baudrate = 115200
fmt = «../GPS-%4d-%02d-%02d-%02d-%02d-%02d.csv»

filename = fmt % time.localtime()[:6]
f = open(filename, ‘w’)
while True:
line = ser.readline()
f.write(str(line)+ «\n»)
#print (line,)
print(line.decode(),)

Выдает вот так — через строку.
$GPRMC,001133.000,V,0000.00000,N,00000.00000,E,0.0,0.0,071214. N*77

Но почему-то перестало писаться в файл.

Ой! Я извиняюсь!
Я не обратил внимания на строку

Её тоже нужно немного изменить:

Эта строка выводит информацию в файл, а строка print(…) — выводит ту же информацию на консоль.

Спасибо.
Можно ещё пару вопросов.
1. Как сделать, что этот скрипт записывал данные от GPS в течении суток. А в 00.00 сохранял файл и начинал запись в новый.
2. Как сделать из питона вызов внешней программы для обработки записанного файла с gps измерениями.

1.
Самое простое — это периодически (на каждом витке цикла) проверять значение системного времени. И как только часы компьютера покажут значение 00 часов 00 минут 00 секунд, закрывать текущий файл и открывать новый.

Модуль time предназначен для работы со временем. Для работы с этим модулем его нужно сначала импортировать:

В модуле есть функция strftime(), которая позволит получить текущее время в виде строки.

Вот пара примеров использования функции:

Я думаю, это не сложно. Опасность состоит в том, что время 00:00:00 длится целую секунду. И если ваша программа успеет за это время совершить не один оборот по циклу, то вы ровно столько же раз закроете старый файл и откроете новый.

Иначе говоря, время 00:00:00 — это не событие (мгновение), а процесс (длящийся во времени). А Вам для правильной работы нужно именно событие.

Событием является переход от 23:59:59 к 00:00:00. Это событие происходит один раз. Но для его детектирования нужно иметь переменную, в которую каждый раз будет записываться значение времени. Таким образом, в текущей итерации цикла нужно делать примерно так:

2.
Вызов внешней программы из Питона может осуществляться с помощью функции system() из модуля os. Вот простенький пример кода:

Только учтите, что запуск внешних процессов бывает разный. Программы из приведённого выше примера запустятся и заработают нормально, а Питоновская программа сможет выполняться и дальше. А вот запуск штатного Дебиановского калькулятора galculator, который происходит в модальном режиме, не вернёт управление в Питоновскую прогу до тех пор, пока не закончит свою работу.

Рассмотрение вопросов запуска внешних процессов — это довольно-таки сложная тема. Её невозможно качественно осветить в ответах, нужно писать отдельную статью. Поищите в интернете, материала на эту тему много.

Спасибо. Буду разбираться и пробовать.

Хорошо написано, в смысле стиля изложения. Забрел сюда по запросу «Python и Com. 1» И информационность на серьезном уровне. Хорошо, что интернет не только для чайников. Спасибо. Зайду еще, поскольку есть задача сделать на Питоне прогу, считывающую датчики в автомобиле.

Спасибо Вам за теплые слова!

спасибо за статью!

Здравствуйте
Перед тем как принимать поток, необходимо в GPS подать команду на выдачу необходимых сообщений.
Как можно реализовать?

К сожалению за давностью времени я уже и не помню как правильно обращаться к GPS-модулю — какие команды ему давать.

1. Если Вас устраивает одноразовая инициализация GPS-модуля, которая осуществляется в самом начале работы программы, то после инициализации последовательного порта:

ser = serial.Serial(«/dev/ttyUSB0»)
ser.baudrate = 9600

допишите команду пересылки в GPS-модуль инициализирующей строки примерно как-то:

Обратите внимание на символы «\n». Они означают конец ввода и начало обработки введённых перед ними символов (то есть инициализирующей строки). Возможно, вместо последовательности символов «\n» Вам нужно будет записать последовательность «\n\r» или «\r\n». А может просто — «\r». Этих деталей я уже не помню. Попробуйте подобрать правильное решение сами.

После того как GPS-модуль будет проинициализирован, можете принимать от него информацию так, как описано в статье.

2. Если же Вам нужно в процессе работы пререконфигурировать GPS-модуль (то есть в в процессе работы давать ему команды), то дело сильно усложняется.

В этом случае я бы рекомендовал Вам изменить модель построения программы. Для таких решений программа должна быть многопоточной. Вам нужно из основного потока создать ещё один поток — рабочий, и в уже в нём принимать информацию от GPS-модуля и выводить её на консоль или в файл. А основной поток при этом будет обслуживать клавиатуру.

Как написать простое многопоточное приложение — это относительно большая отдельная тема.

Необходимо подать следующую последовательность.
!NVS CFG-PVTRATE 1
!WAIT 1000
!NVS CFG-RAWRATE 1
Вылетает ошибка

Пожалуйста, приведите данные по этой ошибке. Ведь не понятно — кто там у Вас «ругается», что ему конкретно не нравится…

Источник