Word dword что это

В VC ++ 6.0 BYTE, WORD, DWORD — это целое число без знака, которое определено в WINDEF.h

typedef unsigned char BYTE;

typedef unsigned short WORD;

typedef unsigned long DWORD;

Другими словами, BYTE — это тип без знака, WORD — беззнаковый короткий тип, а DWORD — беззнаковый длинный тип.

В VC ++ 6.0 1 байт символа, short — 2 байта, int и long — 4 байта, поэтому можно считать, что переменные, определяемые BYTE, WORD, DWORD, — это 1 раздел, 2 байта, 4 слова. Раздел.

То есть: BYTE = unsigned char, WORD = unsigned short, DWORD = unsigned long

DWORD обычно используется для сохранения адреса или сохранения указателя

Разница между словом и словом

Определение WORD и DWORD в основном для: 1. Легко трансплантировать; 2. Более строгая проверка типов

WORD фиксируется на 2 байта, DWORD фиксируется на 4 байта

Int, с разными операционными системами, имеет разное количество байтов, в 32-битной операционной системе — 4 байта, в 16-битной операционной системе — 2 байта

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

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

В данном примере будут задействованы int 10h для очистки экрана (AL=3) и для расположения курсора текста (AH=2).
Ну и int 21h для вывода текста на экран.
Всё, других прерываний в уроках больше не будет. О них за долгие годы написано достаточно.

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

Целые числа

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

Первым делом необходимо выбрать систему счисления, наиболее подходящую для применения в конкретных устройствах. Для электронных устройств самой простой реализацией является двоичная система: есть ток — нет тока, или малый уровень тока — большой уровень тока. Хотя наиболее эффективной являлась бы троичная система. Наверное, выбор двоичной системы связан еще и с использование перфокарт, в которых она проявляется в виде наличия или отсутствия отверстия. Отсюда в качестве цифр для представления информации используются 0 и 1.

Таким образом данные в компьютере представляются в виде потока нулей и единиц. Один разряд этого потока называется битом. Однако в таком виде неудобно оперировать с данными вручную. Стандартом стало разделение всего потока на равные последовательные группы из 8 битов — байты или октеты. Далее несколько байтов могут составлять слово. Здесь следует разделять машинное слово и слово как тип данных. В первом случае его разрядность обычно равна разрядности процессора, т.к. машинное слово является наиболее эффективным элементом для его работы. В случае, когда слово трактуется как тип данных (word), его разрядность всегда равна 16 битам (два последовательных байта). Также как типы данных существую двойные слова (double word, dword, 32 бита), четверные слова (quad word, qword, 64 бита) и т.п.

Теперь мы вплотную подошли к представлению целых чисел в памяти. Т.к. у нас есть байты и различные слова, то можно создать целочисленные типы данных, которые будут соответствовать этим элементарным элементам: byte (8 бит), word (16 бит), dword (32 бита), qword (64 бита) и т.д. При этом любое число этих типов имеет обычное двоичное представление, дополненное нулями до соответствующей размерности. Можно заметить, что число меньшей размерности можно легко представить в виде числа большей размерности, дополнив его нулями, однако в обратном случае это не верно. Поэтому для представления числа большей размерности необходимо использовать несколько чисел меньшей размерности. Например:

Если A — число, B₁..B_k — части числа, N — разрядность числа, M — разрядность части, N = k*M, то:

Например:

Существуют понятия младшая часть (low) и старшая часть (hi) числа. Старшая часть входит в число с коэффициентом 2^N-M, а младшая с коэффициентом 2⁰. Например:

Байты числа можно хранить в памяти в различном порядке. В настоящее время используются два способа расположения: в прямом порядке байт и в обратном порядке байт. В первом случае старший байт записывается в начале, затем последовательно записываются остальные байты, вплоть до младшего. Такой способ используется в процессорах Motorola и SPARC. Во втором случае, наоборот, сначала записывает младший байт, а затем последовательно остальные байты, вплоть до старшего. Такой способ используется в процессорах архитектуры x86 и x64. Далее приведен пример:

Используя подобные целочисленные типы можно представить большое количество неотрицательных чисел: от 0 до 2^N-1, где N — разрядность типа. Однако, целочисленный тип подразумевает представление также и отрицательных чисел. Можно ввести отдельные типы для отрицательных чисел от -2^N до -1, но тогда такие типы потеряют универсальность хранить и неотрицательные, и отрицательные числа. Поэтому для определения знака числа можно выделить один бит из двоичного представления. По соглашению, это старший бит. Остальная часть числа называется мантиссой.

Если старший бит равен нулю, то мантисса есть обычное представление числа от 0 до 2^N-1-1. Если же старший бит равен 1, то число является отрицательным и мантисса представляет собой так называемый дополнительный код числа. Поясним на примере:

Как видно из рисунка, дополнительный код равен разнице между числом 2^N-1 и модулем исходного отрицательного числа (127 (1111111) = 128 (10000000) — |-1| (0000001)). Из этого вытекает, что сумма основного и дополнительного кода одного и того же числа равна 2^N-1.

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

В итоге можно составить таблицу наиболее используемых целочисленных типов данных:

Прежде
чем переходить к непосредственно
изучению МЭК-языков,
необходимо познакомиться с общими
элементами этих
языков. Общие элементы служат единым
фундаментом, по­зволяющим
объединить многоязычные компоненты в
одном про­екте.
В главе будут рассмотрены данные, с
которыми способен работать
стандартный ПЛК, форматы их представления
и наиболее общие
приемы и тонкости работы с ними.

Типы данных

Тип
данных переменной определяет род
информации, диапазон представления и
множество допустимых операций. Языки
МЭК
используют идеологию строгой проверки
типов данных. Это означает,
что любую переменную можно использовать
только по­сле
ее объявления. Присваивать значение
одной переменной другой
можно, только если они обе одного типа.
Допускается также присваивание
значения переменной совместимого типа,
имеющей более
широкое множество допустимых значений.
В этом случае происходит
неявное преобразование типа без
потерь. Неявные преобразования
типов данных с потерями запрещены. Так,
например,
логическую переменную, способную
принимать только два
значения (логические 0 и 1), можно присвоить
переменной типа
SINT
(-128…+127), но не наоборот.

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

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

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

Типы
данных МЭК разделяются на две категории
— элементарные и составные. Элементарные
или
базовые
типы являются
основой для построения составных типов.
К составным
типам
относятся
перечисления, массивы, структуры, массивы
структур
и т. д.

Элементарные
типы данных

Целочисленные
типы

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

Нижний
предел диапазона целых без знака 0,
верхний предел определяется
как (2ⁿ)
— 1, где n
— число разрядов числа. Для чисел
со знаком нижний предел —(2ⁿ-1),
верхний
предел (2ⁿ-1).

Наименования
целых типов данных образуются с
применением
префиксов, выражающих отношение размера
к 16-разрядным словам:
S
(short
*1/2) короткое, D
(double
*2) двойное, L
(long
*4) длинное.
Префикс U
(unsigned)
указывает на представление це­лых
без знака.

Переменные
типов BYTE,
WORD,
DWORD
и LWORD
определяются
стандартом как битовые строки ANY_BIT.
Говорить
о диапазоне значений чисел для этих
переменных вообще некорректно. Они
представляют строки из 8, 16 и 32 бит,
соответственно.
Помимо обращения с такими переменными
как к единым целым,
их можно использовать побитно.

Целые
числа могут быть представлены в двоичной,
восьмеричной,
десятичной или шестнадцатеричной
системе счисления. Числовые
константы, отличные от десятичных,
требуют указания основания
системы счисления перед знаком «#».
Например:

2#0100_1110

8#116

16#4E78

Для
обозначения шестнадцатеричных цифр от
10 до 15 испо­льзуются
латинские буквы от А до F.
Символ
подчеркивания «_» не влияет на значение
и использу­ется
исключительно для улучшения зрительного
восприятия числа.
Например: 10_000, 16#01_88. Подчеркивание можно
применять
только между цифрами или в конце числа.
Два или более подчеркивания
подряд применять нельзя.

Логический тип

Два значении False
и True.
Начальная инициализация – ложь.

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

Действительные
типы

Переменные
действительного типа REAL
представляют действительные
числа в диапазоне ±10^±38.
Из 32 бит, занимаемых числом, мантисса
занимает 23 бита. В результате точность
пред­ставления
приблизительно составляет 6 — 7 десятичных
цифр.

Длинный
действительный формат LREAL
занимает
64 бита. Число
содержит 52-битовую мантиссу. Точность
представления приблизительно
составляет 15 — 16 десятичных цифр.
Диапазон чисел
длинного действительного ±10^±307.

Числа
с плавающей запятой, записываются в
формате с точкой:
14.0, -120.2, 0.33_ или в экспоненциальной форме:
-1.2Е10, 3.1е7.

Интервал времени

Переменные
типа TIME
используются для выражения интервалов
времени. В
отличие от времени суток (TIME_OF_DAY)
временной
интервал не ограничен максимальным
значением в 24
часа.

Числа,
выражающие временной интервал, должны
начинаться с
ключевого слова TIME#
или в сокращенной форме Т#. В общем случае
представление времени составляется из
полей дней (d),
ча­сов
(h),
минут (m),
секунд (s)
и миллисекунд (ms).
Порядок представления
должен быть именно такой, хотя ненужные
элементы можно опускать. Для лучшего
зрительного восприятия поля допускается
разделять символом подчеркивания.
Например:

VAR

TIME1:
TIME:=
T#10h_14m_5s;

END_VAR

Старший
элемент может превышать верхнюю границу
диапа­зона представления. Так, если
в представлении присутствуют дни или
часы, то секунды не могут превышать
значения 59. Если секунды
стоят первыми, то их значение может быть
и большим. Смысл
этого правила состоит в том, что если
вы хотите выражать интервал,
например, исключительно в секундах —
пожалуйста. Но
если вы задействуете минуты, то для
единообразия представ­ления, секунды
обязаны соблюдать принятые «правила
субординации».

Младший
элемент можно представить в виде
десятичной дроби:
TIME1:=
T#1.2S; (*равносильно
Т#1s200ms*)

Время суток и
дата

Типы
переменных, выражающие время дня или
дату, пред­ставляются
в соответствии с ISO
8601.

Дата
записывается в формате «год» — «месяц»
— «число». Время
записывается в формате «часы»: «минуты»:
«секунды».«со­тые».
Дата определяется ключевым словом DATE#
(сокращенно D#),
время дня TIME_OF_DAY#
(сокращенно TOD#),
дата и время
DATE
AND
TIME#
(сокращенно DT#).

DATE#2002-01-31
или
D#2002-01-31 TIME_OF_DAY#16:03:15.47
или
TOD#16:03:15.47

DATE_AND_TIME#2002-01-31-16:03:15.47
или

DT#2002-01-31-16:03:15.47

Все
три типа данных физически занимают 4
байта (DWORD).
Тип
TOD
содержит время суток в миллисекундах
начиная с 0 ча­сов. Типы DATE
и DT
содержат время в секундах начиная с 0
ча­сов
1 января 1970 года.

Строки

Тип
строковых
переменных STRING
определяет
переменные, содержащие текстовую
информацию. Размер строки задается при
объявлении.
Например, объявление строки strl,
вмещающей до 20
символов, и str2
— до 60 символов:

VAR

str1:
STRING(20); str2:
STRING(60):= ‘Тест’;

END_VAR

Если
начальное значение не задано, то при
инициализации будет
создана пустая строка.

Количество
необходимой памяти определяется заданным
при объявлении
размером строки. Для типа STRING
каждый
символ занимает
1 байт (WSTRING
2
байта). Строковые константы задаются
между одинарных кавычек:

str1
:= ‘Полет нормальный’;

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

$$

$’

$L
или $l
для LF

$N
для CR

$T
для Tab

Иерархия
элементарных типов

Приведенная
ниже иерархия
элементарных типов применяет­ся
исключительно для удобства описания
программ. Каждое наи­менование ANY_…
объединяет некоторое множество типов.
Так, при
описании любой битовой операций удобнее
указать, что она применима
для ANY_BIT,
чем перечислять всякий раз допусти­мые
элементарные типы. Применять ANY_
при
объявлении пере­менных,
конечно, нельзя.

Пользовательские
типы данных

Описание
пользовательских
типов данных (кроме
массивов) должно
выполняться на уровне проекта (в CoDeSys
на вкладке «Типы
данных» — «Организатор Объектов»).
Объявление типа всегда
начинается с ключевого слова TYPE
и
заканчивается строкой END
TYPE.

Массивы

Массивы
представляют
собой множество однотипных элемен­тов
с произвольным доступом. Массивы могут
быть многомерны­ми.
Размерность массива и диапазоны индексов
задаются при объявлении
(см. пример задания трехмерного массива):

<Имя
массива>: ARRAY

[<li1…lh1>,
<li2…lh2>,
<li3…lh3>]
OF
<mun
элемента>;

где
,
li1,
li2,
li3
указывают нижние пределы индексов; lh1,
lh2
и lh3
— верхние пределы. Индексы должны быть
целого типа и только
положительные, отрицательные индексы
использовать нельзя.

Примеры объявления
массивов:

XYbass: ARRAY
[1..10,1..20] OF
INT;

TxtMsg: ARRAY
[0..10] OF STRING(32);

Massl: ARRAY
[1..6] OF SINT := 1,1,2,2,2,2;

Mass2: ARRAY
[1..6] OF
SINT
:= 1,1,4(2);

Два
нижних примера показывают, как можно
выполнить элементов
массива при объявлении. Оба примера
со­здают
одинаковые массивы. В первом примере
все начальные зна­чения приведены
через запятую. Во втором примере
присутствует сокращение N(a,b,c..),
которое означает — повторить
последовательность а, b,
с.. N раз. Многомерные массивы
инициализируют­ся построчно:

Mass2d:
ARRAY
[1..2,1..4] OF
SINT
:= 1,2,3,4,5,6,7,8;

Для
доступа к элементам массива применяется
следующий синтаксис:

<Имя_массива>[Индекс1,Индекс2,ИндексЗ]

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

XYbass[2,12]
:= 1;

i
:= STR_TO_INT(TxtMsg[4]);

Если
это не принципиально, используйте в
массивах нумерацию с
0. В этом случае вычисление физического
адреса элемента при ис­полнении
проще. В результате код получается
несколько короче.

Структуры

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

В
отличие от массивов структура действительно
вводит новый тип данных. Это означает,
что до применения конкретной пере­менной
нужно выполнить как минимум два
объявления. Сначала нужно
описать структуру. Описание структуры
происходит глоба­льно,
на уровне проекта. Описанная структура
получает иденти­фикатор
(имя
структуры). Но это еще не переменная,
это новый тип
данных. Теперь, используя новый
идентификатор, нужно объявить
одну или сколько угодно переменных,
точно так же, как
и для базовых типов. Только теперь
переменная нового типа получает
«телесную оболочку» или, иными словами,
конкретное место
в памяти данных.

Объявление
структуры должно
начинаться с ключевого слова STRUCT
и заканчиваться END_STRUCT.
Синтаксис объявления выглядит
так:

TYPE
<Имя_структуры>:
STRUCT

<Объявление
переменной 1>

• • •

<Объявление
переменной п>

END_STRUCT

END_TYPE

Пример
объявления структуры по имени Trolley:

TYPE Trolley: STRUCT

Start: TIME;

Distance: INT;

Load,
On: BOOL;

Articl: STRING(16);

END_STRUCT

END_TYPE

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

Telegal:
Trolley
:= (Articl:=’Пустой’);

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

Для доступа к
элементам структуры используется
следующий синтаксис:

<Имя__переменной>.<Имя_элемента>

Например:

Telegal.On
:= True;

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

TrolleySet:
ARRAY[0..2]
OF
Trolley
:= (Articl
:= ‘Т1’), (Articl
:= ‘Т2’), (Articl
:= ‘ТЗ’); TrolleySet[i].On
:= TRUE;

Если
структура содержит вложенную структуру,
то доступ к элементам
вложенной структуры осуществляется с
применением составного имени, содержащего
две точки:

train.wagon[5].
weight;
(*wagon[]
вложенный массив структур*)

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

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

Перечисления

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

TYPE
<Имя
перечисления>:

(<Элемент
0>, < Элемент 1>, … <
Элемент
п>);

END_TYPE

Объявленная
позднее переменная типа <Имя
перечисления> может
принимать только перечисленные значения.
При инициа­лизации переменная получает
первое из списка значение. Если числовые
значения элементов перечисления не
указаны явно, им присваиваются
последовательно возрастающие числа
начиная с 0. Фактически элемент перечисления
— это число типа INT
с огра­ниченным набором значений.
Если необходимо, значения элемен­там
можно присвоить явно при объявлении
типа перечисления. Например:

TYPE
TEMPO:

(Adagio
:= 1,

Andante
:= 2,

Allegro
:= 4);

END_TYPE

Идентификаторы
элементов перечисления используются
в про­грамме
как значения переменной:

VAR

LiftTemp:
TEMPO:= Allegro;

END_VAR

Если
в разные перечисления включены элементы
с одинаковыми именами, возникает
неоднозначность. Для решения этой
проб­лемы
применяется префикс, содержащий
перечисление: TEMPO#Adagio.
В CoDeSys
все наименования элементов перечис­ления
обязаны быть уникальными.

Ограничение
диапазона

Тип
переменных с ограниченным
диапазоном значений позволяет
определить допустимое множество значений
переменной. Объявление
типа переменной с ограниченным диапазоном
должно происходить
непосредственно между ключевыми словами
TYPE
и END_TYPE:

TYPE
<Имя>
:

<Целый
тип> (от ..до)

END_TYPE

Например:

TYPE
DAC10:

INT(0..16#3FF);

END_TYPE

Применение
переменной с ограничением диапазона
покажем на
примере:

VAR

dac: DAC10;

END_VAR

dac:= 2000;

При
попытке трансляции данного примера
возникает законная ошибка:

‘Error:
Type mismatch: Cannot convert ‘2000’ to INT(0.
.1023)’.

Псевдонимы типов

Проблема
выбора подходящего типа данных не всегда
решает­ся легко. Допустим, вы работаете
с температурой, замеренной 16-разрядным
АЦП. Может ли быть температура только
выше нуля
или когда-либо потребуется работать в
отрицательной облас­ти,
еще не совсем очевидно. В одном случае
нужно использовать тип
переменных UINT,
а в другом — INT.
Здесь удобно опреде­лить
новый тип данных:

TYPE
TEMPERATURA:

UINT;

END
TYPE

Далее
везде в программе вы используете тип
TEMPERATURA
при
объявлении переменных. Если вдруг
понадобится изменить тип
температуры на INT,
то это легко и быстро можно будет сде­лать
в одном месте.

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

Переменные

Каждая
переменная
обязательно
имеет наименование и тип. Сущность
переменной может быть различной.
Переменная может представлять
вход или выход ПЛК, данные в оперативной
или энергонезависимой памяти. Далее мы
рассмотрим правила объяв­ления
и некоторые практические сложности и
тонкости, возника­ющие при работе с
переменными.

Идентификаторы

Имя
переменной (ее
идентификатор) должно быть составлено
из
печатных символов и цифр. Цифру нельзя
ставить на первое место. Пробелы в
наименовании использовать нельзя.
Вместо них
обычно
применяется символ подчеркивания.
Символ подчеркива­ния
является значимым. Так имена ‘Varl’,
‘Var_l’
и ‘_Varl’
яв­ляются
различными. Два подчеркивания подряд
использовать нельзя.
Регистр букв не учитывается. Так ‘VAR1’
и ‘Varl’
одно и то значение.
Как минимум, 6 первых знаков идентификатора
являются значимыми
для всех систем программирования.

Аналогичные
требования относятся и к любым
идентификаторам
МЭК-программ (компоненты, метки, типы и
т. д.).

Распределение
памяти переменных

Контроллер
с точки зрения МЭК программы имеет
несколько областей
памяти, имеющих разное назначение.

1. Область входов
   ПЛК.

2. Область выходов
   ПЛК.

3. Область прямо
   адресуемой памяти.

4. Оперативная память
   пользователя (ОЗУ).

Аппаратные
ресурсы ПЛК присутствуют в МЭК-проектах
в неявной форме. Размещение переменной
в одной из трех первых об­ластей
приводит к ее связи с определенной
аппаратурой — входа­ми,
выходами или переменными системы
исполнения (диагности­ка
модулей, настройка параметров ядра и
т. д.). Распределение пе­ременных
в этих областях определяется изготовителем
ПЛК. Привязка
к конкретным адресам задается при помощи
прямой адреса­ции.
Для обеспечения переносимости программного
обеспечения прямые
адреса нужно использовать только в
разделе объявлений. В языках программирования
стандарта не предусмотрено опера­ций
прямого чтения входов-выходов. Эту
работу выполняет систе­ма исполнения.
При необходимости для низкоуровневого
обращения
изготовителем ПЛК поставляются
специальные библиотеки.

Объявление
переменной без префикса AT
физически означает выделение
ей определенной памяти в области ОЗУ.
Распределение доступной
памяти ОЗУ транслятор осуществляет
автоматически.

Переменные
принято разделять на глобальные и
локальные по области
видимости. Глобальные
переменные определяются
на Уровне
ресурсов проекта (VAR_GLOBAL)
и доступны для всех про­граммных
компонентов проекта. Локальные
переменные описываются
при объявлении компонента и доступны
только внутри него. Описание любого
программного компонента содержит, как
мини­мум, один раздел объявления
локальных переменных VAR,
пере­менных
интерфейса VAR_INPUT,
VAR_OUTPUT,
VAR_IN_OUT
и
внешних глобальных переменных VAR_EXTERNAL
(см.
по­дробнее
«Компоненты организации программ»).

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

Прямая адресация

Для
создания прямо
адресуемой переменной
используется сле­дующее
объявление:

имя
переменной АТ%
прямой
адрес тип;

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

Далее следует
символ, определяющий тип прямого адреса:

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

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

В
прямом адресе указывается именно номер
элемента. Это ко­ренным
образом отличается от физических адресов
микропроцес­сора.
Если прямой адрес определяет байт, то
номер элемента — это
номер байта. Если прямой адрес определяет
слово, то номер элемента
— это номер слова, и, естественно, один
элемент зани­мает два байта. Так,
следующие два объявления адресуют один
и тот
же байт:

a1 AT%QB5 BYTE;

a2 AT%QW2 WORD;

a1:=5;

a2.0:=8;

В
каждой области памяти адресация элементов
начинается с нуля.
Физическое размещение прямо адресуемых
областей в ОЗУ определяется
конфигурацией контроллера. Очевидно,
что сопо­ставление идентификаторов
переменных прямым адресам является
делом, требующим большой аккуратности.
Поэтому для слож­ных
модульных контроллеров применяются
специальные фирменные
конфигураторы, подключаемые к оболочке
комплекса программирования
и позволяющие графически «собрать» ПЛК
и определить
все необходимые интерфейсные переменные.

Входы
ПЛК — это переменные с прямыми адресами
в области
I.
Они доступны в прикладных программах
только по чтению, Выходы Q
— только по записи. Переменные в области
М доступ­ны
по записи и чтению.

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

Прямые
адреса можно использовать в программах
непосредственно:

IF
%IW4
> 1 THEN

(*3начение входа
IW4*)

Тем
не менее все же желательно компактно
сосредоточить в проекте
все аппаратно-зависимые моменты.

Обратите
внимание, что прямая адресация позволяет
разместить
несколько разнотипных переменных в
одной и той же памяти.
Например, специально для быстрого
обнуления 16-дискретных выходов
(BOOL)
можно использовать переменную типа
WORD.
Или, например, совместить переменную
STRING
и несколько пе­ременных
типа BYTE,
что даст возможность организовать
форма­тирование
вывода без применения строковых функций.
Посколь­ку
физическое распределение адресов
известно на этапе трансля­ции,
компилятор формирует максимально
компактный код для таких
объединений, чего не удается достичь
при работе с элемен­тами
массива, где требуется динамическая
адресация.

Синтаксис
прямых или МЭК адресов выглядит следующим
образом:
каждый адрес начинается с
символа %,
с последующим префиксом области.
Префикс
I
указывает на область входов, Q
— область выходов и M
— область маркеров.
Далее следует
идентификатор размера: X
или ничего – один бит, B
обозначает байт (8 бит), W
— это 16 разрядное слово и D
— это двойное слово (32 бита). Завершают
адрес цифры, указывающие последовательные
адреса в заданной области, начиная с
0.

Например:
%IW215 — это 216-тое слово
в области входов.
%QX1.1 — это 2-й бит 2-го
слова в области выходов.
%MD48 — это 49-е
двойное слово в области маркеров.

Поразрядная
адресация

В
стандарте предусмотрена удобная форма
работы с отдельны­ми битами переменных
типа битовых строк — поразрядная
адре­сация.
Необходимый
бит указывается через точку после
иденти­фикатора.
Аналогичным образом можно использовать
отдельные биты прямо адресуемой памяти.
Младшему биту соответствует нулевой
номер. Поразрядная нумерация не должна
превышать гра­ницы
соответствующего типа числа.

VAR

a: WORD;

bStop AT %IX64.3:
BOOL;

END_VAR

a:=0;

a.3:=
1; (*или
а.З := TRUE;
— результат 2#0000_1000*)

a.18:=
TRUE; (*ошибка,
в WORD
не может быть бит а.18*)

IF
a.15
THEN
… (*а
меньше нуля?*)

Преобразования
типов

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

Рассмотрим
сначала работу с целыми числами. Пусть,
на­пример,
объявлена переменная siVar
типа короткое целое (SINT
8 бит) и переменная iVar
типа целое (INT
16 бит). Допус­тим
siVar
= 100, a
iVar
= 1000. Выражение iVar
:= siVar
являет­ся
вполне допустимым, поскольку числа типа
SINT
являются подмножеством
INT
(iVar
примет значение 100). Здесь преобра­зование
типа будет выполнено транслятором
автоматически, без каких-либо дополнительных
указаний. Обратное присваивание siVar:=
iVar
приведет к переполнению и потере данных.
Заста­вить
транслятор выполнить преобразование
с вероятной поте­рей
данных можно только в явной форме при
помощи специа­льного
оператора siVar
:= INT_TO_SINT(iVar).
Результат равен 24 (в шестнадцатеричной
форме 1000 это 1б#ОЗЕ8 и только младший его
байт перейдет в SINT,
значение 16#Е8 соответст­вует десятичному
числу 24).

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

Операторы
явного преобразования базовых МЭК-типов
образу-к>т свои наименования из двух
частей. Вначале указывается «ис­ходный
тип», затем «_ТО _» и «тип результата*.
Например:

(*
Результат 16#АА*) (*120*)

i
:= REAL_TO_INT(2.7); (*Результат
3*)

i
:= TRUNC(2.7); (*Результат
2*)

t
:= STRING_TO_TIME(‘T#216ms’); (*РезультатТ#216ms*)

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

Обратите
внимание, что операции преобразования
допустимы для
любых комбинаций базовых типов, а не
только для совмести­мых
типов (например, дату в строку). Так,
преобразования <…>_TO_STRING
фактически заменяют оператор PRINT,
распространенный
в языках общего применения.

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

Венгерская запись

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

Для
этого может использоваться специальная
запись имен переменных.
Впервые такая запись имен была предложена
Чарль­зом
Симони (Charles
Simonyi)
и обоснована в его докторской дис­сертации.
Возможно, потому что Симони родился в
Будапеште и образованные
по его системе наименования причудливы
(на пер­вый
взгляд), как венгерский язык, за его
методикой записи за­крепилось
название «венгерская запись». В настоящее
время Си­мони
является ведущим инженером Microsoft,
а венгерская за­пись
стала общепризнанной при программировании
под Windows.

Идея
венгерской записи заключается в
прибавлении к идентификаторам коротких
префиксов, определяющих тип и некоторые
другие
важные характеристики переменной.
Префиксы принято записывать
строчными буквами, а имя переменной с
заглавной буквы.
Поскольку венгерская запись «работает»
для любых типи­зированных языков,
имеет смысл применить ее и при
программи­ровании
ПЛК.

Для
базовых типов МЭК можно предложить
следующие пре­фиксы
типов.

Примеры обозначений:

bStop: BOOL;

bySet: BYTE;

wSize UINT;

«Венгерские»
имена сами говорят о корректности их
примене­ния.
Очевидно, следующее выражение является
бессмысленным; bStop
:= wSize
* 2; а выражение bStop
:= wSize
> 2; вполне допус­тимым.

Уточнить
назначение переменной можно добавлением
еще од­ного
символа перед префиксом типа:

Для
временных переменных можно вообще не
утруждать се­бя
придумыванием имен, а использовать
только префиксы. На­пример:

aiSample:
ARRAY
[1..32]
OF
INT;
ci: INT;

FOR ci := 1 TO 32 DO

(*без
комментариев*)

siSample[ci]
:= -1; END_FOR

К
сожалению, некоторые из предложенных
префиксов совпа­дают
с зарезервированными словами (BY,
AT,
D,
DT,
N,
ST).
При использовании
их в качестве временных переменных вы
можете добавить
порядковый номер или букву алфавита.
Например:

ЬуА,
ЬуВ, byl,
Ьу2: ‘BYTE;

Структуры
и функциональные блоки образуют имена
экземп­ляров
с включением полного или сокращенного
наименования типа.
Например, tpUpDelay:
TP;

Символ
подчеркивания удобно использовать для
индикаций способа
обращения к переменной. Подчеркивание
в начале имени указывает
— только чтение. Идентификаторы
переменных, соответствующих
входами ПЛК, начинаются символом
подчеркива­ния.
Подчеркивание в конце имени указывает
— только запись. Идентификаторы выходов
заканчиваются символом подчеркива­ния.
Например, Jylnpl,
byOut2_.

Если
система обозначений хорошо продумана,
то ее примене­ние
не вызывает сложности. Единый подход к
наименованию очень
здорово облегчает чтение программы и
позволяет отказать­ся от излишних
комментариев. Уникальные префиксы
удобны не только
для базовых типов, но и для широко
используемых в про­екте собственных
типов данных и функциональных блоков.
Стан­дарт
МЭК не содержит рекомендаций по
составлению имен пере­менных
и компонентов программы. Никакого
стандартного набо­ра
префиксов венгерской записи также нет.
Вы можете использо­вать
вышеописанную систему или разработать
свою собственную. Главное,
чтобы принятая система была понятна
всем программи­стам
— участникам проекта.

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

Формат
BCD

Двоично-кодированный
десятичный формат представления BCD
(binary
coded
decimal)
представляет собой числа в позицион­ной
десятичной системе, где каждая цифра
числа занимает 4 бита.
Например, десятичное число 81 будет
представлено в виде 2#1000_0001.
Арифметические
операции с BCD-числами
требуют применения специального
математического аппарата, малоэффек­тивны
в сравнении с обычным двоичным
представлением. Но, с другой
стороны, BCD
оказывается очень удобным при организа­ции
клавиатурного ввода и индикации.
Например, функции вы­вода
числа на принтер или даже на сегментный
индикатор полу­чаются тривиальными
(одна одномерная таблица на 10 констант).

Для
хранения чисел в формате BCD
стандарт МЭК предлагает использовать
переменные типов ANY_BIT
(кроме BOOL,
конеч­но).
Арифметика BCD-вычислений
обычно не поддерживается в стандартном
комплекте библиотек систем программирования
ПЛК.
В библиотеке утилит CoDeSys
реализованы две простые Функции
BCD
преобразования: BCD_TO_INT
и INT_TO_BCD.

К.Р.3