#ifndef __qmx_core_h__
#define __qmx_core_h__

#include "qmx.h"

extern WORD GLastErrorNumber[128];
extern char *error_helper[128][4];
extern char *error_function[128];

static char slot_err_helper[]="Parameter \"Slot\" valid range is [0..7].\n";
#define QMX_CHECK_SD(SD) if(SD==INVALID_HANDLE_VALUE || SD==NULL) {return(QMXE_INVALID_DESCRIPTOR);};
#define QMX_CHECK_SLOT(SD, SLOT) if(SLOT>8) {QMX_ClearErrorHelpers((QMX_SYSTEM *)SD); error_function[((QMX_SYSTEM *)SD)->Controller.VirtualSlot]=current_function_name; GLastErrorNumber[((QMX_SYSTEM *)SD)->Controller.VirtualSlot]=QMXE_BAD_PARAMETER; error_helper[((QMX_SYSTEM *)SD)->Controller.VirtualSlot][0]=slot_err_helper; return(QMX_ERR);}

// дескрипторы
typedef struct QMX_SYSTEM QMX_SYSTEM;		// Дескриптор системы
typedef struct QMX_CCTL QMX_CCTL;		// Дескриптор крейт-контроллера
typedef struct QMX_MODULE QMX_MODULE;		// Дескриптор модуля
// структуры
typedef struct QMX_MOD_FLASH QMX_MOD_FLASH;	// Системная область флэш модуля
typedef struct QMX_AVR_FLASH QMX_AVR_FLASH;
// вспомогательные структуры
typedef struct QMX_PARSER_PARAMS QMX_PARSER_PARAMS;

int QMX_Init(void);
int QMX_Exit(void);

// низкоуровневые функции ======================================================
void QMX_ClearErrorHelpers(QMX_SYSTEM *SD);
QMX_EXT QMX_API int __stdcall QMX_MOD_Start(QMX_SYSTEM *SD, BYTE Slot);
QMX_EXT QMX_API int __stdcall QMX_MOD_Stop(QMX_SYSTEM *SD, BYTE Slot);
QMX_EXT QMX_API int __stdcall QMX_OpenOnly(WORD VirtualSlot, QMX_SYSTEM **QSD); // open without loading any fpga
QMX_EXT QMX_API int __stdcall QMX_GetControllerInfo(QMX_SYSTEM *SD);
QMX_EXT QMX_API int __stdcall QMX_SendCommand(QMX_SYSTEM *SD, WORD Command, WORD Param); // old name is RtSendCommandToModule
QMX_EXT QMX_API int __stdcall QMX_PutArray(QMX_SYSTEM *SD, WORD Target, WORD LocalAddress, WORD N, BYTE *Data);
QMX_EXT QMX_API int __stdcall QMX_GetArray(QMX_SYSTEM *SD, WORD Target, WORD LocalAddress, WORD N, BYTE *Data);
QMX_EXT QMX_API int __stdcall QMX_PutQMbus(QMX_SYSTEM *SD, WORD BusAddress, WORD N, WORD *Data);
QMX_EXT QMX_API int __stdcall QMX_GetQMbus(QMX_SYSTEM *SD, WORD BusAddress, WORD N, WORD *Data);
QMX_EXT QMX_API int __stdcall QMX_PutFlash(QMX_SYSTEM *SD, QMX_AVR_FLASH *fi);  // internal flash of controller's AVR
QMX_EXT QMX_API int __stdcall QMX_GetFlash(QMX_SYSTEM *SD, QMX_AVR_FLASH *fi);  // internal flash of controller's AVR

// address in bytes offset
QMX_EXT QMX_API int __stdcall QMX_PutI2C(QMX_SYSTEM *SD, BYTE Slot, WORD Address, WORD N, BYTE *Buffer, BOOL WriteEnable); // modules EEPROM; ON LOADED fpga ONLY
QMX_EXT QMX_API int __stdcall QMX_GetI2C(QMX_SYSTEM *SD, BYTE Slot, WORD Address, WORD N, BYTE *Buffer); // modules EEPROM;  ON LOADED fpga ONLY

QMX_EXT QMX_API int __stdcall QMX_LoadMasterFPGA(QMX_SYSTEM *SD, char *FileName);
QMX_EXT QMX_API int __stdcall QMX_LoadFPGA(QMX_SYSTEM *SD, char *FileName);
QMX_EXT QMX_API int __stdcall QMX_ResetReadPipe(QMX_SYSTEM *SD);
QMX_EXT QMX_API int __stdcall QMX_ResetWritePipe(QMX_SYSTEM *SD);
QMX_EXT QMX_API int __stdcall QMX_GetOsVer(void);
QMX_EXT QMX_API int QMX_ServerSync(QMX_SYSTEM *SD, HANDLE Event);
QMX_EXT QMX_API int __stdcall QMX_Units2StrF(QMX_CC_F *cc);
QMX_EXT QMX_API int __stdcall QMX_Units2StrD(QMX_CC_D *cc);
QMX_EXT QMX_API int __stdcall QMX_TtfPathFromRegistry(QMX_SYSTEM *SD, char *path, DWORD path_len);

// описание структур ===========================================================
// структура системной области пользовательского ППЗУ
#pragma pack(push)
#pragma pack(1)
// заголовок флэш памяти модуля 
struct QMX_MOD_FLASH {
 BYTE Name[9];			// Имя модуля
 BYTE Revision;			// Ревизия модуля
 BYTE SerialNumber[9];          // Серийный номер модуля
 BYTE FPGA;			// ToDo: а если DSP?
 BYTE RAMSize;	 		// Размер ОЗУ на борту (показатель степени 2) ToDo: слова или байты?
 BYTE Direction;		// Направление скоростной передачи данных (в ПК или из ПК). MOD_TYPE_INPUT || MOD_TYPE_OUTPUT

 WORD Type;
 BYTE FlashSize; 		// 2^n
 WORD ExtentionLen;
 BYTE Reserved[3];
 WORD CRC;			// include mod extention
};				// len: 32 bytes

// дескриптор модуля
struct QMX_MODULE {
 QMX_MOD_FLASH 	  FlashHdr;	   // Системная область FLASH
 WORD		  Address;	   // Базовый адрес
 WORD		  AddressRange;	   // Протяженность адресного пространства ToDo: слова или байты?
 WORD		  InterruptVector; // Вектор прерывания

 double		  InputOutputRate; // Частота сбора/выдачи данных (в кГц)
 DWORD		  LocalBufferSize; // Размер половины локального буфера (в словах c учетом метки модуля)
 BYTE		  DMAnumber;	   // Порядковый номер модуля при опросе

 BYTE		  On_Off;	   // Флаг работы модуля. QMX_ON || QMX_OFF
 BYTE		  ChannelsN;	   // Кол-во каналов модуля, попадающих в поток данных
};

// дескриптор крейт контроллера
struct QMX_CCTL {
 HANDLE		  DevHandle;	   // Хэндл драйвера (действителен только в процессе, открывшем драйвер. для остальных исп. GDevHandle[QMX_CCTL->VirtualSlot]
 WORD		  VirtualSlot;	   // Виртуальный слот открытой системы
 CHAR		  Name[10];        // Название контроллера
 CHAR		  BIOSversion[5];  // Версия БИОСа контроллера
 CHAR		  SerialNumber[9]; // Серийный номер контроллера
};

// дескриптор циклического буфера
struct QMX_CIRC_BUF {
 volatile HANDLE Reserved;			// хэндл объекта filemapping (в адресном пространстве сервера)
 volatile DWORD Length;				// максимальный размер буфера в словах (=размеру filemapping / 2)
 volatile SHORT *Data_first;			// указатель на первое слово буфера (для сервера)
 volatile SHORT *Data_last;			// указатель на последнее фактическое слово буфера (для сервера)
 volatile DWORD T_length;			// размер буфера в мс
 volatile DWORD S_length;			// размер буфера в словах
 volatile DWORD Writed;				// беззнаковый счетчик записанных слов (изменяет сервер ввода)
 volatile DWORD Readed;				// беззнаковый счетчик прочитанных слов (изменяет сервер вывода)
 volatile DWORD WritePtr;			// счетчик [0..S_length-1] записанных слов (изменяет сервер ввода)
 volatile DWORD ReadPtr;			// счетчик [0..S_length-1] прочитанных слов (изменяет сервер вывода)
 volatile SHORT *Writed_ptr;			// указатель на последнее записаное слово (в адресном пространстве сервера)
 volatile SHORT *Readed_ptr;			// указатель на последнее считаное слово (в адресном пространстве сервера)
 volatile HANDLE SyncEvent;			// сигнал о заполнении очередной порции буфера
};


// в помощь при разборе сырых данных
#define QMX_PARSER_MODE_SLOT_TAG	0
#define QMX_PARSER_MODE_SLOT_DATA	1
#define QMX_PARSER_MODE_FLOW_ERROR	2

struct QMX_PARSER_PARAMS {
 BYTE CurSlot;
 BYTE CurMode;
 SHORT *ParsePtr;
 DWORD DataToParse;
 DWORD SlotDataToParse;
};

// дескриптор системы (лежит целиком в разделяемой памяти)
struct QMX_SYSTEM {
 BYTE 		  UsbSpeed;	   // Текущая скорость USB
 BYTE 		  ModulesQuantity; // Количество модулей в системе
 QMX_CCTL 	  Controller;	   // Структура, описывающая крейт-контроллер
 QMX_MODULE	  QM_Module[8];    // Структуры, описывающие модули
 DWORD  	  ReadFileSize;	   // Размер ридфайла в СЛОВАХ
 DWORD  	  WriteFileSize;   // Размер райтфайла в СЛОВАХ
 DWORD  	  DMAinputSize;	   // Размер запроса DMA при приеме данных ToDo: слова или байты?
 DWORD  	  DMAoutputSize;   // Размер запроса DMA при выдаче данных ToDo: слова или байты?
 WORD   	  RespTime;	   // Рассчетное время реакции в мс
 WORD   	  InOutState;	   // Текущее состояние (активность ввода/вывода);
 HANDLE		  SdFileMapping;   // Объект FileMapping созданный для хранения дескриптора QMX_SYSTEM
 BYTE		  IsRun;	   // QMX_ON - был старт; QMX_OFF - был стоп
 HANDLE		  SyncMutex;	   // Объект синхронизации
// Для работы с серверами:
 BYTE		  ServerStatus;    // Статус сервера (код ошибки)
 DWORD		  HostProcessId;   // PID процесса открывшего систему
 DWORD		  ServerProcessId; // PID процесса сервера
 HANDLE		  PrepareEvent;	   // Генерируется в конце QMX_Prepare в случае ее успешного завершения
 HANDLE		  StartEvent;	   // Генерируется в начале QMX_Start в случае ее успешного завершения
 HANDLE		  StopEvent;	   // Генерируется в конце QMX_Stop в случае ее успешного завершения
 HANDLE		  CloseEvent;	   // Генерируется в конце QMX_Close в случае ее успешного завершения
 HANDLE		  ReadyEvent;	   // Генерируется сервером как подтверждение Prepare, Start, Stop
 HANDLE 	  StoreFile;	   // Хэндл файла по которому сервер должен записывать данные (в простр. сервера)

 QMX_CIRC_BUF 	  InBuf[8];	   // Циклические входные буфера для каждого слота
 QMX_CIRC_BUF 	  OutBuf[8];	   // Циклические выходные буфера для каждого слота (8шт на будущее)

 int (* QMX_PrepareCB)(HANDLE SD, QMX_CONFIG *Config);
 int (* QMX_CloseCB)(HANDLE SD);
 int (* QMX_StartCB)(HANDLE SD);
 int (* QMX_StopCB)(HANDLE SD);

 QMX_PARSER_PARAMS ParserParams;
};

//
struct QMX_AVR_FLASH {
 BYTE FlashBytes[256];
};
#pragma pack(pop)

// Управляющие коды для DeviceIoControl ========================================
#define IOCTL_GET_CONFIG        CTL_CODE (FILE_DEVICE_UNKNOWN,0x800,METHOD_BUFFERED,FILE_ANY_ACCESS)
#define DIOC_START              CTL_CODE (FILE_DEVICE_UNKNOWN,0x1,METHOD_OUT_DIRECT,FILE_ANY_ACCESS)
#define DIOC_STOP               CTL_CODE (FILE_DEVICE_UNKNOWN,0x2,METHOD_OUT_DIRECT,FILE_ANY_ACCESS)
#define DIOC_LOAD_BIOS_USB      CTL_CODE (FILE_DEVICE_UNKNOWN,0x3,METHOD_OUT_DIRECT,FILE_ANY_ACCESS)
#define DIOC_SEND_COMMAND       CTL_CODE (FILE_DEVICE_UNKNOWN,0x4,METHOD_OUT_DIRECT,FILE_ANY_ACCESS)
#define DIOC_RESET_PIPE1        CTL_CODE (FILE_DEVICE_UNKNOWN,0x5,METHOD_OUT_DIRECT,FILE_ANY_ACCESS)
#define DIOC_RESET_PIPE3        CTL_CODE (FILE_DEVICE_UNKNOWN,0x6,METHOD_OUT_DIRECT,FILE_ANY_ACCESS)

// Номера доступных пользовательских запросов для USB (vendor request) =========
enum {  V_RESET_DSP,
        V_PUT_ARRAY,
        V_GET_ARRAY,
        V_START_READ,
        V_START_WRITE,
        V_COMMAND_IRQ,
        V_GET_USB_SPEED,
	V_GET_MODULE_NAME = 11,
	V_GET_MODULE_SERIAL_NUMBER = 13
};


// Команды, подаваемые с ПК по вендору V_COMMAND_IRQ ===========================
#define CMD_START_LOAD_MASTER_FPGA	0x0000
#define CMD_STOP_LOAD_FPGA	     	0x0002
#define CMD_RESET_WHOLE_SYSTEM		0x0004
#define CMD_SET_IAO			0x0005
#define CMD_START_STOP      		0x0006
#define CMD_SYNC_TYPE      		0x0007 // (0 manual, 1 external)

//==============================================================================
#define MAX_USB_BLOCK           4096            // максимальное кол-во байт для передачи по ContolPipe
#define I2C_BASE                0xA400          // базовый адрес для обращения в I2C флэшки до инициализации
#define I2C_BASE_USER           0xA600          // базовый адрес для обращения в I2C флэшки после инициализации

#define	MCLK			36000000.0
#define	MAX_MODULES	        8
#define	MAX_FILE_SIZE		(1024*1024)
#define	MAX_SYSTEM_SPEED_2_0	10000.0		// kSamples for usb 2.0
#define	MAX_SYSTEM_SPEED_1_1	500.0		// kSamples for usb 1.1
#define	MAX_DMA_SIZE		0x20000

#define SETBIT(ADDRESS,BIT) (ADDRESS |= (1<<BIT))
#define CLEARBIT(ADDRESS,BIT) (ADDRESS &= ~(1<<BIT))

#define MOD_TYPE_INPUT	        0
#define MOD_TYPE_OUTPUT         1


// Пространства при обращении из ПК ============================================
#define FLASH_TARGET		0x0000		// Обращение к Флэши
#define FPGA_TARGET		0x0001		// Запись в ФПГА
#define BUS_TARGET		0x0002		// Обращение к шине QMbus
#define CNTR_REGS_TARGET	0x0003		// Чтение статусных регистров
#define IR_STATUS_TARGET	0x0004		// Чтение состояния IR (при инициализации)
#define I2C_TARGET	        0x0005		// Обращение по I2C
#define DMA_ORDER_TARGET        0x0006		// Запись в регистры автомата DMA
#define START_STOP_TARGET       0x0007		// Запуск/останов модулей
#define DMA_SIZE_TARGET		0x0008		// Прописывание размеров DMA

// Адреса регистров, общих для всех модулей серии QM
#define DMA_STROBE_ADDR		0x0000		// Обращение к локальному буферу по ДМА
#define LOC_BUF_LEN_LSB_ADDR	0x0001		// Младшее слово длины локального буфера
#define LOC_BUF_LEN_MSB_ADDR	0x0002		// Старшее слово длины локального буфера
#define START_ADDR		0x0003		// Регистр запуска/останова модуля / write 1 - start; 0 -stop
#define MARKER_ADDR		0x0004		// Регистр маркера локального буфера
#define FLASH_ENA_ADDR		0x0005		// Обращение к Флэши
#define START_LOAD_ADDR		0x0006		// Флаг первоначального заполнения буфера вывода
#define IO_RATE_ADDR		0x0007		// mod rate = 36MHz/(IO_RATE+1) (min speed is 600Hz)
#define START_MODE_ADDR		0x0008		// Регистр режима запуска модуля (ToDo: для всех один адрес???)

// Адреса регистров QM14
#define	QM14_TEST_TYPE_ADDR	0x1e		// Выбор вида тестовой последовательности

// Адреса регистров QMS10
#define	QMS10_ADC_MODE_ADDR	0x10		// Адрес канала АЦП для асинхронного чтения
#define	QMS10_ADC_DATA_ADDR	0x11		// Запись - асинхронный старт АЦП. Чтение - чтение данных АЦП.
#define	QMS10_DAC_DATA_ADDR	0x12		// Запись слова ЦАП
#define	QMS10_TABLE_LEN_ADDR	0x13		// Запись длины таблицы опроса
#define	QMS10_TABLE_DATA_ADDR	0x14		// Запись содержимого таблицы опроса.


// Адреса регистров QMS15
#define	QMS15_ADC_MODE_ADDR	0x10		// Адрес канала АЦП для асинхронного чтения
#define	QMS15_ADC_DATA_ADDR	0x11		// Запись - асинхронный старт АЦП. Чтение - чтение данных АЦП.
#define	QMS15_TABLE_LEN_ADDR	0x13		// Запись длины таблицы опроса
#define	QMS15_TABLE_DATA_ADDR	0x14		// Запись содержимого таблицы опроса.



// Адреса регистров QMS17
#define	QMS17_ADC_MODE_ADDR	0x10		// Адрес канала АЦП для асинхронного чтения
#define	QMS17_ADC_DATA_ADDR	0x11		// Запись - асинхронный старт АЦП. Чтение - чтение данных АЦП.
#define	QMS17_TABLE_LEN_ADDR	0x13		// Запись длины таблицы опроса
#define	QMS17_TABLE_DATA_ADDR	0x14		// Запись содержимого таблицы опроса.
#define	QMS17_DIAP_RELEY_ADDR	0x15		// Переключение диапазона с помощью реле



// Адреса регистров QMS45
#define QMS45_DAC_DATA_ADDR	0x10		// Данные в ЦАП
#define QMS45_DAC_CHANNEL_ADDR	0x11		// Номер канала ЦАП
#define QMS45_DAC_MODE_ADDR	0x12		// Режим синхр/асинх
#define QMS45_DAC_ENABLE_ADDR	0x13		// Вкл/выкл питания


// Адреса регистров QMS50
#define	QMS50_STROBE_SEL_ADDR	0x15		// Выбор источника стробов (0 - внешний строб)
#define	QMS50_IO_DIR		0x16		// Направление линий (1 - линия выходная)
#define	QMS50_IO_STATE		0x17		// Состояние линий (1 - линия в 1)


// Адреса регистров QMS75
#define	QMS75_SET_RELAYS_ADDR	0x17		// Установка реле


// Адреса регистров QMS80
#define	QMS80_DAC_DATA_ADDR	0x0A		// Данные для ЦАП
#define	QMS80_DAC_ADDR_ADDR	0x0B		// Адрес ЦАП
#define	QMS80_WIRE_CH_ADDR	0x0C		// Адрес канала опроса проводов
#define	QMS80_ADC_MODE_ADDR	0x10		// Адрес канала АЦП для асинхронного чтения
#define	QMS80_ADC_DATA_ADDR	0x11		// Запись - асинхронный старт АЦП. Чтение - чтение данных АЦП.
#define	QMS80_TABLE_LEN_ADDR	0x13		// Запись длины таблицы опроса
#define	QMS80_TABLE_DATA_ADDR	0x14		// Запись содержимого таблицы опроса.


// Адреса регистров QMS85
#define	QMS85_DAC_ADDR_ADDR	0x0A		// Адрес ЦАП
#define	QMS85_DAC_DATA_ADDR	0x0B		// Данные для ЦАП
#define	QMS85_AD8556_ADDR	0x0C		// Адрес усилителя AD8556
#define	QMS85_CHANNEL_MASK_ADDR	0x0D		// Адрес маски каналов
#define	QMS85_FILTR_LENGTH_ADDR	0x0E		// Адрес маски каналов
#define	QMS85_ADC_MODE_ADDR	0x10		// Адрес канала АЦП для асинхронного чтения
#define	QMS85_ADC_DATA_ADDR	0x11		// Запись - асинхронный старт АЦП. Чтение - чтение данных АЦП.
#define	QMS85_TABLE_LEN_ADDR	0x13		// Запись длины таблицы опроса
#define	QMS85_TABLE_DATA_ADDR	0x14		// Запись содержимого таблицы опроса.


// Адреса регистров QMS90
#define	QMS90_OUTPUT_EN_ADDR		0x10		// Выбор источника стробов (0 - внешний строб)
#define	QMS90_IO_READ_LATCH_ADDR	0x11		// Направление линий (1 - линия выходная)
#define	QMS90_IO_STATE_ADDR		0x12		// Состояние линий (1 - линия в 1)


// Номера контрольных регистров в АВР ==========================================
#define INTERRUPT_VECTOR	0		//
#define FPGA_STATUS_BYTE	1		//
#define DMA_STATUS_BYTE	        2		//

// Системные ошибки ============================================================
#define QMXE_INTERNAL_ERR			0x8000		// Признак системной ошибки
#define QMXE_VENDOR_GET_USB_SPEED       	(QMXE_INTERNAL_ERR|1L)
#define QMXE_VENDOR_GET_CRATE_NAME      	(QMXE_INTERNAL_ERR|2L)
#define QMXE_VENDOR_GET_CRATE_SN       		(QMXE_INTERNAL_ERR|3L)
#define QMXE_INVALID_HANDLE_VALUE       	(QMXE_INTERNAL_ERR|4L)
#define QMXE_VENDOR_SEND_CMD            	(QMXE_INTERNAL_ERR|5L)
#define QMXE_RESET_MASTER_FPGA          	(QMXE_INTERNAL_ERR|6L)
#define QMXE_VENDOR_PUT_ARRAY           	(QMXE_INTERNAL_ERR|7L)
#define QMXE_VENDOR_GET_ARRAY           	(QMXE_INTERNAL_ERR|8L)
#define QMXE_PUT_FLASH                  	(QMXE_INTERNAL_ERR|9L)
#define QMXE_GET_FLASH                  	(QMXE_INTERNAL_ERR|10L)
#define QMXE_SYSTEM_RESET               	(QMXE_INTERNAL_ERR|11L)
#define QMXE_GET_IR                     	(QMXE_INTERNAL_ERR|12L)
#define QMXE_SET_IAO                    	(QMXE_INTERNAL_ERR|13L)
#define QMXE_MAX_MODULES_REACHED        	(QMXE_INTERNAL_ERR|14L)
#define QMXE_FPGA_STATUS_BYTE_READ      	(QMXE_INTERNAL_ERR|15L)
#define QMXE_FPGA_CONFIGURATION         	(QMXE_INTERNAL_ERR|16L)
#define QMXE_READ_I2C_FLASH             	(QMXE_INTERNAL_ERR|17L)
#define QMXE_WRITE_BASE_ADDRESS         	(QMXE_INTERNAL_ERR|18L)
#define QMXE_GET_ADDRESS_SPACE_CODE     	(QMXE_INTERNAL_ERR|19L)
#define QMXE_SET_BASE_ADDRESS           	(QMXE_INTERNAL_ERR|20L)
#define QMXE_PUT_QM_BUS                 	(QMXE_INTERNAL_ERR|21L)
#define QMXE_GET_QM_BUS                 	(QMXE_INTERNAL_ERR|22L)
#define QMXE_INSUFFICIENT_ADDRESS_SPACE 	(QMXE_INTERNAL_ERR|23L)
#define QMXE_VENDOR_RESET_RD_PIPE       	(QMXE_INTERNAL_ERR|24L)
#define QMXE_VENDOR_RESET_WR_PIPE       	(QMXE_INTERNAL_ERR|25L)
#define QMXE_WRITE_INT_VECTOR           	(QMXE_INTERNAL_ERR|26L)

// Для работы с калибровочными коэффициентами ==================================
#define QMX_BUILD_UNIT_CODE(ORDER, UNITS)	((ORDER<<5)|(UNITS&0x1F))
#define QMX_ORDER_PICO				0
#define QMX_ORDER_NANO				1
#define QMX_ORDER_MICRO				2
#define QMX_ORDER_MILLI				3
#define QMX_ORDER_NO				4
#define QMX_ORDER_KILO				5
#define QMX_ORDER_MEGA				6
#define QMX_ORDER_GIGA				7

#define QMX_UNITS_V				0
#define QMX_UNITS_A				1
#define QMX_UNITS_OHM				2
#define QMX_UNITS_UNKMOWN			15

// Заготовки для формирования строки с ед. измерения по кодам получаемым от QMX_BUILD_UNIT_CODE
static char *QMX_ORDERS[8]={"p","n","u","m","","k","M","G"};
static char *QMX_UNITS[32]={"V", "A", "Ohm","","","","","","","","","","","","","","","","","","","","","","","","","","","","",""};
#endif
