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

Знакомимся с LabView

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

Практически у всех разработчиков устройств на микроконтроллерах, будь то любители или профессионалы, рано или поздно возникает необходимость подключить микроконтроллерный девайс к его «старшему брату», а именно к PC.

Вот тогда и встает вопрос, а какой софт использовать для обмена с микроконтроллером, анализировать и обрабатывать полученные от него данные? Часто для обмена МК с компьютером используют интерфейс и протокол RS232 — старый добрый COM порт в той или иной реализации.

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

Некоторые пишут подобное ПО самостоятельно на каком либо языке программирования (Delphi, C++), наделяя необходимым функционалом.

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

На фоне этих подходов резко отличается концепция виртуальных приборов (vi). В этой статье пойдет речь о программном продукте LabView фирмы Nationals Instruments. Я только начинаю осваивать этот замечательный продукт, поэтому могу допускать неточности и ошибки. Спецы поправят :-)) Собственно что такое LabView?

LabView — это среда разработки и платформа для выполнения программ, созданных на графическом языке программирования «G» фирмы National Instruments.

Говоря простым языком, LabView — Это среда создания приложений для задач сбора, обработки, визуализации информации от различных приборов, лабораторных установок и т.п. А также для управления технологическими процессами и устройствами. Однако с помощью LabView можно создавать вполне себе обычное прикладное ПО. У меня нет цели подробно описывать этот продукт и работу с ним.

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

Цель статьи — показать насколько просто и удобно, по сравнению с традиционным программированием, можно создавать приложения для ПК и какую мощь несет в себе LabView. (На самом деле спорно, т.к.

в традиционном программировании, на той же Delphi сделать не сложней. И по эффективности вряд ли хуже, если не лучше. Но для этого дельфу надо гораздо дольше изучать. Тут же все быстро и понятно почти сразу. Пару методичек проштудировал и вперед городить циферблаты всякие. Так что для программистов оно как собаке пятая нога, а вот таким далеким от компа товарищам как я — самое то.

Я когда то, за полчаса, впервые увидев LabView, по тоненькой методичке сваял зверскую систему управления поливом и отоплением для конопляной теплицы. С ПИД регуляторами всякими. Вывел на потенциометры и датчики лабораторного стенда, что стоял в нашем технаре и запустил этот адский агрегат. Причем все заработало сразу, без отладки.

Кстати, на LabView работает вся аппаратура адронного коллайдера, а также очень много научной аппаратуры. прим. DI HALT) Ведь большинству электронщиков чуждо программирование для PC, верно? Вот это мы и попробуем исправить. Дабы не изучать сферических вакуумных коней, поставим для себя и реализуем простенькую задачу.

Задача действительно проста, но на основе нее можно понять основные принципы программирования в LabView. Мы будем использовать LabView версии 2010. Для других версий отличия будут минимальны.

Задача
У нас есть плата с микроконтроллером AVR, соединенная с компьютером по RS232.

В контроллер залита прошивка, согласно которой контроллер измеряет значение напряжения на одном из входов АЦП, и передает код АЦП (от 0 до 1023) в компьютер по последовательному каналу.

Необходимо написать программу для ПК, которая будет принимать поток данных от АЦП, отображать код АЦП, преобразовывать код АЦП в значение напряжения в вольтах, отображать значение напряжения в вольтах, строить график изменения напряжения во времени.

Ну наверное хватит лирики, начнем пожалуй!

Итак что нам потребуется для работы:

  • Собственно сама LabView. Можно скачать с сайта NI триал версию: http://www.ni.com/trylabview/. Также без проблем нагугливается пиратская версия. Кстати, на rutracker.org, помимо прорвы пиратских, лежит и версия под Linux на которую регистрация вроде как не требуется вообще. NI решила пойти навстречу опенсорцу?
  • Также обязательно необходимо скачать компонент NI VISA. Без этой программы LabView не «увидит» COM порт на компьютере. VISA содержит в себе функции для работы с комуникационными портами и много чего еще. Скачать ее можно с joule.ni.com. Устанавливаем LabView и VISA. Установка этого ПО стандартная, каких либо особенностей не имеет.

Первым делом нам нужно убедится, что VISA нашла в системе COM порт и корректно с ним работает. Проверить это можно так: запускаем программу Measurement & Automation. Она ставится вместе с LabView. Если она не установилась, установить можно вручную. На диске (образе с LabView она есть).

В левой части окна мы видим оборудование, обнаруженное в системе. Среди всего прочего находим наш COM порт. Справа есть кнопка Open Visa test panel. С помощью нее можно протестировать выбранное устройство.

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

Запускаем LabView. В окне Getting Started выбираем пункт Blank Vi, тобишь новый виртуальный прибор.

Получаем вот такую штуку:

Итак что мы имеем. Рабочая область состоит из двух больших панелей Front Panel и Block Diagram. На лицевой панели мы будем составлять интерфейс нашей программы, используя элементы управления с панели Controls.

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

Тут надо немного отступить и пояснить принцип программирования на LabView. Небольшой пример. Принято работу над прогой начинать с оформления интерфейса, а затем реализации алгоритма работы на блок-диаграмме. Сделаем простейшую прогу умножения двух чисел.

Для этого разместим на лицевой панели путем перетаскивания три элемента управления, скажем элементы Knob и Numeric Indicator для отображения результата.

Сформируем интерфейс как душа пожелает, например вот так:

Ок, теперь нам необходимо реализовать собственно умножение. Переходим на панель Block diagram и видим что для каждого из наших контролов создался соответствующий значек. Лучше всего сразу перевести режим отображения в виде терминалов. Не будет так загромождаться диаграмма.

Кроме того в терминалах виден тип данных, которыми оперирует тот или иной контрол. Для этого щелкаем ПКМ по значку и снимаем галку View as icon. Вверху на скрине контрол в виде терминала, внизу и справа в виде иконки.

Для того чтобы настроить вид на блок-диаграмме в виде терминалов по умолчанию, нужно выбрать пункт меню Tools->Options, слева выбрать Block diagram и снять галку Place front panel terminals as icons. Очень полезно вывести контекстной справки. Вывести его можно комбинацией Ctrl+H.

В этом окошке отображается информация о объекте на котором в данный момент налодится курсор. Мега удобная вещь.

Теперь нужно добавить на блок-диаграмму функцию умножения. Щелкаем ПКМ на блок-диаграмме и из палитры Numeric выбираем функцию умножения Multiply. Преносим ее на диаграмму. Стоит заметить, что LabView имеет просто огромный набор функций. Это и различная математика, статистика, анализ сигналов, PID регулирование, обработка видео, звука и изображений. Всего не перечислишь.

Важнейшей концепцией программирования на LabView является концепция потоков данных DataFlow.

Суть такова: В отличие от императивных языков программирования, где операторы выполняются в порядке следования, в LabView функции работают только если на всех входах функции есть информация (каждая функция имеет входные и выходные значения).

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

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

Для соединения элементов на блок-диаграмме используется инструмент Connect Wire с панели Tools. Выбираем его и рисуем наши соединения.

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

Как видно, ничего сложного вроде бы нет. Но в то же время LabView позволяет решать задачи любой сложности! Епт, система управления БАК на нем сделана! Так то.

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

Итак, что нам необходимо сделать. Сначала нужно настроить и проинициализировать последовательный порт. Запустить бесконечный цикл . В цикле мы используем функцию чтения из порта и принимаем информацию. Преобразуем инфу для отображения на графике, пересчитываем код АЦП в значение напряжения в вольтах.

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

Хотя делать нужно наоборот! Но в данном случае так удобнее.

На панели блок-диаграммы помещаем из палитры Structures элемент While Loop, это наш бесконечный цикл. Обводим рамкой цикла область, достаточную для размещения внутри алгоритма. В правом нижнем углу есть красная точка, щелкнем по ней ПКМ и выберем Create Control. На лицевой панели у нас тут же появится кнопка Stop. При щелчке на ней наша прога завершится.

Теперь вне цикла мы должны разместить функции инициализации и закрытия порта. Слева инициализация, справа закрытие. Опять же щелкаем ПКМ и выбираем функции Configure Port, Read и Close. Эти функции находятся в палитре Instrument I/O —> Serial. Функцию чтения помещаем внутрь цикла.

Соединяем с помощью катушки с проводами выходы и входы функций. Для функции Read мы должны задать количество байт, которая она будет принимать. Щелкаем ПКМ на среднем входе функции Read и выбираем Create->Constant, вводим значение, например 200.

На данном этапе должно получится как на скрине.

Нужно создать контролы для функции инициализации порта. Нам вполне хватит двух — скорость порта и имя порта. Точно так же как мы создавали константу для функции чтения, создаем контролы. ПКМ на нужных входах функции инициализации и пункт

Create->Control.

Нас интересуют два входа: Visa resourse name и Baud Rate (по умолчанию 9600). Таперь перейдем на лицевую панель и добавим необходимые компоненты, а именно экран отрисовки графика и метки для отображения кода АЦП и напряжения в вольтах.
Соответственно это элементы Waweform Chart c палитры Graph и два элемента Numeric Indicator с палитры Numeric.

Вернемся к блок-диаграмме и переместим появившиеся элементы внутрь цикла. Мы близимся к завершению! Единственное, нам нужно еще преобразовать строку символов, поступающих с выхода функции Read к формату, который переварят наши индикаторы. И еще реализовать простейшую математику по переводу кода АЦП в вольты. Ниже скрины лицевой панели и блок-диаграммы на данном этапе:

Для преобразования строки мы воспользуемся функцией Scan from string из палитры String. Помещаем ее внутрь цикла. Теперь математика.

Для того чтобы преобразовать код АЦП в значение напряжения в вольтах нужно умножить код на величину опорного напряжения (в моем случае это пять вольт) и получившееся значение разделить на 1023 (так как АЦП имеет разрядность 10 бит).

Необходимые функции умножения и деления, а также константы (5 и 1023) разместим в цикле. Скрины каждого соединения делать не буду, ибо и так картинок дофига. Приведу финальный скрин всех соединений. Там все предельно просто.

Я думаю все понятно, если будут вопросы спрашивайте в каментах. Вместе разберемся :-))) Тем временем прога готова.

Перейдем к нашему интерфейсу и немного настроим график. Выделим нижнее значение по оси Y и поставим 0. Выделем верхнее и поставим 5. Таким образом наша шкала по оси Y в диапазоне 0-5 вольт.

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

Щелкаем на кнопке Stop чтобы остановить прогу.

Как видите все достаточно просто. Данный пример это лишь мизерная часть всех возможностей LabView. Если кому поможет данная статья, буду рад. Только в коментах сильно не бейте я же не профи.

Читайте также:  Типичные неисправности контакторов

Еще один маленький трюк. Если диаграмма стала похожа на Ктулху, можно попробовать воспользоваться кнопкой CleanUp Diagram. Она приведет диаграмму в более-менее божеский вид, но пользоваться надо осторожно.

Вот результат ее работы

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

Много книжек по LabView можно качнуть на automationlabs.ru

Bomond для Easyelectronics.ru

Источник: http://easyelectronics.ru/znakomimsya-s-labview.html

Интеграция с оборудованием

 Содержание
Взаимодействие NI LabVIEW с оборудованием
Сокращение времени разработки  за счет простой интеграции оборудования
Оборудование NI
Оборудование сторонних производителей
Простое взаимодействие LabVIEW с оборудованием

Взаимодействие NI LabVIEW с оборудованием

Более 20 лет инженеры и ученые используют при работе с измерительными устройствами и системами управления среду NI LabVIEW, которая легко интегрируется с множеством различных устройств и помогает сэкономить время разработки.

Сокращение времени разработки  за счет простой интеграции оборудования

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

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

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

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

Подключение к любому устройству

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

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

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

 

Рис.1. LabVIEW легко интегрируется с тысячами измерительных устройств и устройств управления

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

National Instruments – мировой лидер в области компьютеризированных систем сбора данных. За последние 10 лет было продано оборудования, имеющее в сумме более 50 млн. каналов ввода/вывода.

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

Используя драйверы NI-DAQmx, вы можете подключить более 200 устройств сбора данных с различными интерфейсами и конструктивными исполнениями (форм-факторами), включая USB, PCI, PCI Express, PXI, PXI Express, Ethernet и беспроводную связь.

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

Программируемые контроллеры автоматизации NI, используемые для систем измерения и управления на производстве, объединяют в себе надежность ПЛК и производительность ПК.

Устройства для систем машинного зрения обладают дополнительными возможностями, которые не часто встречаются у аналогичного оборудования (например, проверка позиционирования объекта, подсчет элементов, чтение штрих-кода). Для каждого типа оборудования имеются соответствующие наборы драйверов

  •  •    Цифровые мультиметры
  •  •    Высокоскоростные АЦП (осциллографы)
  •  •    Анализаторы радиочастотных сигналов
  •  •    Генераторы радиочастотных сигналов
  •  •    Генераторы сигналов
  •  •    Высокоскоростные модули цифрового ввода-вывода
  •  •    Коммутаторы
  •  •    Программируемые источники питания
  •  •    Реконфигурируемые системы ввода/вывода на базе ПЛИС
  •  •    Контролеры управления движением
  •  •    Системы машинного зрения

Эти драйверы разработаны c учетом специфики LabVIEW и максимальных возможностей оборудования. Драйверы устанавливаются непосредственно в LabVIEW и автоматически добавляют соответствующие функции в палитру функций блок-диаграммы.

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

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

Оборудование сторонних производителей

LabVIEW работает не только с оборудованием NI, но из тысячами других устройств, используя драйверы приборов. Более 8 тысяч бесплатных драйверов устройств более 275 сторонних производителей доступно на Instrument Driver Network (IDNet). Большая часть этих драйверов сертифицирована NI, а это значит, что они соответствуют стандартам качества NI.

В том случае, когда найти нужный драйвер не получается, вы можете модернизировать имеющийся с помощью интерактивных мастеров LabVIEW. Поддерживаются основные интерфейсы взаимодействия с оборудованием: GPIB, последовательные (RS232, RS485 и RS422), USB, VXI, PXI, Ethernet, IEE 1394, VISA, Modbus и OPC-серверы.

Быстрый поиск драйвераНа сайте ni.com размещены тысячи бесплатных драйверов оборудования NI и сторонних производителей. Все оборудование NI комплектуется драйверами LabVIEW, однако, в случае утери CD с драйверами или необходимости обновления версии, вы всегда можете найти нужные файлы на ni.com. Многие сторонние производители также поставляют своё оборудование вместе с драйверами LabVIEW. Почти все эти драйверы можно обнаружить на IDNet – крупнейшем ресурсе по этой теме с драйверами для тысяч моделей сотен производителей.

Рис.2. IDNet – это крупнейшая библиотека драйверов оборудования

Помимо ручного поиска на IDNet, вы можете воспользоваться Instrument Driver Finder для установки драйверов оборудования сторонних производителей. LabVIEW автоматически определит подключенные устройства, выполнит поиск драйверов на IDNet и установит их.

 

Рис.3. Утилита LabVIEW Instrument Driver Finder обнаруживает подключенные устройства и осуществляет поиск соответствующих драйверов

Драйверы LabVIEW устанавливаются собственным установщиком или с помощью Instrument Driver Finder, поэтому вам не придется вручную копировать библиотеки DLL.

Удобный доступ к функциям

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

 

Рис.4. После установки драйвера устройства его функции становятся доступны через палитру функций

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

Простая проверка работоспособности подключения

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

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

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

 

Рис.5. Некоторые драйверы LabVIEW предоставляют пользователю справочную информацию – схемы подключения

Кроме того, драйвер NI-DAQmx также позволяет быстро отобразить и проверить текущие данные, поступающие с устройства, с помощью тестовой панели.

Рис.6. Используя тестовые возможности драйверов NI-DAQmx можно быстро увидеть сигнал и определить неисправность

Последовательная методика разработки

Драйверы LabVIEW скрывают низкоуровневые механизмы взаимодействия с оборудованием за простыми высокоуровневыми функциями.

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

Рис. 7. Драйверы оборудования LabVIEW используют единую программную архитектуру.

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

Именно поэтому драйверы LabVIEW обычно предоставляют доступ к простым высокоуровневым функциям, таким как “Read Single Point Measurement” или “Configure Sample Clock” помимо низкоуровневых, которые необходимы для более сложного взаимодействия с устройствами, например, для синхронизации устройств.

Тысячи примеров кода, которые можно использовать в качестве основы вашего приложения

Независимо от того, начинающий ли вы пользователь LabVIEW или опытный программист, вы по достоинству оцените функционал инструмента NI Example Finder.

Вам доступно огромное количество примеров из самых разных областей – от анализа и отображения данных до специфических особенностей работы драйверов вашего оборудования.

Вы всегда можете использовать пример в качестве основы собственного приложения или позаимствовать необходимые фрагменты кода.

 

Рис.8. NI Example Finder отображает список демонстрационных примеров для установленных драйверов

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

Простое взаимодействие LabVIEW с оборудованием

Среда LabVIEW способна взаимодействовать с тысячами разнообразных устройств и поэтому является наилучшим выбором для построения системы на базе ПК. Кроме этого, LabVIEW позволяет сократить время разработки, предлагая единую программную архитектуру взаимодействия с оборудованием.

Однако следует помнить, что LabVIEW – это не просто программный интерфейс к оборудованию.

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

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



Источник: http://www.labview.ru/labview/what_is_labview/integration_with_hardware.php

LabView первое знакомство

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

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

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

При открытии LabView вам предложат создать новую программу (New Blank VI). Сделайте это.
Вы увидите два окна:

Первая из них Front Panel – лицевая (передняя) панель, на которой возможно создавать произвольный виртуальный прибор путем выбора разнообразных деталей из меню Control (появляется при нажатии правой клавиши манипулятора), среди которых большое разнообразие ручек настроек, переключателей, индикаторов, панелей
отображения графиков, а также элементов дизайна для улучшения внешнего вида виртуального прибора.

Вместе с лицевой панелью появляется функциональная панель Block Diagram – панель диаграммы, имеющая то же имя что и передняя панель. На этой панели
одновременно с элементами, располагаемыми на передней панели, появляются соответствующие им значки (терминалы).

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

Если соединения сделаны без ошибок, то программа готова к запуску на выполнение.

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

В оба окна (панели) добавляються элементы при помощи окон, которые появляються по правому клику в свободной области:

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

Для этого в меню кликаем правой клавишей и элемент Knob:

Затем разместим “лампочку” led:

Индикатор:

Обратите внимание, что при помещении каждого объекта во втором окне (окне блок-схемы), появляются соответствующие блоки.
Расположите их любым удобным для вас образом, я сделал вот так:

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

Для этого нам понадобиться блок сравнения:

Сформируйте вот такую схему:

Думаю любые пояснения здесь излишни. Понять и простить, как говориться…

Теперь смело жмите кнопку Run Continuously. При вращении ручки (Knob) вы видите текущее значение в поле Numeric. Также при достижении значения 5, загорается светодиод.

Скачать пример

Источник: http://blablacode.ru/labview/426

Записки программиста

Благодаря заметке Микроконтроллеры STM32: работа с внешним EEPROM мы научились работать с внешней EEPROM-памятью с I2C-интерфейсом. Сегодня же мы научимся использовать флеш-память с SPI-интерфейсом на примере популярных чипов AT45DBxx. Существуют разные модификации этих чипов, отличающиеся в основном объемом памяти.

Читайте также:  Первые цифровые оптические ультрафиолетовые датчики от silicon labs

При написании этой заметки я использовал AT45DB161E объемом 16 Мбит (2 Мб). Но, по идее, все описанное ниже справедливо и для других чипов этой серии.<\p>

Пожалуй, наиболее очевидное преимущество чипов AT45DBxx перед рассмотренными ранее 24Cxx заключается в существенно большем объеме памяти.

У первых я видел модификации, хранящие 8 Мб данных (AT45DB641E), и теоретически протокол позволяет работать с объемами данных до 16 Мб. Вторые же предлагают максимум 256 Кб. AT45DB161E поддерживает передачу данных с тактовой частотой до 85 МГц, против 400 КГц у 24LC64. То есть, чипы AT45DBxx позволяют передавать данные намного быстрее.

Но при этом следует учитывать время выполнения конкретных операций. Например, операция очистки и записи одной страницы в случае AT45DBxx занимает десятки миллисекунд.

EEPROM хорош тем, что он более долговечен. Даташит 24LC64 [PDF] сообщает, что чип переживает более 1 миллиона циклов очистки-записи, и что данные будут хранится более 200 лет.

Для сравнения, согласно даташиту AT45DB161E, гарантируется только 100 000 циклов очистки-записи, и данные хранятся лишь 20 лет. Кроме того, чипы 24Cxx заметно дешевле. Розничные цены в России на них начинаются где-то от 0.1$, против 0.6$ у чипов AT45DBxx.

Наконец, как мы скоро убедимся, работать с AT45DBxx несколько сложнее, хотя эта сложность и может быть завернута в библиотеку.

Итак, создадим новый проект в STM32CubeMX. Для своих экспериментов я все также использую отладочную плату Nucleo-F411RE. Если у вас другая отладочная плата, отличия в настройке будут минимальными. Для общения с ПК включаем USART2, как делали это в статье Микроконтроллеры STM32: обмен данными по UART.

Также включаем периферию SPI1, в выпадающем списке Mode выбираем «Full-Duplex Master». В этом режиме периферии нужен пин PA5, который по умолчанию управляет светодиодом на отладочной плате. Поэтому STM32CubeMX будет жаловаться на ошибку в конфигурации, пока мы не освободим пин PA5. Также помечаем пин PB6 как GPIO_Output.

Он будет использоваться для выбора SPI устройства, с которым мы хотим поговорить (так называемый «chip select» или «slave select»).

Вот что должно получиться:

В случае подключения Arduino-шилда к плате Nucleo расположение пинов будет следующее: пины (D13, D12, D11, D10) шилда = пины (PA5, PA6, PA7, PB6) микроконтроллера = пины (SCK, MISO, MOSI, CS) шины SPI.

Далее генерируем проект, правим немного Makefile — все как обычно.

Можно взять за основу Makefile из предыдущего проекта, убрав из списка C_SOURCES все лишнее (например, про I2C) и добавив в него строчку:

$(FIRMWARE)/Drivers/STM32F4xx_HAL_Driver/Src/stm32f4xx_hal_spi.c<\p>

Взглянем на распиновку AT45DB161E (иллюстрация из даташита [PDF]):

Питание подается через пины VCC и GND, нужно от 2.5 В до 3.6 В. Общение с чипом по SPI производится через пины SI, SO, SCK и CS. Подключаем их к соответствующим пинам отладочной платы. Пин WP — это write protection. Если WP подключен к плюсу, разрешено и чтение и запись. Если же пин подключен к минусу, разрешено только чтение.

По умолчанию WP уже подтянут к плюсу, поэтому можно оставить его висящим. Тем не менее, даташит рекомендуется по возможности дополнительно подключать его к VCC. Наконец, подача низкого напряжения на пин RESET сбрасывает его внутреннее состояние. Если эта возможность не используется, даташит рекомендует подключить пин к VCC.

С учетом всего вышесказанного, у меня получился такой сэндвич:

На этом работа с железной частью завершена, переходим к софтверной. Даташит содержит подробное описание множества команд, поддерживаемых чипом. Рассмотрим некоторые из них.

Важно! Существует две модификации чипов AT45DBxx. Первая модификация работает со страницами размером 528 байт. Пример полной маркировки такого чипа: AT45DB161E-SHD.

Вторая модификация работает со страницами размером 512 байт, пример маркировки: AT45DB161E-SHD2B, где часть «2B» как раз указывает на размер страниц в 512 байт (см разел 27.1 даташита). В зависимости от размера страницы меняется и их адресация.

Далее приводится код для -SHD чипов, в котором также присутствует закомментированный код для -SHD2B чипов.

Самая простая команда, это, пожалуй, получение device id. Я бы советовал выполнить ее в первую очередь, чтобы убедиться в правильности подключения и всего такого. Команда имеет код 0x9F и принимает в ответ 5 байт:

HAL_StatusTypeDef res1, res2;
uint8_t devid_cmd[1] = { 0x9F };
uint8_t devid_res[5];

HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6, GPIO_PIN_RESET);

res1 = HAL_SPI_Transmit(&hspi1, devid_cmd, sizeof(devid_cmd),
                        HAL_MAX_DELAY);
res2 = HAL_SPI_Receive(&hspi1, devid_res, sizeof(devid_res),
                       HAL_MAX_DELAY);
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6, GPIO_PIN_SET);

if((res1 != HAL_OK) || (res2 != HAL_OK)) {

    char msg[256];
    snprintf(
        msg, sizeof(msg),
        “Error during getting the device id, res1 = %d, res2 = %d
“,
        res1, res2);
    HAL_UART_Transmit(&huart2, (uint8_t*)msg, strlen(msg),
                      HAL_MAX_DELAY);
    return;
}  

{  

    char msg[256];
    snprintf(msg, sizeof(msg),
        “Manufacturer ID: 0x%02X

        “Device ID (byte 1): 0x%02X

        “Device ID (byte 2): 0x%02X

        “Extended device information (EDI) string length: 0x%02X

        “EDI byte 1: 0x%02X

        “——–
“,
        devid_res[0], devid_res[1], devid_res[2],
        devid_res[3], devid_res[4]);
    HAL_UART_Transmit(&huart2, (uint8_t*)msg, strlen(msg),
                      HAL_MAX_DELAY);
}

Ответ должен быть следующим:

Manufacturer ID: 0x1F Device ID (byte 1): 0x26 Device ID (byte 2): 0x00 Extended device information (EDI) string length: 0x01

EDI byte 1: 0x00

Для чтения и записи существует сильно больше одной команды. Устройство имеет два SRAM-буфера, каждый размером в одну страницу.

И предусмотрены команды вроде «записать содержимое буфера 1 в страницу», «прочитать содержимое буфера 2», «очистить страницу», и подобного рода.

В определенных задачах эти команды могут быть полезны, однако мы рассмотрим лишь самые простые с точки зрения использования команды.

Чтобы записать данные через буфер 1 с предварительной очисткой страницы, воспользуемся командой 0x82. Следом за кодом команды должны следовать три байта, содержащие адрес, по которому мы хотим осуществить запись, а затем и сами данные. О том, что передача данных завершилась, устройство узнает по исчезновению низкого напряжения с пина CS:

uint16_t pageAddr = 0x123;
const char wmsg[] = “This is a test message”;

uint8_t wcmd[4];

// opcode
wcmd[0] = 0x82; // 0x82 for buffer 1, 0x85 for buffer 2
// for 512 bytes/page chip address is transfered in form:
// 000AAAAA AAAAAAAa aaaaaaaa
// wcmd[1] = (pageAddr >> 7) & 0x1F;
// wcmd[2] = (pageAddr > 6) & 0x3F;
wcmd[2] = (pageAddr > 1) & 0x01;
uint8_t page_size = (status_res[0]) & 0x01;
uint8_t epe = (status_res[1] >> 5) & 0x01;
uint8_t sle = (status_res[1] >> 3) & 0x01;
char msg[256];
snprintf(msg, sizeof(msg),
    “Await loop took %ld ms, %ld iterations

    “Sector protection status: %s

    “Page size: %d bytes

    “Erase/program error: %s

    “Sector lockdown command: %s

    “——–
“,
    delta, cnt,
    protect ? “enabled” : “disabled”,
    page_size ? 512 : 528,
    epe ? “ERROR!” : “no error”,
    sle ? “enabled” : “disabled”);
HAL_UART_Transmit(&huart2, (uint8_t*)msg, strlen(msg), HAL_MAX_DELAY);

Пример вывода:

Await loop took 10 ms, 1750 iterations Sector protection status: disabled Page size: 528 bytes Erase/program error: no error

Sector lockdown command: enabled

Дождавшись завершения записи, можно попытаться и прочитать только что записанные данные. Для этого существуют команды 0x0B и 0x1B.

Последняя, насколько я смог выяснить, появилась лишь в более поздних чипах производства Adesto (компания купила эту часть бизнеса у Atmel в 2012 году), и не упоминается в даташитах более старых устройств, например AT45DB161D [PDF]. Поэтому рассмотрим более переносимую команду 0x0B.

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

char rmsg[sizeof(wmsg)] = {0};

uint8_t rcmd[5];

// opcode
rcmd[0] = 0x0B;

// for 512 bytes/page chip address is transfered in form:

// rcmd[1] = (pageAddr >> 7) & 0x1F;
// rcmd[2] = (pageAddr > 6) & 0x3F;
rcmd[2] = (pageAddr

Источник: https://eax.me/stm32-spi-flash/

Arduino, LabView и датчик температуры

В статье рассмотрены основы передачи данных Arduino на персональный компьютер и в обратном направлении с использованием LabView.

Вы научитесь отсылать строки и получать данные, которые передаются через USB порт.

Вам помогут навыки программирования на Arduino и создания блок-диаграм виртуальных инструментов (ВИ) в LabView, но даже если вы ни разу не работали в LabView или Arduino IDE, интсрукция достаточно подробная и ее должно хватить.

Для проекта вам понадобятся

  • Микроконтроллер Arduino UNO;
  • LM35 (Или другой сенсор);
  • Программа LabVIEW С установленным NI-VISA Driver;

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

Что такое LabVIEW?

LabVIEW (Laboratory Virtual Instrument Engineering Workbench) – это визуальный язык программирования, разработанный компанией National Instruments. Наибольшее применение LabView нашел в сферах получение данных с измерительных приборов (основная идея примера в этой статье), управления, промышленной автоматизации.

Arduino – это open-source платформа, которая обеспечивает разработку интерактивных проектов. В этих проектах берутся данные с различных датчиков или элементов управления (джойстики, кнопки и т.п.) и передаются дальше для управления светодиодами, моторами и т.д.

Проекты на Arduino могут быть автономными и могут передавать-получать данные с программного обеспечения на вашем персональном компьютере (для этого часто используют технологии Flash, Processing, MaxMSP).

Плату Arduino можно собрать самостоятельно, а можно купить уже собранную, в том числе и у неоригинального (итальянского) производителя.

Оболочка для программирования Arduino IDE доступна для скачивания совершенно бесплатно с оффициального сайта Arduino.

LabVIEW: создаем программу (виртуальный инструмент)

1. Создайте новый VI (ВИ), перейдя на вкладку File > New VI.

2. Перейдите в окно block diagram (блок-диаграмма). Выберите ВП в Data Communication > Protocols > Serial.

3. Настройте:

  • VISA Configure Serial Port: установите серийный порт.
  • VISA Write (2x): запись данных на подключенное устройство.
  • VISA Read: считывание данных с серийного порта подключенного устройства.
  • VISA Close: закрытие подключения.
  • Bytes at Serial Port: проверка того, доступны ли какие-то данные.

LabVIEW: Structures (структуры) и основы создания программы

Настало время создать основу нашего ВИ в LabView.

1. Создайте цикл условия while loop Programming > Structures > While Loop.

2. Создайте три структуры Case structure внутри цикла while loop. Цикл Case находится в Programming > Structures > Case Structure.

3. Первые две структуры Case используются для записи строки, а последняя – для чтения.

4. Иконки с операторами VISA Configure Serial Port и VISA Close выносятся за пределы структуры while loop.

Вы можете разместить VISA Configure Serial Port внутри структуры while loop. В примере, который рассматривается нами вам надо будет выбрать COM порт перед запуском виртуального инструмента (ВИ). Если же вы разместите VISA Configure… внутри структуры, вы сможете выбрать COM порт в любое время.

5. Visa Bytes at Port располагается внутри структуры while Loop. Для ого, чтобы активировать условие для считывания информации, надо проверить, есть ли она вообще на серийном порту. Для этого мы проверяем количество байтов на серийном порту и сравниваем его с 0. Для этого используется Programming > Comparison > Grater than 0 VI.

6. Если количество байт на порту больше 0, активируется структура “True Case Structure” и VISA Read вернет считанные байты.

7. VISA Configure Serial Port дает пользователю возможность выбрать какой именно серийный порт будет использоваться и устанавливает скорость обмена данными. То есть “Visa resource name” и “Baud Rate” должны быть элементами управления. По умолчанию скорость обмена данными равна 9600.

8. Используйте блок VISA Write > Write Buffer. Эта строка будет передана на USB порт. В этой статье в дальнейшем будут использоваться условные обозначения ВКЛ для Включить и ВЫКЛ для Выключить.

Если вы хотите передавать команды с клавиатуры, вы можете использовать VISA Write для создания элемента управления строками. В этом примере использовались кнопки.

Читайте также:  Переделка старых блоков питания компьютера ат в атх

9. Перейдите в окно Front Panel (Интерфейс пользователя) и создайте необходимые элементы интерфейса.

10. Для того, чтобы отобразить полученные данные (температура), можно использовать Numerics > Thermometer и параллельно Graph Indicators > Chart.

11. Добавьте кнопки (Buttons > OK Button), для того, чтобы вкл/выкл датчик. Измените Mechanical Action на Switch Until Released и добавьте числовые индикаторы (Num Inds > Num Indicator), чтобы отслеживать температуру.

Вы также можете добавить элементы управления вроде “USB Control” и “LM35”;

12. Вернитесь в окно блок-диаграмы, чтобы настроить кнопки (Buttons), графики (Graph), термометр (Thermometer) и числовые индикаторы (Num inds).

Для отображения данных, полученных с USB порта, их надо преобразовать из строки в число:

  • Programming > String > String/Number Convertions > Fract/Exp String to Number: конвертирует строку в число. Этот ВИ надо добавить внуть структуры read case structure, чтобы убедиться, что все полученные данные будут конвертированы.
  • Вход String данного ВИ подключен к read buffer подпрограммы VISA Read.

13. Теперь подключите Gaph, Thermometer и Num ind к выходу Number, который находится в Fract/Exp String to Number.

14. Подключите кнопку turn on (вкл) к первому условию case structure, а кнопку turn off (выкл) – ко всторому условию. Кнопку stop подключите к условию While Loop.

15. Так как процесс проходит достаточно быстро, добавьте небольшую задержку (delay) в пределах цикла while loop: Programming > Timing > Wait (ms). Выставьте задержку равной 600 мс, чтобы убедиться, что все данные были получены. При этом Arduino будет обновлять данные каждые 500 мс (смотрите скетч Arduino).

VISA Configure Serial Port находится внутри структуры while loop на рисунке выше.

LabVIEW: дополнительные фичи

  • Вы можете проверить, доступен ли USB порт или проверить наличие ошибок на нем. Этот (Programming > Dialog and User Interface > Find First Error) ВИ возвращает “true”, если есть ошибка. Если ошибки нет или она устранена, COM порт будет доступен.
  • Можете создать так называемый “error handler” (Programming > Dialog and User Interface > Simple Error Handler). С его помощью вы сможете не только обнаружить ошибку, но и узнать, где она, получить ее описание.
  • Кроме того, вы можете перезапустить ВИ в любой момент его работы. Просто используйте VI Server Reference (Programming > Application Control> VI Server Reference) и Invoke Node (Programming > Application Control> Invoke Node).

Программа для Arduino

1. Инициализируем все переменные и пины, которые вы будете использовать. В данном случае:

  • 1 светодиод (Светодиод на Arduino);
  • 1 сенсор LM35.

char command;

String string;

#define led 13

#define lm A1

2. Void Setup.

void setup()

{

Serial.begin(9600);

pinMode(led, OUTPUT);

}

3. Void Loop.

void loop()

{

if (Serial.available() > 0)

{string = “”;}

while(Serial.available() > 0)

{

command = ((byte)Serial.read());

if(command == ':')

{

break;

}

else

{

string += command;

}

delay(1);

}

if(string == “TO”)

{

TempOn();

}

if(string ==”TF”)

{

TempOff();

}

}

4. В коде для Arduino используются две функции: TempOn(); и TempOff();. Они управляют сенсором.

4.1: TempOn() – функция, которая запускает измерения:

Вы спокойно можете использовать другой сенсор или просто вкл/выкл светодиоды. Для это достаточно немного изменить функции;

void TempOn()

{

int x = analogRead(lm);

float temp = (5.0*x*100.0)/1024.0;

Serial.println(temp);

digitalWrite(led, HIGH);

delay(500);

}

4.2: TempOff() – функция, которая прерывает измерения:

void TempOff()

{

digitalWrite(led, LOW);

delay(500);

}

Необходимые пояснения к программе для Arduino

Цикл void loop – самая важная часть программы. Внутри этого цикла проверяется наличие подключенных устройств на серийном порту. Именно поэтому используется Serial.available(); Эта функция проверяет байты на порту.

Если на порту есть информация, формируется строка этих байтов, после чего в работу вступает Serial.read(); и благодаря строке

string =+ string + command;

полностью отрабатывает необходимый алгоритм.

Загрузки

Ниже приведены скетч для Arduino и ВИ для LabView, которые были детально рассмотрены в статье. Скачивайте и экспериментируйте!

LabVIEW_Write_Read.ino

Arduino and LabVIEW.vi

Оставляйте Ваши комментарии, вопросы и делитесь личным опытом ниже. В дискуссии часто рождаются новые идеи и проекты!

Источник: http://arduino-diy.com/arduino-LabView-datchik-temperatury

Учебный стенд LESO6 и LabVIEW

Шауэрман Александр А. shamrel@yandex.ru

В этой статье постараемся разобраться, как организовать взаимодействие персонального компьютера (ПК) с учебным стендом LESO6 в среде графического программирования LabVIEW (National instruments).

Эта информация будет актуальна для учебного стенда LESO1 и для любого другого устройства на микроконтроллере, где для связи с компьютером использован преобразователь USB от Future Technology Devices International (FTDI).

И так, стенд LESO6 (а также и LESO1, и LESO3) подключается к ПК через интерфейс USB. На стендах установлена микросхема преобразователя USBUART FT232RL. Таким образом, на стороне микроконтроллера взаимодействие будет происходить через последовательный интерфейс UART.

Согласно принципиальной схеме стенда это USART1. На стороне компьютера стенд определится как последовательный порт.

Из среды LabVIEW для работы с последовательными портами можно использовать компонент NI-VISA, однако, как показала многолетняя практика нашей лаборатории, удобнее и надежнее использовать непосредственно драйвер D2XX.

Для организации такого взаимодействия нужно решить следующие задачи:
1. Разработать протокол взаимодействия, другими словами определить в каком формате будут передаваться команды и данные с устройства на ПК и обратно, определить формат пакета.

2. Разработать программное обеспечение для микроконтроллера. Оно должно включать в себя драйвер USART, декодер и формирователь команд, и собственно, функции, которые выполняют сами прикладные действия.
3. Разработать ПО для компьютера.

Рассмотрим решение задачи в режиме “от простого к сложному”.

Шаг первый. Подключаем стенд

На первом этапе обойдемся без программы для микроконтроллера и какого-либо протокола связи. Научим LabVIEW взаимодействовать со стендом.

Как уже говорилось, работать будем непосредственно с драйвером. Драйвер представляет собой динамическую библиотеку ftd2xx.dll, которая находится в директории с Windows (как правило C:WindowsSystem32). Естественно, в системе должен быть установлен драйвер FTDI D2XX.

Если это не так, то скачиваем с официального сайта www.ftdichip.com и устанавливаем. В LabVIEW работа с динамическими библиотеками dll осуществляется с помощью узла (Node) Call Library Function (палитра Connectivity -> Libraries & Executables).

Этот узел позволяет вызвать определенную функцию из dll, для этого нужно указать путь к библиотеке, выбрать функцию, определить типы входных и выходных переменных, назначит буфера для ввода-вывода…

Если вдруг кто-то по какой-то причине не захочет этим заниматься, то можно скачать готовые подприборы (subVI) с сайта FTDI LabVIEW Examples. Так мы и сделаем. Скачиваем и распаковываем архив D2XX_Functions_7.0.zip.

Для создания простейшей программы на LabVIEW для работы со стендом на понадобится всего лишь один subVI из скаченной библиотеки. Создадим новый VI и добавим туда через пункт “Select a VI…” подприбор FT_Get_Number_of_Devices.

Этот subVI возвращает количество устройств FTDI, подключенных к компьютеру. Модуль имеет всего два выхода “FT_Status” и “Number of Devices”. Легко догадаться, что последний как раз и возвращает число устройств, а первый возвращает статус.

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

Напомню, для того, чтобы создался индикатор требуемого типа, правой кнопкой мыши нажмем на выводе, выберем пункт “Create”, а там уже “Indicator”. В результате должно получиться как на рисунке ниже.

Для компактности вида я обычно в контекстном меню индикатора или контрола убираю галочку с “View As Icon”.

Если в результате запуска число устройств будет больше нуля, а статус – “FT_OK”, то можно работать дальше, если иначе, следует разобраться с драйверами и еще раз проверить физическое подключение стенда.

Аналогичную простейшую программу с одним subVI можно создать с помощью некоторых других модулей, например FT_Get_Device_Description_By_Index – возвращает строку с описанием подключенного прибора.

Шаг второй. Открываем и закрываем

Идеология программного взаимодействия с устройством FTDI напоминает работу с файлами. Также как файл, устройство перед операциями чтения/записи должно быть открыто, а после работы закрыто. Вместо дескриптора служит handle – четырехбайтная переменная. Все обращения к устройству выполняются через handle.

Устройство может быть открыто по его номеру в системе (если устройство одно, то этот номер 0), по его описанию (прошито в память FTDI, для стендов это “LESO6”, “LESO1.1” и т.д.), по серийному номеру или по его положению на шине USB (номер USB порта).

Для каждого способа предназначен соответствующий subVIE: FT_Open_Device_By_Index, FT_Open_Device_By_Description, FT_Open_Device_By_Serial_Number, FT_Open_Device_By_Location.

На рисунке ниже пример программы, которая открывает устройство по индексу, возвращает статус и закрывает устройство.

Такой способ наиболее простой и подходит, если к компьютеру подключено одновременно не более одного преобразователя FTDI, в противном случае, целесообразно использовать открытие по описанию (By Description), как показано ниже:

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

В противном случае, при повторном запуске программы драйвер сообщит (вернет FT_Status), что устройство занято и/или уже используется.

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

Шаг третий. Обмен данными

Реpализуем на LabVIEW типовой алгоритм взаимодействия с прибором: открыть устройство -> настроить устройство -> послать данные -> принять данные -> закрыть устройство.

Для начала создадим простейший проект для LESO6, я буду использовать драйвера периферии из проекта leso6_demo (можно взять из git репозитория). Программа инициализирует UART на скорости 11520 кБит/с, в функции обратного вызова uart_rx_cb() принятый байт отправляется обратно. Программа реализует алгоритм “Эхо”. Листинг ниже.

#include
#include
 
#include “gpio.h”
#include “uart.h”
//< Функция обратного вызова для приема байта по uart. void uart_rx_cb(uint8_t ch) { uart_putchar(ch, NULL); }   int main() { uart_init(); //!< Инициализируем UART. // Устанавливаем функцию обратного вызова на прием байта по UART. uart_set_input_cb(uart_rx_cb); while(1); // return 0; }

Компилируем и загружаем программу в лабораторный стенд. (Как это сделать?)

Открывать и закрывать устройство мы уже умеем, разберемся как настраивать. Подприбор FT_Set_Baud_Rate устанавливает скорость передачи (для нашего примера 115200), подприбор FT_Set_Data_Characteristics задает режим работы: 8/7-ми битный, количество стоп-бит, наличие/отсутствие/назначение бита паритета (9-ый бит, бит четности).

После настройки правилом хорошего тона является очистить входные и выходные буфера, для этого используем subVI FT_Purge.

Отправить данные микроконтроллеру можно с помощью подприборов FT_Write_Byte_Data и FT_Write_String_Data.

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

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

Для приема данных служат два похожих subVI: FT_Read_Byte_Data и FT_Read_String_Data. Как понятно из названия, первый принимает байтовый массив, второй строку – по сути это одно и тоже.

Обоим подприборам помимо handle на вход следует подать количество байт для приема. На выходе собственно сами принятые данные, их количество и, как всегда, статус.

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

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

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

Отсюда следует, что если у двух узлов одновременно на входа поступят данные, то очередность их выполнения будет случайной. Так на рисунке выше видно, что на подприборы FT_Purge, FT_Set_Baud_Rate и FT_Set_Data_Characteristics данные приходят одновременно, потому порядок их выполнения предсказать сложно.

Однако в этом конкретном примере для нас это не играет никакой роли: не важно, установим ли мы вначале скорость передачи или количество стоп-бит. Совсем другое дело, если поменяется очередь выполнения записи и чтения (FT_Write_Byte_Data и FT_Read_Byte_Data), в этом случае будет нарушен алгоритм работы.

В нашей программе для того, чтобы упорядочить очередь выполнения использована Flat Sequence Structure (палитра Programming -> Structures). Рамки в этой структуре выполняются последовательно слева направо.

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

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

Источник: http://www.labfor.ru/articles/labview/leso6_part1

Ссылка на основную публикацию
Adblock
detector