myvtm/DevAdapter/self/dep/libGPIOLoader/libGPIOLoader.cpp

#include "stdafx.h"
#include <Windows.h>
#include < stdio.h >
#include "libGPIOLoader.h"



typedef ErrorCodeEnum(*DevAdaptObjCreateFunc)(DeviceBaseClass*& baseObj);
typedef ErrorCodeEnum(*DevAdaptObjReleaseFunc)(DeviceBaseClass*& pBaseObj);

HINSTANCE hinstLib = NULL;

DevAdaptObjCreateFunc pFuncCreateAdapt = NULL;
DevAdaptObjReleaseFunc pFuncReleaseAdapt = NULL;
GpioClass* pDevAdapterInstance = NULL;

struct DevErrorInfo errInfoInstance;

void SetLastErrInfo(const char* formatStr, ...)
{
	va_list arg;
	va_start(arg, formatStr);
	sprintf_s(errInfoInstance.szErrMsg, MAX_DEV_ERROR_MSG_LEN, formatStr, arg);
	errInfoInstance.dwErrMsgLen = strlen(errInfoInstance.szErrMsg);
	va_end(arg);
}

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_LoadDevObject(const char* libraryPath)
{
	ErrorCodeEnum erroCode;
	hinstLib = LoadLibraryA(libraryPath);
	if (hinstLib != NULL) {
		pFuncCreateAdapt = (DevAdaptObjCreateFunc)GetProcAddress(hinstLib, "CreateDevComponent");
		if (NULL == pFuncCreateAdapt) {
			FreeLibrary(hinstLib);
			pFuncCreateAdapt = NULL;
			pFuncReleaseAdapt = NULL;
			return Error_MisMatched;
		}
		pFuncReleaseAdapt = (DevAdaptObjReleaseFunc)GetProcAddress(hinstLib, "ReleaseDevComponent");
		if (NULL == pFuncCreateAdapt) {
			FreeLibrary(hinstLib);
			pFuncCreateAdapt = NULL;
			pFuncReleaseAdapt = NULL;
			return Error_NotIntegrated;
		}
		erroCode = pFuncCreateAdapt((DeviceBaseClass*&)pDevAdapterInstance);
		if (erroCode != Error_Succeed) {
			pDevAdapterInstance = NULL;
			FreeLibrary(hinstLib);
			pFuncCreateAdapt = NULL;
			pFuncReleaseAdapt = NULL;
			return Error_NoTarget;
		}
		if (pDevAdapterInstance == NULL) {
			FreeLibrary(hinstLib);
			pFuncCreateAdapt = NULL;
			pFuncReleaseAdapt = NULL;
			return Error_Null;
		}

	} else {
		SetLastErrInfo("load library failed %d", GetLastError());
		return Error_DevLoadFileFailed;
	}
	return Error_Succeed;
}

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_ReleaseDevObject()
{
	if (pFuncReleaseAdapt != NULL && pDevAdapterInstance != NULL) {
		DeviceBaseClass* devBasePtr = static_cast<DeviceBaseClass*>(pDevAdapterInstance);
		pFuncReleaseAdapt(devBasePtr);
		pDevAdapterInstance = NULL;
	}
	if (hinstLib != NULL) {
		FreeLibrary(hinstLib);
		hinstLib = NULL;
	}
	return Error_Succeed;
}

//////////////////////////////////////////////////////////////////////////

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_GetDevCategory(DevCategoryInfo* pDevCategory)
{
	ErrorCodeEnum result;
	if (pDevAdapterInstance == NULL) {
		return Error_NotInit;
	}

	DevCategoryInfo inner;
	memset(inner.szType, 0, sizeof(char) * MAX_DEV_TYPE_LEN);
	memset(inner.szModel, 0, sizeof(char) * MAX_DEV_MODEL_LEN);
	memset(inner.szVendor, 0, sizeof(char) * MAX_DEV_VENDOR_LEN);

	result = pDevAdapterInstance->GetDevCategory(inner);
	if (result == Error_Succeed) {

		memset(pDevCategory->szType, 0, sizeof(char) * MAX_DEV_TYPE_LEN);
		memset(pDevCategory->szModel, 0, sizeof(char) * MAX_DEV_MODEL_LEN);
		memset(pDevCategory->szVendor, 0, sizeof(char) * MAX_DEV_VENDOR_LEN);

		strncpy_s(pDevCategory->szType, MAX_DEV_TYPE_LEN, inner.szType, strlen(inner.szType) > MAX_DEV_TYPE_LEN - 1 ? MAX_DEV_TYPE_LEN - 1 : strlen(inner.szType));
		strncpy_s(pDevCategory->szModel, MAX_DEV_MODEL_LEN, inner.szModel, strlen(inner.szModel) > MAX_DEV_MODEL_LEN - 1 ? MAX_DEV_TYPE_LEN - 1 : strlen(inner.szModel));
		strncpy_s(pDevCategory->szVendor, MAX_DEV_VENDOR_LEN, inner.szVendor, strlen(inner.szVendor) > MAX_DEV_VENDOR_LEN - 1 ? MAX_DEV_TYPE_LEN - 1 : strlen(inner.szVendor));

		pDevCategory->eState = inner.eState;
		pDevCategory->version.wMajor = inner.version.wMajor;
		pDevCategory->version.wMinor = inner.version.wMinor;
		pDevCategory->version.wRevision = inner.version.wRevision;
		pDevCategory->version.wBuild = inner.version.wBuild;
	}
	return result;
}

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_Reset()
{
	if (pDevAdapterInstance == NULL) {
		return Error_NotInit;
	}
	return pDevAdapterInstance->Reset();
}

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_DevClose()
{
	if (pDevAdapterInstance == NULL) {
		return Error_NotInit;
	}
	return pDevAdapterInstance->DevClose();
}

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_GetLastErr(DevErrorInfo* pDevErrInfo)
{
	if (pDevAdapterInstance == NULL) {
		strcpy_s(pDevErrInfo->szErrMsg, MAX_DEV_ERROR_MSG_LEN, errInfoInstance.szErrMsg);
		pDevErrInfo->dwErrMsgLen = errInfoInstance.dwErrMsgLen;
		return Error_Succeed;
	}
	DevErrorInfo inner;
	ErrorCodeEnum result = pDevAdapterInstance->GetLastErr(inner);
	if (result == Error_Succeed) {
		memset(pDevErrInfo->szErrMsg, 0, sizeof(char) * MAX_DEV_ERROR_MSG_LEN);
		strncpy_s(pDevErrInfo->szErrMsg, MAX_DEV_ERROR_MSG_LEN, inner.szErrMsg, strlen(inner.szErrMsg) > MAX_DEV_ERROR_MSG_LEN - 1 ? MAX_DEV_ERROR_MSG_LEN - 1 : strlen(inner.szErrMsg));
		pDevErrInfo->dwErrMsgLen = inner.dwErrMsgLen;
	}
	return result;
}

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_DevOpen(Bridge_GpioInitParam initParam)
{
	if (pDevAdapterInstance == NULL) {
		return Error_NotInit;
	}
	GpioInitParam inner;
	inner.dwPort = initParam.dwPort;
	inner.dwBaudRate = initParam.dwBaudRate;
	inner.dwPortNum = initParam.dwPortNum;
	for (int i = 0; i < MAX_PORT_NUM; ++i) {
		inner.dir[i] = !!initParam.dir[i];
	}

	return pDevAdapterInstance->DevOpen(inner);
}

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_WritePort(DWORD dwPort, BYTE btData)
{
	if (pDevAdapterInstance == NULL) {
		return Error_NotInit;
	}
	return pDevAdapterInstance->WritePort(dwPort, btData);
}

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_ReadPort(DWORD dwPort, BYTE* btStatus)
{
	if (pDevAdapterInstance == NULL) {
		return Error_NotInit;
	}

	BYTE inner = *btStatus;
	ErrorCodeEnum result = pDevAdapterInstance->ReadPort(dwPort, inner);
	*btStatus = inner;
	return result;
}

//////////////////////////////////////////////////////////////////////////