#ifndef __API_H__
#define __API_H__

#include <objbase.h>
#include <winioctl.h>
#include "public.h"


/**
 * \file can200-api.h
 * \brief Файл содержит описание функций для работы с платами CAN200.
 */

/** \cond */
#define CAN200_DEPRECATE_TEXT(_Text) __declspec(deprecated(_Text))
#define CAN200_DEPRECATE(_Replacement) CAN200_DEPRECATE_TEXT("This function is deprecated. Consider using " #_Replacement " instead.")
/** \endcond */

//Раскомментируйте следующую строку для работы с функциями старого синтаксиса
//#define __USE__OLD_CAN200_FUNCTIONS__

//-----------------------------------------------------------------------------
//
// Новый синтаксис
//
//-----------------------------------------------------------------------------

/**
 * \fn int CAN200_GetNumberDevice(int *count)
 * \brief Определение количества установленных плат
 *
 * Функция определяет количество установленных в компьютере плат CAN-200PCI и CAN-200PCIe
 * \param count (OUT) Указатель на переменную типа int, где будет сохранено количество установленных плат
 * \return CAN200_OK - успешное завершение
 * \return CAN200_ERR_PARM - ошибка входных параметров
 * \return CAN200_ERR_SYS - системная ошибка (для определения причины используйте (GetLastError())
 */
int CAN200_GetNumberDevice(int *count);

/**
 * \fn HANDLE CAN200_Open(int number)
 * \brief Открытие одной из плат для работы
 *
 * Функция позволяет открыть одну из плат для работы. Номер открываемой платы определяется входным параметром
 * \param number (IN) Номер открываемой платы
 * \return INVALID_HANDLE_VALUE - ошибка открытия платы с указанным номером
 * \return иначе - хэндл для работы с платой
 * \warning Нумерация устройств начинается с нуля
 */
HANDLE CAN200_Open(int number);

/**
 * \fn int CAN200_Close(HANDLE Handle)
 * \brief Закрытие ранее открытой платы
 *
 * Функция позволяет закрыть ранее открытую плату
 * \param Handle (IN) Хэндл закрываемой платы (возвращенный функцией #CAN200_Open)
 * \return CAN200_OK - успешное завершение
 * \return CAN200_ERR_PARM - ошибка входных параметров
 * \return CAN200_ERR_SYS - системная ошибка (для определения причины используйте (GetLastError())
 */
int CAN200_Close(HANDLE Handle);

/**
 * \fn int CAN200_SetWorkMode(HANDLE Handle, int Channel, int Mode)
 * \brief Настройка режима работы одного из каналов платы
 *
 * Функция позволяет настроить один из каналов платы в режим #BasicCAN или #PeliCAN
 * \param Handle (IN) Хэндл платы (возвращенный функцией #CAN200_Open)
 * \param Channel (IN) Номер канала платы
 * \param Mode (IN) Режим работы канала платы (BasicCAN или PeliCAN)
 * \return CAN200_OK - успешное завершение
 * \return CAN200_ERR_PARM - ошибка входных параметров
 * \return CAN200_ERR_SYS - системная ошибка (для определения причины используйте (GetLastError())
 */
int CAN200_SetWorkMode(HANDLE Handle, int Channel, int Mode);

/**
 * \fn int CAN200_GetWorkMode(HANDLE Handle, int Channel, int *Mode)
 * \brief Получение текущего режима работы одного из каналов платы
 *
 * Функция позволяет получить текущий режим работы одного из каналов платы
 * \param Handle (IN) Хэндл платы (возвращенный функцией #CAN200_Open)
 * \param Channel (IN) Номер канала платы
 * \param Mode (OUT) Указатель на переменную типа int, где будет сохранен текущий режим работы канала платы
 * \return CAN200_OK - успешное завершение
 * \return CAN200_ERR_PARM - ошибка входных параметров
 * \return CAN200_ERR_SYS - системная ошибка (для определения причины используйте (GetLastError())
 */
int CAN200_GetWorkMode(HANDLE Handle, int Channel, int *Mode);

/**
 * \fn int CAN200_SetDriverMode(HANDLE Handle, int Channel, int Mode)
 * \brief Настройка выходных формирователей канала платы
 *
 * Функция позволяет настроить выходные формирователи заданного канала платы
 * \param Handle (IN) Хэндл платы (возвращенный функцией #CAN200_Open)
 * \param Channel (IN) Номер канала платы
 * \param Mode (IN) Параметр настройки выходных формирователей (для нормальной работы должен быть равен 0x1B)
 * \return CAN200_OK - успешное завершение
 * \return CAN200_ERR_PARM - ошибка входных параметров
 * \return CAN200_ERR_SYS - системная ошибка (для определения причины используйте (GetLastError())
 * \warning Функцию необходимо вызвать один раз при инициализации CAN-контроллера после включения питания.
 * Без вызова этой функции прием/передача данных CAN-контроллером будет невозможна!
 */
int CAN200_SetDriverMode(HANDLE Handle, int Channel, int Mode);

/**
 * \fn int CAN200_GetConfig(HANDLE Handle, pTCAN_VPDData Buffer)
 * \brief Получение описания платы
 *
 * Функция возвращает описание платы (тип, серийный номер и т.д.)
 * \param Handle (IN) Хэндл платы (возвращенный функцией #CAN200_Open)
 * \param Buffer (OUT) Указатель на структуру #TCAN_VPDData, где будет сохранена информация о плате
 * \return CAN200_OK - успешное завершение
 * \return CAN200_ERR_PARM - ошибка входных параметров
 * \return CAN200_ERR_SYS - системная ошибка (для определения причины используйте (GetLastError())
 */
int CAN200_GetConfig(HANDLE Handle, pTCAN_VPDData Buffer);

/**
* \fn int CAN200_GetNumChannel(HANDLE Handle, int *NumChannel)
* \brief Получение количества каналов в плате
*
* Функция возвращает количество каналов в плате
* \param Handle (IN) Хэндл платы (возвращенный функцией #CAN200_Open)
* \param NumChannel (OUT) Указатель на переменную, где будет сохранено количество каналов в плате
* \return CAN200_OK - успешное завершение
* \return CAN200_ERR_PARM - ошибка входных параметров
* \return CAN200_ERR_SYS - системная ошибка (для определения причины используйте (GetLastError())
*/
int CAN200_GetNumChannel(HANDLE Handle, int *NumChannel);

/**
 * \fn int CAN200_SetCANSpeed(HANDLE Handle, int Channel, unsigned int Speed)
 * \brief Настройка скорости обмена одного из каналов платы
 *
 * Функция позволяет настроить скорость обмена по шине CAN одиного из каналов платы
 * \param Handle (IN) Хэндл платы (возвращенный функцией #CAN200_Open)
 * \param Channel (IN) Номер канала платы
 * \param Speed (IN) Значение скорости обмена по шине CAN (одно из значений #CAN_SPEED_1000,
 * #CAN_SPEED_800, #CAN_SPEED_500, #CAN_SPEED_250, #CAN_SPEED_125, #CAN_SPEED_50, #CAN_SPEED_20,
 * #CAN_SPEED_10 или #CAN_SPEED_USER_DEFINED)
 * \return CAN200_OK - успешное завершение
 * \return CAN200_ERR_PARM - ошибка входных параметров
 * \return CAN200_ERR_SYS - системная ошибка (для определения причины используйте (GetLastError())
 */
int CAN200_SetCANSpeed(HANDLE Handle, int Channel, unsigned int Speed);

/**
 * \fn int CAN200_GetCANSpeed(HANDLE Handle, int Channel, unsigned int *Speed)
 * \brief Получение текущей скорости обмена по CAN одного из каналов платы
 *
 * Функция позволяет получить текущее значение скорости обмена по CAN одного из каналов платы
 * \param Handle (IN) Хэндл платы (возвращенный функцией #CAN200_Open)
 * \param Channel (IN) Номер канала платы
 * \param Speed (OUT) Указатель на переменную типа int, где будет сохранено текущее значение скорости обмена по CAN
 * \return CAN200_OK - успешное завершение
 * \return CAN200_ERR_PARM - ошибка входных параметров
 * \return CAN200_ERR_SYS - системная ошибка (для определения причины используйте (GetLastError())
 */
int CAN200_GetCANSpeed(HANDLE Handle, int Channel, unsigned int *Speed);

/**
 * \fn int CAN200_GetStatus(HANDLE Handle, int Channel, int *Status)
 * \brief Получение статуса одного из каналов платы
 *
 * Функция позволяет получить статус одного из каналов платы
 * \param Handle (IN) Хэндл платы (возвращенный функцией #CAN200_Open)
 * \param Channel (IN) Номер канала платы
 * \param Status (OUT) Указатель на переменную типа int, где будет сохранен статус канала платы
 * (используются младшие 8 бит, для расшифровки значений можно использовать структуру #CAN_status_t)
 * \return CAN200_OK - успешное завершение
 * \return CAN200_ERR_PARM - ошибка входных параметров
 * \return CAN200_ERR_SYS - системная ошибка (для определения причины используйте (GetLastError())
 */
int CAN200_GetStatus(HANDLE Handle, int Channel, int *Status);

/**
 * \fn int CAN200_SetInterruptSource(HANDLE Handle, int Channel, int Source)
 * \brief Настройка разрешения прерываний для одного из каналов платы
 *
 * Функция позволяет настроить разрешение (маску) прерываний для одного из каналов платы
 * \param Handle (IN) Хэндл платы (возвращенный функцией #CAN200_Open)
 * \param Channel (IN) Номер канала платы
 * \param Source (IN) Маска прерываний (используются младшие 8 бит, бит равный 1 разрешает соответствующее прерывание,
 * для расшифровки значений отдельных битов можно использовать структуру #CAN_interrupt_t)
 * \return CAN200_OK - успешное завершение
 * \return CAN200_ERR_PARM - ошибка входных параметров
 * \return CAN200_ERR_SYS - системная ошибка (для определения причины используйте (GetLastError())
 * \warning Бит №4 в режиме #BasicCAN не маскирует соответствующую причину прерывания (выход контроллера из режима "сна").
 * Эта причина в режиме #BasicCAN не маскируется и всегда приводит к возникновению прерывания от платы.
 */
int CAN200_SetInterruptSource(HANDLE Handle, int Channel, int Source);

/**
 * \fn int CAN200_GetInterruptSource(HANDLE Handle, int Channel, int *Source)
 * \brief Получение маски прерываний
 *
 * Функция позволяет получить маску прерываний для одного из каналов платы
 * \param Handle (IN) Хэндл платы (возвращенный функцией #CAN200_Open)
 * \param Channel (IN) Номер канала платы
 * \param Source (OUT) Указатель на переменную типа int, где будет сохранена маска прерываний канала платы (используются младшие 8 бит,
 * для расшифровки значений отдельных битов можно использовать структуру #CAN_interrupt_t)
 * \return CAN200_OK - успешное завершение
 * \return CAN200_ERR_PARM - ошибка входных параметров
 * \return CAN200_ERR_SYS - системная ошибка (для определения причины используйте (GetLastError())
 */
int CAN200_GetInterruptSource(HANDLE Handle, int Channel, int *Source);

/**
 * \fn int CAN200_SetCommand(HANDLE Handle, int Channel, int Command)
 * \brief Выдача команды CAN контроллеру одного из каналов платы
 *
 * Функция позволяет выдать команду управления CAN контроллеру одного из каналов платы
 * \param Handle (IN) Хэндл платы (возвращенный функцией #CAN200_Open)
 * \param Channel (IN) Номер канала платы
 * \param Command (IN) Команда (используются младшие 8 бит, для расшифровки можно использовать
 * структуру #CAN_command_t)
 * \return CAN200_OK - успешное завершение
 * \return CAN200_ERR_PARM - ошибка входных параметров
 * \return CAN200_ERR_SYS - системная ошибка (для определения причины используйте (GetLastError())
 */
int CAN200_SetCommand(HANDLE Handle, int Channel, int Command);

/**
 * \fn int CAN200_SetTxBuffer(HANDLE Handle, int Channel, pRX_TX_Buffer Buffer)
 * \brief Запись кадра в буфер выдачи
 *
 * Функция позволяет записать CAN кадр в буфер выдачи одного из каналов платы
 * \param Handle (IN) Хэндл платы (возвращенный функцией #CAN200_Open)
 * \param Channel (IN) Номер канала платы
 * \param Buffer (IN) Указатель на структуру #RX_TX_Buffer, где содержится выдаваемый кадр
 * \return CAN200_OK - успешное завершение
 * \return CAN200_ERR_PARM - ошибка входных параметров
 * \return CAN200_ERR_BUSY - буфер выдачи занят
 * \return CAN200_ERR_SYS - системная ошибка (для определения причины используйте (GetLastError())
 */
int CAN200_SetTxBuffer(HANDLE Handle, int Channel, pRX_TX_Buffer Buffer);

/**
 * \fn int CAN200_DefEvent(HANDLE Handle, int Channel, HANDLE hEvent)
 * \brief Передача события синхронизации драйверу
 *
 * Функция позволяет передать событие синхронизации (созданное функцией CreateEvent) драйверу.
 * Данное событие будет привязано в драйвере к данной плате и указанному каналу.
 * Событие может быть использование для организации приема данных без циклического опроса статуса платы.
 * \param Handle (IN) Хэндл платы (возвращенный функцией #CAN200_Open)
 * \param Channel (IN) Номер канала платы
 * \param hEvent (IN) Хэндл события синхронизации
 * \return CAN200_OK - успешное завершение
 * \return CAN200_ERR_PARM - ошибка входных параметров
 * \return CAN200_ERR_SYS - системная ошибка (для определения причины используйте (GetLastError())
 * \return CAN200_ERR_MODE - режим работы канала не соответствует #BasicCAN
 */
int CAN200_DefEvent(HANDLE Handle, int Channel, HANDLE hEvent);

/**
 * \fn int CAN200_GetEventData(HANDLE Handle, int Channel, pTEventData Buffer)
 * \brief Получение причины события (из буфера драйвера)
 *
 * Функция возвращает причину возникновения события (прием кадра, ошибка и т.д.) из буфера приема драйвера для одного из каналов платы
 * \param Handle (IN) Хэндл платы (возвращенный функцией #CAN200_Open)
 * \param Channel (IN) Номер канала платы
 * \param Buffer (OUT) Указатель на переменную типа #TEventData, где будет сохранена причина прерывания
 * и, в случае приема кадра, принятый кадр
 * \return CAN200_OK - успешное завершение
 * \return CAN200_ERR_PARM - ошибка входных параметров
 * \return CAN200_ERR_SYS - системная ошибка (для определения причины используйте (GetLastError())
 */
int CAN200_GetEventData(HANDLE Handle, int Channel, pTEventData Buffer);

/**
 * \fn int CAN200_GetRxBuffer(HANDLE Handle, int Channel, pRX_TX_Buffer Buffer)
 * \brief Получение содержимого буфера приема
 *
 * Функция возвращает содержимое буфера приема контроллера CAN одного из каналов платы
 * \param Handle (IN) Хэндл платы (возвращенный функцией #CAN200_Open)
 * \param Channel (IN) Номер канала платы
 * \param Buffer (OUT) Указатель на переменную типа #RX_TX_Buffer, где будет сохранено содержимое буфера приема
 * \return CAN200_OK - успешное завершение
 * \return CAN200_ERR_PARM - ошибка входных параметров
 * \return CAN200_ERR_SYS - системная ошибка (для определения причины используйте (GetLastError())
 * \warning Функция возвратит содержимое буфера приема, даже если этот буфер пустой (содержит случайные данные).
 * Для получения принятого кадра перед вызовом этой функции необходимо использовать функцию #CAN200_GetStatus.
 */
int CAN200_GetRxBuffer(HANDLE Handle, int Channel, pRX_TX_Buffer Buffer);

/* Функции для режима BasicCAN */
/** \addtogroup BasicCAN
 * \{
 * \fn int CAN200_B_SetInputFilter(HANDLE Handle, int Channel, bFilter_t *filter)
 * \brief Настройка фильтра входных кадров для режима #BasicCAN
 *
 * Функция позволяет настроить фильтр входных кадров для режима #BasicCAN (для одного из каналов)
 * \param Handle (IN) Хэндл платы (возвращенный функцией #CAN200_Open)
 * \param Channel (IN) Номер канала платы
 * \param filter (IN) Указатель на структуру #bFilter_t с описанием фильтра
 * \return CAN200_OK - успешное завершение
 * \return CAN200_ERR_PARM - ошибка входных параметров
 * \return CAN200_ERR_MODE - режим работы канала не соответствует #BasicCAN
 * \return CAN200_ERR_SYS - системная ошибка (для определения причины используйте (GetLastError())
 * \par Функционирование входного фильтра в режиме BasicCAN.
 * Таблица, поясняющая функционирование входного фильтра
 * <TABLE>
 * <TR>
 * <TD rowspan=2 style='background:#D9D9D9'></TD> <TD colspan=11 align=center style='background:#D9D9D9'>Бит</TD>
 * </TR>
 * <TR>
 * <TD style='background:#D9D9D9'>10</TD> <TD style='background:#D9D9D9'>9</TD> <TD style='background:#D9D9D9'>8</TD> <TD style='background:#D9D9D9'>7</TD> <TD style='background:#D9D9D9'>6</TD> <TD style='background:#D9D9D9'>5</TD> <TD style='background:#D9D9D9'>4</TD> <TD style='background:#D9D9D9'>3</TD> <TD style='background:#D9D9D9'>2</TD> <TD style='background:#D9D9D9'>1</TD> <TD style='background:#D9D9D9'>0</TD>
 * </TR>
 * <TR>
 * <TD>Идентификатор кадра</TD> <TD>1</TD> <TD>0</TD> <TD>1</TD> <TD>0</TD> <TD>1</TD> <TD>0</TD> <TD>1</TD> <TD>0</TD> <TD>1</TD> <TD>0</TD> <TD>1</TD>
 * </TR>
 * <TR>
 * <TD colspan=12>&nbsp;</TD>
 * </TR>
 * <TR>
 * <TD rowspan=2 style='background:#D9D9D9'></TD> <TD colspan=8 align=center style='background:#D9D9D9'>Бит</TD>
 * </TR>
 * <TR>
 * <TD style='background:#D9D9D9'>7</TD> <TD style='background:#D9D9D9'>6</TD> <TD style='background:#D9D9D9'>5</TD> <TD style='background:#D9D9D9'>4</TD> <TD style='background:#D9D9D9'>3</TD> <TD style='background:#D9D9D9'>2</TD> <TD style='background:#D9D9D9'>1</TD> <TD style='background:#D9D9D9'>0</TD>
 * </TR>
 * <TR>
 * <TD>Маска</TD> <TD>1</TD> <TD>1</TD> <TD>1</TD> <TD>1</TD> <TD>0</TD> <TD>0</TD> <TD>0</TD> <TD>0</TD>
 * </TR>
 * <TR>
 * <TD>Идентификатор входного фильтра</TD> <TD>x</TD> <TD>x</TD> <TD>x</TD> <TD>x</TD> <TD>1</TD> <TD>0</TD> <TD>1</TD> <TD>0</TD>
 * </TR>
 * <TR>
 * <TD>Результат сравнения</TD> <TD>1</TD> <TD>1</TD> <TD>1</TD> <TD>1</TD> <TD>1</TD> <TD>1</TD> <TD>1</TD> <TD>1</TD>
 * </TR>
 * </TABLE>
 * х – любое значение.
 *
 * Входной фильтр функционирует следующим образом:
 * Биты 3-10 идентификатора кадра сравниваются на идентичность (поразрядно) с идентификатором входного фильтра.
 * Если в соответствующем разряде маски стоит логическая 1, то биты идентификатора кадра и идентификатора входного
 * фильтра в этом разряде не сравниваются и результат сравнения в данном разряде принимается равным логической 1.
 * Кадр проходит приемный фильтр, если результат сравнения во всех разрядах содержит логические 1.
 *
 * Пример:
 *
 * В таблице выше показан пример сравнения идентификатора кадра в приёмном фильтре.
 * Результат сравнения положительный и кадр будет записан в буфер приёма.
 * \note Для приема всех кадров необходимо установить маску равную FFh (значение идентификатора входного фильтра можно установить любое).
 */
int CAN200_B_SetInputFilter(HANDLE Handle, int Channel, bFilter_t *filter);
/** \} */

/** \addtogroup BasicCAN
 * \{
 * \fn int CAN200_B_GetInputFilter(HANDLE Handle, int Channel, bFilter_t *filter)
 * \brief Получение фильтра входных кадров для режима #BasicCAN
 *
 * Функция позволяет получить текущие настройки фильтра входных кадров для режима #BasicCAN (для одного из каналов)
 * \param Handle (IN) Хэндл платы (возвращенный функцией #CAN200_Open)
 * \param Channel (IN) Номер канала платы
 * \param filter (IN) Указатель на структуру #bFilter_t, где будет сохранено описание фильтра
 * \return CAN200_OK - успешное завершение
 * \return CAN200_ERR_PARM - ошибка входных параметров
 * \return CAN200_ERR_MODE - режим работы канала не соответствует #BasicCAN
 * \return CAN200_ERR_SYS - системная ошибка (для определения причины используйте (GetLastError())
 */
int CAN200_B_GetInputFilter(HANDLE Handle, int Channel, bFilter_t *filter);
/** \} */

/* Функции для режима PeliCAN */
/** \addtogroup PeliCAN
 * \{
 * \fn int CAN200_P_SetInputFilter(HANDLE Handle, int Channel, pFilter_t *filter)
 * \brief Настройка фильтра входных кадров для режима #PeliCAN
 *
 * Функция позволяет настроить фильтр входных кадров для режима #PeliCAN (для одного из каналов)
 * \param Handle (IN) Хэндл платы (возвращенный функцией #CAN200_Open)
 * \param Channel (IN) Номер канала платы
 * \param filter (IN) Указатель на структуру #pFilter_t с описанием фильтра
 * \return CAN200_OK - успешное завершение
 * \return CAN200_ERR_PARM - ошибка входных параметров
 * \return CAN200_ERR_MODE - режим работы канала не соответствует #PeliCAN
 * \return CAN200_ERR_SYS - системная ошибка (для определения причины используйте (GetLastError())
 * \par Функционирование входного фильтра в режиме PeliCAN.
 * Фильтр входных пакетов может функционировать в одном из двух режимов.
 * В следующих таблицах приведено отображение битов полей Filter и Mask на биты входного кадра.
 *
 * Таблица, поясняющая функционирование входного фильтра при приеме стандартного кадра (режим Single, Mode = 1);
 * <TABLE>
 * <TR>
 * <TD colspan=8 align=center style='background:#D9D9D9'>Бит Filter[0]</TD> <TD colspan=8 align=center style='background:#D9D9D9'>Бит Filter[1]</TD> <TD colspan=8 align=center style='background:#D9D9D9'>Бит Filter[2]</TD> <TD colspan=8 align=center style='background:#D9D9D9'>Бит Filter[3]</TD>
 * </TR>
 * <TR>
 * <TD>7</TD> <TD>6</TD> <TD>5</TD> <TD>4</TD> <TD>3</TD> <TD>2</TD> <TD>1</TD> <TD>0</TD>
 * <TD>7</TD> <TD>6</TD> <TD>5</TD> <TD>4</TD> <TD colspan=4>unused</TD>
 * <TD>7</TD> <TD>6</TD> <TD>5</TD> <TD>4</TD> <TD>3</TD> <TD>2</TD> <TD>1</TD> <TD>0</TD>
 * <TD>7</TD> <TD>6</TD> <TD>5</TD> <TD>4</TD> <TD>3</TD> <TD>2</TD> <TD>1</TD> <TD>0</TD>
 * </TR>
 * <TR>
 * <TD colspan=8 align=center style='background:#D9D9D9'>Бит Mask[0]</TD> <TD colspan=8 align=center style='background:#D9D9D9'>Бит Mask[1]</TD> <TD colspan=8 align=center style='background:#D9D9D9'>Бит Mask[2]</TD> <TD colspan=8 align=center style='background:#D9D9D9'>Бит Mask[3]</TD>
 * </TR>
 * <TR>
 * <TD>7</TD> <TD>6</TD> <TD>5</TD> <TD>4</TD> <TD>3</TD> <TD>2</TD> <TD>1</TD> <TD>0</TD>
 * <TD>7</TD> <TD>6</TD> <TD>5</TD> <TD>4</TD> <TD colspan=4>unused</TD>
 * <TD>7</TD> <TD>6</TD> <TD>5</TD> <TD>4</TD> <TD>3</TD> <TD>2</TD> <TD>1</TD> <TD>0</TD>
 * <TD>7</TD> <TD>6</TD> <TD>5</TD> <TD>4</TD> <TD>3</TD> <TD>2</TD> <TD>1</TD> <TD>0</TD>
 * </TR>
 * <TR>
 * <TD colspan=32 align=center style='background:#D9D9D9'>Входной кадр</TD>
 * </TR>
 * <TR>
 * <TD>ID.28</TD> <TD>ID.27</TD> <TD>ID.26</TD> <TD>ID.25</TD> <TD>ID.24</TD> <TD>ID.23</TD> <TD>ID.22</TD> <TD>ID.21</TD>
 * <TD>ID.20</TD> <TD>ID.19</TD> <TD>ID.18</TD> <TD>RTR</TD> <TD colspan=4>&nbsp;</TD>
 * <TD>DB1.7</TD> <TD>DB1.6</TD> <TD>DB1.5</TD> <TD>DB1.4</TD> <TD>DB1.3</TD> <TD>DB1.2</TD> <TD>DB1.1</TD> <TD>DB1.0</TD>
 * <TD>DB2.7</TD> <TD>DB2.6</TD> <TD>DB2.5</TD> <TD>DB2.4</TD> <TD>DB2.3</TD> <TD>DB2.2</TD> <TD>DB2.1</TD> <TD>DB2.0</TD>
 * </TR>
 * </TABLE>
 * Таблица, поясняющая функционирование входного фильтра при приеме расширенного кадра (режим Single, Mode = 1);
 * <TABLE>
 * <TR>
 * <TD colspan=8 align=center style='background:#D9D9D9'>Бит Filter[0]</TD> <TD colspan=8 align=center style='background:#D9D9D9'>Бит Filter[1]</TD> <TD colspan=8 align=center style='background:#D9D9D9'>Бит Filter[2]</TD> <TD colspan=8 align=center style='background:#D9D9D9'>Бит Filter[3]</TD>
 * </TR>
 * <TR>
 * <TD>7</TD> <TD>6</TD> <TD>5</TD> <TD>4</TD> <TD>3</TD> <TD>2</TD> <TD>1</TD> <TD>0</TD>
 * <TD>7</TD> <TD>6</TD> <TD>5</TD> <TD>4</TD> <TD>3</TD> <TD>2</TD> <TD>1</TD> <TD>0</TD>
 * <TD>7</TD> <TD>6</TD> <TD>5</TD> <TD>4</TD> <TD>3</TD> <TD>2</TD> <TD>1</TD> <TD>0</TD>
 * <TD>7</TD> <TD>6</TD> <TD>5</TD> <TD>4</TD> <TD>3</TD> <TD>2</TD> <TD colspan=2>unused</TD>
 * </TR>
 * <TR>
 * <TD colspan=8 align=center style='background:#D9D9D9'>Бит Mask[0]</TD> <TD colspan=8 align=center style='background:#D9D9D9'>Бит Mask[1]</TD> <TD colspan=8 align=center style='background:#D9D9D9'>Бит Mask[2]</TD> <TD colspan=8 align=center style='background:#D9D9D9'>Бит Mask[3]</TD>
 * </TR>
 * <TR>
 * <TD>7</TD> <TD>6</TD> <TD>5</TD> <TD>4</TD> <TD>3</TD> <TD>2</TD> <TD>1</TD> <TD>0</TD>
 * <TD>7</TD> <TD>6</TD> <TD>5</TD> <TD>4</TD> <TD>3</TD> <TD>2</TD> <TD>1</TD> <TD>0</TD>
 * <TD>7</TD> <TD>6</TD> <TD>5</TD> <TD>4</TD> <TD>3</TD> <TD>2</TD> <TD>1</TD> <TD>0</TD>
 * <TD>7</TD> <TD>6</TD> <TD>5</TD> <TD>4</TD> <TD>3</TD> <TD>2</TD> <TD colspan=2>unused</TD>
 * </TR>
 * <TR>
 * <TD colspan=32 align=center style='background:#D9D9D9'>Входной кадр</TD>
 * </TR>
 * <TR>
 * <TD>ID.28</TD> <TD>ID.27</TD> <TD>ID.26</TD> <TD>ID.25</TD> <TD>ID.24</TD> <TD>ID.23</TD> <TD>ID.22</TD> <TD>ID.21</TD>
 * <TD>ID.20</TD> <TD>ID.19</TD> <TD>ID.18</TD> <TD>ID.17</TD> <TD>ID.16</TD> <TD>ID.15</TD> <TD>ID.14</TD> <TD>ID.13</TD>
 * <TD>ID.12</TD> <TD>ID.11</TD> <TD>ID.10</TD> <TD>ID.9</TD> <TD>ID.8</TD> <TD>ID.7</TD> <TD>ID.6</TD> <TD>ID.5</TD>
 * <TD>ID.4</TD> <TD>ID.3</TD> <TD>ID.2</TD> <TD>ID.1</TD> <TD>ID.0</TD> <TD>RTR</TD> <TD colspan=2>&nbsp;</TD>
 * </TR>
 * </TABLE>
 * Таблица, поясняющая функционирование входного фильтра при приеме стандартного кадра (режим Dual, Mode = 0);
 * <TABLE>
 * <TR>
 * <TD colspan=8 align=center style='background:#D9D9D9'>Бит Filter[0]</TD> <TD colspan=8 align=center style='background:#D9D9D9'>Бит Filter[1]</TD> <TD colspan=4 align=center style='background:#D9D9D9'>Бит Filter[3]</TD>
 * </TR>
 * <TR>
 * <TD>7</TD> <TD>6</TD> <TD>5</TD> <TD>4</TD> <TD>3</TD> <TD>2</TD> <TD>1</TD> <TD>0</TD>
 * <TD>7</TD> <TD>6</TD> <TD>5</TD> <TD>4</TD> <TD>3</TD> <TD>2</TD> <TD>1</TD> <TD>0</TD>
 * <TD>3</TD> <TD>2</TD> <TD>1</TD> <TD>0</TD>
 * </TR>
 * <TR>
 * <TD colspan=8 align=center style='background:#D9D9D9'>Бит Mask[0]</TD> <TD colspan=8 align=center style='background:#D9D9D9'>Бит Mask[1]</TD> <TD colspan=4 align=center style='background:#D9D9D9'>Бит Mask[3]</TD>
 * </TR>
 * <TR>
 * <TD>7</TD> <TD>6</TD> <TD>5</TD> <TD>4</TD> <TD>3</TD> <TD>2</TD> <TD>1</TD> <TD>0</TD>
 * <TD>7</TD> <TD>6</TD> <TD>5</TD> <TD>4</TD> <TD>3</TD> <TD>2</TD> <TD>1</TD> <TD>0</TD>
 * <TD>3</TD> <TD>2</TD> <TD>1</TD> <TD>0</TD>
 * </TR>
 * <TR>
 * <TD colspan=20 align=center style='background:#D9D9D9'>Входной кадр</TD>
 * </TR>
 * <TR>
 * <TD>ID.28</TD> <TD>ID.27</TD> <TD>ID.26</TD> <TD>ID.25</TD> <TD>ID.24</TD> <TD>ID.23</TD> <TD>ID.22</TD> <TD>ID.21</TD>
 * <TD>ID.20</TD> <TD>ID.19</TD> <TD>ID.18</TD> <TD>RTR</TD> <TD>DB1.7</TD> <TD>DB1.6</TD> <TD>DB1.5</TD> <TD>DB1.4</TD> <TD>DB1.3</TD> <TD>DB1.2</TD> <TD>DB1.1</TD> <TD>DB1.0</TD>
 * </TR>
 * <TR>
 * <TD colspan=8 align=center style='background:#D9D9D9'>Бит Mask[2]</TD> <TD colspan=4 align=center style='background:#D9D9D9'>Бит Mask[3]</TD>
 * </TR>
 * <TR>
 * <TD>7</TD> <TD>6</TD> <TD>5</TD> <TD>4</TD> <TD>3</TD> <TD>2</TD> <TD>1</TD> <TD>0</TD>
 * <TD>7</TD> <TD>6</TD> <TD>5</TD> <TD>4</TD>
 * </TR>
 * <TR>
 * <TD colspan=8 align=center style='background:#D9D9D9'>Бит Filter[2]</TD> <TD colspan=4 align=center style='background:#D9D9D9'>Бит Filter[3]</TD>
 * </TR>
 * <TR>
 * <TD>7</TD> <TD>6</TD> <TD>5</TD> <TD>4</TD> <TD>3</TD> <TD>2</TD> <TD>1</TD> <TD>0</TD>
 * <TD>7</TD> <TD>6</TD> <TD>5</TD> <TD>4</TD>
 * </TR>
 * </TABLE>
 * Таблица, поясняющая функционирование входного фильтра при приеме расширенного кадра (режим Dual, Mode = 0);
 * <TABLE>
 * <TR>
 * <TD colspan=8 align=center style='background:#D9D9D9'>Бит Filter[0]</TD> <TD colspan=8 align=center style='background:#D9D9D9'>Бит Filter[1]</TD>
 * </TR>
 * <TR>
 * <TD>7</TD> <TD>6</TD> <TD>5</TD> <TD>4</TD> <TD>3</TD> <TD>2</TD> <TD>1</TD> <TD>0</TD>
 * <TD>7</TD> <TD>6</TD> <TD>5</TD> <TD>4</TD> <TD>3</TD> <TD>2</TD> <TD>1</TD> <TD>0</TD>
 * </TR>
 * <TR>
 * <TD colspan=8 align=center style='background:#D9D9D9'>Бит Mask[0]</TD> <TD colspan=8 align=center style='background:#D9D9D9'>Бит Mask[1]</TD>
 * </TR>
 * <TR>
 * <TD>7</TD> <TD>6</TD> <TD>5</TD> <TD>4</TD> <TD>3</TD> <TD>2</TD> <TD>1</TD> <TD>0</TD>
 * <TD>7</TD> <TD>6</TD> <TD>5</TD> <TD>4</TD> <TD>3</TD> <TD>2</TD> <TD>1</TD> <TD>0</TD>
 * </TR>
 * <TR>
 * <TD colspan=20 align=center style='background:#D9D9D9'>Входной кадр</TD>
 * </TR>
 * <TR>
 * <TD>ID.28</TD> <TD>ID.27</TD> <TD>ID.26</TD> <TD>ID.25</TD> <TD>ID.24</TD> <TD>ID.23</TD> <TD>ID.22</TD> <TD>ID.21</TD>
 * <TD>ID.20</TD> <TD>ID.19</TD> <TD>ID.18</TD> <TD>ID.17</TD> <TD>ID.16</TD> <TD>ID.15</TD> <TD>ID.14</TD> <TD>ID.13</TD>
 * </TR>
 * <TR>
 * <TD colspan=8 align=center style='background:#D9D9D9'>Бит Mask[2]</TD> <TD colspan=8 align=center style='background:#D9D9D9'>Бит Mask[3]</TD>
 * </TR>
 * <TR>
 * <TD>7</TD> <TD>6</TD> <TD>5</TD> <TD>4</TD> <TD>3</TD> <TD>2</TD> <TD>1</TD> <TD>0</TD>
 * <TD>7</TD> <TD>6</TD> <TD>5</TD> <TD>4</TD> <TD>3</TD> <TD>2</TD> <TD>1</TD> <TD>0</TD>
 * </TR>
 * <TR>
 * <TD colspan=8 align=center style='background:#D9D9D9'>Бит Filter[2]</TD> <TD colspan=8 align=center style='background:#D9D9D9'>Бит Filter[3]</TD>
 * </TR>
 * <TR>
 * <TD>7</TD> <TD>6</TD> <TD>5</TD> <TD>4</TD> <TD>3</TD> <TD>2</TD> <TD>1</TD> <TD>0</TD>
 * <TD>7</TD> <TD>6</TD> <TD>5</TD> <TD>4</TD> <TD>3</TD> <TD>2</TD> <TD>1</TD> <TD>0</TD>
 * </TR>
 * </TABLE>
 *
 * Входной фильтр функционирует следующим образом:
 * Биты кадра (приведенные в соответствующей таблице) сравниваются на идентичность (поразрядно) с идентификатором входного фильтра.
 * Если в соответствующем разряде маски стоит логическая 1, то биты кадра и идентификатора входного
 * фильтра в этом разряде не сравниваются и результат сравнения в данном разряде принимается равным логической 1.
 * Кадр проходит приемный фильтр, если результат сравнения во всех разрядах содержит логические 1.
 *
 * \note Для приема всех кадров необходимо установить маску равную FFh-FFh-FFh-FFh (значение идентификатора входного фильтра можно установить любое).
 */
int CAN200_P_SetInputFilter(HANDLE Handle, int Channel, pFilter_t *filter);
/** \} */

/** \addtogroup PeliCAN
 * \{
 * \fn int CAN200_P_GetInputFilter(HANDLE Handle, int Channel, pFilter_t *filter)
 * \brief Получение фильтра входных кадров для режима #PeliCAN
 *
 * Функция позволяет получить текущие настройки фильтра входных кадров для режима #PeliCAN (для одного из каналов)
 * \param Handle (IN) Хэндл платы (возвращенный функцией #CAN200_Open)
 * \param Channel (IN) Номер канала платы
 * \param filter (IN) Указатель на структуру #pFilter_t, где будет сохранено описание фильтра
 * \return CAN200_OK - успешное завершение
 * \return CAN200_ERR_PARM - ошибка входных параметров
 * \return CAN200_ERR_MODE - режим работы канала не соответствует #PeliCAN
 * \return CAN200_ERR_SYS - системная ошибка (для определения причины используйте (GetLastError())
 */
int CAN200_P_GetInputFilter(HANDLE Handle, int Channel, pFilter_t *filter);
/** \} */

/** \addtogroup PeliCAN
 * \{
 * \fn int CAN200_P_SetRxErrorCounter(HANDLE Handle, int Channel, int Counter)
 * \brief Установка счетчика ошибок приема по шине CAN (только для режима #PeliCAN)
 *
 * Функция позволяет установить значение счетчика ошибок приема по шине CAN для одного из каналов
 * \param Handle (IN) Хэндл платы (возвращенный функцией #CAN200_Open)
 * \param Channel (IN) Номер канала платы
 * \param Counter (IN) Значение счетчика ошибок
 * \return CAN200_OK - успешное завершение
 * \return CAN200_ERR_PARM - ошибка входных параметров
 * \return CAN200_ERR_MODE - режим работы канала не соответствует #PeliCAN
 * \return CAN200_ERR_SYS - системная ошибка (для определения причины используйте (GetLastError())
 */
int CAN200_P_SetRxErrorCounter(HANDLE Handle, int Channel, int Counter);
/** \} */

/** \addtogroup PeliCAN
 * \{
 * \fn int CAN200_P_GetRxErrorCounter(HANDLE Handle, int Channel, int *Counter)
 * \brief Получение счетчика ошибок приема по шине CAN (только для режима #PeliCAN)
 *
 * Функция позволяет получить значение счетчика ошибок приема по шине CAN для одного из каналов
 * \param Handle (IN) Хэндл платы (возвращенный функцией #CAN200_Open)
 * \param Channel (IN) Номер канала платы
 * \param Counter (IN) Указатель на переменную типа int, где будет сохранено значение счетчика ошибок
 * \return CAN200_OK - успешное завершение
 * \return CAN200_ERR_PARM - ошибка входных параметров
 * \return CAN200_ERR_MODE - режим работы канала не соответствует #PeliCAN
 * \return CAN200_ERR_SYS - системная ошибка (для определения причины используйте (GetLastError())
 */
int CAN200_P_GetRxErrorCounter(HANDLE Handle, int Channel, int *Counter);
/** \} */

/** \addtogroup PeliCAN
 * \{
 * \fn int CAN200_P_SetTxErrorCounter(HANDLE Handle, int Channel, int Counter)
 * \brief Установка счетчика ошибок выдачи по шине CAN (только для режима #PeliCAN)
 *
 * Функция позволяет установить значение счетчика ошибок выдачи по шине CAN для одного из каналов
 * \param Handle (IN) Хэндл платы (возвращенный функцией #CAN200_Open)
 * \param Channel (IN) Номер канала платы
 * \param Counter (IN) Значение счетчика ошибок
 * \return CAN200_OK - успешное завершение
 * \return CAN200_ERR_PARM - ошибка входных параметров
 * \return CAN200_ERR_MODE - режим работы канала не соответствует #PeliCAN
 * \return CAN200_ERR_SYS - системная ошибка (для определения причины используйте (GetLastError())
 */
int CAN200_P_SetTxErrorCounter(HANDLE Handle, int Channel, int Counter);
/** \} */

/** \addtogroup PeliCAN
 * \{
 * \fn int CAN200_P_GetTxErrorCounter(HANDLE Handle, int Channel, int *Counter)
 * \brief Получение счетчика ошибок выдачи по шине CAN (только для режима #PeliCAN)
 *
 * Функция позволяет получить значение счетчика ошибок выдачи по шине CAN для одного из каналов
 * \param Handle (IN) Хэндл платы (возвращенный функцией #CAN200_Open)
 * \param Channel (IN) Номер канала платы
 * \param Counter (IN) Указатель на переменную типа int, где будет сохранено значение счетчика ошибок
 * \return CAN200_OK - успешное завершение
 * \return CAN200_ERR_PARM - ошибка входных параметров
 * \return CAN200_ERR_MODE - режим работы канала не соответствует #PeliCAN
 * \return CAN200_ERR_SYS - системная ошибка (для определения причины используйте (GetLastError())
 */
int CAN200_P_GetTxErrorCounter(HANDLE Handle, int Channel, int *Counter);
/** \} */

/** \addtogroup PeliCAN
 * \{
 * \fn int CAN200_P_SetErrorWarningLimit(HANDLE Handle, int Channel, int Limit)
 * \brief Установка верхнего предела счетчика ошибок CAN (только для режима #PeliCAN)
 *
 * Функция позволяет установить значение верхнего предела счетчика ошибок CAN для одного из каналов.
 * Если хоть один из счетчиков ошибок (при приеме или выдаче) превысит значение предела заданного этой функцией,
 * произойдет установка бита "Наличие ошибок" (см. #CAN200_GetStatus).
 * По умолчанию верхний предел счётчиков ошибок равен 96.
 * \param Handle (IN) Хэндл платы (возвращенный функцией #CAN200_Open)
 * \param Channel (IN) Номер канала платы
 * \param Limit (IN) Значение верхнего предела счетчика ошибок
 * \return CAN200_OK - успешное завершение
 * \return CAN200_ERR_PARM - ошибка входных параметров
 * \return CAN200_ERR_MODE - режим работы канала не соответствует #PeliCAN
 * \return CAN200_ERR_SYS - системная ошибка (для определения причины используйте (GetLastError())
 */
int CAN200_P_SetErrorWarningLimit(HANDLE Handle, int Channel, int Limit);
/** \} */

/** \addtogroup PeliCAN
 * \{
 * \fn int CAN200_P_GetErrorWarningLimit(HANDLE Handle, int Channel, int *Limit)
 * \brief Получение верхнено предела счетчика ошибок CAN (только для режима #PeliCAN)
 *
 * Функция позволяет получить значение верхнего предела счетчика ошибок CAN для одного из каналов
 * \param Handle (IN) Хэндл платы (возвращенный функцией #CAN200_Open)
 * \param Channel (IN) Номер канала платы
 * \param Limit (IN) Указатель на переменную типа int, где будет сохранено значение верхнего предела счетчика ошибок
 * \return CAN200_OK - успешное завершение
 * \return CAN200_ERR_PARM - ошибка входных параметров
 * \return CAN200_ERR_MODE - режим работы канала не соответствует #PeliCAN
 * \return CAN200_ERR_SYS - системная ошибка (для определения причины используйте (GetLastError())
 */
int CAN200_P_GetErrorWarningLimit(HANDLE Handle, int Channel, int *Limit);
/** \} */

/** \addtogroup PeliCAN
 * \{
 * \fn int CAN200_P_GetArbitrationLostCapture(HANDLE Handle, int Channel, int *Data)
 * \brief Получение номера бита, на котором был проигран арбитраж (только для режима #PeliCAN)
 *
 * Функция позволяет получить значение Получение номера бита, на котором был проигран арбитраж для одного из каналов
 * \param Handle (IN) Хэндл платы (возвращенный функцией #CAN200_Open)
 * \param Channel (IN) Номер канала платы
 * \param Data (IN) Указатель на переменную типа int, где будет сохранено значение бита, на котором был проигран арбитраж
 * (используются младшие 8 бит, для расшифровки значения можно использовать структуру #CAN_arbitration_lost_capture_t)
 * \return CAN200_OK - успешное завершение
 * \return CAN200_ERR_PARM - ошибка входных параметров
 * \return CAN200_ERR_MODE - режим работы канала не соответствует #PeliCAN
 * \return CAN200_ERR_SYS - системная ошибка (для определения причины используйте (GetLastError())
 */
int CAN200_P_GetArbitrationLostCapture(HANDLE Handle, int Channel, int *Data);
/** \} */

/** \addtogroup PeliCAN
 * \{
 * \fn int CAN200_P_GetRxMessageCounter(HANDLE Handle, int Channel, int *Counter)
 * \brief Получение количества принятых (и не прочитанных) кадров в буфере приёма (только для режима #PeliCAN)
 *
 * Функция позволяет получить количество принятых (и не прочитанных) кадров в буфере приёма для одного из каналов
 * \param Handle (IN) Хэндл платы (возвращенный функцией #CAN200_Open)
 * \param Channel (IN) Номер канала платы
 * \param Counter (IN) Указатель на переменную типа int, где будет сохранено значение количество принятых (и не прочитанных)
 * кадров в буфере приема
 * \return CAN200_OK - успешное завершение
 * \return CAN200_ERR_PARM - ошибка входных параметров
 * \return CAN200_ERR_MODE - режим работы канала не соответствует #PeliCAN
 * \return CAN200_ERR_SYS - системная ошибка (для определения причины используйте (GetLastError())
 */
int CAN200_P_GetRxMessageCounter(HANDLE Handle, int Channel, int *Counter);
/** \} */

/** \addtogroup PeliCAN
 * \{
 * \fn int CAN200_P_GetErrorCode(HANDLE Handle, int Channel, int *Code)
 * \brief Получение типа и местоположения ошибки при обмене по шине CAN (только для режима #PeliCAN)
 *
 * Функция позволяет получить тип и местоположение ошибки при обмене по шине CAN для одного из каналов
 * \param Handle (IN) Хэндл платы (возвращенный функцией #CAN200_Open)
 * \param Channel (IN) Номер канала платы
 * \param Code (IN) Указатель на переменную типа int, где будет сохранен тип и местоположение ошибки при обмене по шине CAN
 * кадров в буфере приема (используются младшие 8 бит, для расшифровки значения можно использовать структуру #CAN_error_t)
 * \return CAN200_OK - успешное завершение
 * \return CAN200_ERR_PARM - ошибка входных параметров
 * \return CAN200_ERR_MODE - режим работы канала не соответствует #PeliCAN
 * \return CAN200_ERR_SYS - системная ошибка (для определения причины используйте (GetLastError())
 */
int CAN200_P_GetErrorCode(HANDLE Handle, int Channel, int *Code);
/** \} */

/**
 * \fn int CAN200_GetOverCounter(HANDLE Handle, int Channel, int *Counter)
 * \brief Получение текущего кол-ва кадров отбрашенных из-за нехватки места в буфере
 *
 * Функция позволяет получить текущий режим работы одного из каналов платы
 * \param Handle (IN) Хэндл платы (возвращенный функцией #CAN200_Open)
 * \param Channel (IN) Номер канала платы
 * \param Counter (OUT) Указатель на переменную типа int, где будет сохранено кол-во кадров отбрашенное из-за нехватки места
 * \return CAN200_OK - успешное завершение
 * \return CAN200_ERR_PARM - ошибка входных параметров
 * \return CAN200_ERR_SYS - системная ошибка (для определения причины используйте (GetLastError())
 */
int CAN200_GetOverCounter(HANDLE Handle, int Channel, int *Counter);

/**
* \fn int CAN200_GetDriverVersion(HANDLE Handle, int *Version)
* \brief Отмена выдачи пакетов
*
* Функция возвращает версию драйвера.
* \param Handle (IN) Хэндл платы (возвращенный функцией #CAN200_Open)
* \param Version (OUT) Версия драйвера (3 байта, младший - подподверсия, второй - подверсия, третий - версия)
* \return CAN200_OK - успешное завершение
* \return CAN200_ERR_PARM - ошибка входных параметров
* \return CAN200_ERR_SYS - системная ошибка (для определения причины используйте (GetLastError())
*/
int CAN200_GetDriverVersion(HANDLE Handle, int *Version);

/** \cond */
//-----------------------------------------------------------------------------
int CAN200_SetCANReg(HANDLE Handle, int Channel, int Port, int Data);

//-----------------------------------------------------------------------------
int CAN200_GetCANReg(HANDLE Handle, int Channel, int Port, int *Data);
/** \endcond */

/** \cond */
//-----------------------------------------------------------------------------
//
// Устаревший синтаксис функций
//
//-----------------------------------------------------------------------------
#ifdef __USE__OLD_CAN200_FUNCTIONS__
//-----------------------------------------------------------------------------
CAN200_DEPRECATE(CAN200_Open) unsigned short CANOpen(int number);

//-----------------------------------------------------------------------------
CAN200_DEPRECATE(CAN200_Close) void CANClose(int number);

//-----------------------------------------------------------------------------
CAN200_DEPRECATE(CAN200_Open) int SelectCAN(int number);

//-----------------------------------------------------------------------------
CAN200_DEPRECATE(CAN200_Open) void chBaseAddress(unsigned int Base);

//-----------------------------------------------------------------------------
CAN200_DEPRECATE(CAN200_SetWorkMode) unsigned short SetWorkMode(unsigned short Mode);

//-----------------------------------------------------------------------------
CAN200_DEPRECATE(CAN200_GetWorkMode) unsigned short GetWorkMode(void);

//-----------------------------------------------------------------------------
CAN200_DEPRECATE(CAN200_SetDriverMode) void SetDriverMode(unsigned short Mode);

//-----------------------------------------------------------------------------
CAN200_DEPRECATE(CAN200_GetConfig) unsigned short GetConfig(pTCAN_VPDData Buffer);

//-----------------------------------------------------------------------------
CAN200_DEPRECATE(CAN200_SetCANSpeed) unsigned short SetCANSpeed(unsigned int Speed);

//-----------------------------------------------------------------------------
CAN200_DEPRECATE(CAN200_GetStatus) unsigned short GetStatus(void);

//-----------------------------------------------------------------------------
CAN200_DEPRECATE(CAN200_B_SetInputFilter) unsigned short B_SetInputFilter(unsigned short Filter1,
																		  unsigned short Filter2);

//-----------------------------------------------------------------------------
CAN200_DEPRECATE(CAN200_B_SetInterruptSource) void SetInterruptSource(unsigned short Source);

//-----------------------------------------------------------------------------
CAN200_DEPRECATE(CAN200_P_SetInputFilter) unsigned short P_SetInputFilter(unsigned short mode,
																		  unsigned short ACR0,
																		  unsigned short ACR1,
																		  unsigned short ACR2,
																		  unsigned short ACR3,
																		  unsigned short AMR0,
																		  unsigned short AMR1,
																		  unsigned short AMR2,
																		  unsigned short AMR3);

//-----------------------------------------------------------------------------
CAN200_DEPRECATE(CAN200_P_SetRxErrorCounter) unsigned short P_SetRxErrorCounter(unsigned short Counter);

//-----------------------------------------------------------------------------
CAN200_DEPRECATE(CAN200_P_GetRxErrorCounter) int P_GetRxErrorCounter(void);

//-----------------------------------------------------------------------------
CAN200_DEPRECATE(CAN200_P_SetTxErrorCounter) unsigned short P_SetTxErrorCounter(unsigned short Counter);

//-----------------------------------------------------------------------------
CAN200_DEPRECATE(CAN200_P_GetTxErrorCounter) int P_GetTxErrorCounter(void);

//-----------------------------------------------------------------------------
CAN200_DEPRECATE(CAN200_P_SetErrorWarningLimit) unsigned short P_SetErrorWarningLimit(unsigned short Limit);

//-----------------------------------------------------------------------------
CAN200_DEPRECATE(CAN200_P_GetErrorWarningLimit) int P_GetErrorWarningLimit(void);

//-----------------------------------------------------------------------------
CAN200_DEPRECATE(CAN200_P_GetArbitrationLostCapture) int P_GetArbitrationLostCapture(void);

//-----------------------------------------------------------------------------
CAN200_DEPRECATE(CAN200_P_GetRxMessageCounter) int P_GetRxMessageCounter(void);

//-----------------------------------------------------------------------------
CAN200_DEPRECATE(CAN200_P_GetErrorCode) int P_GetErrorCode(void);

//-----------------------------------------------------------------------------
CAN200_DEPRECATE(CAN200_SetCommand) void SetCommand(unsigned short Command);

//-----------------------------------------------------------------------------
CAN200_DEPRECATE(CAN200_SetTxBuffer) unsigned short SetTxBuffer(pRX_TX_Buffer Buffer);

//-----------------------------------------------------------------------------
CAN200_DEPRECATE(CAN200_DefEvent) void DefEvent(HANDLE hEvent, BOOL fEventSet);

//-----------------------------------------------------------------------------
CAN200_DEPRECATE(CAN200_GetEventData) unsigned short GetEventData(pTEventData Buffer);

//-----------------------------------------------------------------------------
CAN200_DEPRECATE(CAN200_GetRxBuffer) unsigned short GetRxBuffer(pRX_TX_Buffer Buffer);

//-----------------------------------------------------------------------------
CAN200_DEPRECATE(CAN200_SetCANReg) void SetCANReg(unsigned short port, unsigned short data);

//-----------------------------------------------------------------------------
CAN200_DEPRECATE(CAN200_GetCANReg) unsigned short GetCANReg(unsigned short port);

#endif /* __USE__OLD_CAN200_FUNCTIONS__ */
/** \endcond */

#endif /* __API_H__ */