Проектирование устройства передачи данных по радиоканалу

/* 7 stop signal send 7id-phasing-slave */

/* 8 7id-rephasing-slave */

/* 9 4id-phasing-slave */

/* 10 4id-rephasing-slave */

/* 11 iss */

/* 12 irs */

UCHAR arqf; /* ARQ flag */

/* b0 : 0 = slave, 1=master */

/* b1 : 1 = WRU */

/* b2 : 1 = OVER FLAG */

/* b3 : */

/* b4 : */

UCHAR SelfTest;

UCHAR FirstIdleBlock;

UCHAR SendFCCInfo;

UCHAR IDLEAcnt; /* IDLE ALFA counter for FEC */

UINT RxErr,RxOK; /* Received Err and OK symbol */

UCHAR SHIFT; /* LET=0,FIG=1,RUS=2 */

/*UCHAR PTT;*/ /* -BK intenal bit */

UCHAR WRU_SUPPORT=1;

UCHAR DX[5]; /* INPUT DX LINE FOR FEC */

UCHAR RX[5]; /* INPUT RX LINE FOR FEC */

UCHAR ID_IN[7]; /* INPUT SFEC ID SHIFT REG */

UCHAR SFSIS4[4]; /* SFEC self identification signal for 4-digit ID */

UCHAR SFSIS5[4]; /* SFEC self identification signal for 5-digit ID */

UCHAR SFSIS9[7]; /* SFEC self identification signal for 9-digit ID */

UCHAR SCID[7]; /* SFEC called station ID */

UINT n[10]; /* ARQ(and other) supervisor counters */

UCHAR connector;

UCHAR CB[3][3]; /* CALLING BLOCK DURING SLAVE PHASING */

/* AND FOR CALL DURING ARQ MASTER */

UCHAR CIB[3][3]; /* CALLER ID BLOCK FOR 7-digit SLAVE SYNC */

UCHAR CCS[3]; /* CS DURING ARQ MASTER CALL */

/* AND DURING SLAVE PHASING */

UCHAR CKERR; /* CK errors during phasing */

/*UCHAR RCB[3][3];*/ /* REPHASING: CALLING BLOCK DURING SLAVE REPHASING */

UCHAR RDATA[3]; /* RECEIVE DATA BLOCK */

UCHAR SLICE_BUF[2];

UCHAR LAST_CS;

UCHAR LAST_BLOCK[3];/* last sended block */

UCHAR LAST_BL_NO;

UCHAR LAST_ID[10]; /* last comm try ID */

UCHAR RQ; /* REPEAT REQUEST */

UCHAR RPTF; /* REPEAT FLAG */

UCHAR ID_TYPE; /* 4- or 7-DIGIT ID TYPE. 0-4,1-7 */

UCHAR WRU_CNT; /* MULTIPLE WRU REQUST COUNT */

UCHAR strAAB[21]; /* not converted AAB */

UCHAR AAB[AAB_LEN];/* converted AAB */

UCHAR SIS4[6]; /* self id signal for 4-digit ID */

UCHAR SIS5[6]; /* self id signal for 5-digit ID */

UCHAR SIS9[9]; /* self id signal for 9-digit ID */

UCHAR SCS9[3]; /* self id check sum for 9-digit ID */

char o_shift=4; /* output shift */

char RQ3SIG [3] = "\x33\x33\x33"; /* rq-rq-rq */

char B_A_B [3] = "\x66\x78\x66"; /* b-a-b */

char EOC_SIG[3] = "\x78\x78\x78"; /* a-a-a */

/*UCHAR PRE_KEY; */ /* PRE KEY IN MS (0..100) */

/*UCHAR POST_KEY;*/ /* POST KEY IN MS (0..100) */

UCHAR CFEC_RX=1; /* CFEC RECEIVING ON/OFF, default ON */

UCHAR FEC_RATE=50; /* FEC ERROR RATE, default 50% */

UCHAR IN_CHNL =2; /* INPUT CHANNEL L/R, default RIGHT */

UCHAR OUT_CHNL=1; /* OUTPUT CHANNEL L/R, default LEFT */

UCHAR LAST_RX_CS = 0;

UCHAR LAST_RX_BLOCK = 0;

UCHAR after_rephase = 0;

extern int SlaveAnswerTime; /* Called mode answer delay */

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

void StandBy(void) // В алгоритме вызывается при ошибке

{

MODEM_STATE=5; /* state = 5 - RESET */

COMF = STATE = SHIFT = RxErr = RxOK = /*RQ = RPTF = */ 0;

LAST_STATE = 0;

IDLEAcnt = 0;

connector = 0;

/*memset(DX,0,5);memset(RX,0,5);*/

FirstIdleBlock = 0;

SendFCCInfo = 0;

arqf = 0;

LAST_CS = 0;

o_shift = 4; /* output shift not defined */

WRU_SUPPORT=1; /* Set default as ON */

hiClear();

hoClear();

Clear();

doClear();

if(dip_sw & DIP_SW3)

{

if(SlaveAnswerTime != (21+2))

{

SlaveAnswerTime = 21+2; /* Called mode answer delay 20 ms */

goto inform_host;

}

}

else

{

if(SlaveAnswerTime != (21+5))

{

SlaveAnswerTime = 21+5; /* Called mode answer delay 50 ms */

inform_host:

SendCommandHostDBG(1,"CHANGE SLAVE ANSWER TIME [%X0 msec]",SlaveAnswerTime-21);

}

}

send_stat();

/*FS[0] = 1;*/ /* restart FREE SIGNAL */

SendCommandHostDBG(1,"STAND BY");

}

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

void send_stat(void) /* Послать статус устройства в host-компьютер */

{

/*

SendCommandHost("STAT","%02X;%02X;%02X;%03X;%02X;%02X",

COMF,STATE,arqf,hiIFree,hi_count,connector);

*/

SendCommandHost("STAT","%02X;%02X;%02X;%03X;%02X;%X;%X",

COMF,STATE,arqf,hiIFree,hi_count,MODEM_STATE,connector);

}

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

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

/* Mode */

/* 0 - ARQ */

/* 1 - CFEC */

/* 2 - SFEC */

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

UCHAR convert(char ch) // Конвертер в NBDP

{

if(ch == ERR_SMBL) return ERR_SMBL;

{

int index = table2[(int) ch];

if(index)

{

struct CVT *cvt;

cvt = &CVT_TABLE[index-1];

switch(SHIFT)

{

case 0: return cvt->_LET;

case 1: return cvt->_FIG;

case 2: return cvt->_RUS;

}

}

}

return ERR_SMBL;

}

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

void NBDP_Init(void) // Инициализация NBDP (вызывается из main.c)

{

SetID(1,"32610",SIS5,NULL,1);

SetID(2,"123456789",SIS9,SCS9,1);

strcpy(SIS9,"\x2e\x33\x65\x33\x27\x39\x2e\x71\x69");

strcpy(SCS9,"\x17\x4e\x69");

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

StandBy();

}

3. Программа serial.c

Содержит функции для работы с последовательным портом.

#include <stdarg.h>

#include <string.h>

#include <drivers.h>

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

#define MAX_CMD_LEN 127

unsigned int CMDS, /* command rx state */

CMDL; /* command rx pointer */

char CMD[MAX_CMD_LEN+1]; /* command rx buffer */

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

int chr;

int SerialDriver(void) // проверка работы и инициализация последоват. порта

{

/*int chr;*/

repeat:

if(get_char(&chr))

{

if(CMDS) /* command receiving */

{

if(CMDL>=MAX_CMD_LEN)

{

SendHostError(0,0);

reset_state:

CMDL=CMDS=0;

return 0;

}

if((CMD[CMDL-1] == ';') && (chr == '@')) /* EOC */

{

CMD[CMDL++] = chr;

CMD[CMDL] = 0;

HostCommandParser(&CMD[0]);

goto reset_state;

}

else

{

CMD[CMDL++] = chr;

goto repeat;

return 0;

}

}

else /* command waiting */

{

if(chr=='$')

{

CMDL=0;

CMD[CMDL++] = chr;

CMDS=1;

goto repeat;

}

}

}

return 0;

}

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

extern unsigned int No;

char BUFFER[MAX_CMD_LEN+1];

int SendCommandHost(char *cmd, char *fmt,...) // функция для передачи

// команд в терминал

{

/* Make data string to out */

/*int len;*/

va_list argptr;

/* Out the packet header: $CMD;channel_no; */

out_char('$');

out_string(cmd/*,strlen(cmd)*/);

out_char(';');

out_char(No + 0x30);

out_char(';');

/* Out the variable part */

va_start(argptr, fmt);

/*len =*/ vprinter(&BUFFER[0], fmt, argptr);

va_end(argptr);

out_string(BUFFER/*,len*/);

/* Out the end part of packet */

out_string(";@\r\n"/*,4*/);

return 0;

}

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

int SendCommandHostDBG(int level, char *fmt,...)

{

/* Make data string to out */

/*int len;*/

va_list argptr;

if(!(dip_sw & DIP_SW4)) return 0; /* not output debug */

if(level > DebugLevel) return 0;

/* Out the packet header: $CMD;channel_no; */

out_string("$DBG;"); out_char(No + 0x30); out_char(';');

/* Out the variable part */

va_start(argptr, fmt);

vprinter(&BUFFER[0], fmt, argptr);

va_end(argptr);

out_string(BUFFER);

/* Out the end part of packet */

out_string(";@\r\n");

return 0;

}

Критичные по быстродействию функции выполняем на языке ассемблер под ADSP 2181.

Sin.dsp

Функции разложения на синус и косинус используемые при модуляции и демодуляции для вычисления "налету".

.MODULE/RAM _SIN_COS_INTEGER_;

{---------------------------------------------------------------

Sine/Cosine approximation for 1.15 format

int Y = sin_i(int X)

int Y = cos_i(int X)

---------------------------------------------------------------

---------------------------------------------------------------

Calling parameters

AR = X in scaled 1.15 format

M1 = 1

L1 = 0

Return values

AR = X in 1.15 format

Computation time

sin : 30 + (3) cycles

cosine: 32 + (3) cycles

---------------------------------------------------------------

}

.VAR/DM sin_coeff[5];

.INIT sin_coeff : 0x3240, 0x0053, 0xAACC, 0x08B7, 0x1CCE;

.ENTRY sin_i_;

.ENTRY cos_i_;

cos_i_:

AY1 = 0x4000; { AY0 = PI/2 }

AR = AR + AY1; { AR = X+PI/2 }

sin_i_:

SI = AR; { save AR }

I1 = ^sin_coeff; {ptr to coeff buffer }

AY1=0x4000;

AF=AR AND AY1; {check 2nd or 4th quad.}

IF NE AR=-AR; {If yes negate input }

AY1=0x7FFF;

AR = AR AND AY1; {remove sign bit }

MY1=AR;

/*#ifndef GLOBAL_F*/

SR1 = MSTAT; { save MSTAT }

DIS M_MODE; { set fractional }

/*#endif*/

SR0 = MX1; {save MX1 }

MF=AR*MY1 (RND), MX1=DM(I1,M1); {MF = X^2 }

MR=MX1*MY1 (SS) , MX1=DM(I1,M1); {MR = C1*X }

CNTR=3;

DO approx UNTIL CE;

MR=MR+MX1*MF (SS);

approx: MF=AR*MF (RND), MX1=DM(I1,M1);

MR=MR+MX1*MF (SS);

MX1 = SR0; { restore MX1 }

/*#ifndef GLOBAL_F*/

MSTAT = SR1; { restore MSTAT }

/*#endif*/

SR=ASHIFT MR1 BY 3 (HI);

SR=SR OR LSHIFT MR0 BY 3 (LO); {convert to 1.15 format}

AR=PASS SR1;

IF LT AR=PASS AY1; {saturate if needed }

AY1=SI;

AF=PASS AY1;

IF LT AR=-AR;

RTS;

.ENDMOD;

Программа 2181_hdr.dsp

Содержит код инициализации ADSP 2181.

.MODULE/ABS=0 ADSP2181_Runtime_Header;

#define _MY_HANDLER 1

// объявление внешних функций Си для использования их в ассемблере

.EXTERNAL ___lib_setup_everything;

.EXTERNAL main_;

#ifndef _MY_HANDLER

.EXTERNAL ___lib_sp0r_ctrl;

#endif

.EXTERNAL stat_flag_;

.EXTERNAL next_cmd_;

.EXTERNAL process_a_bit; { uart }

.EXTERNAL IRQE_Flag_;

// Установка векторов прерываний

// По сбросу загружать функцию Си main

__Reset_vector: CALL ___lib_setup_everything;

CALL main_; RTS; NOP; {Begin C program}

__Interrupt2: rti;NOP;NOP;NOP;

__InterruptL1: rti;NOP;NOP;NOP;

__InterruptL0: rti;NOP;NOP;NOP;

__Sport0_trans: jump _sp0tx;nop;nop;nop;

#ifndef _MY_HANDLER

__Sport0_recv: JUMP ___lib_sp0r_ctrl;NOP;NOP;NOP;

#else

__Sport0_recv: JUMP _sp0rx;NOP;NOP;NOP;

#endif

__InterruptE: ena sec_reg; ar = 1; dm(IRQE_Flag_)=ar; rti;

__BDMA_interrupt: rti;NOP;NOP;NOP;

#ifndef HW_UART

__Interrupt1: pop sts; /* 20: SPORT1 tx or IRQ1 */

ena timer; rts; rti;

#else

__Interrupt1: rti; /* 20: SPORT1 tx or IRQ1 */

rti; rti; rti;

#endif

__Interrupt0: rti;NOP;NOP;NOP;

__Timer_interrupt: jump process_a_bit; /* 28: timer */

rti; rti; rti;

__Powerdown_interrupt: rti;NOP;NOP;NOP;

#ifdef _MY_HANDLER

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

1) Enble sec reg bank

2) Save all unaltered registers

3) Setup stack, Run C-handler

4) Restore unaltered registers

5) disable sec reg bank

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

.var/dm REG_SAVE_SP0RX[11];

.external modulator_;

.external demodulator_;

_sp0rx:

// сохранение регистров

dm(REG_SAVE_SP0RX + 0) = PX; /* 1 */

dm(REG_SAVE_SP0RX + 1) = L0; /* 2 */

dm(REG_SAVE_SP0RX + 2) = I1; /* 3 */

dm(REG_SAVE_SP0RX + 3) = L1; /* 4 */

dm(REG_SAVE_SP0RX + 4) = M2; /* 5 */

dm(REG_SAVE_SP0RX + 5) = M3; /* 6 */

dm(REG_SAVE_SP0RX + 6) = M5; /* 7 */

dm(REG_SAVE_SP0RX + 7) = L5; /* 8 */

dm(REG_SAVE_SP0RX + 8) = I6; /* 9 */

dm(REG_SAVE_SP0RX + 9) = M6; /* 10 */

dm(REG_SAVE_SP0RX + 10) = L6; /* 11 */

/* enable second register bank */

ena sec_reg;

/* set predefined INTR modes */

DIS BIT_REV, DIS AR_SAT, DIS AV_LATCH, ENA M_MODE;

L0=0;

L1=0;

L5=0;

L6=0;

M2=0;

M6=0;

/* restore unaltered registers */

PX = dm(REG_SAVE_SP0RX + 0)/* = PX*/; /* 1 */

L0 = dm(REG_SAVE_SP0RX + 1)/* = L0*/; /* 2 */

I1 = dm(REG_SAVE_SP0RX + 2)/* = I1*/; /* 3 */

L1 = dm(REG_SAVE_SP0RX + 3)/* = L1*/; /* 4 */

M2 = dm(REG_SAVE_SP0RX + 4)/* = M2*/; /* 5 */

M3 = dm(REG_SAVE_SP0RX + 5)/* = M3*/; /* 6 */

M5 = dm(REG_SAVE_SP0RX + 6)/* = M5*/; /* 7 */

L5 = dm(REG_SAVE_SP0RX + 7)/* = L5*/; /* 8 */

I6 = dm(REG_SAVE_SP0RX + 8)/* = I6*/; /* 9 */

M6 = dm(REG_SAVE_SP0RX + 9)/* = M6*/; /* 10 */

L6 = dm(REG_SAVE_SP0RX + 10)/* = L6*/; /* 11 */

rti;

#endif

.var/dm REG_SAVE_SP0TX[11];

_sp0tx:

/* enable second register bank */

ena sec_reg;

ar = dm(stat_flag_);

ar = pass ar;

if ne jump next_cmd_;

/* save unaltered registers */

dm(REG_SAVE_SP0TX + 0) = PX; /* 1 */

dm(REG_SAVE_SP0TX + 1) = L0; /* 2 */

dm(REG_SAVE_SP0TX + 2) = I1; /* 3 */

dm(REG_SAVE_SP0TX + 3) = L1; /* 4 */

dm(REG_SAVE_SP0TX + 4) = M2; /* 5 */

dm(REG_SAVE_SP0TX + 5) = M3; /* 6 */

dm(REG_SAVE_SP0TX + 6) = M5; /* 7 */

dm(REG_SAVE_SP0TX + 7) = L5; /* 8 */

dm(REG_SAVE_SP0TX + 8) = I6; /* 9 */

dm(REG_SAVE_SP0TX + 9) = M6; /* 10 */

dm(REG_SAVE_SP0TX + 10) = L6; /* 11 */

/* enable second register bank */

/*ena sec_reg;*/

/* set predefined INTR modes */

DIS BIT_REV, DIS AR_SAT, DIS AV_LATCH, ENA M_MODE;

L0=0;

L1=0;

L5=0;

L6=0;

M2=0;

M6=0;

call modulator_;

/* restore unaltered registers */

PX = dm(REG_SAVE_SP0TX + 0)/* = PX*/; /* 1 */

L0 = dm(REG_SAVE_SP0TX + 1)/* = L0*/; /* 2 */

I1 = dm(REG_SAVE_SP0TX + 2)/* = I1*/; /* 3 */

L1 = dm(REG_SAVE_SP0TX + 3)/* = L1*/; /* 4 */

M2 = dm(REG_SAVE_SP0TX + 4)/* = M2*/; /* 5 */

M3 = dm(REG_SAVE_SP0TX + 5)/* = M3*/; /* 6 */

M5 = dm(REG_SAVE_SP0TX + 6)/* = M5*/; /* 7 */

L5 = dm(REG_SAVE_SP0TX + 7)/* = L5*/; /* 8 */

I6 = dm(REG_SAVE_SP0TX + 8)/* = I6*/; /* 9 */

M6 = dm(REG_SAVE_SP0TX + 9)/* = M6*/; /* 10 */

L6 = dm(REG_SAVE_SP0TX + 10)/* = L6*/; /* 11 */

rti;

.ENDMOD;