Andrey
04a9d989fb
Сохранить состояние TESTLAMP при кратких провалах входа и исключить повторный вход Timer1 во время передачи индикации. Явно сбрасывать служебный обмен CAN при запуске и выбирать соседнюю фазу по локальному индексу канала АЦП. Сохранить текущую последовательность DATA/CLK и проверочные варианты таймингов, добавить поведенческие тесты и обновить образ прошивки с картой памяти.
1474 lines
105 KiB
C
1474 lines
105 KiB
C
/* Обработка датчиков, вычисление величин и миллисекундный такт системы. Русские пояснения сохранены в UTF-8. */
|
||
/* Подключает "DSP2833x_Device.h": поставляемое TI описание Device для семейства C2833x. */
|
||
#include "DSP2833x_Device.h" // DSP2833x Headerfile Include File
|
||
/* Подключает "DSP2833x_SWPrioritizedIsrLevels.h": поставляемое TI описание SWPrioritizedIsrLevels для семейства C2833x. */
|
||
#include "DSP2833x_SWPrioritizedIsrLevels.h"
|
||
/* Подключает "filter_bat2.h": накопительный фильтр измерительных каналов. */
|
||
#include "filter_bat2.h"
|
||
/* Подключает "package.h": адреса устройств, типы плат и псевдонимы технологических регистров. */
|
||
#include "package.h"
|
||
|
||
/* Подключает "measure.h": обработка датчиков, вычисление величин и миллисекундный такт системы. */
|
||
#include "measure.h"
|
||
/* Подключает "package.h": адреса устройств, типы плат и псевдонимы технологических регистров. */
|
||
#include "package.h"
|
||
|
||
/* Подключает "peripher.h": перемычки режима платы, дискретные входы и выходы. */
|
||
#include "peripher.h"
|
||
/* Подключает "ADC.h": настройка АЦП, обработка преобразований и первичная фильтрация измерений. */
|
||
#include "ADC.h"
|
||
/* Подключает "DAC.h": выход ЦАП и автомат защиты нагрузки с проверкой напряжения и свежести CAN. */
|
||
#include "DAC.h"
|
||
|
||
/* Подключает "RS485.h": приём и передача SCI-A/SCI-B, упаковка команд и FIFO первого порта. */
|
||
#include "RS485.h"
|
||
/* Подключает "message.h": обработка Modbus, заводские параметры и сохранение настроек. */
|
||
#include "message.h"
|
||
/* Подключает "log_to_mem.h": двухбанковый регистратор событий нагрузки во внешней RAM. */
|
||
#include "log_to_mem.h"
|
||
|
||
/* Подключает <math.h>: настройки и интерфейс math. */
|
||
#include <math.h> // Это чтобы мерить амплитуду! sqrt без этого будет крив!!!
|
||
|
||
/* Объявляет CanPowse — CAN Powse; CANPOWSE — данные CANPOWSE; CanGO — CAN GO. Начальное значение задаётся справа от знака равенства. */
|
||
unsigned int CanPowse=CANPOWSE,CanGO=0;
|
||
|
||
/* Объявляет Maska[2][8];. */
|
||
unsigned int Maska[2][8];
|
||
|
||
/* Объявляет READY — данные READY. Начальное значение задаётся справа от знака равенства. */
|
||
int READY=0; // Все загрузилос
|
||
|
||
/* Объявляет TPL_CANS — данные TPL_CANS. Начальное значение задаётся справа от знака равенства. */
|
||
int TPL_CANS=0; // Количество температурных каналов
|
||
/* Объявляет tpl_cans — данные tpl_cans. Начальное значение задаётся справа от знака равенства. */
|
||
int tpl_cans=0; // Количество температурных датчиков
|
||
/* Объявляет cal_addr — данные cal_addr. Начальное значение задаётся справа от знака равенства. */
|
||
int cal_addr=0; // Начало калибровочных датчиков
|
||
/* Объявляет pow_addr — данные pow_addr. Начальное значение задаётся справа от знака равенства. */
|
||
int pow_addr=0; // Начало датчиков напражениа\тока
|
||
|
||
/* Объявляет period_ready — период ready; period_blink — период blink. */
|
||
int period_ready, period_blink;
|
||
|
||
/* Объявляет chk — данные chk; sig — данные sig. */
|
||
FLAG chk,sig;
|
||
/* Объявляет time_1_5sec — данные time_1_5sec; time_5msec — данные time_5msec; time_3sec — данные time_3sec; time_5sec — данные time_5sec. */
|
||
unsigned int time_1_5sec, time_5msec, time_3sec, time_5sec;
|
||
|
||
/* Объявляет low_count — low число. Начальное значение задаётся справа от знака равенства. */
|
||
unsigned int low_count[2] = {0,0};
|
||
/* Объявляет err_count — err число. */
|
||
unsigned int err_count[6];
|
||
/* Объявляет lev_count — lev число. */
|
||
int lev_count[6];
|
||
/* Объявляет lev_quadr — данные lev_quadr. */
|
||
float lev_quadr[6];
|
||
/* Объявляет zer_count — zer число. */
|
||
float zer_count[4];
|
||
|
||
/* Объявляет sens_type — данные sens_type. */
|
||
int sens_type[24];
|
||
/* Объявляет sens_pair — данные sens_pair. */
|
||
int sens_pair[24];
|
||
/* Объявляет din_count — din число. */
|
||
unsigned int din_count[32];
|
||
|
||
/* Объявляет ext_temp — данные ext_temp. */
|
||
int ext_temp[8];
|
||
/* Объявляет ext_diag — данные ext_diag. */
|
||
int ext_diag[8];
|
||
|
||
/* Объявляет Caliber_time — данные Caliber_time. Начальное значение задаётся справа от знака равенства. */
|
||
unsigned int Caliber_time = 0;
|
||
/* Объявляет Curr_Edge — данные Curr_Edge. */
|
||
int Curr_Edge;
|
||
/* Объявляет okay — данные okay. */
|
||
ERROR okay;
|
||
|
||
/* Объявляет powK — данные powK. Начальное значение задаётся справа от знака равенства. */
|
||
float powK[] =
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Элемент постоянной таблицы 0.127,; порядок значений совпадает с порядком индексов потребителя. */
|
||
0.127, // питание 380В
|
||
/* Элемент постоянной таблицы 0.127,; порядок значений совпадает с порядком индексов потребителя. */
|
||
0.127, // питание 380В
|
||
|
||
/* Элемент постоянной таблицы 1.000,; порядок значений совпадает с порядком индексов потребителя. */
|
||
1.000, // ток
|
||
/* Элемент постоянной таблицы 1.000,; порядок значений совпадает с порядком индексов потребителя. */
|
||
1.000, // напражение
|
||
|
||
/* Элемент постоянной таблицы 0.0076,; порядок значений совпадает с порядком индексов потребителя. */
|
||
0.0076, // питание 31В
|
||
/* Элемент постоянной таблицы 0.0076,; порядок значений совпадает с порядком индексов потребителя. */
|
||
0.0076, // питание 24В
|
||
/* Элемент постоянной таблицы 0.0076,; порядок значений совпадает с порядком индексов потребителя. */
|
||
0.0076, // питание 24В
|
||
/* Элемент постоянной таблицы 0.0076,; порядок значений совпадает с порядком индексов потребителя. */
|
||
0.0076, // питание 15В
|
||
/* Элемент постоянной таблицы 1.0000,; порядок значений совпадает с порядком индексов потребителя. */
|
||
1.0000, // термодатчик мелкосхема
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
};
|
||
|
||
/* Объявляет def_FILTERBAT — данные def_FILTERBAT; DEF_FILTERBAT — данные DEF_FILTERBAT. Начальное значение задаётся справа от знака равенства. */
|
||
FILTERBAT def_FILTERBAT = DEF_FILTERBAT;
|
||
/* Объявляет adc_filter — АЦП filter. */
|
||
FILTERBAT adc_filter[20+4]; // макс.TPL*2 + 4 калибр
|
||
/* Объявляет out_filter — данные out_filter. */
|
||
FILTERBAT out_filter[20+4]; // макс.TPL*2 + 4 напраж
|
||
/* Объявляет zer_filter — данные zer_filter. */
|
||
FILTERBAT zer_filter[4]; // 4 напраж
|
||
|
||
/* Объявляет sens_count — sens число. */
|
||
long sens_count[24+4];
|
||
|
||
/* Объявляет K100 — данные K100; K_50 — данные K_50. */
|
||
float K100,K_50;
|
||
/* Объявляет K_T1 — данные K_T1; K_T2 — данные K_T2. */
|
||
float K_T1,K_T2;
|
||
|
||
/* Выполняет миллисекундный такт датчиков, таймеров связи, регистратора и защиты нагрузки. */
|
||
interrupt void cpu_timer1_isr_SENS(void);
|
||
|
||
/********************************************************************/
|
||
/* Расчет модула тока из показаний двух фаз */
|
||
/********************************************************************/
|
||
/* Начинает функцию im_calc; назначение модуля — обработка датчиков, вычисление величин и миллисекундный такт системы. */
|
||
float im_calc(float ia,float ib)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Объявляет isa — данные isa; isb — данные isb. */
|
||
float isa,isb;
|
||
|
||
/* Записывает isa значением - 1.5 * (ia + ib); данные isa. */
|
||
isa = - 1.5 * (ia + ib);
|
||
/* Записывает isb значением COSPi6 * (ia - ib); данные isb. */
|
||
isb = COSPi6 * (ia - ib);
|
||
/* Завершает im_calc и возвращает (2*sqrt(isa*isa+isb*isb)/3). */
|
||
return (2*sqrt(isa*isa+isb*isb)/3);
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Начинает функцию calc_sensor_koef; назначение модуля — обработка датчиков, вычисление величин и миллисекундный такт системы. */
|
||
void calc_sensor_koef()
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Объявляет i — данные i. */
|
||
int i;
|
||
/* Объявляет K — данные K. */
|
||
float K;
|
||
|
||
/* Проверяет if(TermoRS); последующий оператор выполняется только при истинном условии. */
|
||
if(TermoRS)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает K100 значением 129.0/(K150_D - K100_D); данные K100. */
|
||
K100 = 129.0/(K150_D - K100_D);
|
||
/* Записывает K_50 значением 261.8/(K150_D - K100_D); данные K_50. */
|
||
K_50 = 261.8/(K150_D - K100_D);
|
||
/* Записывает K_T1 значением 129.0/(K150_1 - K100_1); данные K_T1. */
|
||
K_T1 = 129.0/(K150_1 - K100_1);
|
||
/* Записывает K_T2 значением 129.0/(K150_2 - K100_2); данные K_T2. */
|
||
K_T2 = 129.0/(K150_2 - K100_2);
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Проверяет if(TermoAD); последующий оператор выполняется только при истинном условии. */
|
||
if(TermoAD)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает K_T1 значением 100.0/(K400_1 - K300_1); данные K_T1. */
|
||
K_T1 = 100.0/(K400_1 - K300_1);
|
||
/* Записывает K_T2 значением 100.0/(K400_2 - K300_2); данные K_T2. */
|
||
K_T2 = 100.0/(K400_2 - K300_2);
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
// if(Kurrent)
|
||
/* Цикл for(i=0;i<4;i++); задаёт начальное значение, условие продолжения и шаг перебора. */
|
||
for(i=0;i<4;i++)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает K значением Caliber[i]; данные K. */
|
||
K = Caliber[i];
|
||
/* Проверяет if(sens_type[i]==CURRENT) K/=1000.0; последующий оператор выполняется только при истинном условии. */
|
||
if(sens_type[i]==CURRENT) K/=1000.0;
|
||
/* Выполняет альтернативу, если предыдущее условие if оказалось ложным. */
|
||
else K/=10000.0;
|
||
/* Записывает powK[i] значением K; данные powK. */
|
||
powK[i] = K;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
} }
|
||
|
||
/* Выполняет миллисекундный такт датчиков, таймеров связи, регистратора и защиты нагрузки. */
|
||
interrupt void cpu_timer1_isr_SENS(void)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Объявляет . */
|
||
static unsigned int
|
||
/* Записывает count_blink значением 0, count_bright=0, count_mode,; число blink. */
|
||
count_blink=0, count_bright=0, count_mode,
|
||
/* Продолжает список аргументов, полей или выражение blink_over, blink_alarm, work_lamp, heat_lamp, power_lamp;; порядок элементов сохраняется. */
|
||
blink_over, blink_alarm, work_lamp, heat_lamp, power_lamp;
|
||
/* Объявляет preTest — данные preTest. */
|
||
static int preTest;
|
||
|
||
/* Объявляет TST — данные TST. */
|
||
int TST;
|
||
|
||
/* Задаёт err_lamp = work_lamp; данные err_lamp. */
|
||
#define err_lamp work_lamp // это дла шкапа,
|
||
/* Задаёт alm_lamp = heat_lamp; данные alm_lamp. */
|
||
#define alm_lamp heat_lamp // чтоб было понатнее
|
||
|
||
/* Разрешение записи в защищённые регистры периферии. */
|
||
EALLOW;
|
||
/* Изменяет счётчик в выражении CpuTimer1.InterruptCount++; на один для следующего шага. */
|
||
CpuTimer1.InterruptCount++;
|
||
/* Условие компиляции RS232_USE_FIFO: выбранный блок включается в текущий вариант прошивки. */
|
||
#if RS232_USE_FIFO
|
||
/* Вызывает RS_FifoTick1ms. Уменьшает защитную паузу RX FIFO по миллисекундному такту. */
|
||
RS_FifoTick1ms();
|
||
/* Закрывает условный блок препроцессора; дальнейшие строки относятся к внешнему уровню. */
|
||
#endif
|
||
/* Устанавливает биты IER значением M_INT13; регистр разрешения прерываний ядра C28x. */
|
||
IER |= M_INT13; // Set "global" priority
|
||
/* Оставляет биты маски IER значением MINT13; регистр разрешения прерываний ядра C28x. */
|
||
IER &= MINT13; // Set "global" priority
|
||
/* Разрешение маскируемых прерываний ядра. */
|
||
EINT;
|
||
/* Закрытие доступа к защищённым регистрам периферии. */
|
||
EDIS; // This is needed to disable write to EALLOW protected registers
|
||
|
||
/* Проверяет if(!cReset) ServiceDog(); последующий оператор выполняется только при истинном условии. */
|
||
if(!cReset) ServiceDog();
|
||
|
||
/* Проверяет if(++CanPowse >= CANPOWSE); последующий оператор выполняется только при истинном условии. */
|
||
if(++CanPowse >= CANPOWSE)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает CanPowse значением 0; CAN Powse. */
|
||
CanPowse = 0;
|
||
/* Записывает CanGO значением 1; CAN GO. */
|
||
CanGO = 1;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Записывает TST значением cTestLamp|bTestLamp; данные TST. */
|
||
TST = cTestLamp|bTestLamp;
|
||
|
||
/* Проверяет if(!sig.bit.Error|TST) toggle_READY(); последующий оператор выполняется только при истинном условии. */
|
||
if(!sig.bit.Error|TST) toggle_READY();
|
||
/* Выполняет альтернативу, если предыдущее условие if оказалось ложным. */
|
||
else clear_READY();
|
||
|
||
/* Проверяет if(Desk==dsk_LOAD); последующий оператор выполняется только при истинном условии. */
|
||
if(Desk==dsk_LOAD)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Вызывает Load_runner. В такте Timer1 проверяет команды, напряжение и давность CAN; управляет STOP, повторным пуском и током ЦАП. */
|
||
Load_runner();
|
||
/* База времени 1 мс; снимок содержит результат текущего шага ЦАП. */
|
||
/* Вызывает ump_log_tick. Продвигает время регистратора в Timer1 и снимает записи с заданным периодом. */
|
||
ump_log_tick();
|
||
/* Завершает cpu_timer1_isr_SENS без возвращаемого значения. */
|
||
return;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Проверяет if(++count_bright == maximum_bright); последующий оператор выполняется только при истинном условии. */
|
||
if(++count_bright == maximum_bright)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает count_bright значением 0 ; число bright. */
|
||
count_bright = 0 ;
|
||
|
||
/* Проверяет if( ((Desk==dsk_SHKF) и power_lamp) или; последующий оператор выполняется только при истинном условии. */
|
||
if( ((Desk==dsk_SHKF) && power_lamp) ||
|
||
/* Продолжает список аргументов, полей или выражение ((Desk==dsk_COMM) && heat_lamp) ) set_RES_OUT_1();; порядок элементов сохраняется. */
|
||
((Desk==dsk_COMM) && heat_lamp) ) set_RES_OUT_1();
|
||
/* Выполняет альтернативу, если предыдущее условие if оказалось ложным. */
|
||
else clear_RES_OUT_1();
|
||
|
||
/* Проверяет if(work_lamp) set_LED_OUT_1(); последующий оператор выполняется только при истинном условии. */
|
||
if(work_lamp) set_LED_OUT_1(); // Она же err_lamp дла шкапа
|
||
/* Выполняет альтернативу, если предыдущее условие if оказалось ложным. */
|
||
else clear_LED_OUT_1();
|
||
/* Проверяет if(heat_lamp) set_LED_OUT_2(); последующий оператор выполняется только при истинном условии. */
|
||
if(heat_lamp) set_LED_OUT_2(); // Она же alm_lamp дла шкапа
|
||
/* Выполняет альтернативу, если предыдущее условие if оказалось ложным. */
|
||
else clear_LED_OUT_2();
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Проверяет if(!TST); последующий оператор выполняется только при истинном условии. */
|
||
if(!TST)
|
||
/* Проверяет if(count_bright == Brightness); последующий оператор выполняется только при истинном условии. */
|
||
if(count_bright == Brightness)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Сбрасывает аппаратный сигнал через clear_LED_OUT_1();. */
|
||
clear_LED_OUT_1();
|
||
/* Сбрасывает аппаратный сигнал через clear_LED_OUT_2();. */
|
||
clear_LED_OUT_2();
|
||
/* Сбрасывает аппаратный сигнал через clear_RES_OUT_1();. */
|
||
clear_RES_OUT_1();
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Проверяет if(TST & !preTest); последующий оператор выполняется только при истинном условии. */
|
||
if(TST & !preTest)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает count_blink значением BLINK_TIME; число blink. */
|
||
count_blink = BLINK_TIME;
|
||
/* Записывает count_mode значением 0; число режим. */
|
||
count_mode = 0;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
/* Записывает preTest значением TST; данные preTest. */
|
||
preTest = TST;
|
||
|
||
/* Проверяет if(++count_blink >= BLINK_TIME); последующий оператор выполняется только при истинном условии. */
|
||
if(++count_blink >= BLINK_TIME)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает count_blink значением 0; число blink. */
|
||
count_blink=0;
|
||
/* Изменяет счётчик в выражении count_mode++; на один для следующего шага. */
|
||
count_mode++;
|
||
/* Записывает blink_over значением (count_mode & 1)?1:0; данные blink_over. */
|
||
blink_over = (count_mode & 1)?1:0;
|
||
/* Записывает blink_alarm значением (count_mode & 7)?1:0; данные blink_alarm. */
|
||
blink_alarm = (count_mode & 7)?1:0;
|
||
|
||
/* Проверяет if(TST); последующий оператор выполняется только при истинном условии. */
|
||
if(TST)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает heat_lamp значением blink_over; данные heat_lamp. */
|
||
heat_lamp = blink_over;
|
||
/* Записывает work_lamp значением blink_over; данные work_lamp. */
|
||
work_lamp = blink_over;
|
||
/* Записывает power_lamp значением blink_over; данные power_lamp. */
|
||
power_lamp= blink_over;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
/* Выполняет альтернативу, если предыдущее условие if оказалось ложным. */
|
||
else
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Проверяет if(Mode==adr_SHKF); последующий оператор выполняется только при истинном условии. */
|
||
if(Mode==adr_SHKF)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает power_lamp значением 1; данные power_lamp. */
|
||
power_lamp= 1;
|
||
/* Проверяет if(sig.bit.Alarm); последующий оператор выполняется только при истинном условии. */
|
||
if(sig.bit.Alarm){// power_lamp= blink_alarm;
|
||
/* Записывает alm_lamp значением blink_over; }; данные alm_lamp. */
|
||
alm_lamp = blink_over; }
|
||
/* Выполняет альтернативу, если предыдущее условие if оказалось ложным. */
|
||
else alm_lamp = 0;
|
||
|
||
/* Проверяет if(sig.bit.Error); последующий оператор выполняется только при истинном условии. */
|
||
if(sig.bit.Error){ power_lamp= blink_over;
|
||
/* Записывает err_lamp значением blink_over; }; данные err_lamp. */
|
||
err_lamp = blink_over; }
|
||
/* Выполняет альтернативу, если предыдущее условие if оказалось ложным. */
|
||
else err_lamp = 0;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
/* Выполняет альтернативу, если предыдущее условие if оказалось ложным. */
|
||
else
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
// if(sig.bit.Error) work_lamp = blink_over;
|
||
// else if(sig.bit.Alarm) work_lamp = blink_alarm;
|
||
// else
|
||
/* Записывает work_lamp значением 1; данные work_lamp. */
|
||
work_lamp = 1;
|
||
|
||
/* Проверяет if(bSecretBt|cSecretBt) work_lamp = blink_alarm; последующий оператор выполняется только при истинном условии. */
|
||
if(bSecretBt|cSecretBt) work_lamp = blink_alarm;
|
||
|
||
/* Проверяет if(sig.bit.OverHeat) heat_lamp = 1; последующий оператор выполняется только при истинном условии. */
|
||
if(sig.bit.OverHeat) heat_lamp = 1;
|
||
/* Проверяет else if(sig.bit.SubHeat) heat_lamp = blink_over; последующий оператор выполняется только при истинном условии. */
|
||
else if(sig.bit.SubHeat) heat_lamp = blink_over;
|
||
/* Проверяет else if(sig.bit.OutHeat) heat_lamp = !blink_alarm; последующий оператор выполняется только при истинном условии. */
|
||
else if(sig.bit.OutHeat) heat_lamp = !blink_alarm;
|
||
/* Выполняет альтернативу, если предыдущее условие if оказалось ложным. */
|
||
else heat_lamp = 0;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
} } } }
|
||
|
||
/* Начинает функцию Init_sensors; назначение модуля — обработка датчиков, вычисление величин и миллисекундный такт системы. */
|
||
void Init_sensors()
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Объявляет i — данные i. */
|
||
int i;
|
||
|
||
/* Записывает TPL_CANS значением tpl_cans = cal_addr = 0; данные TPL_CANS. */
|
||
TPL_CANS = tpl_cans = cal_addr = 0;
|
||
|
||
/* Вызывает switch с аргументами (Mode) в текущей последовательности операций. */
|
||
switch(Mode)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Ветвь выбора для adr_TRN1; выполняется при совпадении селектора switch. */
|
||
case adr_TRN1:
|
||
/* Ветвь выбора для adr_TRN2; выполняется при совпадении селектора switch. */
|
||
case adr_TRN2:
|
||
/* Записывает TPL_CANS значением TPL_TRN; tpl_cans = TPL_TRN*2; cal_addr = tpl_cans; break; данные TPL_CANS. */
|
||
TPL_CANS = TPL_TRN; tpl_cans = TPL_TRN*2; cal_addr = tpl_cans; break;
|
||
/* Ветвь выбора для adr_POW1; выполняется при совпадении селектора switch. */
|
||
case adr_POW1:
|
||
/* Ветвь выбора для adr_POW2; выполняется при совпадении селектора switch. */
|
||
case adr_POW2:
|
||
/* Записывает TPL_CANS значением TPL_POW; tpl_cans = TPL_POW*2; cal_addr = tpl_cans; break; данные TPL_CANS. */
|
||
TPL_CANS = TPL_POW; tpl_cans = TPL_POW*2; cal_addr = tpl_cans; break;
|
||
|
||
/* Ветвь выбора для adr_ENG1; выполняется при совпадении селектора switch. */
|
||
case adr_ENG1:
|
||
/* Записывает TPL_CANS значением TPL_ENG; tpl_cans = TPL_ENG; cal_addr = tpl_cans; break; данные TPL_CANS. */
|
||
TPL_CANS = TPL_ENG; tpl_cans = TPL_ENG; cal_addr = tpl_cans; break;
|
||
|
||
|
||
/* Ветвь выбора для adr_SHKF; выполняется при совпадении селектора switch. */
|
||
case adr_SHKF: tpl_cans = TPL_SHK; cal_addr = tpl_cans-2; break;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Записывает pow_addr значением tpl_cans + Owen; данные pow_addr. */
|
||
pow_addr = tpl_cans + Owen;
|
||
|
||
/* Цикл for(i=0;i<24;i++); задаёт начальное значение, условие продолжения и шаг перебора. */
|
||
for(i=0;i<24;i++)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает sens_type[i] значением 0; данные sens_type. */
|
||
sens_type[i]=0;
|
||
/* Записывает sens_pair[i] значением i; данные sens_pair. */
|
||
sens_pair[i]=i;
|
||
|
||
/* Записывает adc_filter[i] значением def_FILTERBAT; АЦП filter. */
|
||
adc_filter[i] = def_FILTERBAT;
|
||
/* Записывает out_filter[i] значением def_FILTERBAT; данные out_filter. */
|
||
out_filter[i] = def_FILTERBAT;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Проверяет if(TermoSW); последующий оператор выполняется только при истинном условии. */
|
||
if(TermoSW)
|
||
/* Цикл for(i=0;i<tpl_cans;i++); задаёт начальное значение, условие продолжения и шаг перебора. */
|
||
for(i=0;i<tpl_cans;i++)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Проверяет if(TermoRS) sens_type[i] = TERMO_RS; последующий оператор выполняется только при истинном условии. */
|
||
if(TermoRS) sens_type[i] = TERMO_RS;
|
||
/* Проверяет if(TermoAD) sens_type[i] = TERMO_AD; последующий оператор выполняется только при истинном условии. */
|
||
if(TermoAD) sens_type[i] = TERMO_AD;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Цикл for(i=0;i<Owen;i++); задаёт начальное значение, условие продолжения и шаг перебора. */
|
||
for(i=0;i<Owen;i++)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает sens_type[tpl_cans+i] значением TRM_OBEH; данные sens_type. */
|
||
sens_type[tpl_cans+i] = TRM_OBEH;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Проверяет if(Kurrent); последующий оператор выполняется только при истинном условии. */
|
||
if(Kurrent)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает Curr_Edge значением 200; данные Curr_Edge. */
|
||
Curr_Edge = 200;
|
||
|
||
/* Цикл for(i=0;i<4;i++); задаёт начальное значение, условие продолжения и шаг перебора. */
|
||
for(i=0;i<4;i++)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает sens_type[pow_addr+i] значением VOLTAGE; данные sens_type. */
|
||
sens_type[pow_addr+i]=VOLTAGE;
|
||
/* Записывает sens_pair[pow_addr+i] значением pow_addr+(i^1); данные sens_pair. */
|
||
sens_pair[pow_addr+i]=pow_addr+(i^1);
|
||
|
||
/* Записывает zer_count[i] значением Zero_lev[i]; zer число. */
|
||
zer_count[i] = Zero_lev[i];
|
||
/* Записывает zer_filter[i] значением def_FILTERBAT; данные zer_filter. */
|
||
zer_filter[i] = def_FILTERBAT;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
} }
|
||
|
||
/* Проверяет if(Desk==dsk_LOAD); последующий оператор выполняется только при истинном условии. */
|
||
if(Desk==dsk_LOAD)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает Curr_Edge значением 300; данные Curr_Edge. */
|
||
Curr_Edge = 300;
|
||
|
||
/* Записывает sens_type[2] значением ; данные sens_type. */
|
||
sens_type[2]=
|
||
/* Записывает sens_type[3] значением CURRENT; данные sens_type. */
|
||
sens_type[3]=CURRENT;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Проверяет if(Mode==adr_SHKF); последующий оператор выполняется только при истинном условии. */
|
||
if(Mode==adr_SHKF)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает sens_type[0] значением POWER_380; sens_pair[0]=1; данные sens_type. */
|
||
sens_type[0] = POWER_380; sens_pair[0]=1;
|
||
/* Записывает sens_type[1] значением POWER_38O; sens_pair[1]=0; данные sens_type. */
|
||
sens_type[1] = POWER_38O; sens_pair[1]=0;
|
||
/* Записывает sens_type[2] значением POWER_31; sens_pair[2]=3; данные sens_type. */
|
||
sens_type[2] = POWER_31; sens_pair[2]=3;
|
||
/* Записывает sens_type[3] значением POWER_31; sens_pair[3]=2; данные sens_type. */
|
||
sens_type[3] = POWER_31; sens_pair[3]=2;
|
||
/* Записывает sens_type[4] значением POWER_31; sens_pair[4]=5; данные sens_type. */
|
||
sens_type[4] = POWER_31; sens_pair[4]=5;
|
||
/* Записывает sens_type[5] значением POWER_31; sens_pair[5]=4; данные sens_type. */
|
||
sens_type[5] = POWER_31; sens_pair[5]=4;
|
||
/* Записывает sens_type[6] значением POWER_24; данные sens_type. */
|
||
sens_type[6] = POWER_24;
|
||
/* Записывает sens_type[7] значением POWER_27; данные sens_type. */
|
||
sens_type[7] = POWER_27;
|
||
|
||
/* Записывает sens_type[8] значением POWER_24; данные sens_type. */
|
||
sens_type[8] = POWER_24;
|
||
/* Записывает sens_type[9] значением POWER_15; данные sens_type. */
|
||
sens_type[9] = POWER_15;
|
||
/* Записывает sens_type[10] значением POWER_24; данные sens_type. */
|
||
sens_type[10] = POWER_24;
|
||
/* Записывает sens_type[11] значением POWER_24; данные sens_type. */
|
||
sens_type[11] = POWER_24;
|
||
/* Записывает sens_type[12] значением POWER_24; данные sens_type. */
|
||
sens_type[12] = POWER_24;
|
||
/* Записывает sens_type[13] значением TERMO_AD; данные sens_type. */
|
||
sens_type[13] = TERMO_AD;
|
||
/* Записывает sens_type[14] значением TERMO_AD; данные sens_type. */
|
||
sens_type[14] = TERMO_AD;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Записывает DigErr.all значением 0; представление регистра целым словом без разбиения на битовые поля. */
|
||
DigErr.all=0;
|
||
|
||
/* Записывает time_1_5sec значением (3 * ADC_FREQ) / 2; данные time_1_5sec. */
|
||
time_1_5sec = (3 * ADC_FREQ) / 2;
|
||
/* Записывает time_5msec значением (5 * ADC_FREQ) / 1000; данные time_5msec. */
|
||
time_5msec = (5 * ADC_FREQ) / 1000;
|
||
/* Записывает time_3sec значением (3 * ADC_FREQ); данные time_3sec. */
|
||
time_3sec = (3 * ADC_FREQ);
|
||
/* Записывает time_5sec значением (5 * ADC_FREQ); данные time_5sec. */
|
||
time_5sec = (5 * ADC_FREQ);
|
||
|
||
/* Записывает okay.all значением 0; представление регистра целым словом без разбиения на битовые поля. */
|
||
okay.all=0;
|
||
/* Записывает okay.bit.Tear значением 1; данные Tear. */
|
||
okay.bit.Tear=1;
|
||
/* Записывает okay.bit.Bypas значением 1; данные Bypas. */
|
||
okay.bit.Bypas=1;
|
||
/* Записывает okay.bit.Ignor значением 1; данные Ignor. */
|
||
okay.bit.Ignor=1;
|
||
/* Записывает okay.bit.Imit значением 1; данные Imit. */
|
||
okay.bit.Imit=1;
|
||
|
||
/* Цикл for(i=0;i<6; i++); задаёт начальное значение, условие продолжения и шаг перебора. */
|
||
for(i=0;i<6; i++)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает err_count[i] значением 0; err число. */
|
||
err_count[i] = 0;
|
||
/* Записывает lev_count[i] значением 0; lev число. */
|
||
lev_count[i] = 0;
|
||
/* Записывает lev_quadr[i] значением 0; данные lev_quadr. */
|
||
lev_quadr[i] = 0;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
/* Цикл for(i=0;i<28;i++) sens_count[i] = 0;; задаёт начальное значение, условие продолжения и шаг перебора. */
|
||
for(i=0;i<28;i++) sens_count[i] = 0;
|
||
/* Цикл for(i=0;i<32;i++) din_count[i] = 0;; задаёт начальное значение, условие продолжения и шаг перебора. */
|
||
for(i=0;i<32;i++) din_count[i] = 0;
|
||
/* Цикл for(i=0;i<8; i++) ext_temp[i] = ext_diag[i] = 0;; задаёт начальное значение, условие продолжения и шаг перебора. */
|
||
for(i=0;i<8; i++) ext_temp[i] = ext_diag[i] = 0;
|
||
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Начинает функцию Init_sensors_more; назначение модуля — обработка датчиков, вычисление величин и миллисекундный такт системы. */
|
||
void Init_sensors_more()
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Объявляет i — данные i. */
|
||
int i;
|
||
|
||
/* Цикл for(i=0;i<24;i++); задаёт начальное значение, условие продолжения и шаг перебора. */
|
||
for(i=0;i<24;i++)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Оставляет биты маски modbus[i] значением NOER; массив технологических регистров; слово int на C28x занимает 16 бит. */
|
||
modbus[i] &= NOER;
|
||
/* Записывает sens_data[i] значением 0; sens данные. */
|
||
sens_data[i]=0;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Цикл for(i=0;i<4;i++); задаёт начальное значение, условие продолжения и шаг перебора. */
|
||
for(i=0;i<4;i++)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает zer_count[i] значением Zero_lev[i]; zer число. */
|
||
zer_count[i] = Zero_lev[i];
|
||
|
||
/* Проверяет if(Desk==dsk_LOAD); последующий оператор выполняется только при истинном условии. */
|
||
if(Desk==dsk_LOAD)
|
||
/* Проверяет if(sens_type[i]==VOLTAGE); последующий оператор выполняется только при истинном условии. */
|
||
if(sens_type[i]==VOLTAGE)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Проверяет if(i&1) sens_data[i]=560; последующий оператор выполняется только при истинном условии. */
|
||
if(i&1) sens_data[i]=560;
|
||
/* Выполняет альтернативу, если предыдущее условие if оказалось ложным. */
|
||
else sens_data[i]=390;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
} }
|
||
|
||
/* Проверяет if(Desk==dsk_COMM); последующий оператор выполняется только при истинном условии. */
|
||
if(Desk==dsk_COMM)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает Modbus[pow_addr+0].bit.bitE значением 1; бит E. */
|
||
Modbus[pow_addr+0].bit.bitE = 1; // Ignore
|
||
/* Записывает Modbus[pow_addr+1].bit.bitE значением 1; бит E. */
|
||
Modbus[pow_addr+1].bit.bitE = 1; // Ignore
|
||
/* Записывает Modbus[pow_addr+2].bit.bitE значением 1; бит E. */
|
||
Modbus[pow_addr+2].bit.bitE = 1; // Ignore
|
||
/* Записывает Modbus[pow_addr+3].bit.bitE значением 1; бит E. */
|
||
Modbus[pow_addr+3].bit.bitE = 1; // Ignore
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Проверяет if(Desk==dsk_LOAD); последующий оператор выполняется только при истинном условии. */
|
||
if(Desk==dsk_LOAD)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает Modbus[0].bit.bitE значением 1; бит E. */
|
||
Modbus[0].bit.bitE = 1; // Ignore
|
||
/* Записывает Modbus[1].bit.bitE значением 1; бит E. */
|
||
Modbus[1].bit.bitE = 1; // Ignore
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Вызывает calc_sensor_koef с аргументами () в текущей последовательности операций. */
|
||
calc_sensor_koef();
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Начинает функцию Init_packMask; назначение модуля — обработка датчиков, вычисление величин и миллисекундный такт системы. */
|
||
void Init_packMask()
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Объявляет i — данные i; j — данные j; can — CAN. Начальное значение задаётся справа от знака равенства. */
|
||
int i,j,can=0;
|
||
|
||
/* Записывает can значением pow_addr; CAN. */
|
||
can = pow_addr;
|
||
|
||
/* Проверяет if(Kurrent) can += 4; последующий оператор выполняется только при истинном условии. */
|
||
if(Kurrent) can += 4;
|
||
|
||
/* Цикл for(i=0;i<2;i++); задаёт начальное значение, условие продолжения и шаг перебора. */
|
||
for(i=0;i<2;i++)
|
||
/* Цикл for(j=0;j<8;j++) ; задаёт начальное значение, условие продолжения и шаг перебора. */
|
||
for(j=0;j<8;j++) { Maska[i][j]=0; }
|
||
|
||
/* Вызывает switch с аргументами (Desk) в текущей последовательности операций. */
|
||
switch(Desk)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Ветвь выбора для dsk_EPLT; выполняется при совпадении селектора switch. */
|
||
case dsk_EPLT:
|
||
/* Устанавливает биты Maska[m_SLOW][0] значением 0x000F; данные Maska. */
|
||
Maska[m_SLOW][0]|= 0x000F; // Полученное
|
||
/* Устанавливает биты Maska[m_SLOW][6] значением 0x01FC; данные Maska. */
|
||
Maska[m_SLOW][6]|= 0x01FC; // Яркость ламп и одиночество
|
||
/* Прерывает ближайший цикл или ветвь switch и продолжает после него. */
|
||
break;
|
||
|
||
/* Обрабатывает значения селектора, для которых нет отдельной ветви case. */
|
||
default:
|
||
/* Цикл for(i=0;i<can;i++); задаёт начальное значение, условие продолжения и шаг перебора. */
|
||
for(i=0;i<can;i++)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Устанавливает биты Maska[m_FAST][ i /16] значением (1<<( i %16)); данные Maska. */
|
||
Maska[m_FAST][ i /16]|=(1<<( i %16)); // Диагностика
|
||
/* Устанавливает биты Maska[m_FAST][(i+24)/16] значением (1<<((i+24)%16)); данные Maska. */
|
||
Maska[m_FAST][(i+24)/16]|=(1<<((i+24)%16)); // Показаниа
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
/* Цикл for(i=0;i<3; i++); задаёт начальное значение, условие продолжения и шаг перебора. */
|
||
for(i=0;i<3; i++)
|
||
/* Записывает Maska[m_SLOW][i+3] значением Maska[m_FAST][i]; данные Maska. */
|
||
Maska[m_SLOW][i+3] = Maska[m_FAST][i]; // Уставки
|
||
|
||
/* Проверяет if(Desk==dsk_BKSD) Maska[m_SLOW][7]|= 0x0300; последующий оператор выполняется только при истинном условии. */
|
||
if(Desk==dsk_BKSD) Maska[m_SLOW][7]|= 0x0300; // Калибровка термодатчиков
|
||
/* Выполняет альтернативу, если предыдущее условие if оказалось ложным. */
|
||
else
|
||
/* Устанавливает биты Maska[m_SLOW][7] значением 0x0F00; данные Maska. */
|
||
Maska[m_SLOW][7]|= 0x0F00; // Калибровка термодатчиков
|
||
/* Проверяет if(Kurrent); последующий оператор выполняется только при истинном условии. */
|
||
if(Kurrent)
|
||
/* Устанавливает биты Maska[m_SLOW][7] значением 0x000F; данные Maska. */
|
||
{ Maska[m_SLOW][7]|= 0x000F; // Ноль датчиков напражениа
|
||
/* Устанавливает биты Maska[m_SLOW][7] значением 0x00F0; данные Maska. */
|
||
Maska[m_SLOW][7]|= 0x00F0; // Калибровка датчиков напражениа
|
||
/* Устанавливает биты Maska[m_FAST][6] значением 0x3F00; данные Maska. */
|
||
Maska[m_FAST][6]|= 0x3F00; // Фазные значениа
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
/* Проверяет if(Owen) Maska[m_FAST][6]|= 0x0008; последующий оператор выполняется только при истинном условии. */
|
||
if(Owen) Maska[m_FAST][6]|= 0x0008; // Период опроса OWEN
|
||
/* Проверяет if(Desk==dsk_LOAD); последующий оператор выполняется только при истинном условии. */
|
||
if(Desk==dsk_LOAD)
|
||
/* Устанавливает биты Maska[m_SLOW][7] значением 0x0030; данные Maska. */
|
||
{ Maska[m_SLOW][7]|= 0x0030; // Калибровка ЦАП
|
||
/* Устанавливает биты Maska[m_SLOW][5] значением 0x0003; данные Maska. */
|
||
Maska[m_SLOW][5]|= 0x0003; // Начало и конец зарада
|
||
Maska[m_FAST][7]|= 0xF000; /* Быстрый CAN публикует статус 0x7C и настроенный лимит пусков 0x7D; биты 12..15 маски соответствуют адресам 0x7C..0x7F. */ // Дублировать команды /* Устанавливает биты Maska[m_FAST][7] значением 0xF000; данные Maska. */
|
||
/* Устанавливает биты Maska[m_FAST][1] значением 0x3000; данные Maska. */
|
||
Maska[m_FAST][1]|= 0x3000; // Управлающий ток СИФУ
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
} }
|
||
|
||
/* Устанавливает биты Maska[m_FAST][1] значением 0x0001; данные Maska. */
|
||
Maska[m_FAST][1]|= 0x0001; // Дискретные входы
|
||
/* Устанавливает биты Maska[m_SLOW][6] значением 0x0007; данные Maska. */
|
||
Maska[m_SLOW][6]|= 0x0007; // Яркость ламп, и периоды посылок
|
||
/* Устанавливает биты Maska[m_SLOW][7] значением 0xE000; данные Maska. */
|
||
Maska[m_SLOW][7]|= 0xE000; // Адрес, команды, и чтоб не вылазило
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Начинает функцию er_anal; назначение модуля — обработка датчиков, вычисление величин и миллисекундный такт системы. */
|
||
int er_anal(int term, unsigned int * count, long edge, int pre)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Проверяет if (term); последующий оператор выполняется только при истинном условии. */
|
||
if (term)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Проверяет if((*count)>=edge) return 1; последующий оператор выполняется только при истинном условии. */
|
||
if((*count)>=edge) return 1;
|
||
/* Изменяет счётчик в выражении (*count)++; return pre; на один для следующего шага. */
|
||
(*count)++; return pre;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
/* Проверяет if( (*count) == 0 ) return 0; последующий оператор выполняется только при истинном условии. */
|
||
if( (*count) == 0 ) return 0;
|
||
/* Изменяет счётчик в выражении (*count)--; return pre; на один для следующего шага. */
|
||
(*count)--; return pre;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Начинает функцию reset_errs; назначение модуля — обработка датчиков, вычисление величин и миллисекундный такт системы. */
|
||
void reset_errs(int sens, ERROR err)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Объявляет set — установка. */
|
||
ERROR set;
|
||
|
||
/* Записывает set.all значением (sens_error[sens].all & NOER) | err.all; представление регистра целым словом без разбиения на битовые поля. */
|
||
set.all = (sens_error[sens].all & NOER) | err.all;
|
||
/* Устанавливает биты chk.bit.Error значением set.bit.Stop; ошибка. */
|
||
chk.bit.Error|= set.bit.Stop;
|
||
/* Записывает set.bit.Ready значением !set.bit.Stop; данные Ready. */
|
||
set.bit.Ready = !set.bit.Stop;
|
||
/* Записывает sens_error[sens] значением set; sens ошибка. */
|
||
sens_error[sens] = set;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Начинает функцию Current_count; назначение модуля — обработка датчиков, вычисление величин и миллисекундный такт системы. */
|
||
void Current_count(int chan)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Объявляет Numb — данные Numb; Zer — данные Zer; Current — данные Current; Level — данные Level. */
|
||
float Numb,Zer,Current,Level;
|
||
/* Объявляет aCurrent — данные aCurrent; Amplitude — данные Amplitude. */
|
||
static float aCurrent,Amplitude;
|
||
/* Объявляет ignor — данные ignor; sens — данные sens; pair — данные pair; ist — данные ist; thrd — данные thrd. */
|
||
int ignor, sens, pair, ist, thrd, fazz, feed;
|
||
|
||
/* Объявляет error — ошибка. */
|
||
ERROR error;
|
||
|
||
/* Проверяет if(Desk == dsk_LOAD); последующий оператор выполняется только при истинном условии. */
|
||
if(Desk == dsk_LOAD)
|
||
/* Проверяет if(!chan); последующий оператор выполняется только при истинном условии. */
|
||
if(!chan)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает sig.all значением chk.all; представление регистра целым словом без разбиения на битовые поля. */
|
||
sig.all = chk.all;
|
||
/* Записывает chk.all значением 0; представление регистра целым словом без разбиения на битовые поля. */
|
||
chk.all = 0;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Записывает sens значением pow_addr + chan; данные sens. */
|
||
sens = pow_addr + chan;
|
||
/* Младший бит локального канала АЦП выбирает соседнюю фазу (0 <-> 1, 2 <-> 3); sens_pair хранит глобальные номера датчиков со смещением pow_addr и не подходит для индексации lev_count. */
|
||
pair = chan ^ 1;
|
||
/* Записывает ist значением !(chan & 1); данные ist. */
|
||
ist = !(chan & 1);
|
||
/* Записывает feed значением (chan >>1); данные feed. */
|
||
feed = (chan >>1);
|
||
/* Записывает fazz значением feed*3; данные fazz. */
|
||
fazz = feed*3;
|
||
/* Записывает thrd значением feed+4; данные thrd. */
|
||
thrd = feed+4;
|
||
|
||
/* Проверяет if(sens_error[sens].bit.Bypas); последующий оператор выполняется только при истинном условии. */
|
||
if(sens_error[sens].bit.Bypas)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает sens_error[sens].all значением 0; представление регистра целым словом без разбиения на битовые поля. */
|
||
sens_error[sens].all = 0;
|
||
/* Записывает sens_error[sens].bit.Bypas значением 1; данные Bypas. */
|
||
sens_error[sens].bit.Bypas = 1;
|
||
/* Записывает sens_data[sens] значением 0; sens данные. */
|
||
sens_data[sens] = 0;
|
||
/* Завершает Current_count без возвращаемого значения. */
|
||
return;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Записывает Numb значением adc_table_lem[chan]; данные Numb. */
|
||
Numb = adc_table_lem[chan];
|
||
|
||
/* Записывает modbus[0x64+chan] значением Numb; массив технологических регистров; слово int на C28x занимает 16 бит. */
|
||
modbus[0x64+chan] = Numb;
|
||
|
||
// Средний (он же нулевой) уровень показаний АЦП
|
||
/* Увеличивает zer_count[chan] значением (Numb-zer_count[chan])/(5.0 * ADC_FREQ); zer число. */
|
||
zer_count[chan] += (Numb-zer_count[chan])/(5.0 * ADC_FREQ);
|
||
/* Записывает Zer значением (int)(filterbat(&zer_filter[chan],zer_count[chan])); данные Zer. */
|
||
Zer = (int)(filterbat(&zer_filter[chan],zer_count[chan]));
|
||
/* Проверяет if(WAKE < (WAKE_TIME /2)) Zero_lev[chan] = Zer; последующий оператор выполняется только при истинном условии. */
|
||
if(WAKE < (WAKE_TIME /2)) Zero_lev[chan] = Zer;
|
||
/*
|
||
Test_mem_limit(12);
|
||
Log_to_mem((int)adc_table_lem[chan]);
|
||
Log_to_mem((int)zer_count[chan]);
|
||
Log_to_mem((int)Zero_lev[chan]);
|
||
*/
|
||
// Мгновенное значение фазы
|
||
/* Записывает Current значением (Numb - Zero_lev[chan]) * powK[chan]; данные Current. */
|
||
Current = (Numb - Zero_lev[chan]) * powK[chan];
|
||
|
||
// Действующее (среднеквадратичное) значение фазы
|
||
/* Увеличивает lev_quadr[chan] значением ((Current*Current)-lev_quadr[chan])/(1.0 * ADC_FREQ); данные lev_quadr. */
|
||
lev_quadr[chan] += ((Current*Current)-lev_quadr[chan])/(1.0 * ADC_FREQ);
|
||
/* Записывает lev_count[chan] значением sqrt(lev_quadr[chan]); lev число. */
|
||
lev_count[chan] = sqrt(lev_quadr[chan]);
|
||
|
||
// Запомним
|
||
/* Проверяет if(ist); последующий оператор выполняется только при истинном условии. */
|
||
if(ist)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Проверяет if(Desk==dsk_COMM) aCurrent =-Current; последующий оператор выполняется только при истинном условии. */
|
||
if(Desk==dsk_COMM) aCurrent =-Current;
|
||
/* Выполняет альтернативу, если предыдущее условие if оказалось ложным. */
|
||
else aCurrent = Current; // Запомнили мгновенное значение - дла амплитуды
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
/* Выполняет альтернативу, если предыдущее условие if оказалось ложным. */
|
||
else
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
// Вычисление амплитуды
|
||
/* Записывает Amplitude значением filterbat(&out_filter[sens], im_calc(Current,aCurrent)); данные Amplitude. */
|
||
Amplitude = filterbat(&out_filter[sens], im_calc(Current,aCurrent));
|
||
|
||
/* Проверяет if(sens_type[sens]==VOLTAGE); последующий оператор выполняется только при истинном условии. */
|
||
if(sens_type[sens]==VOLTAGE)
|
||
/* Проверяет if(Amplitude<20) Amplitude = 0; последующий оператор выполняется только при истинном условии. */
|
||
if(Amplitude<20) Amplitude = 0;
|
||
|
||
/* Проверяет if(sens_type[sens]==CURRENT); последующий оператор выполняется только при истинном условии. */
|
||
if(sens_type[sens]==CURRENT)
|
||
/* Проверяет if(Amplitude<75) Amplitude = 0; последующий оператор выполняется только при истинном условии. */
|
||
if(Amplitude<75) Amplitude = 0;
|
||
|
||
/* Записывает Level значением Amplitude / RADIX2; данные Level. */
|
||
Level = Amplitude / RADIX2;
|
||
|
||
/* Проверяет if(!WAKE); последующий оператор выполняется только при истинном условии. */
|
||
if(!WAKE)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает sens_data[sens ] значением Amplitude; sens данные. */
|
||
sens_data[sens ] = Amplitude;
|
||
/* Записывает sens_data[sens-1] значением Level; sens данные. */
|
||
sens_data[sens-1] = Level;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
// Действующее (среднеквадратичное) значение третьей фазы
|
||
/* Записывает Numb значением -Current-aCurrent; данные Numb. */
|
||
Numb =-Current-aCurrent;
|
||
/* Увеличивает lev_quadr[thrd] значением (Numb*Numb-lev_quadr[thrd])/(1.0 * ADC_FREQ); данные lev_quadr. */
|
||
lev_quadr[thrd] += (Numb*Numb-lev_quadr[thrd])/(1.0 * ADC_FREQ);
|
||
/* Записывает lev_count[thrd] значением sqrt(lev_quadr[thrd]); lev число. */
|
||
lev_count[thrd] = sqrt(lev_quadr[thrd]);
|
||
/*
|
||
if(!no_write)
|
||
{
|
||
Test_mem_limit(8);
|
||
|
||
Log_to_mem(Current);
|
||
Log_to_mem(aCurrent);
|
||
Log_to_mem(Numb);
|
||
|
||
Log_to_mem(lev_count[chan]);
|
||
Log_to_mem(lev_count[pair]);
|
||
Log_to_mem(lev_count[thrd]);
|
||
|
||
Log_to_mem(Amplitude);
|
||
Log_to_mem(Level);
|
||
}
|
||
*/
|
||
/* Записывает modbus[0x68+fazz ] значением lev_count[pair]; массив технологических регистров; слово int на C28x занимает 16 бит. */
|
||
modbus[0x68+fazz ] = lev_count[pair];
|
||
/* Записывает modbus[0x68+fazz+1] значением lev_count[chan]; массив технологических регистров; слово int на C28x занимает 16 бит. */
|
||
modbus[0x68+fazz+1] = lev_count[chan];
|
||
/* Записывает modbus[0x68+fazz+2] значением lev_count[thrd]; массив технологических регистров; слово int на C28x занимает 16 бит. */
|
||
modbus[0x68+fazz+2] = lev_count[thrd];
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
// Это максимальное
|
||
/* Записывает Numb значением lev_count[chan]; данные Numb. */
|
||
Numb = lev_count[chan];
|
||
/* Проверяет if(Numb<lev_count[pair]) Numb = lev_count[pair]; последующий оператор выполняется только при истинном условии. */
|
||
if(Numb<lev_count[pair]) Numb = lev_count[pair];
|
||
/* Проверяет if(Numb<lev_count[thrd]) Numb = lev_count[thrd]; последующий оператор выполняется только при истинном условии. */
|
||
if(Numb<lev_count[thrd]) Numb = lev_count[thrd];
|
||
|
||
// Зашиты!
|
||
/* Записывает error.all значением 0; представление регистра целым словом без разбиения на битовые поля. */
|
||
error.all = 0;
|
||
/* Проверяет if(WAKE) goto fin; последующий оператор выполняется только при истинном условии. */
|
||
if(WAKE) goto fin;
|
||
/* Записывает ignor значением sens_error[sens].bit.Ignor; данные ignor. */
|
||
ignor = sens_error[sens].bit.Ignor;
|
||
|
||
/* Проверяет if(er_anal( ((Numb-lev_count[chan])/Numb > 0.3) и (Numb>Curr_Edge),; последующий оператор выполняется только при истинном условии. */
|
||
if(er_anal( ((Numb-lev_count[chan])/Numb > 0.3) && (Numb>Curr_Edge),
|
||
/* Продолжает список аргументов, полей или выражение &err_count[chan],time_3sec,0)); порядок элементов сохраняется. */
|
||
&err_count[chan],time_3sec,0))
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает error.bit.Wry значением 1; данные Wry. */
|
||
error.bit.Wry = 1;
|
||
/* Записывает error.bit.Stop значением !ignor; данные Stop. */
|
||
error.bit.Stop = !ignor;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Проверяет if(er_anal( ((Numb-lev_count[thrd])/Numb > 0.3) и (Numb>Curr_Edge),; последующий оператор выполняется только при истинном условии. */
|
||
if(er_anal( ((Numb-lev_count[thrd])/Numb > 0.3) && (Numb>Curr_Edge),
|
||
/* Продолжает список аргументов, полей или выражение &err_count[thrd],time_3sec,0)); порядок элементов сохраняется. */
|
||
&err_count[thrd],time_3sec,0))
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает error.bit.Wry значением 1; данные Wry. */
|
||
error.bit.Wry = 1;
|
||
/* Записывает error.bit.Stop значением !ignor; данные Stop. */
|
||
error.bit.Stop = !ignor;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Проверяет if(Desk == dsk_LOAD); последующий оператор выполняется только при истинном условии. */
|
||
if(Desk == dsk_LOAD)
|
||
/* Проверяет if(!ist); последующий оператор выполняется только при истинном условии. */
|
||
if(!ist)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Проверяет if(Level > sens_hi_edge[sens]); последующий оператор выполняется только при истинном условии. */
|
||
if(Level > sens_hi_edge[sens])
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает error.bit.Hyper значением 1; данные Hyper. */
|
||
error.bit.Hyper = 1;
|
||
/* Записывает error.bit.Stop значением !ignor; данные Stop. */
|
||
error.bit.Stop = !ignor;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Проверяет if(sens_type[sens]==VOLTAGE); последующий оператор выполняется только при истинном условии. */
|
||
if(sens_type[sens]==VOLTAGE)
|
||
|
||
/* Проверяет if(er_anal( (Level < sens_lo_edge[sens]),; последующий оператор выполняется только при истинном условии. */
|
||
if(er_anal( (Level < sens_lo_edge[sens]),
|
||
/* Продолжает список аргументов, полей или выражение &low_count[feed],time_3sec,0)); порядок элементов сохраняется. */
|
||
&low_count[feed],time_3sec,0))
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает error.bit.Out значением 1; данные Out. */
|
||
error.bit.Out = 1;
|
||
/* Записывает error.bit.Stop значением !ignor; данные Stop. */
|
||
error.bit.Stop = !ignor;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Проверяет if(sens_type[sens]==CURRENT); последующий оператор выполняется только при истинном условии. */
|
||
if(sens_type[sens]==CURRENT)
|
||
/* Проверяет if(Level > sens_lo_edge[sens]); последующий оператор выполняется только при истинном условии. */
|
||
if(Level > sens_lo_edge[sens])
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает error.bit.Over значением 1; данные Over. */
|
||
error.bit.Over = 1;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
} }
|
||
/*
|
||
if((chan==1)||(chan==3))
|
||
if(error.all)
|
||
if(!no_write)
|
||
{
|
||
Test_mem_limit(12);
|
||
Log_to_mem(Current);
|
||
Log_to_mem(aCurrent);
|
||
Log_to_mem(Numb);
|
||
Log_to_mem(lev_count[chan]);
|
||
Log_to_mem(lev_count[pair]);
|
||
Log_to_mem(lev_count[thrd]);
|
||
Log_to_mem(Amplitude);
|
||
Log_to_mem(Level);
|
||
Log_to_mem(Zero_lev[chan]);
|
||
Log_to_mem(Curr_Edge);
|
||
Log_to_mem(error.all);
|
||
Log_to_mem(WAKE);
|
||
}
|
||
*/
|
||
/* Метка fin для перехода внутри функции. */
|
||
fin:
|
||
/* Вызывает reset_errs с аргументами (sens,error) в текущей последовательности операций. */
|
||
reset_errs(sens,error);
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Начинает функцию Temper_count; назначение модуля — обработка датчиков, вычисление величин и миллисекундный такт системы. */
|
||
void Temper_count(int chan, int own)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Объявляет Numb — данные Numb. */
|
||
float Numb;
|
||
/* Объявляет Temper — данные Temper. */
|
||
static int Temper;
|
||
/* Объявляет i — данные i; j — данные j; kun — данные kun. */
|
||
int i,j, kun;
|
||
/* Объявляет s — данные s. */
|
||
long s;
|
||
/* Объявляет error — ошибка. */
|
||
ERROR error;
|
||
/* Объявляет ovn — данные ovn. */
|
||
int ovn;
|
||
|
||
/* Проверяет if(!chan); последующий оператор выполняется только при истинном условии. */
|
||
if(!chan)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает sig.all значением chk.all; представление регистра целым словом без разбиения на битовые поля. */
|
||
sig.all = chk.all;
|
||
/* Записывает chk.all значением 0; представление регистра целым словом без разбиения на битовые поля. */
|
||
chk.all = 0;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Проверяет if(sens_error[chan].bit.Bypas); последующий оператор выполняется только при истинном условии. */
|
||
if(sens_error[chan].bit.Bypas)
|
||
/* Проверяет if(chan<tpl_cans); последующий оператор выполняется только при истинном условии. */
|
||
if(chan<tpl_cans)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает sens_error[chan].all значением 0; представление регистра целым словом без разбиения на битовые поля. */
|
||
sens_error[chan].all = 0;
|
||
/* Записывает sens_error[chan].bit.Bypas значением 1; данные Bypas. */
|
||
sens_error[chan].bit.Bypas = 1;
|
||
/* Записывает sens_data[chan] значением 0; sens данные. */
|
||
sens_data[chan] = 0;
|
||
/* Завершает Temper_count без возвращаемого значения. */
|
||
return;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Записывает Numb значением ADC_table[chan]; данные Numb. */
|
||
Numb = ADC_table[chan];
|
||
|
||
/* Проверяет if(cRawMeat); последующий оператор выполняется только при истинном условии. */
|
||
if(cRawMeat)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает sens_data[chan] значением Numb; sens данные. */
|
||
sens_data[chan] = Numb;
|
||
/* Завершает Temper_count без возвращаемого значения. */
|
||
return;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Проверяет if(sens_error[chan].bit.Imit); последующий оператор выполняется только при истинном условии. */
|
||
if(sens_error[chan].bit.Imit)
|
||
/* Проверяет if(chan<tpl_cans); последующий оператор выполняется только при истинном условии. */
|
||
if(chan<tpl_cans)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает j значением 0;s=0; данные j. */
|
||
j=0;s=0;
|
||
|
||
/* Цикл for(i=0;i<start_data;i++); задаёт начальное значение, условие продолжения и шаг перебора. */
|
||
for(i=0;i<start_data;i++)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Проверяет if( sens_type[i]==sens_type[chan]); последующий оператор выполняется только при истинном условии. */
|
||
if( sens_type[i]==sens_type[chan])
|
||
/* Проверяет if(!(sens_error[i].all & okay.all)); последующий оператор выполняется только при истинном условии. */
|
||
if(!(sens_error[i].all & okay.all))
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Увеличивает s значением ADC_table[i]; данные s. */
|
||
s+=ADC_table[i];
|
||
/* Изменяет счётчик в выражении j++; на один для следующего шага. */
|
||
j++;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
} }
|
||
|
||
/* Проверяет if(j) s/=j; последующий оператор выполняется только при истинном условии. */
|
||
if(j) s/=j;
|
||
/* Записывает Numb значением s; данные Numb. */
|
||
Numb = s;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Записывает kun значением chan - cal_addr; данные kun. */
|
||
kun = chan - cal_addr;
|
||
|
||
/* Проверяет if(own); последующий оператор выполняется только при истинном условии. */
|
||
if(own)
|
||
/* Проверяет if(sens_type[chan]==TRM_OBEH); последующий оператор выполняется только при истинном условии. */
|
||
if(sens_type[chan]==TRM_OBEH)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает ovn значением chan-tpl_cans; данные ovn. */
|
||
ovn = chan-tpl_cans;
|
||
/* Записывает Numb значением 0.1 * ext_temp[ovn]; данные Numb. */
|
||
Numb= 0.1 * ext_temp[ovn];
|
||
/* Проверяет if(ext_diag[ovn]); последующий оператор выполняется только при истинном условии. */
|
||
if(ext_diag[ovn])
|
||
/* Записывает Numb значением -100; данные Numb. */
|
||
Numb = -100;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Проверяет if(!own); последующий оператор выполняется только при истинном условии. */
|
||
if(!own)
|
||
/* Проверяет if(TermoAD); последующий оператор выполняется только при истинном условии. */
|
||
if(TermoAD)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Проверяет if(cTermoCal|bTermoCal); последующий оператор выполняется только при истинном условии. */
|
||
if(cTermoCal|bTermoCal)
|
||
/* Проверяет if(!WAKE); последующий оператор выполняется только при истинном условии. */
|
||
if(!WAKE)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Проверяет if(Desk==dsk_SHKF); последующий оператор выполняется только при истинном условии. */
|
||
if(Desk==dsk_SHKF)
|
||
/* Проверяет if(Numb>2200) kun|=2; последующий оператор выполняется только при истинном условии. */
|
||
if(Numb>2200) kun|=2;
|
||
|
||
/* Проверяет if(kun>=0); последующий оператор выполняется только при истинном условии. */
|
||
if(kun>=0)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает TCaliber[kun] значением Numb; данные TCaliber. */
|
||
TCaliber[kun] = Numb;
|
||
/* Вызывает calc_sensor_koef с аргументами () в текущей последовательности операций. */
|
||
calc_sensor_koef();
|
||
/* Завершает Temper_count без возвращаемого значения. */
|
||
return;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
} }
|
||
|
||
/* Проверяет if(chan>=tpl_cans) return; последующий оператор выполняется только при истинном условии. */
|
||
if(chan>=tpl_cans) return;
|
||
|
||
// Kun именно чтоб скомпенсировать нечетность
|
||
/* Проверяет if(kun&1) Numb = (Numb-K300_2)*K_T2+ZERO; последующий оператор выполняется только при истинном условии. */
|
||
if(kun&1) Numb = (Numb-K300_2)*K_T2+ZERO;
|
||
/* Выполняет альтернативу, если предыдущее условие if оказалось ложным. */
|
||
else Numb = (Numb-K300_1)*K_T1+ZERO;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Проверяет if(TermoRS); последующий оператор выполняется только при истинном условии. */
|
||
if(TermoRS)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Проверяет if(kun>=0); последующий оператор выполняется только при истинном условии. */
|
||
if(kun>=0)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Проверяет if(WAKE) out_filter[chan] = adc_filter[chan]; последующий оператор выполняется только при истинном условии. */
|
||
if(WAKE) out_filter[chan] = adc_filter[chan];
|
||
/* Выполняет альтернативу, если предыдущее условие if оказалось ложным. */
|
||
else
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
// Калибровку отфильтруем вторым слоем
|
||
/* Записывает Numb значением filterbat(&out_filter[chan],Numb); данные Numb. */
|
||
Numb = filterbat(&out_filter[chan],Numb);
|
||
|
||
/* Записывает TCaliber[kun] значением Numb; данные TCaliber. */
|
||
TCaliber[kun] = Numb;
|
||
/* Вызывает calc_sensor_koef с аргументами () в текущей последовательности операций. */
|
||
calc_sensor_koef();
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
/* Завершает Temper_count без возвращаемого значения. */
|
||
return;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Проверяет if(Desk==dsk_BKSD); последующий оператор выполняется только при истинном условии. */
|
||
if(Desk==dsk_BKSD)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает sens_data[chan+8] значением ADC_table[chan]; sens данные. */
|
||
sens_data[chan+8] = ADC_table[chan];
|
||
/* Проверяет if(chan<6) Numb = (Numb-K100_D)*K100; последующий оператор выполняется только при истинном условии. */
|
||
if(chan<6) Numb = (Numb-K100_D)*K100;
|
||
/* Выполняет альтернативу, если предыдущее условие if оказалось ложным. */
|
||
else Numb = (Numb-K100_D)*K_50;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
/* Выполняет альтернативу, если предыдущее условие if оказалось ложным. */
|
||
else
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Проверяет if(chan&1) Numb = (Numb-K100_2)*K_T2; последующий оператор выполняется только при истинном условии. */
|
||
if(chan&1) Numb = (Numb-K100_2)*K_T2;
|
||
/* Выполняет альтернативу, если предыдущее условие if оказалось ложным. */
|
||
else Numb = (Numb-K100_1)*K_T1;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
} }
|
||
|
||
/* Проверяет if(Numb < -20) Numb = -20; последующий оператор выполняется только при истинном условии. */
|
||
if(Numb < -20) Numb = -20;
|
||
/* Проверяет if(Numb > 200) Numb = 200; последующий оператор выполняется только при истинном условии. */
|
||
if(Numb > 200) Numb = 200;
|
||
|
||
/* Проверяет if(bSecretBt|cSecretBt) Numb = 40.0; последующий оператор выполняется только при истинном условии. */
|
||
if(bSecretBt|cSecretBt) Numb = 40.0;
|
||
|
||
/* Записывает sens_data[chan] значением Numb*10; sens данные. */
|
||
sens_data[chan] = Numb*10;
|
||
|
||
/* Записывает Temper значением Numb; данные Temper. */
|
||
Temper = Numb;
|
||
|
||
/* Записывает error.all значением 0; представление регистра целым словом без разбиения на битовые поля. */
|
||
error.all = 0;
|
||
/* Проверяет if(WAKE или sens_error[chan].bit.Ignor) goto fin; последующий оператор выполняется только при истинном условии. */
|
||
if(WAKE || sens_error[chan].bit.Ignor) goto fin;
|
||
|
||
// Обрыв или неисправность
|
||
/* Проверяет if(Temper<=-20 или Temper>=200); последующий оператор выполняется только при истинном условии. */
|
||
if(Temper<=-20 || Temper>=200)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает error.bit.Tear значением 1; данные Tear. */
|
||
error.bit.Tear = 1;
|
||
/* Записывает chk.bit.OutHeat значением 1; данные OutHeat. */
|
||
chk.bit.OutHeat = 1;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
/* Выполняет альтернативу, если предыдущее условие if оказалось ложным. */
|
||
else
|
||
|
||
// Перегрев
|
||
/* Проверяет if(((Temper>sens_hi_edge[chan]-Cooling) и (sens_error[chan].bit.Hyper)) или; последующий оператор выполняется только при истинном условии. */
|
||
if(((Temper>sens_hi_edge[chan]-Cooling) && (sens_error[chan].bit.Hyper)) ||
|
||
/* Продолжает список аргументов, полей или выражение (Temper>sens_hi_edge[chan]) ); порядок элементов сохраняется. */
|
||
(Temper>sens_hi_edge[chan]) )
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает error.bit.Hyper значением 1; данные Hyper. */
|
||
error.bit.Hyper = 1;
|
||
/* Записывает error.bit.Stop значением 1; данные Stop. */
|
||
error.bit.Stop = 1;
|
||
/* Записывает chk.bit.OverHeat значением 1; данные OverHeat. */
|
||
chk.bit.OverHeat= 1;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
/* Выполняет альтернативу, если предыдущее условие if оказалось ложным. */
|
||
else
|
||
|
||
// Предупреждение по температуре
|
||
/* Проверяет if(Temper>sens_lo_edge[chan]); последующий оператор выполняется только при истинном условии. */
|
||
if(Temper>sens_lo_edge[chan])
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает error.bit.Over значением 1; данные Over. */
|
||
error.bit.Over = 1;
|
||
/* Записывает chk.bit.SubHeat значением 1; данные SubHeat. */
|
||
chk.bit.SubHeat = 1;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Метка fin для перехода внутри функции. */
|
||
fin:
|
||
/* Вызывает reset_errs с аргументами (chan,error) в текущей последовательности операций. */
|
||
reset_errs(chan,error);
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Начинает функцию Power_count; назначение модуля — обработка датчиков, вычисление величин и миллисекундный такт системы. */
|
||
void Power_count(int chan)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Объявляет Numb — данные Numb. */
|
||
float Numb;
|
||
/* Объявляет Power — данные Power; bitt — данные bitt. */
|
||
int Power,bitt;
|
||
/* Объявляет error — ошибка. */
|
||
ERROR error;
|
||
|
||
/* Проверяет if(!chan); последующий оператор выполняется только при истинном условии. */
|
||
if(!chan)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает sig.all значением chk.all; представление регистра целым словом без разбиения на битовые поля. */
|
||
sig.all = chk.all;
|
||
/* Записывает chk.all значением 0; представление регистра целым словом без разбиения на битовые поля. */
|
||
chk.all = 0;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Проверяет if(sens_error[chan].bit.Bypas); последующий оператор выполняется только при истинном условии. */
|
||
if(sens_error[chan].bit.Bypas)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает sens_error[chan].all значением 0; представление регистра целым словом без разбиения на битовые поля. */
|
||
sens_error[chan].all = 0;
|
||
/* Записывает sens_error[chan].bit.Bypas значением 1; данные Bypas. */
|
||
sens_error[chan].bit.Bypas = 1;
|
||
/* Записывает sens_data[chan] значением 0; sens данные. */
|
||
sens_data[chan] = 0;
|
||
/* Завершает Power_count без возвращаемого значения. */
|
||
return;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Записывает Numb значением ADC_table[chan]; данные Numb. */
|
||
Numb = ADC_table[chan];
|
||
|
||
/* Проверяет if(cRawMeat); последующий оператор выполняется только при истинном условии. */
|
||
if(cRawMeat)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает sens_data[chan] значением Numb; sens данные. */
|
||
sens_data[chan] = Numb;
|
||
/* Завершает Power_count без возвращаемого значения. */
|
||
return;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
|
||
/* Записывает Power значением Numb * powK[sens_type[chan]]; данные Power. */
|
||
Power = Numb * powK[sens_type[chan]];
|
||
|
||
/* Записывает sens_data[chan] значением Power; sens данные. */
|
||
sens_data[chan] = Power;
|
||
|
||
/* Записывает error.all значением 0; представление регистра целым словом без разбиения на битовые поля. */
|
||
error.all = 0;
|
||
|
||
/* Проверяет if(WAKE или sens_error[chan].bit.Ignor) goto fin; последующий оператор выполняется только при истинном условии. */
|
||
if(WAKE || sens_error[chan].bit.Ignor) goto fin;
|
||
|
||
// Дискретные каналы
|
||
/* Записывает bitt значением chan*2; данные bitt. */
|
||
bitt = chan*2;
|
||
/* Проверяет if(chan!=7); последующий оператор выполняется только при истинном условии. */
|
||
if(chan!=7)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает error.bit.Discr1 значением er_anal(((DigErr.all>>bitt)&1), &din_count[bitt], 1000, 0); bitt++; данные Discr1. */
|
||
error.bit.Discr1 = er_anal(((DigErr.all>>bitt)&1), &din_count[bitt], 1000, 0); bitt++;
|
||
/* Записывает error.bit.Discr2 значением er_anal(((DigErr.all>>bitt)&1), &din_count[bitt], 1000, 0); bitt++; данные Discr2. */
|
||
error.bit.Discr2 = er_anal(((DigErr.all>>bitt)&1), &din_count[bitt], 1000, 0); bitt++;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
/* Проверяет if(chan==6); последующий оператор выполняется только при истинном условии. */
|
||
if(chan==6)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает error.bit.Discr3 значением er_anal(((DigErr.all>>bitt)&1), &din_count[bitt], 1000, 0); bitt++; данные Discr3. */
|
||
error.bit.Discr3 = er_anal(((DigErr.all>>bitt)&1), &din_count[bitt], 1000, 0); bitt++;
|
||
/* Записывает error.bit.Discr4 значением er_anal(((DigErr.all>>bitt)&1), &din_count[bitt], 1000, 0); bitt++; данные Discr4. */
|
||
error.bit.Discr4 = er_anal(((DigErr.all>>bitt)&1), &din_count[bitt], 1000, 0); bitt++;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|
||
/* Записывает error.bit.Contr значением error.bit.Discr1 | error.bit.Discr2 | error.bit.Discr3 | error.bit.Discr4; данные Contr. */
|
||
error.bit.Contr = error.bit.Discr1 | error.bit.Discr2 | error.bit.Discr3 | error.bit.Discr4;
|
||
|
||
// Пониженное напражение
|
||
/* Проверяет if(Power <sens_lo_edge[chan]); последующий оператор выполняется только при истинном условии. */
|
||
if(Power <sens_lo_edge[chan])
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает error.bit.Out значением 1; данные Out. */
|
||
error.bit.Out = 1;
|
||
|
||
/* Проверяет if(sens_error[sens_pair[chan]].bit.Out); последующий оператор выполняется только при истинном условии. */
|
||
if(sens_error[sens_pair[chan]].bit.Out)
|
||
/* Открывает составной блок или описание полей; следующие строки принадлежат этому уровню вложенности. */
|
||
{
|
||
/* Записывает error.bit.Stop значением 1; данные Stop. */
|
||
error.bit.Stop = 1;
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
} }
|
||
|
||
// Повышенное напражение
|
||
/* if(Power > sens_hi_edge[chan])
|
||
{
|
||
error.bit.Hyper = 1;
|
||
error.bit.Stop = 1;
|
||
}
|
||
*/
|
||
/* Проверяет if(error.all); последующий оператор выполняется только при истинном условии. */
|
||
if(error.all)
|
||
/* Записывает chk.bit.Alarm значением 1; данные Alarm. */
|
||
chk.bit.Alarm = 1;
|
||
|
||
/* Метка fin для перехода внутри функции. */
|
||
fin:
|
||
/* Вызывает reset_errs с аргументами (chan,error) в текущей последовательности операций. */
|
||
reset_errs(chan,error);
|
||
/* Закрывает текущий блок или список полей; следующие операторы относятся к внешнему уровню. */
|
||
}
|