Segnetics matrix руководство

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296

#include "shm.hpp"
#include <stdio.h>
#include <time.h>
#include <unistd.h>
#include <signal.h>
#include <rlserial.h>
 
// -----------------------------------------------------------------------------
// Это пример программы обмена со slave устройством.
// Пример рабочий и показывает основные аспекты работы с последовательным портом.
// По реализации, rs485 и rs232 в данном примере не отличаются. Протокол обмена
// взят следующий, в нем есть только один тип запросов и один тип ответа на
// запрос, причем формат запроса и ответа ничем не отличается. Формат запросов:
// - пакет должен начинаться с символа ':' и заканчиваться контрольной суммой
// LRC и последовательностью 'r''n' (0x0A0x0D), в точности как в modbus ascii.
// Данные по протоколу передаются в ASCII формате, старшим байтом вперед
// также как в modbus ascii, но передается только одно значение слейву и
// одно значение же со слейва считывается. Протокол безадресный, т.е. подключить
// несколько устройств по шине нельзя. Проверка адреса и добавление различных
// функций по спецификациям протоколов задача тривиальная, поэтому в протоколе
// этого примера не рассмотрено, для простоты примера. Некоторые функции написаны
// не самым оптимальным образом, это сделано исключительно для наглядности.
// -----------------------------------------------------------------------------
 
// Наименование интерфейса
// Доступные названия /dev/rs485 /dev/rs232 соотвественно для 485 и 232 интерфейса
// /dev/usbdev /dev/usbhost для виртуальных com портов на usb портах
#define SERIAL_DEVICE       "/dev/rs485"
 
// Таймаут ожидания ответа от slave устройства
#define RESPONSE_TIMEOUT    100000
 
// -----------------------------------------------------------------------------
// TODO: сенкция инициализации глобальных переменных
// -----------------------------------------------------------------------------
 
// Класс работы с портом, из библиотеки rllib, взят для удобства использования 
// и наглядности примера
rlSerial       serial;
 
// Буфер обмена для всех передаваемых данных
unsigned char Msg[256+1];
// Указатель на этот же массив, но с первого элемента, чтобы опустить разделитель
// начала пакета ':'
unsigned char* Data = Msg+1;
 
// -----------------------------------------------------------------------------
// TODO: сенкция обьявления необходимых дополнительных функций
// -----------------------------------------------------------------------------
 
// Функция преобразования ASCII => int, старший байт вперед, как в modbus ascii
int buf2short_ascii(unsigned char *buf){
    int val;
    sscanf((char *) buf,"%4x",&val);
    return val;
}
// Функция преобразования int => ASCII, старший байт вперед, как в modbus ascii
void short2buf_ascii(int i, unsigned char *buf){
    char tmp = buf[4];  // sprintf поставит ноль в конце строки, нам это не надо
    sprintf((char *) buf,"%04x",i);
    buf[4] = tmp;       // вернем на место то, что затерлось нулем
}
 
// Функция подсчета LRC, полный аналог LRC modbus ascii, взять из rllib
// opensource библиотеки.
// Аргументы функции - указатель на место в пакете, где содержатся данные
// а также указатель на буфер, куда скопировать LRC, и длинну данных в пакете
void CalcLRC(char* from, char *to, int len)
{
  unsigned char lrc;
  int i,high,low,val;
 
  if(len < 0) return;
  lrc = 0;
  for(i=0; i<len; i+=2)
  {
    sscanf((const char *) &from[i],   "%1X", &high);
    sscanf((const char *) &from[i+1], "%1X", &low);
    val = high*16 + low;
    lrc += val;
  }
  lrc = ((unsigned char)(-((char) lrc)));
  sprintf((char *) to,"%02X",(unsigned int) lrc);
}
 
// Функция установки LRC для текущего пакета
void SetLRC(int len){
    // Установка LRC в конец пакета
    CalcLRC((char*)Data, (char*)Data+len, len);
}
 
// Функция проверки LRC для текущего пакета
int CheckLRC(int len){
    char result[3];
    // Подсчет LRC
    CalcLRC((char*)Data, result, len);
    // Проверка LRC
    if(result[0] == Msg[len+1] && result[1] == Msg[len+2])
        return 1;
    else
        return -1;
}
 
// Функция чтения пакета из порта, функция записывает данные в глобальный массив
// Msg. Возвращаемое значение: (-1) истек таймаут ожидания данных
//                             (число > 0) количество принятых байт в пакете
int ReadLineASCII(){
    int ret;
    int len = 0;
 
    // Побайтный цикл считывания данных из порта
 
    while(1) {
 
        // Функция select останавливает выполнение программы до тех пор,
        // пока не будут доступны новые данные (функция вернет ненулевое значение)
        // либо не истечет таймаут ожидания данных (функция вернет нулевое значение)
        if(serial.select(RESPONSE_TIMEOUT))
            ret = serial.readChar();    // пришли новые данные в порт
        else return -1; // Истек таймаут ожидания данных
 
        // Если функция ReadChar вернула отрицательное значение
        // выведем код ошибки для диагностики
        if(ret < 0)
            printf("Error in readChar %d", ret);
 
        // Если приняли признак начала пакета, начинаем запись пакета с начала
        if(ret == ':')
            len = 0;
        // Запишем принятый байт в буфер обмена
        Msg[len] = ret;
        // Увеличим индекс текущего элемента в буфере обмена
        // Остаток от деления использован только для защиты от переполнения
        // буфера
        ++len %= sizeof(Msg)-1;
 
        // Определение конца пакета, конец пакета обозначен для наглядности
        // как в modbus ascii - символами rn, соответствует коду 0x0A 0x0D
        // т.е. можно было записать if(ret == 0x0D) if(Msg[len-2] == 0x0A)
        // Важно! В других ASCII протоколах могут быть другие огранители
        // начала и конца посылки. Данные же взяты только для наглядности.
        if(ret == 'n'){
            if(Msg[len-2] == 'r')
                return len;
        }
    }
}
 
// Функция отправки пакета, возвращаемое значение - число отправленных байт
// в случае успеха, отрицателное число в случае ошибки
int SendMessage(int datalen){
        // Запишем первый байт - признак начала пакета
    Msg[0] = ':';
    // Установка контрольной суммы
    //в моем случае контрольная сумма не нужна
    //SetLRC(datalen);
    // Установка признаков конца пакета
    Msg[1+datalen] = 'r'; // индекс = 1(старт байт)+(datalen-данные)                  //+2(LRC)
    Msg[1+datalen+1] = 'n'; // индекс = 1(старт байт)+(datalen-данные)+1('r')     // +(2-LRC)
 
    // Функция передачи пакета в порт, принимает указатель на передаваемый массив,
    // содержащего пакет и размер передаваемого пакета
    //int ret = serial.writeBlock(Msg,1+datalen+2+1+1); // размер = 1(старт байт)+
    int ret = serial.writeBlock(Msg,1+datalen+1+1); 
    // datalen(данные)+2(LRC)+1('r')+1('n')
 
    if(ret < 0) // Если возникла ошибка отправки пакета, выведем ее для диагностики
        printf("Error sending %s with %dn", Msg, ret);
    else // Если пакет отправлен удачно,
        printf("send - %s", Msg);   // выведем его содержимое для диагностики
    return ret;
}
 
// Функция чтения и проверки пакета, возвращаемое значение - число полученных байт
// в случае успеха, отрицателное число в случае ошибки
int ReadMessage(){
    // Вызов функции чтения пакета из порта
    int ret = ReadLineASCII();
 
    // Проверка возвращаемого значения
    if(ret < 0){
        // Значит вышли из функции ReadLineASCII по таймауту
        // Иначе говоря, за отведенное время новых данных не пришло
        printf("read timed outn");
        return ret;
    }
    // Проверка контрольной суммы
    if(CheckLRC(ret-1-2-2) < 0){
        // Контрольная сумма не совпала, выведем диагнотстическое сообщение
        printf("LRC errorn");
        // И вернем отрицательное значение - чтобы сигнализировать об ошибке
        return -2;
    }
 
    // В конце пакета поставим ноль, чтобы размер пакета правильно определялся
    // библиотечными функциями printf strlen и т.п.
    Msg[ret] = 0;
    printf("received - %s", Msg);
    return ret;
}
 
// -----------------------------------------------------------------------------
// Функция main, с нее начинается выполнение программы
// -----------------------------------------------------------------------------
int main()
{
    // -------------------------------------------------------------------------
    // Секция инициализации локальных переменных функции main
    // -------------------------------------------------------------------------
 
    Shm mymem("./load_files.srv"); //Инициализация переменных разделяемой памяти
    
    // Проверим наличие sharedmem переменных в проекте и корректность типа данных
    //if(mymem.getType("TestValue") != SHORT)     exit(1);
    //if(mymem.getType("master") != SHORT)        exit(1);
    //if(mymem.getType("slave") != SHORT)         exit(1);
    if(mymem.getType("cmd") != FLOAT)    exit(1);
    if(mymem.getType("mass") != FLOAT)     exit(1);  
    
    // TODO: Здесь можно разместить обьявить и
    // инициализировать необходимые вам переменные
 
    // Выведем для диагностики, что программа начала выполнение
    printf("startn");
 
    // Вызов функции для начала работы с портом и установки параметров связи
    // Здесь можно менять значения параметров кроме 3го и 4го
    // Первый параметр - имя интерфейса, определен макросом SERIAL_DEVICE
    // Второй параметр - скорость обмена по порту (должен быть как у slave)
    // Третий параметр - блокирующие вызовы отправки и приема байт (не менять)
    // Четвертый параметр - использование аппаратного управления (не менять)
    // Пятый параметр - количество байт данных (чаще всего менять не нужно)
    // Шестой параметр - количество стоповых бит (должен быть как у slave)
    // Седьмой параметр - четность (должен быть как у slave)
    if(serial.openDevice(SERIAL_DEVICE,B4800,1,0,8,1,rlSerial::EVEN) < 0)
    {
        printf("Error opening serialn");
        exit(1);
    }
 
    // Чтение переменной из FBD проекта
    short value = mymem.getShort("cmd");
    // Сохранение этого значения для отслеживания его изменения
    short oldvalue = value;
    // Конвертация значения в ASCII формат, как в Modbus ASCII
    short2buf_ascii(value, Data);
 
    // Структура для управления задержкой между отдельными посылками - 1 секунда
    // по смыслу фактически соответствует периоду обмена
    struct timespec delay;
    delay.tv_sec = 1;
    delay.tv_nsec = 0;
 
    while(1){
 
        // Проверить, если установили из FBD новое значение переменной
        //if(mymem.getBool("cmd") != oldvalue){
        //    oldvalue = mymem.getBool("cmd");
            // Записать новое значение в переменную value
        //    value = oldvalue;
        value = mymem.getShort("cmd");
        }
 
        // Конвертация value в ASCII формат и загрузка value в буфер обмена
        // по указателю Data, который и определяет место переменной в буфере обмена
        short2buf_ascii(value, Data);
 
        // Отправить slave устройству short переменную value, которая
        // к этому моменту уже находится в буфере обмена
        // При преобразовании в ASCII формат все переменные конвертируются в
        // 2 раза большее число байт. Т.е. число типа short - 2 байтное, при
        // преобразовании в ASCII занимает 4 байта. Поэтому длинна передаваемых
        // данных 4 байта, это число и указывается при вызове SendMessage.
        if(SendMessage(4) < 0)
            continue;
 
        // Прочитать в ответ от slave устройства
        if(ReadMessage() < 0)
            continue;
 
        // Сконвертировать значение, содержащееся в приемном буфере в short
        // и сохранить в переменной value
        value = buf2short_ascii(Data);
        // Передать принятое значение опрашиваемой переменной в FBD
        mymem.setShort("mass", value);
 
        // Задержка между отправляемыми пакетами, иначе говоря период обмена
        nanosleep(&delay, NULL);
    }
    // Закрытие порта, фактически в данном примере сюда никогда не попадем
    serial.closeDevice();
 
    // Завершение работы программы
    printf("Close application");
    exit(0);
}