Выводы по охране труда

7.4 Выводы по охране труда

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

Приложение 1

Главный модуль

main.c

// Подключаем заголовочные файлы и объявляем локальные и глобальные // переменные

#include <drivers.h>

#include <nbdp.h>

#include <string.h>

#include <ctype.h>

int PTT_Recalc;

int DebugLevel;

/*-------------------------------------------------------------*/

int cntr;

int CALL_ID[10];

// Объявление внешних функций и переменных

extern void FreeSignal(void);

extern int IsCharReady(void);

extern int FRE_FLAG;

extern int setISS,setIRS;

/*-------------------------------------------------------------*/

void main()

{

int save_dsw;

/*-------------------------------------------------------------*/

// Сброс выводов FL2..FL0

asm("reset fl0;");

asm("reset fl1;");

asm("reset fl2;");

init_1847(); // Инициализация кодека AD1847

UART_Init(); // Инициализация интерфейса UART

// Дадим команду host-устройству на инициалицацию

SendCommandHost("INIT","POWER ON");

// Инициализируем структуру NBDP (narrowband direct printing)

NBDP_Init();

// Процесс обмена данными

while(1)

{

if(COMF & 1)

{

if(COMF & 0x02) arq(); // запустить протокол ARQ , описание в

// npdp_arq.c

else if(COMF & 0x1C) fec(); // запустить протокол FEC , описание в

// npdp_fec.c

else // Если другое сотояние COMF, то ошибку в host

{

SendHostError(5,COMF); /* COMF ERROR */

StandBy();

}

}

if(FRE_FLAG) // Если модем свободен

{

FRE_FLAG=0;

// Отправим команду в host , что модем свободен

SendCommandHost("FRE",FRE_FLAG == 1 ? "1":"0");

}

/* Если символ готов к передаче , выбрать команды из порта*/

if(IsCharReady()) SerialDriver();

// Передача символов в HOST

if((COMF & 1) && (ho_count))

{

char block[15],d;

int i=0;

while(hoRead(&d) != -1)

{

block[i++] = d;

if(i>14) break;

}

block[i]=0;

SendCommandHost("TXT",block); // отправка блока в host

}

} // end of while

} // end of main()

/*-------------------------------------------------------------*/

int CheckCommRequest(char *DATA) // Проверка корректности номера

// объекта связи (парохода), по

// которому происходит связь с данным

// объектом

{

int j=0,tmp;

for(j=0;DATA[j]!=';';)

{

tmp = DATA[j];

if(!(tmp>='0' && tmp<='9')) // цифры не могут быть кодом объекта

{

SendHostError(11,tmp); /* ERR;01.1;ID WRONG DIGIT (%c),ID[j] */

return 1;

}

CALL_ID[j] = tmp;

j++;

if(j>9) break;

}

CALL_ID[j]=0;

if(j!=4 && j!=5 && j!=9) /* incorrect ID */ // символ ';' в коде должен быть // третьим, четвертым или восьмым

{

SendHostError(12,j);

return 1;

}

return 0; // проверка успешна, возврат 0.

}

/*-------------------------------------------------------------*/

// массив названий команд для функции SendCommandHost(char *cmd, ...)

char *cmds[] =

{

"TXT","ARQ","CFE","SFE","SET", /* 0... 4 */

"STA","INI","DEB","DBG","DIA", /* 5... 9 */

"FRE","STB","TST","STR","FCC", /* 10...14 */

NULL

};

int CheckCommRequest(char *DATA);

/*-------------------------------------------------------------*/

Программа модуляции

За основу данного способа модуляции взята - частотная модуляция с использованием протокола морского телеграфа NBDP ( narrowband direct printing) - узкополосное буквопечатанье. В основе лежит таблица кодовых значений сиволов, которые представляются в виде комбинации 1 и 0 и после модулируются с соответственно частотами 1615 Hz и 1785 Hz. ( таблица символов в файле nbdp_table.c ).

Mod.c

// Подключаем заголовочные файлы и объявляем локальные и глобальные // переменные

#include <drivers.h>

#include <template.h>

#include <nbdp.h>

/*-------------------------------------------------------------*/

/*#define OUT_KOEFF 0x6000*/

#ifdef RX_TO_TX_

extern int RX_TO_TX[2];

#endif

/*-------------------------------------------------------------*/

int PH_ACC,TMP_PH_ACC;

int PH_INC;

int mod_ready=1;

int BITTIME=1;

int bits_left;

int out_data;

volatile int l_out,r_out;

extern int FDIV,FS_PTT_OFF;

int dbg_cntr;

/*-------------------------------------------------------------*/

/* MODULATOR */

/*-------------------------------------------------------------*/

extern void Timing(void);

void modulator(void)

{

// Возможна работа в тестовом режиме.

if(SelfTest) goto test_modes;

FDIV++;

// через 10 мс обнуление отсчетов и посылка в хост синхронизирующего // сигнала цикла ARQ.

if(FDIV==80) {FDIV=0;NBDP_THR_TX();}

#ifdef RX_TO_TX_

tx_buf[1] = RX_TO_TX[0];

tx_buf[2] = RX_TO_TX[1];

return;

#endif

// Проверка нужна ли модуляция, если нет то возврат

if(!Modulator_ON)

{

PH_ACC = 0;

return;

}

restart:

if(mod_ready)

{

tx_buf[1] = tx_buf[2] = 0;

if(FS_PTT_OFF) // выключение модуляции

{

FS_PTT_OFF=0;

PTT_OFF();

}

return;

}

test_modes:

BITTIME--;

if(BITTIME==0)

{

/*=== determine the new bit from out byte ===*/

// Режим реальной работы

if(!SelfTest) out_data <<= 1; /* 7 bit mode */

if(out_data & 0x80) /* MARK */

{

PH_INC = MARK_INC;

asm("

#define PFDATA 0x3fe5

ar = b#0000000001000000; /* set 1 PF6/TLG OUT */

ay1 = dm(PFDATA);

ar = ar or ay1;

dm(PFDATA) = ar;");

}

else /* SPACE */

{

PH_INC = SPACE_INC;

asm("

ar = b#1111111110111111; /* reset 1 PF6/TLG OUT */

ay1 = dm(PFDATA);

ar = ar and ay1;

dm(PFDATA) = ar;");

}

// Тестовый режим, работа в 8-битном режиме

if(SelfTest) out_data <<= 1;

BITTIME = BITLENGTH;

bits_left--;

if(bits_left<0)

{

mod_ready=1;

modulating();

goto restart;

}

else

{

/* blink by PF7 as syncro_out */

asm("

ar = dm(PFDATA);

ar = tglbit 7 of ar;

dm(PFDATA) = ar; ");

/* -------------------------- */

}

}

/*asm ("dis m_mode;");*/

PH_ACC += PH_INC;

l_out = sin_i(PH_ACC);

tx_buf[2] = l_out; // выдача результатов в порт ( связь с кодеком)

}

/*-------------------------------------------------------------*/

void modulating(void)

{

if(SelfTest)

{

if(SelfTest==1) /* space */

{

out_data = 0;

}

else if(SelfTest==2) /* mark */

{

out_data = 0xFF;

}

else if(SelfTest==3) /* dot */

{

/* 10101010 */

out_data = 0xAA;

}

else if(SelfTest==4) /* big dot */

{

/* 11110000 */

out_data = 0xF0;

}

else

{

SelfTest=0;

}

BITTIME=1;

bits_left=8; // 8-битный режим работы

mod_ready=0;

return;

}

// В случае тестового режима дальше не идем

if(mod_ready == 0) return;

BITTIME=1;

if(ModulatorGet(&out_data)==0) /* nothing to get */

{

// обнуление флагов и возврат

/* clear PF6 as TLG & PF7 as syncro_out */

asm("

ar = dm(PFDATA);

ar = clrbit 7 of ar;

ar = clrbit 6 of ar;

dm(PFDATA) = ar; ");

/* -------------------------- */

return;

}

bits_left=7; // 7-битный режим работы

mod_ready=0;

}

Программа демодуляции

Принцип демодуляции входного сигнала нашего устройства, основывается на том, что нам известны частоты поступающие от отдельного устройства приема сигнала по радиоканалу, уже отфильтрованные и поданные на вход нашего устройства. И нам необходимо выделить соответственно частоты 1785 Hz = MARK = ' 0 ' и 1615 Hz = SPACE = ' 1 ' и получить определенный код. После получении кода происходит раскодирование по таблице NBDP и передача в ЭВМ, где программа TERMINAL соответственно реагирует на данные кода.

// Demod.c

// Подключаем заголовочные файлы и объявляем локальные и глобальные // переменные

#include <drivers.h>

#include <stdlib.h>

#include <template.h>

#include <nbdp.h>

extern void out_mcr(int data);

#define DMD_KOEFF 0x019A

#define DMD_LEVEL 0x1000 /* порог срабатывания */

#define OUT_MARK 'M'

#define OUT_SPACE 'S'

#define OUT_ERR 'E'

int my_fir(int NewValue);

int my_sqrt(int NewValue);

/*-------------------------------------------------------------*/

volatile int l_in,r_in;

int Demodulator_ON=1; // Demodulator ON/OFF flag

int PH_TONE_ACC[2]; // опорный MARK/SPACE PHASE ACC

int PH_TONE_INC[2] = {MARK_INC, SPACE_INC};

int i,j; // временные счетчики

int R [4]; // временные результаты

int S [4]; // частичные суммы

int DL[4*BITLENGTH]; // Delay lines for 4 bands

int DLp = 0; // DL pointer

int countN=BITLENGTH; // Cycle count

int REZ[2]; // Результаты

int PRZLT[2]; // Приблизительные результаты (prev. Rez)

int svMode; /* Save multiplier mode location */

int JitterOff; /* Bit syncro OFF flag */

int OutData[2];

void demodulator(void)

{

// Если демодулятор откл., то обнуление результатов и возврат

if(!Demodulator_ON && (dip_sw & DIP_SW1))

{

REZ[0] = 0;

out_mcr(0);

goto CheckCycle;

}

if(SelfTest) // Если тестовый режим, то возврат

{

return;

}

// Выключение режима целочисленной арифметики

asm("dis m_mode;");

l_in = rx_buf[IN_CHNL];

// ограничить входной сигнал для устранения переполнения фильтра

r_in = _FRACT_MULTIPLY_(r_in,DMD_KOEFF);

Заполняем массив временных результатов для MARK и SPACE

PH_TONE_ACC[0] += PH_TONE_INC[0];

R[0] = _FRACT_MULTIPLY_(r_in,sin_i(PH_TONE_ACC[0]));

R[1] = _FRACT_MULTIPLY_(r_in,cos_i(PH_TONE_ACC[0]));

PH_TONE_ACC[1] += PH_TONE_INC[1];

R[2] = _FRACT_MULTIPLY_(r_in,sin_i(PH_TONE_ACC[1]));

R[3] = _FRACT_MULTIPLY_(r_in,cos_i(PH_TONE_ACC[1]));

//Извлекаем старые данные и добавляем новые

for(i=0;i<4;i++)

{

S[i] = S[i] - DL[DLp];

S[i] = S[i] + R[i];

DL[DLp++] = R[i];

}

if(DLp >= (4*BITLENGTH)) DLp=0; /* wrap DL pointer */

// Получение результата по каждому фильтру.

PRZLT[0] = REZ[0]; // Предварительный результат

REZ[0] = _FRACT_MULTIPLY_(S[0],S[0]) + _FRACT_MULTIPLY_(S[1],S[1]);

REZ[1] = _FRACT_MULTIPLY_(S[2],S[2]) + _FRACT_MULTIPLY_(S[3],S[3]);

if(dip_sw & DIP_SW2)

{

REZ[0] = my_sqrt(REZ[0]);

REZ[1] = my_sqrt(REZ[1]);

}

R[1] = (REZ[0]-REZ[1]);

R[2] = (REZ[0]+REZ[1]);

R[0] = _FRACT_MULTIPLY_((_FRACT_DIVIDE_(R[1],R[2])),0x6400);

REZ[0] = R[0];

/* debug solution output */

tx_buf[1] = REZ[0];

/*================================================

STEP 4.

Time supervision, bit detection, etc.

================================================*/

CheckCycle:

countN--;

if(!countN)

{

if(abs(REZ[0]) > DMD_LEVEL)

{

if(REZ[0] > 0)

{

OutData[0] = OUT_MARK;

asm("reset fl0; set fl2; set fl1; ");

}

else

{

OutData[0] = OUT_SPACE;

asm(" set fl0; reset fl2; set fl1; ");

}

}

else

{

OutData[0] = OUT_ERR;

asm(" set fl0; set fl2; reset fl1; ");

}

countN = BITLENGTH;

// отправляем на ЦАП (кодек)

NBDP_THR_RX(OutData[0]);

}

// включение режима целочисленной арифметики

asm("ena m_mode;");

}

Дополнительные программы и функции