Описание библиотеки микросхемы 5023ВС016 процессора "Спутник"
manchester_test.c
См. документацию.
1 
31 #include "manchester_test.h"
32 
33 const uint32_t sys_freq = 80000000;
34 char dbg_buffer[256];
35 
36 #define SYS_FREQ 80
37 #define INTERNAL_TEST // Внутренний тест
38 #define MKPD_MAX_WORD_IN_PACKET 32
39 #define MKPD_EP_SUBADDR_COUNT 32
41 unsigned int EP1_addr;
42 unsigned int EP2_addr;
43 unsigned int reply_error = 0;
44 
45 int com_error = 0;
46 int data_error = 0;
47 int monitor_error = 0;
48 
50 
52 
54 
56 
57 #ifndef INTERNAL_TEST
58 
59 #if (FREQ != SYS_FREQ)
60 #error Manchester frequency has not correct value (speed will not be equal to 2 Mbit/s)
61 #endif
62 
63 #endif
64 
65 volatile unsigned int irq_counter[4] = {0,0,0,0};
66 
68 {
69  irq_counter[0]++;
70 }
71 
73 {
74  irq_counter[1]++;
75 }
76 
78 {
79  irq_counter[2]++;
80 }
81 
83 {
84  irq_counter[3]++;
85 }
86 
87 //Проверка корректности командного слова, принятого оконечным устройством
88 void CheckCommandWord(Command_Word_T command, uint32_t ep_addr, uint32_t tx_rx, uint32_t ep_subaddr, uint32_t word_count)
89 {
90  if ((command.bit.EP_addr != ep_addr) ||
91  (command.bit.Tx_rx_mark != tx_rx) ||
92  (command.bit.Command_word_mark != 1) ||
93  (command.bit.Subaddr__Manage_mode != ep_subaddr) ||
94  (command.bit.Data_size__Command_code != (word_count % MKPD_MAX_WORD_IN_PACKET)))
95  com_error++;
96 }
97 
98 unsigned int com_error1 = 0;
99 unsigned int reply_error1 = 0;
100 
101 
105 typedef struct
106 {
107  volatile unsigned short FEP1:1;
108  volatile unsigned short MAN:1;
109  volatile unsigned short FEP0:1;
110  volatile unsigned short BUSY:1;
111  volatile unsigned short Group_rx:1;
112  volatile unsigned short RES:3;
113  volatile unsigned short SREQ:1;
114  volatile unsigned short Reply_tx:1;
115  volatile unsigned short Data_err:1;
116  volatile unsigned short EP_addr:5;
118 
122 typedef union Reply_Word
123 {
124 volatile unsigned short all;
126 } Reply_Word_T;
127 
128 //Количество слов данных, передаваемых в пакете. Длина слова 16 бит
130 //Содержимое ответного слова, получаемого контроллером шины от оконечного устройства
132 
133 #define INPORT_MUX ((INPORT_MUX_t*) 0xA0FF0000)
134 #define OUTPORT_MUX ((OUTPORT_MUX_t*) 0xA0FF1000)
135 
139 {
140  unsigned int NUM_FUNC :8;
141  unsigned int rsrv1 :8;
142  unsigned int LOOPBACK :1;
143  unsigned int rsrv2 :14;
144  unsigned int ENA :1;
145 };
146 
151 {
152  volatile unsigned int all;
154 };
155 
159 typedef struct
160 {
161  volatile unsigned int MCU_PORT[144];
162 }INPORT_MUX_t;
163 
168 {
169  unsigned int NUM_PORT :8;
170  unsigned int rsrv1 :23;
171  unsigned int ENA :1;
172 };
173 
178 {
179  volatile unsigned int all;
180  struct OUTPORT_MUX_BITS bit;
181 };
182 
186 typedef struct
187 {
188  volatile unsigned int FPGA_PORT[250];
189 } OUTPORT_MUX_t;
190 
192 {
196 
200 
204 
208 
209 }
210 
212 {
213  //Настройка временных параметров для всех блоков
214  for (uint8_t index = 0; index < 4; index++)
215  {
216 
217  switch (index)
218  {
219  case 0:
220  MKPD_Set_Interpacket_Time(mkpd[index], 0xF);
221  break;
222  case 1:
223  MKPD_Set_Interpacket_Time(mkpd[index], 0xF);
224  break;
225  case 2:
226  MKPD_Set_Interpacket_Time(mkpd[index], 0xF);
227  break;
228  case 3:
229  MKPD_Set_Interpacket_Time(mkpd[index], 0xF);
230  break;
231  }
232 
233  MKPD_Set_Wait_Time(mkpd[index], 38); // >= 21 mks
234  MKPD_Set_Edge_Time(mkpd[index], SYS_FREQ/5); // > 0.2 mks
235  MKPD_Set_System_Clock(mkpd[index], SYS_FREQ);
236  MKPD_Set_InvTX(mkpd[index], 1);
237  MKPD_Set_IncWith(mkpd[index], 0);
238  MKPD_Set_DecoderDisable(mkpd[index], 0x0); //all enabled
239 
240  MKPD_Set_NoActivity_Time(mkpd[index], SYS_FREQ * 13 / 10); // > 1.3 mks
241  MKPD_Set_BCWaitReply_Time(mkpd[index], 36); // > 35 mks
242  MKPD_Set_Clk_500NS(mkpd[index], SYS_FREQ / 2);
243  MKPD_Set_Clk_1250NS(mkpd[index], SYS_FREQ * 125 / 100);
244  MKPD_Set_Clk_1500NS(mkpd[index], SYS_FREQ * 150 / 100);
245  MKPD_Set_Clk_1750NS(mkpd[index], SYS_FREQ * 175 / 100);
246  MKPD_Set_Clk_2250NS(mkpd[index], SYS_FREQ * 225 / 100);
247  }
248 }
249 
250 //Проверка корректности ответного слова
251 void CheckReplyWord(uint32_t ep_addr, uint32_t group_rx)
252 {
253  if ((reply_word.bit.EP_addr != ep_addr) ||
254  (reply_word.bit.Data_err != RESET) ||
255  (reply_word.bit.Reply_tx != RESET) ||
256  (reply_word.bit.SREQ != RESET) ||
257  (reply_word.bit.Group_rx != group_rx) ||
258  (reply_word.bit.BUSY != RESET) ||
259  (reply_word.bit.FEP0 != RESET) ||
260  (reply_word.bit.MAN != RESET) ||
261  (reply_word.bit.FEP1 != RESET))
262  reply_error++;
263 }
264 
265 //Отображение отчёта о количестве ошибок в подтесте
266 uint8_t ErrorReport()
267 {
268  uint8_t errors = 0;
269 
270  if (data_error > 0 )
271  {
272  PRINT("Error in subtest\n");
273 
274  PRINT("\tData word errors: %d\n", data_error);
275  DBG_TX_Flush(); // Вывод всех данных, накопленных в кольцевом буфере, в отладочный UART
276 
277  errors = 1;
278  }
279  else
280  {
281  PRINT("\t\t\tSubtest complete - OK\n");
282  }
283 
284  com_error = 0;
285  reply_error = 0;
286  data_error = 0;
287  monitor_error = 0;
288 
289  return errors;
290 }
291 
292 
294 {
295 
296  EP1_addr = (rand() % 30) + 1;
297  EP2_addr = (rand() % 30) + 1;
298  while (EP2_addr == EP1_addr)
299  EP2_addr = (rand() % 30) + 1;
300 
301 }
302 
304 {
305  //прим.: т.к. чтение регистров не работает, побитовые обращения к регистрам не будут корректно работать
307  for (unsigned int port = 55; port < 250; port++)
308  {
309  if (port != 67 &&
310  port != 117 &&
311  port != 118 &&
312  port != 119
313  )
314  {
315  if (port < 144)
316  INPORT_MUX->MCU_PORT[port] = 0;
317  OUTPORT_MUX->FPGA_PORT[port] = 0;
318  }
319  }
320 
321  INPORT_MUX->MCU_PORT[64] = 64 | (1 << 31);
322  OUTPORT_MUX->FPGA_PORT[63] = 63 | (1 << 31);
323 }
324 void MKPD_init()
325 {
326  MKPD_Clock_Init(); // Подача тактовых сигналов
327 
328  NVIC_EnableIRQ(MKPD1_NUM,20); // Разрешение прерываний
332 
333  //Настройка временных параметров для всех блоков
334  for (uint8_t index = 0; index < 4; index++)
335  {
336 
337 
338  switch (index)
339  {
340  case 0:
341  MKPD_Set_Interpacket_Time(mkpd[index], 0xF);
342  break;
343  case 1:
344  MKPD_Set_Interpacket_Time(mkpd[index], 0xF);
345  break;
346  case 2:
347  MKPD_Set_Interpacket_Time(mkpd[index], 0xF);
348  break;
349  case 3:
350  MKPD_Set_Interpacket_Time(mkpd[index], 0xF);
351  break;
352  }
353 
354  MKPD_Set_Wait_Time(mkpd[index], 38); // >= 21 mks
355  MKPD_Set_Edge_Time(mkpd[index], SYS_FREQ/5); // > 0.2 mks
356  MKPD_Set_System_Clock(mkpd[index], SYS_FREQ);
357  MKPD_Set_InvTX(mkpd[index], 1);
358  MKPD_Set_IncWith(mkpd[index], 0);
359  MKPD_Set_DecoderDisable(mkpd[index], 0x0); //all enabled
360 
361  //MKPD_Set_NoActivity_Time(mkpd[index], 185); // > 1.3 mks
362  MKPD_Set_NoActivity_Time(mkpd[index], SYS_FREQ * 13 / 10); // > 1.3 mks
363  MKPD_Set_BCWaitReply_Time(mkpd[index], 36); // > 35 mks
364  MKPD_Set_Clk_500NS(mkpd[index], SYS_FREQ / 2);
365  MKPD_Set_Clk_1250NS(mkpd[index], SYS_FREQ * 125 / 100);
366  MKPD_Set_Clk_1500NS(mkpd[index], SYS_FREQ * 150 / 100);
367  MKPD_Set_Clk_1750NS(mkpd[index], SYS_FREQ * 175 / 100);
368  MKPD_Set_Clk_2250NS(mkpd[index], SYS_FREQ * 225 / 100);
369  }
370 }
371 
372 //Проверка обмена между двумя модулями MKPD: КШ и одно оконечное устройство
373 uint8_t TestTwoBlocks2(MKPD_T * ManBC, MKPD_T * ManEP, MKPD_SETTING0_CHANNEL_T Channel)
374 {
375 
376  Update_EP_addrs();
377 
378  //Буфер слов данных для ОУ1
379  uint8_t* EP1_Buffer = malloc(MKPD_MAX_WORD_IN_PACKET * MKPD_EP_SUBADDR_COUNT * 2 * sizeof(uint8_t));
380 
381  //Буфер слов данных для ОУ2
382  uint8_t* EP2_Buffer = malloc(MKPD_MAX_WORD_IN_PACKET * MKPD_EP_SUBADDR_COUNT * 2 * sizeof(uint8_t));
383 
384  com_error = 0;
385  reply_error = 0;
386  data_error = 0;
387  monitor_error = 0;
388 
389  //Настройка контроллера шины
390  MKPD_ConfigBusController(ManBC, (uint32_t)BC_RX_Buffer, (uint32_t)BC_TX_Buffer, Channel);
391 
392  //Настройка оконечного устройства
393  MKPD_ConfigEndpoint(ManEP, (uint32_t)EP1_Buffer, EP1_addr);
394 
395  //сброс признаков оконечного устройства
397 
398  for (int i=0; i < MKPD_MAX_WORD_IN_PACKET * MKPD_EP_SUBADDR_COUNT * 2; i++)
399  {
400  EP1_Buffer[i] = i;
401  }
402 
403  for (int i=0; i < MKPD_EP_SUBADDR_COUNT * 2; i++)
404  {
405  BC_TX_Buffer[i] = 0;
406  BC_RX_Buffer[i] = 0xFF;
407  }
408 
409  unsigned char stop_test = 0;
410  for (Word_count = 1; Word_count < 33; Word_count++)
411  {
412  if (stop_test)
413  break;
414  //uint32_t EP_subaddr = 0;
415  for (uint32_t EP_subaddr = 1; EP_subaddr < MKPD_EP_SUBADDR_COUNT - 1; EP_subaddr++)
416  {
417  if (MKPD_StartMessage(ManBC,
418  TX_ONE,
419  2,
420  EP1_addr,
421  EP_subaddr,
422  0,
423  0,
424  Word_count,
425  10000,
426  1) != 0)
427  {
428  PRINT("Error: BC busy timeout\n");
429  DBG_TX_Flush(); // Вывод всех данных, накопленных в кольцевом буфере, в отладочный UART
430 
431  stop_test = 1;
432  break;
433  }
434 
435  //проверка содержимого командного слова, принятого ОУ
436  ep_command1.all = MKPD_Get_Endpoint_Command_Word(ManEP);
437  CheckCommandWord(ep_command1, EP1_addr, 1, EP_subaddr, Word_count);
438 
439  //проверка содержимого ответного слова, полученного от ОУ
440  reply_word.all = MKPD_BC_Reply_Word(ManBC, TX_ONE);
442 
443  //проверка данных
444  for (uint32_t i = 0; i< Word_count*2; i++)
445  if (BC_RX_Buffer[i] != EP1_Buffer[i+(EP_subaddr-1)*64])
446  data_error++;
447  }
448  }
449 
450  free(EP1_Buffer);
451  free(EP2_Buffer);
452  MKPD_ConfigEndpoint(ManEP, (uint32_t)EP1_Buffer, 0);
453 
454  return ErrorReport();
455 }
456 
457 //настройка портов для manchester для одного из режимов альтернативных функций
458 #warning в тесте важен порядок запуска режимов - сначала mode == 0, и только потом mode == 1. Иначе нужно по другому настраивать RAM_DATA
459 void Init_ports_Manchester(unsigned int mode)
460 {
462 
475 
476  if (mode == 0)
477  {
478  //config altfunc
479  CMN_REG->ALT_FUNCTION_CTRL[4] &= 0x000000FF; //E4-E15 - func 1
480  CMN_REG->ALT_FUNCTION_CTRL[5] = 0x00000000;
481  CMN_REG->ALT_FUNCTION_CTRL[6] &= 0xFFFFFF00;
482 
483  //enable altfunc in gpio
484  GPIO_E->ALTFUNCSET = 0xFFF0; //E4-15
485  GPIO_F->ALTFUNCSET = 0xFFFF; //F0-15
486  GPIO_G->ALTFUNCSET = 0x000F; //G0-3
487 
488  for (int i = 0; i < 32; i++)
489  {
490  INPORT_MUX->MCU_PORT[68 + i] = (68 + i) | (1 << 31);
491  OUTPORT_MUX->FPGA_PORT[68 + i] = (68 + i) | (1 << 31);
492  }
493  }
494 
495  MKPD_Clock_Init(); // Подача тактовых сигналов
496 
497 }
498 
499 #define TEST_CHANNEL_A
500 #define TEST_CHANNEL_B
501 
503 {
504  PRINT("\n********** MKPD test start **********\n");
505  DBG_TX_Flush(); // Вывод всех данных, накопленных в кольцевом буфере, в отладочный UART
506 
507 
509 
510  MKPD_init();
511 
512  uint32_t errors = 0;
513 
514  Update_EP_addrs();
515 
516  PRINT("\t\tTest blocks in pairs\n");
517  DBG_TX_Flush(); // Вывод всех данных, накопленных в кольцевом буфере, в отладочный UART
518 
519  for (uint8_t BC_index = 0; BC_index < 4; BC_index++)
520  for (uint8_t EP_index = 0; EP_index < 4; EP_index++)
521  if (EP_index != BC_index)
522  {
523 #ifdef TEST_CHANNEL_A
524  PRINT("\t\t\tBC = %d, EP = %d, Channel A\n", BC_index, EP_index);
525  DBG_TX_Flush(); // Вывод всех данных, накопленных в кольцевом буфере, в отладочный UART
526 
527  errors += TestTwoBlocks2(mkpd[BC_index], mkpd[EP_index], MKPD_SETTING0_CHANNEL_A);
528 #endif
529 #ifdef TEST_CHANNEL_B
530  PRINT("\t\t\tBC = %d, EP = %d, Channel B\n", BC_index, EP_index);
531  DBG_TX_Flush(); // Вывод всех данных, накопленных в кольцевом буфере, в отладочный UART
532 
533  errors += TestTwoBlocks2(mkpd[BC_index], mkpd[EP_index], MKPD_SETTING0_CHANNEL_B);
534 #endif
535  }
536  return 0;
537 }
538 
static void MKPD_Set_NoActivity_Time(MKPD_T *pMKPD, unsigned int Noacttime)
Настройка времени ожидания отсутствия активности на линии, не менее 1.3 мкс
Definition: mkpd.h:400
static unsigned int MKPD_StartMessage(MKPD_T *pMKPD, MKPD_TX_T index, unsigned int type_trans, unsigned int ep_addr0, unsigned int sub_addr0, unsigned int ep_addr1, unsigned int sub_addr1, unsigned int num, unsigned int timeout, unsigned int manage_code)
Передача сообщения от КШ
Definition: mkpd.h:697
uint8_t BC_RX_Buffer[MKPD_MAX_WORD_IN_PACKET *2]
Буфер слов данных для приёма на КШ
unsigned int reply_error
#define PRINT(...)
Макросы для использования отладочного выхода
Definition: debug_uart.h:48
volatile uint16_t Command_word_mark
Definition: mkpd.h:250
int data_error
Структура для доступа к командному слову (КС)
Definition: mkpd.h:258
Reply_Word_T reply_word
void MKPD_init()
void Manchester3_IRQ()
void MKPD_Set_Interpacket_Time(MKPD_T *pMKPD, uint32_t time)
Установка временного интервала между передачей пакетов
Definition: mkpd.c:60
int MKPD_Test()
void PWR_RST_Enable(CTRL_T CTRLn)
Ввод модуля в асинхронный сброс
Definition: system.c:309
Структура для доступа к регистрам МКПД.
Definition: mkpd.h:38
static void MKPD_Set_Endpoint_Attributes(MKPD_T *pMKPD, uint32_t attributes)
Установка признаков в ОС ОУ
Definition: mkpd.h:771
void NVIC_EnableIRQ(IRQn_T IRQn, uint32_t vec)
Разрешение прерывания
Definition: system.c:74
uint32_t MKPD_Get_Endpoint_Command_Word(MKPD_T *pMKPD)
Возвращает командное слово, принятое ОУ
Definition: mkpd.c:314
Этот файл содержит структуры, макросы и функции необходимые необходимые для тестовой программы для ап...
Содержимое ответного слова (ОС)
volatile unsigned int irq_counter[4]
uint8_t ErrorReport()
volatile unsigned short BUSY
uint32_t Word_count
static void MKPD_Set_Clk_1750NS(MKPD_T *pMKPD, unsigned int Clk)
Тонкая настройка количества тактов системной частоты в 1750 нс
Definition: mkpd.h:450
Структура бит MUX.
#define MKPD4
Указатель на структуру MKPD4.
volatile unsigned short FEP1
static void MKPD_Set_Clk_500NS(MKPD_T *pMKPD, unsigned int Clk)
Тонкая настройка количества тактов системной частоты в 500 нс
Definition: mkpd.h:420
union Reply_Word Reply_Word_T
Структура для доступа к ОС побитово и в целом
volatile uint16_t all
Definition: mkpd.h:260
void MKPD_configure_time()
void MKPD_Set_InvTX(MKPD_T *pMKPD, unsigned int invTX)
Установка инвертирования дифференциального сигнала на передаче
Definition: mkpd.c:39
unsigned int EP2_addr
void MKPD_Set_Wait_Time(MKPD_T *pMKPD, uint32_t rwait)
Установка времени ожидания ОС или СД в режиме работы КШ и ОУ
Definition: mkpd.c:75
Структура регистров MUX.
int monitor_error
volatile unsigned short Group_rx
Definition: mkpd.h:239
static void MKPD_Set_BCWaitReply_Time(MKPD_T *pMKPD, unsigned int Bcwaitreply)
Настройка времени ожидания ОС в режиме КШ
Definition: mkpd.h:410
#define GPIO_G
Указатель на структуру GPIO_G.
void PWR_CLK_Disable(CTRL_T CTRLn)
Отключение тактового сигнала от модуля
Definition: system.c:328
void MKPD_Set_Edge_Time(MKPD_T *pMKPD, uint32_t edge)
Установка времени запрещенного состояния дифференциального сигнала
Definition: mkpd.c:90
MKPD_SETTING0_CHANNEL_T
Definition: mkpd.h:163
void Manchester1_IRQ()
#define CLK_INIT_PAUSE
Definition: system.h:40
unsigned int com_error1
MKPD_T * mkpd[4]
const uint32_t sys_freq
Системная частота
Структура для доступа к ОС побитово и в целом
static void MKPD_Set_DecoderDisable(MKPD_T *pMKPD, unsigned int Disable_mask)
Программное отключение декодеров
Definition: mkpd.h:390
static void MKPD_Set_Clk_1250NS(MKPD_T *pMKPD, unsigned int Clk)
Тонкая настройка количества тактов системной частоты в 1250 нс
Definition: mkpd.h:430
char dbg_buffer[256]
Отладочный буфер
volatile unsigned short EP_addr
#define INPORT_MUX
void PWR_RST_Disable(CTRL_T CTRLn)
Вывод модуля из асинхронного сброса
Definition: system.c:318
volatile unsigned short SREQ
void Update_EP_addrs()
void PWR_CLK_Enable(CTRL_T CTRLn)
Подача тактового сигнала на модуль
Definition: system.c:337
volatile uint16_t Subaddr__Manage_mode
Definition: mkpd.h:249
unsigned int EP1_addr
Структура бит MUX.
void Init_ports_Manchester(unsigned int mode)
volatile unsigned short Data_err
void CheckReplyWord(uint32_t ep_addr, uint32_t group_rx)
volatile unsigned int all
void FPGA_MUX_Disable_all()
Структура INPORT_MUX.
void CheckCommandWord(Command_Word_T command, uint32_t ep_addr, uint32_t tx_rx, uint32_t ep_subaddr, uint32_t word_count)
int com_error
void Manchester2_IRQ()
uint32_t MKPD_BC_Reply_Word(MKPD_T *pMKPD, MKPD_TX_T index)
Возвращает ответное слово, полученное от ОУ
Definition: mkpd.c:232
#define MKPD1
Указатель на структуру MKPD1.
#define OUTPORT_MUX
static void MKPD_Set_Clk_2250NS(MKPD_T *pMKPD, unsigned int Clk)
Тонкая настройка количества тактов системной частоты в 2250 нс
Definition: mkpd.h:460
static void MKPD_Set_IncWith(MKPD_T *pMKPD, unsigned int IncWith)
Настройка сигнала разрешения передачи
Definition: mkpd.h:379
Структура OUTPORT_MUX.
void MKPD_Set_System_Clock(MKPD_T *pMKPD, uint32_t sys_clk)
Установка значения системной частоты
Definition: mkpd.c:49
struct Command_Word_Bits bit
Definition: mkpd.h:261
Структура регистров MUX.
#define MKPD2
Указатель на структуру MKPD2.
void MKPD_Clock_Init()
struct Reply_Word_Bits bit
void Manchester4_IRQ()
volatile unsigned short Reply_tx
volatile unsigned short MAN
#define GPIO_E
Указатель на структуру GPIO_E.
#define CMN_REG
Указатель на структуру CMN_REG.
volatile unsigned short all
void DBG_TX_Flush(void)
Вывод всех данных, накопленных в кольцевом буфере, в отладочный UART.
Definition: debug_uart.c:80
volatile unsigned int all
uint8_t BC_TX_Buffer[MKPD_MAX_WORD_IN_PACKET *2]
Буфер слов данных для передачи с КШ
volatile uint16_t Tx_rx_mark
Definition: mkpd.h:251
Command_Word_T ep_command1
Содержимое командного слова, принимаемого оконечным устройством 1.
volatile unsigned short FEP0
#define SYS_FREQ
Системная частота для использования в библиотечных функциях для MKPD.
static void MKPD_ConfigBusController(MKPD_T *pMKPD, uint32_t address_one, uint32_t address_two, uint32_t channel)
Настройка контроллера шины
Definition: mkpd.h:591
unsigned int reply_error1
static void MKPD_ConfigEndpoint(MKPD_T *pMKPD, uint32_t address, uint32_t ep_address)
Настройка оконечного устройства
Definition: mkpd.h:743
volatile uint16_t EP_addr
Definition: mkpd.h:252
#define MKPD3
Указатель на структуру MKPD3.
volatile uint16_t Data_size__Command_code
Definition: mkpd.h:248
#define MKPD_MAX_WORD_IN_PACKET
#define GPIO_F
Указатель на структуру GPIO_F.
#define MKPD_EP_SUBADDR_COUNT
Definition: types.h:64
uint8_t TestTwoBlocks2(MKPD_T *ManBC, MKPD_T *ManEP, MKPD_SETTING0_CHANNEL_T Channel)
static void MKPD_Set_Clk_1500NS(MKPD_T *pMKPD, unsigned int Clk)
Тонкая настройка количества тактов системной частоты в 1500 нс
Definition: mkpd.h:440