ICS-Microprocessor-2020/Modbus_1_Deva4ki
4
0
Fork 0
Code Issues 7 Pull Requests Projects Releases Wiki Activity

Загрузил(а) файлы в ''

Browse Source
This commit is contained in:
Анастасия Салангина 2023-06-20 14:16:30 +00:00
parent d86e2a8805
commit 8be941b2b2
5 changed files with 663 additions and 385 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

103
gpio.c Normal file
View File

@ -0,0 +1,103 @@
#include "device_ring_buffer.h"
#include "device_adc.h"
#include "device_address.h"
#include "UART.h"
#include "modbus.h"
#include "timer.h"
#include "gpio.h"
//èíèöèàëèçàöèÿ
void gpio_init(void)
{
//Óñòàíîâêà ïèíîâ pin_coils â ðåæèì âûõîäà - 1
DDRD |= (1 « PIN_COIL1);
DDRD |= (1 « PIN_COIL2);
DDRD |= (1 « PIN_COIL3);
DDRD |= (1 « PIN_COIL4);
//Óñòàíîâêà ïèíîâ pin_discrete_inputs â ðåæèì âõîäà - 0
DDRB &= ~(1 « PIN_DISCRETE_INPUT_1);
DDRB &= ~(1 « PIN_DISCRETE_INPUT_2);
DDRB &= ~(1 « PIN_DISCRETE_INPUT_3);
DDRB &= ~(1 « PIN_DISCRETE_INPUT_4);
}
//÷òåíèå
uint8_t gpio_read(uint8_t pin)
{
switch (pin)
{
//÷òåíèå pin_coils
case PIN_COIL1:
return (PIND & (1 « PIN_COIL1)) » PIN_COIL1; // ×òåíèå çíà÷åíèÿ íà ïèíå è ñäâèã âïðàâî íà íîìåð ïèíà
case PIN_COIL2:
return (PIND & (1 « PIN_COIL2)) » PIN_COIL2;
case PIN_COIL3:
return (PIND & (1 « PIN_COIL3)) » PIN_COIL3;
case PIN_COIL4:
return (PIND & (1 « PIN_COIL4)) » PIN_COIL4;
//÷òåíèå pin_discrete_inputs
case PIN_DISCRETE_INPUT_1:
return (PINB & (1 « PIN_DISCRETE_INPUT_1)) » PIN_DISCRETE_INPUT_1;
case PIN_DISCRETE_INPUT_2:
return (PINB & (1 « PIN_DISCRETE_INPUT_2)) » PIN_DISCRETE_INPUT_2;
case PIN_DISCRETE_INPUT_3:
return (PINB & (1 « PIN_DISCRETE_INPUT_3)) » PIN_DISCRETE_INPUT_3;
case PIN_DISCRETE_INPUT_4:
return (PINB & (1 « PIN_DISCRETE_INPUT_4)) » PIN_DISCRETE_INPUT_4;
default:
return 0;
}
}
//çàïèñü
void gpio_write(uint8_t pin, uint8_t value)
{
switch (pin)
{
case PIN_COIL1:
if (value != 0x0000)
{
PORTD |= (1 « PIN_COIL1);
}
else
{
PORTD &= ~(1 « PIN_COIL1);
}
break;
case PIN_COIL2:
if (value != 0x0000)
{
PORTD |= (1 « PIN_COIL2);
}
else
{
PORTD &= ~(1 « PIN_COIL2);
}
break;
case PIN_COIL3:
if (value != 0x0000)
{
PORTD |= (1 « PIN_COIL3);
}
else
{
PORTD &= ~(1 « PIN_COIL3);
}
break;
case PIN_COIL4:
if (value != 0x0000)
{
PORTD |= (1 « PIN_COIL4);
}
else
{
PORTD &= ~(1 « PIN_COIL4);
}
break;
default:
break;
}

26
gpio.h Normal file
View File

@ -0,0 +1,26 @@
#ifndef GPIO_H
#define GPIO_H
#include "device_ring_buffer.h"
#include "device_adc.h"
#include "device_address.h"
#include "UART.h"
#include "modbus.h"
#include "timer.h"
#define PIN_COIL1 PD4
#define PIN_COIL2 PD5
#define PIN_COIL3 PD6
#define PIN_COIL4 PD7
#define PIN_DISCRETE_INPUT_1 PB0
#define PIN_DISCRETE_INPUT_2 PB1
#define PIN_DISCRETE_INPUT_3 PB2
#define PIN_DISCRETE_INPUT_4 PB3
void gpio_init(void);
uint8_t gpio_read(uint8_t pin);
void gpio_write(uint8_t pin, uint8_t value);
#endif /*GPIO_H*/

812
modbus.c
View File

@ -1,360 +1,452 @@
#include "modbus.h"
#define On 1
#define Off 0 uint8_t state;
#define Change_output 10 uint8_t packet[SIZE_MODBUS_PAKET];
#define discrete_output_reading 11 uint8_t size_of_packet;
uint16_t crc_modbus;
uint16_t first_register_device;
volatile unsigned char Data_Rx_ModbasRtu[30];//массив принятых данных uint16_t number_of_registers_required;
volatile unsigned char quantity_Data_ModbasRtu; //количество принятых данных uint16_t crc_answ;
//Volatile — ключевое слово языков C/C++, которое информирует компилятор о том, что значение переменной может меняться извне и что компилятор не будет оптимизировать эту переменную uint8_t modbus_answ[SIZE_MODBUS_PAKET];
volatile unsigned int Data_ModbasRtu_analog_input[1]; //данные на аналоговом входе [1 - НОМЕР АНАЛОГОВОГО ВХОДА] uint16_t expected_crc;
volatile unsigned int Data_ModbasRtu_analog_Output[1]; //данные на аналоговом выходе [1 - НОМЕР АНАЛОГОВОГО ВЫХОДА] unsigned long time;
volatile unsigned char Data_ModbasRtu_Binary_input[(1/8)+1]; //данные на дискретном входе [1 - НОМЕР ДИСКРЕТНОГО ВХОДА] uint8_t packet_accepted;
volatile unsigned char Data_ModbasRtu_Binary_Output[(1/8)+1]; //данные на дискретном выходе [1 - НОМЕР ДИСКРЕТНОГО ВЫХОДА] uint16_t last_possible_register;
uint16_t crc_chk(uint8_t *data, uint8_t length);
//ПРИНЯТЬ ДАННЫЕ С КОЛЬЦЕВОГО БУФЕРА(Data_Rx_ModbasRtu) uint16_t bytes_unification(uint8_t high, uint8_t low);
//выглядит как int rb_get(struct rb* _rb, char *element) uint8_t read_coils(uint8_t address, uint8_t value, uint8_t *modbus_answ);
Data_Rx_ModbasRtu = rb_get(&, 1); uint8_t read_discrete_inputs(uint8_t address, uint8_t value, uint8_t *modbus_answ);
uint8_t read_holding_registers(uint8_t address, uint8_t value, uint8_t *modbus_answ);
uint8_t read_input_registers(uint8_t address, uint8_t value, uint8_t *modbus_answ);
//КОНТРОЛЬНАЯ СУММА(+) uint8_t write_single_coil(uint8_t address, uint16_t coil_addr, int on, uint8_t *modbus_answ);
int crc_chk(unsigned char* data, unsigned char length) uint8_t write_single_register(uint8_t address, uint16_t register_addr, uint16_t new_value, uint8_t *modbus_answ);
{ uint8_t write_multiple_coils(uint8_t address, uint16_t first_coil_addr, uint16_t recorded_num, uint8_t *modbus_answ);
register int j; // register - спецификатор, который предполагает, что доступ к объекту будет быстрым uint8_t write_multiple_registers(uint8_t address, uint16_t first_register_addr, uint16_t recorded_num, uint8_t *modbus_answ);
register unsigned int reg_crc = 0xFFFF; //объявление 16-битного регистра uint8_t modbus_err_answ(uint8_t address, uint8_t func_code, uint8_t err_code, uint8_t *modbus_answ);
while (length--) void modbus_rtu_send(uint8_t answ_len);
{
reg_crc ^= *data++; //каждый байт-исключение складывается по исключающему ИЛИ с текущим значением регистра контр суммы. После последнего 8 сдвига следующий байт складывается с текущей величиной регистра контр суммы и процесс сдвига повторяется повторно 8 раз void modbus_init(void)
for (j = 0; j < 8; j++) {
{ size_of_packet = 0;
if (reg_crc & 0x01) //проверка младшего бита crc_modbus = 0xFFFF;
{ state = 0;
reg_crc = (reg_crc >> 1) ^ 0xA001; //проверочный код на основе полинома. Результат всегда сдвигается в сторону младшего бита с заполнением нулем старшего бита. Если младший бит = 1, то производится искл ИЛИ содержимого регистра контр суммы и полиномиального числа }
}
else void range_in_range(uint8_t a, uint8_t b, uint8_t x, uint8_t y)
{ {
reg_crc = reg_crc >> 1; //если младший бит = 0, искл ИЛИ не делается uint8_t c = a + b - 1;
} if (a >= x && a <= y) || (c >= x && c <= y)
} {
} return 0;
return reg_crc; //регистр хранения конечного результата контр суммы }
} else
{
return 1;
//ОБЪЕДИНЕНИЕ ДВУХ БАЙТ(старшего и младшего) }
int ModbasRtu_Register_address(unsigned char Li) }
//Hi - старший байт
//Li - младший // Функция приема modbus-запроса RTU
{ void modbus_rtu(void)
register char Hi = Li - 1; {
return Data_Rx_ModbasRtu[Hi] * 256 + Data_Rx_ModbasRtu[Li]; //считываем адрес старшего и младшего байта // состояние приема
} if (state == 0)
{
//АДРЕС uint8_t data;
int Modbus_addr() // Размер пакета 0
{ size_of_packet = 0;
volatile unsigned int adres; // Записываем время начала приема пакета
adres = ModbasRtu_Register_address(1); time = get_millis();
} // Пакет не принят
packet_accepted = 0;
//ПРОВЕРКА КОНТРОЛЬНОЙ СУММЫ В ПОЛУЧЕННОЙ ПОСЫЛКЕ ДАННЫХ
char Data_integrity() // Цикл приема символов
{ while (!packet_accepted)
register unsigned int Temp_2; {
register unsigned char Temp_3; // Читаем символ из входящего кольцевого буфера
quantity_Data_ModbasRtu = quantity_Data_ModbasRtu - 2; //убираем контрольную сумму от адресов // Кольцевой буфер не пуст
Temp_2 = crc_chk(Data_Rx_ModbasRtu, quantity_Data_ModbasRtu); //вычисляем контрольную сумму if (count_elements(get_rb_receive()) > 0)
Temp_3 = Temp_2; //выделяем старший байт с контрольной суммы {
if (Data_Rx_ModbasRtu[quantity_Data_ModbasRtu] == Temp_3) //сравнимаем с таблицы старший байт с контрольной суммой // Читаем символ из кольцевого буфера
{ rb_get(get_rb_receive(), &data);
quantity_Data_ModbasRtu++; //объем данных увеличается if (size_of_packet == 0)
Temp_3 = (Temp_2 >> 8); //сдвиг на 8 бит {
if (Data_Rx_ModbasRtu[quantity_Data_ModbasRtu] == Temp_3) //старший // Пришел новый пакет
{ packet[0] = data;
return 1; size_of_packet = 1;
} time = get_millis();
} }
return 0;
} else
{
// Проверяем линейный буфер на переполнение
//РАБОТА С ДИСКРЕТНЫМИ ВХОДАМИ И ВЫВОДАМИ if (size_of_packet == SIZE_MODBUS_PAKET)
char _Bin_input_Output(register unsigned char NUMBER, register unsigned char state, volatile unsigned char* Masiv, volatile unsigned char Sd) {
{ // Буфер переполнился
volatile unsigned char Temp = 0, Temp_1 = 0; // Ждем новый пакет
while (NUMBER >= 8) size_of_packet = 0;
{ continue;
NUMBER = NUMBER - 8; }
Temp++; //определяем, в каком регистре нужно изменить либо считывать бит else
} {
Temp_1 = Masiv[Temp]; time = get_millis();
if (Sd == 10) //выполняется, если нужно изменить бит packet[size_of_packet] = data;
{ size_of_packet++;
if (state == On) }
Temp_1 |= (1 << NUMBER); }
else }
Temp_1 &= ~(1 << NUMBER); // Проверка временного интервала между символами
Masiv[Temp] = Temp_1; else
} {
else //выполняется, если нужно прочитать состояние бита if ((get_millis() - time) > MAX_PAUSE)
{ {
if (Temp_1 & (1 << NUMBER)) // Превышен таймаут
NUMBER = 1; // Пакет закончился
else packet_accepted = 1;
NUMBER = 0; }
} }
return NUMBER; //возвращает состояние прочитанного бита }
} // Проверяем размер пакета
if (size_of_packet < 5)
{
//КОДЫ ФУНКЦИИ : size_of_packet = 0;
crc_modbus = 0xFFFF;
//Чтение значений нескольких регистров флагов 0x01, Чтение значений нескольких дискретных входов 0x02 return;
void Reading_Discrete_Output(unsigned char* Massiv, register unsigned char Number_) }
{
volatile unsigned int adres, Number_bits; // считаем контрольную сумму CRC и сравниваем с CRC в пакете
register unsigned char Temp = 0, Data, Temp2 = 0, adres2 = 0, Temp3 = 2; expected_crc = bytes_unification(size_of_packet - 2, size_of_packet - 1);
adres = ModbasRtu_Register_address(3); //адрес регистра, к которому обращается мастер crc_modbus = crc_chk(packet, size_of_packet - 3);
if (adres > Number_) //проверка, что адрес не превышает допустимый // проверка контрольной суммы CRC
{ if (crc_modbus != expected_crc)
Error_modbasRtu(0x02); //недопустимый адрес {
} size_of_packet = 0;
else crc_modbus = 0xFFFF;
{ // формируем ошибку произошла невосполнимая ошибка
Number_bits = ModbasRtu_Register_address(5); //количество бит, которые нужно передать return;
while (adres >= 8) //узнаем номер ячейки массива, с которой начнем считывать данные }
{ // проверка адреса устройства
adres = adres - 8; //по завершению преобразования хранится бит, с которого нужно начинать считывание else if (get_device_address() != packet[0])
Temp++; //номер байта в массиве к которому изначально происходит обращение {
} size_of_packet = 0;
Data = Massiv[Temp]; //считываем данные crc_modbus = 0xFFFF;
//считываем побитно и формируем данные для отправки // формируем ошибку адреса
while (Number_bits > 0) //проверка, что все биты запроса переданы return;
{ }
Number_bits--; else
if (Data & (1 << adres)) {
{ // Расчленяем пакет
Temp2 |= (1 << adres2); state = 1;
} return;
adres2++; }
adres++; }
if (adres2 == 8) }
{
adres2 = 0; // Функция отправки modbus-запроса в кольцевой буфер
Temp3++; void modbus_rtu_send(uint8_t answ_len)
Data_Rx_ModbasRtu[Temp3] = Temp2; {
Temp2 = 0; size_of_packet = 0;
} // состояние отправки
if (adres == 8) if (state == 1)
{ {
adres = 0; // цикл отправки символов
Temp++; while (state == 1)
Data = Massiv[Temp]; //считываем данные {
} // Отправка всех байт в кольцевой буфер
} rb_put(get_rb_transmit(), modbus_answ[size_of_packet]);
if (adres2 > 0)
{ // смещаем указатель
Temp3++; size_of_packet++;
Data_Rx_ModbasRtu[Temp3] = Temp2; if (size_of_packet == answ_len)
} {
Data_Rx_ModbasRtu[2] = Temp3 - 2; //количество переданных байт (без учета адреса и кода команды) state = 0;
Temp3++; size_of_packet = 0;
check_sum(Temp3); //подсчитаем контрольную сумму для передачи данных crc_modbus = 0xFFFF;
} return;
} }
}
//Чтение значений нескольких регистров хранения 0x03, Чтение значений нескольких регистров ввода 0x04 }
void Read_analog_input(unsigned char* Massiv, register unsigned char Number_, unsigned char Vt) }
//Vt - ввод или вывод
{ // Функция формирования modbus-ответа RTU
volatile unsigned int address, Number_bits, Data; void modbus_answer()
volatile unsigned char Adress = 4; {
address = ModbasRtu_Register_address(3); //адрес регистра, к которому обращается мастер switch (packet[1])
if (address > Number_) //проверка, что адрес не превышает допустимый {
{ case READ_COILS:
Error_modbasRtu(0x02); //указанный в запросе адрес не существует first_register_device = bytes_unification(2, 3);
} number_of_registers_required = bytes_unification(4, 5);
else
{ if (range_in_range(first_register_device, number_of_registers_required, COIL_1, COIL_4) && number_of_registers_required > 0)
Number_bits = ModbasRtu_Register_address(5); //количество байт, которые нужно передать (старший и младший) {
Data_Rx_ModbasRtu[2] = Number_bits * 2; //количество байт информащии, которые будут переданы modbus_rtu_send(modbus_err_answ(get_device_address(), packet[1], ILLEGAL_DATA_ADDRESS, &modbus_answ));
Adress = 3; }
while (Number_bits > 0) else
{ {
if (Vt == 1) //определение, что считывать - вход или выход uint8_t value = 0;
{ while (number_of_registers_required > 0)
Data = Data_ModbasRtu_analog_input[address]; {
} switch (first_register_device)
else {
{ case COIL_1:
Data = Data_ModbasRtu_analog_Output[address]; value |= (gpio_read(PIN_COIL1));
} break;
address++; case COIL_2:
Massiv = &Data; value |= (gpio_read(PIN_COIL2));
Data_Rx_ModbasRtu[Adress++] = Massiv[1]; //считываем старший байт break;
Data_Rx_ModbasRtu[Adress++] = Massiv[0]; //считываем младший байт case COIL_3:
Number_bits = Number_bits - 1; value |= (gpio_read(PIN_COIL3));
} break;
check_sum(Adress); //подсчитаем контрольную сумму для передачи данных case COIL_4:
} value |= (gpio_read(PIN_COIL4));
} break;
}
//Запись одного регистра флагов 0x05
void Changing_Discrete_Output(void) first_register_device++;
{ number_of_registers_required--;
register unsigned int address; }
address = ModbasRtu_Register_address(3); //адрес регистра, к которому обращается мастер modbus_rtu_send(read_coils(get_device_address(), value, &modbus_answ));
if (address > 11) //проверка, что адрес не превышает допустимый [11 - НОМЕР ДИСКРЕТНОГО ВЫХОДА] }
{
Error_modbasRtu(0x02); break;
} case READ_DISCRETE_INPUTS:
else first_register_device = bytes_unification(2, 3);
{ number_of_registers_required = bytes_unification(4, 5);
if (Data_Rx_ModbasRtu[4] == 255)
_Bin_input_Output(address, On, Data_ModbasRtu_Binary_Output, Change_output); if (range_in_range(first_register_device, number_of_registers_required, DISCRETE_INPUTS_1, DISCRETE_INPUTS_4) && number_of_registers_required > 0)
else {
_Bin_input_Output(address, Off, Data_ModbasRtu_Binary_Output, Change_output); modbus_rtu_send(modbus_err_answ(get_device_address(), packet[1], ILLEGAL_DATA_ADDRESS, &modbus_answ));
} }
} else
{
//Запись одного регистра хранения 0x06 uint8_t value = 0;
void analog_output_recording(void) while (number_of_registers_required > 0)
{ {
register int address; switch (first_register_device)
address = ModbasRtu_Register_address(3); {
if (address > 11) //[11 - НОМЕР АНАЛОГОВОГО ВЫХОДА] case DISCRETE_INPUTS_1:
{ value |= (gpio_read(PIN_DISCRETE_INPUT_1));
Error_modbasRtu(0x02); break;
} case DISCRETE_INPUTS_2:
else value |= (gpio_read(PIN_DISCRETE_INPUT_2));
{ break;
Data_ModbasRtu_analog_Output[address] = ModbasRtu_Register_address(5); //данные, которые нужно записать case DISCRETE_INPUTS_3:
} value |= (gpio_read(PIN_DISCRETE_INPUT_3));
} break;
case DISCRETE_INPUTS_4:
value |= (gpio_read(PIN_DISCRETE_INPUT_4));
//ОШИБКА break;
void Error_modbasRtu(volatile unsigned char Temp_Error) }
{
Data_Rx_ModbasRtu[1] |= (1 << 7); first_register_device ++;
Data_Rx_ModbasRtu[2] = Temp_Error; //код ошибки number_of_registers_required--;
check_sum(3); //подсчитаем контрольную сумму для передачи данных }
} modbus_rtu_send(read_discrete_inputs(get_device_address(), value, &modbus_answ));
}
//ОТВЕТ КОНТРОЛЬНОЙ СУММЫ break;
void check_sum(register unsigned char Adress) case READ_HOLDING_REGISTERS:
{ first_register_device = bytes_unification(2, 3);
register unsigned int RC; number_of_registers_required = bytes_unification(4, 5);
RC = crc_chk(Data_Rx_ModbasRtu, Adress); //вычисляем контрольную сумму
Data_Rx_ModbasRtu[Adress] = RC; //младший байт контрольной суммы if (first_register_device != HOLDING_REGISTER_SLAVE_ADDRESS || number_of_registers_required != 1)
Adress++; {
Data_Rx_ModbasRtu[Adress] = RC >> 8; //старший байт контрольной суммы modbus_rtu_send(modbus_err_answ(get_device_address(), packet[1], ILLEGAL_DATA_ADDRESS, &modbus_answ));
quantity_Data_ModbasRtu = Adress; }
} else
{
modbus_rtu_send(read_holding_registers(get_device_address(), get_device_address(), &modbus_answ));
//ФОРМИРУЕМ ДЕЙСТВИЕ И ОТВЕТ НА ПРИНЯТЫЕ КОМАНДЫ ИЛИ ФОРМИРУЕМ ОТВЕТ ОБ ОШИБКАХ }
void modbasRtu_Answer()
{ break;
switch (Data_Rx_ModbasRtu[1]) case READ_INPUT_REGISTERS:
{ first_register_device = bytes_unification(2, 3);
case 1: number_of_registers_required = bytes_unification(4, 5);
//Modbus RTU чтение дискретного выхода 0x01
Reading_Discrete_Output(Data_ModbasRtu_Binary_Output, 11); //[11 - НОМЕР ДИСКРЕТНОГО ВЫХОДА] if (first_register_device != INPUT_REGISTERS || number_of_registers_required != 1)
break; {
case 2: modbus_rtu_send(modbus_err_answ(get_device_address(), packet[1], ILLEGAL_DATA_ADDRESS, &modbus_answ));
//Modbus RTU чтение дискретного входа 0x02 }
Reading_Discrete_Output(Data_ModbasRtu_Binary_input, 11); //[11 - НОМЕР ДИСКРЕТНОГО ВХОДА] else
break; {
case 3: modbus_rtu_send(read_input_registers(get_device_address(), get_adc_value(), &modbus_answ));
}
Read_analog_input(Data_ModbasRtu_analog_Output, 11, 0); //Modbus RTU на чтение аналогового выхода 0x03 [11 - НОМЕР АНАЛОГОВОГО ВЫХОДА]
break; break;
case 4: case WRITE_SINGLE_COIL:
first_register_device = bytes_unification(2, 3);
Read_analog_input(Data_ModbasRtu_analog_input, 11, 1); //Modbus RTU на чтение аналогового входа 0x04 [11 - НОМЕР АНАЛОГОВОГО ВХОДА]
break; if (range_in_range(first_register_device, 1, COIL_1, COIL_4))
case 5: {
//Modbus RTU на запись дискретного вывода 0x05 modbus_rtu_send(modbus_err_answ(get_device_address(), packet[1], ILLEGAL_DATA_ADDRESS, &modbus_answ));
Changing_Discrete_Output(); }
break; else
case 6: {
//Modbus RTU на запись аналогового выхода 0x06 uint8_t value = 0;
analog_output_recording(); switch (first_register_device)
break; {
case 15: case COIL_1:
//Modbus RTU на запись нескольких дискретных выводов 0x0F value = gpio_write(PIN_COIL1, packet[4]);
asm("nop"); //команда протокола, которая предписывает ничего не делать break;
//break; case COIL_2:
case 16: value = gpio_write(PIN_COIL2, packet[4]);
//Modbus RTU на запись нескольких аналоговых выводов 0x10 break;
asm("nop"); case COIL_3:
//break; value = gpio_write(PIN_COIL3, packet[4]);
default: break;
//команды не подерживаются case COIL_4:
Error_modbasRtu(0x01); //принятый код функции не может быть обработан value = gpio_write(PIN_COIL4, packet[4]);
break; break;
} }
}
modbus_rtu_send(write_single_coil(get_device_address(), first_register_device, GPIORead(first_register_device), &modbus_answ));
}
//ПОДПРОГРАММЫ ДЛЯ ОБРАБОТКИ ЗНАЧЕНИЙ
break;
//прочитать бит входов case WRITE_SINGLE_REGISTER:
char read_digital_inputs(volatile unsigned char Temp1) first_register_device = bytes_unification(2, 3);
{
return _Bin_input_Output(Temp1, On, Data_ModbasRtu_Binary_input, discrete_output_reading); //считать состояние выхода из буферного массива if (first_register_device != HOLDING_REGISTER_SLAVE_ADDRESS)
} {
modbus_rtu_send(modbus_err_answ(get_device_address(), packet[1], ILLEGAL_DATA_ADDRESS, &modbus_answ));
//изменить бит входов }
void change_digital_inputs(volatile unsigned char Temp1, volatile unsigned char Temp2) else
{ {
_Bin_input_Output(Temp1, Temp2, Data_ModbasRtu_Binary_input, Change_output); write_device_address(bytes_unification(4, 5));
}
modbus_rtu_send(write_single_register(get_device_address(), first_register_device, get_device_address(), &modbus_answ));
//прочитать бит выходов }
char read_digital_Output(volatile unsigned char Temp1)
{ break;
return _Bin_input_Output(Temp1, On, Data_ModbasRtu_Binary_Output, discrete_output_reading); //считать состояние выхода из буферного массива default:
} modbus_rtu_send(modbus_err_answ(get_device_address(), packet[1], ILLEGAL_FUNCTION, &modbus_answ));
break;
//изменить бит выходов }
void change_digital_Output(volatile unsigned char Temp1, volatile unsigned char Temp2) }
{
_Bin_input_Output(Temp1, Temp2, Data_ModbasRtu_Binary_Output, Change_output); // Функция вычисления контрольной суммы CRC
} uint16_t crc_chk(uint8_t *data, uint8_t length)
{
//записать значение аналоговых выходов register int16_t j;
void change_analogue_Output(volatile unsigned char nomer, int Data) register uint16_t reg_crc = 0xFFFF;
{ while (length--)
Data_ModbasRtu_analog_Output[nomer] = Data; {
} reg_crc ^= *data++;
for (j = 0; j < 8; j++)
//записать значение аналоговых входов {
void change_analogue_input(volatile unsigned char nomer, int Data) if (reg_crc & 0x01)
{ {
Data_ModbasRtu_analog_input[nomer] = Data; reg_crc = (reg_crc >> 1) ^ 0xA001;
} }
else
//считать значение аналоговых выходов {
int read_analogue_Output(volatile unsigned char nomer) reg_crc = reg_crc >> 1;
{ }
return Data_ModbasRtu_analog_Output[nomer]; }
} }
return reg_crc;
//считать значение аналоговых выходов }
int read_analogue_input(volatile unsigned char nomer)
{ // Функция объединения двух байт (старшего и младшего)
return Data_ModbasRtu_analog_input[nomer]; uint16_t bytes_unification(uint8_t high, uint8_t low)
} {
return (packet[high] << 8) | packet[low];
}
//(отправить по rb_put в кольцевой буфер ответ)
//выглядит как int rb_put(struct rb* _rb, char element) // Коды функций (для формирования ответа)
void Data_Modbus_answer()
{ // Чтение данных с регистров флагов (функция с кодом 1)
uint8_t read_coils(uint8_t address, uint8_t value, uint8_t *modbus_answ)
} {
modbus_answ[0] = address; // Адрес
modbus_answ[1] = 0x01; // Код функции
modbus_answ[2] = 0x01; // Кол-во передаваемых байт
modbus_answ[3] = value; // Данные
crc_answ = crc_chk(modbus_answ, 4); // Подсчет контрольной суммы
modbus_answ[4] = crc_answ & 0xFF; // Первый байт контрольной суммы
modbus_answ[5] = (crc_answ >> 8) & 0xFF; // Второй байт контрольной суммы
return 6;
}
// Чтение данных с дискретных входов (функция с кодом 2)
uint8_t read_discrete_inputs(uint8_t address, uint8_t value, uint8_t *modbus_answ)
{
modbus_answ[0] = address; // Адрес
modbus_answ[1] = 0x02; // Код функции
modbus_answ[2] = 0x01; // Кол-во передаваемых байт
modbus_answ[3] = value; // Данные
crc_answ = crc_chk(modbus_answ, 4); // Подсчет контрольной суммы
modbus_answ[4] = crc_answ & 0xFF; // Первый байт контрольной суммы
modbus_answ[5] = (crc_answ >> 8) & 0xFF; // Второй байт контрольной суммы
return 6;
}
// Чтение данных с регистров хранения (функция с кодом 3)
uint8_t read_holding_registers(uint8_t address, uint16_t value, uint8_t *modbus_answ)
{
modbus_answ[0] = address; // Адрес
modbus_answ[1] = 0x03; // Код функции
modbus_answ[2] = 0x01; // Кол-во передаваемых байт
modbus_answ[3] = value; // Первый байт данных
modbus_answ[4] = value >> 8; // Второй байт данных
crc_answ = crc_chk(modbus_answ, 5); // Подсчет контрольной суммы
modbus_answ[5] = crc_answ & 0xFF; // Первый байт контрольной суммы
modbus_answ[6] = (crc_answ >> 8) & 0xFF; // Второй байт контрольной суммы
return 7;
}
// Чтение данных с регистров ввода (функция с кодом 4)
uint8_t read_input_registers(uint8_t address, uint16_t value, uint8_t *modbus_answ)
{
modbus_answ[0] = address; // Адрес
modbus_answ[1] = 0x04; // Код функции
modbus_answ[2] = 0x01; // Кол-во передаваемых байт
modbus_answ[3] = value; // Первый байт данных
modbus_answ[4] = value >> 8; // Второй байт данных
crc_answ = crc_chk(modbus_answ, 5); // Подсчет контрольной суммы
modbus_answ[5] = crc_answ & 0xFF; // Первый байт контрольной суммы
modbus_answ[6] = (crc_answ >> 8) & 0xFF; // Второй байт контрольной суммы
return 7;
}
// Запись данных в регистр флагов (функция с кодом 5)
uint8_t write_single_coil(uint8_t address, uint16_t coil_addr, int on, uint8_t *modbus_answ)
{
modbus_answ[0] = address; // Адрес
modbus_answ[1] = 0x05; // Код функции
modbus_answ[2] = (coil_addr >> 8) & 0xFF; // Старший байт адреса
modbus_answ[3] = coil_addr & 0xFF; // Младший байт адреса
modbus_answ[4] = on ? 0xFF : 0x00; // Значение, которое нужно записать
modbus_answ[5] = 0x00;
crc_answ = crc_chk(modbus_answ, 6); // Подсчет контрольной суммы
modbus_answ[6] = crc_answ & 0xFF; // Первый байт контрольной суммы
modbus_answ[7] = (crc_answ >> 8) & 0xFF; // Второй байт контрольной суммы
return 8;
}
// Запись данных в регистр (функция с кодом 6)
uint8_t write_single_register(uint8_t address, uint16_t register_addr, uint16_t new_value, uint8_t *modbus_answ)
{
modbus_answ[0] = address; // Адрес
modbus_answ[1] = 0x06; // Код функции
modbus_answ[2] = (register_addr >> 8) & 0xFF; // Старший байт адреса
modbus_answ[3] = register_addr & 0xFF; // Младший байт адреса
modbus_answ[4] = (new_value >> 8) & 0xFF; // Старший байт значения
modbus_answ[5] = new_value & 0xFF; // Младший байт значения
crc_answ = crc_chk(modbus_answ, 6); // Подсчет контрольной суммы
modbus_answ[6] = crc_answ & 0xFF; // Первый байт контрольной суммы
modbus_answ[7] = (crc_answ >> 8) & 0xFF; // Второй байт контрольной суммы
return 8;
}
// Сообщение об ошибке
uint8_t modbus_err_answ(uint8_t address, uint8_t func_code, uint8_t err_code, uint8_t *modbus_answ)
{
modbus_answ[0] = address; // Адрес
modbus_answ[1] = 0x80 + func_code; // Код функции + ошибка
modbus_answ[2] = err_code; // Код ошибки
crc_answ = crc_chk(modbus_answ, 3); // Подсчет контрольной суммы
modbus_answ[3] = crc_answ & 0xFF; // Первый байт контрольной суммы
modbus_answ[4] = (crc_answ >> 8) & 0xFF; // Второй байт контрольной суммы
return 5;
}

79
modbus.h
View File

@ -1,25 +1,54 @@
#ifndef MODBUS_H
#ifndef MODBUS_H #define MODBUS_H
#define MODBUS_H
#include "device_ring_buffer.h"
int crc_chk(unsigned char* data, unsigned char length); #include "device_adc.h"
int ModbasRtu_Register_address(unsigned char Li); #include "device_address.h"
char Data_integrity(); #include "UART.h"
char _Bin_input_Output(register unsigned char NUMBER, register unsigned char state, volatile unsigned char* Masiv, volatile unsigned char Sd); #include "timer.h"
void Reading_Discrete_Output(unsigned char* Massiv, register unsigned char Number_); #include "gpio.h"
void Read_analog_input(unsigned char* Massiv, register unsigned char Number_, unsigned char Vt); #include <stdint.h>
void Changing_Discrete_Output(void);
void analog_output_recording(void); #define SIZE_MODBUS_PAKET (32)
void Error_modbasRtu(volatile unsigned char Temp_Error); #define MAX_PAUSE (4)
void check_sum(register unsigned char Adress);
void modbasRtu_Answer(); // Объявление адреса Slave
char read_digital_inputs(volatile unsigned char Temp1); #define HOLDING_REGISTER_SLAVE_ADDRESS 100
void change_digital_inputs(volatile unsigned char Temp1, volatile unsigned char Temp2);
char read_digital_Output(volatile unsigned char Temp1); // Объявление номеров Discrete Inputs
void change_digital_Output(volatile unsigned char Temp1, volatile unsigned char Temp2); #define DISCRETE_INPUTS_1 0x00
void change_analogue_Output(volatile unsigned char nomer, int Data); #define DISCRETE_INPUTS_2 0x01
void change_analogue_input(volatile unsigned char nomer, int Data); #define DISCRETE_INPUTS_3 0x02
int read_analogue_Output(volatile unsigned char nomer); #define DISCRETE_INPUTS_4 0x03
int read_analogue_input(volatile unsigned char nomer);
// Объявление номеров Coil
#endif /*MODBUS_H*/ #define COIL_1 0x00
#define COIL_2 0x01
#define COIL_3 0x02
#define COIL_4 0x03
// Объявление номеров Input Registers
#define INPUT_REGISTERS 0x00
// Объявление кодов функций
#define READ_COILS 1
#define READ_DISCRETE_INPUTS 2
#define READ_HOLDING_REGISTERS 3
#define READ_INPUT_REGISTERS 4
#define WRITE_SINGLE_COIL 5
#define WRITE_SINGLE_REGISTER 6
#define WRITE_MULTIPLE_COILS 15
#define WRITE_MULTIPLE_REGISTER 16
//Объявление кодов ошибок
#define ILLEGAL_FUNCTION 1
#define ILLEGAL_DATA_ADDRESS 2
#define SLAVE_DEVICE_FAILURE 4
uint8_t size_of_packet;
void modbus_init(void);
void modbus_rtu (void);
void modbus_answer(void);
#endif /*MODBUS_H*/

28
timer.c Normal file
View File

@ -0,0 +1,28 @@
#include <avr/io.h>
#include <avr/interrupt.h>
static unsigned long millis = 0;
void setup_timer()
{
// Включаем режим СТС
TCCR0A = (1 << WGM01);
// Устанавливаем счетчик с предделителем 64
TCCR0B = (1 << CS01) | (1 << CS00);
// Устанавливаем значение сравнения для 1 мс
OCR0A = 250;
// Разрешаем прерывание по совпадению
TIMSK0 = (1 << OCIE0A);
// Разрешаем все прерывания
sei();
}
unsigned long get_millis()
{
return millis;
}
ISR(TIMER0_COMPA_vect)
{
++millis;
}