Symbolnamen angepasst. Diverse andere Änderungen.

DemoSlave/.cproject

@@ -16,7 +16,7 @@
 				</extensions>
 			</storageModule>
 			<storageModule moduleId="cdtBuildSystem" version="4.0.0">
-				<configuration artifactExtension="out" artifactName="${ProjName}" buildProperties="" cleanCommand="${CG_CLEAN_CMD}" description="" id="com.ti.ccstudio.buildDefinitions.TMS470.Debug.1546360525" name="Debug" parent="com.ti.ccstudio.buildDefinitions.TMS470.Debug">
+				<configuration artifactExtension="out" artifactName="${ProjName}" buildProperties="" cleanCommand="${CG_CLEAN_CMD}" description="" id="com.ti.ccstudio.buildDefinitions.TMS470.Debug.1546360525" name="Debug" parent="com.ti.ccstudio.buildDefinitions.TMS470.Debug" postbuildStep="@${PWD}\..\distribute.bat Debug;">
 					<folderInfo id="com.ti.ccstudio.buildDefinitions.TMS470.Debug.1546360525." name="/" resourcePath="">
 						<toolChain id="com.ti.ccstudio.buildDefinitions.TMS470_18.1.exe.DebugToolchain.1208027939" name="TI Build Tools" superClass="com.ti.ccstudio.buildDefinitions.TMS470_18.1.exe.DebugToolchain" targetTool="com.ti.ccstudio.buildDefinitions.TMS470_18.1.exe.linkerDebug.1030918387">
 							<option id="com.ti.ccstudio.buildDefinitions.core.OPT_TAGS.1379166674" superClass="com.ti.ccstudio.buildDefinitions.core.OPT_TAGS" valueType="stringList">
@@ -90,6 +90,18 @@
 							<tool id="com.ti.ccstudio.buildDefinitions.TMS470_18.1.hex.1558575738" name="ARM Hex Utility" superClass="com.ti.ccstudio.buildDefinitions.TMS470_18.1.hex"/>
 						</toolChain>
 					</folderInfo>
+					<fileInfo id="com.ti.ccstudio.buildDefinitions.TMS470.Debug.1546360525.1537504561" name="distribute.bat" rcbsApplicability="disable" resourcePath="distribute.bat" toolsToInvoke=""/>
+					<fileInfo id="com.ti.ccstudio.buildDefinitions.TMS470.Debug.1546360525.639681177" name="demoexcl.txt" rcbsApplicability="disable" resourcePath="distribute.excl" toolsToInvoke="">
+						<tool customBuildStep="true" id="org.eclipse.cdt.managedbuilder.ui.rcbs.1575727032" name="Resource Custom Build Step">
+							<inputType id="org.eclipse.cdt.managedbuilder.ui.rcbs.inputtype.1127406180" name="Resource Custom Build Step Input Type">
+								<additionalInput kind="additionalinputdependency" paths=""/>
+							</inputType>
+							<outputType id="org.eclipse.cdt.managedbuilder.ui.rcbs.outputtype.764801743" name="Resource Custom Build Step Output Type"/>
+						</tool>
+					</fileInfo>
+					<sourceEntries>
+						<entry excluding="distribute.excl|distribute.bat" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
+					</sourceEntries>
 				</configuration>
 			</storageModule>
 			<storageModule moduleId="org.eclipse.cdt.core.externalSettings"/>
@@ -179,4 +191,12 @@
 	</storageModule>
 	<storageModule moduleId="scannerConfiguration"/>
 	<storageModule moduleId="org.eclipse.cdt.make.core.buildtargets"/>
+	<storageModule moduleId="refreshScope" versionNumber="2">
+		<configuration configurationName="Debug">
+			<resource resourceType="PROJECT" workspacePath="/DemoSlave"/>
+		</configuration>
+		<configuration configurationName="Release">
+			<resource resourceType="PROJECT" workspacePath="/DemoSlave"/>
+		</configuration>
+	</storageModule>
 </cproject>

DemoSlave/distribute.bat

@@ -0,0 +1,34 @@
+@echo off
+set PRJDIR=%~dp0
+set CONFIG=%1
+set LIBMAJOR=1
+set LIBMINOR=0
+set LIBBASENAME=gfambrtuslv
+set GFALIBS=%GfATivaLibsRoot%
+set LIBNAME=%LIBBASENAME%.%LIBMAJOR%.%LIBMINOR%
+
+set DSTDIR=%GFALIBS%\%LIBNAME%\demo
+set LIBDIR=%GFALIBS%\%LIBNAME%\lib\ccs\%CONFIG%
+set INCDIR=%GFALIBS%\include
+set SRCDIR=%GFALIBS%\%LIBNAME%\src
+set OUTDIR=%PRJDIR%%CONFIG%
+
+mkdir "%DSTDIR%" 1>nul 2>&1
+xcopy "%PRJDIR%*.*" "%DSTDIR%" /S /I /H /R /Y /Q /EXCLUDE:%PRJDIR%distribute.excl
+
+rem copy /Y "%OUTDIR%\%LIBBASENAME%.lib" "%LIBDIR%"
+rem copy /Y "%PRJDIR%%LIBBASENAME%.h" "%INCDIR%"
+rem copy /Y "%PRJDIR%*.c" "%SRCDIR%"
+
+set PRJDIR=
+set CONFIG=
+set LIBMAJOR=
+set LIBMINOR=
+set LIBBASENAME=
+set LIBNAME=
+set GFALIBS=
+set INCDIR=
+set SRCDIR=
+set LIBDIR=
+set OUTDIR=
+set DSTDIR=

DemoSlave/distribute.excl

@@ -0,0 +1,4 @@
+.bat
+\Debug\
+.gitignore
+distribute.excl

DemoSlave/main.c

@@ -1,12 +1,10 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <stdarg.h>
 #include <stdint.h>
 #include <stdbool.h>
 #include <gfambrtuslv.h>
 #include "mbslvapp.h"
-#include "inc/tm4c1231e6pz.h"
 #include "driverlib/sysctl.h"
 
 /////////////////////////////////////////////////////////////////////////////
@@ -16,7 +14,7 @@
 
 /////////////////////////////////////////////////////////////////////////////
 // fake implementation for demo purposes
-// usually the time will be retrieved from a realtime clock
+// usually the date and time will be retrieved from a realtime clock
 
 static int32_t _GetRTCTDateTimeTZ(struct tm *ptm)
 {
@@ -31,7 +29,7 @@ static int32_t _GetRTCTDateTimeTZ(struct tm *ptm)
 	ptm->tm_hour	= 17;
 	ptm->tm_min		= 40;
 
-	return 2;
+	return 2; // return timezone
 }
 
 /////////////////////////////////////////////////////////////////////////////
@@ -41,11 +39,14 @@ int main(void)
 	struct tm utc;
 	int32_t nTzIndex;
 
+    /////////////////////////////////////////////////////////////////////////
+	// System initialization
+
 	SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN);
     GfaUtilsInit();
 
     /////////////////////////////////////////////////////////////////////////
-    // set Date, Time, Timezone
+    // set date, time and timezone
 
     if((nTzIndex = _GetRTCTDateTimeTZ(&utc)) < 0)
     	return 1;
@@ -54,6 +55,7 @@ int main(void)
     	return 1;
 
 	/////////////////////////////////////////////////////////////////////////
+	// start the modbus slave
 
 	if(!GfaInitModbusSlaveApp())
     	return 1;

DemoSlave/mbslvapp.c

@@ -68,10 +68,10 @@ static uint16_t _MapRegisterAddress(uint16_t nAddr)
 static void _PreReadRegisters(uint8_t func, uint16_t nRegStart, uint16_t nRegCount)
 {
 	float f1 = GfaBufGetUnaligned_float(&g_mbRegs[0]);
-	float f2 = GfaBufGetUnaligned_float(&g_mbRegs[1]);
+	float f2 = GfaBufGetUnaligned_float(&g_mbRegs[2]);
 
 	GfaBufSetUnaligned_float(&g_mbRegs[0], ++f1);
-	GfaBufSetUnaligned_float(&g_mbRegs[1], --f2);
+	GfaBufSetUnaligned_float(&g_mbRegs[2], --f2);
 }
 
 static void _PostReadRegisters(uint8_t func, uint16_t nRegStart, uint16_t nRegCount)
@@ -88,9 +88,9 @@ static void _PostWriteRegisters(uint8_t func, uint16_t nRegStart, uint16_t nRegC
 
 /////////////////////////////////////////////////////////////////////////////
 
-static void _InitUARTConfig(LPUART_CONFIG puc)
+static void _InitUARTConfig(LPGFA_UART_CONFIG puc)
 {
-	memset(puc, 0, sizeof(LPUART_CONFIG));
+	memset(puc, 0, sizeof(LPGFA_UART_CONFIG));
 
 	puc->P_UART_BASE		  = UART_BASE;
 	puc->P_UART_BASE_SYSCTL   = UART_BASE_SYSCTL;
@@ -119,18 +119,18 @@ static void _InitUARTConfig(LPUART_CONFIG puc)
 
 bool GfaInitModbusSlaveApp(void)
 {
-	UART_CONFIG uartParams;
+	GFA_UART_CONFIG uartParams;
 	g_hMbSlv = NULL;
 	_InitUARTConfig(&uartParams);
 
-	if(MB_UART_Init(&uartParams))
+	if(GfaMbUartInit(&uartParams))
 	{
 		GFA_MODBUS_RTU_SLAVE_PARAMETERS slvParams;
 		memset(&slvParams, 0, sizeof(slvParams));
 
 		slvParams.slaveID					= MODBUS_SLAVE_ID;
-		slvParams.hFifoRX					= MB_UART_GetRxFifo();
-		slvParams.hFifoTX					= MB_UART_GetTxFifo();
+		slvParams.hFifoRX					= GfaMbUartGetRxFifo();
+		slvParams.hFifoTX					= GfaMbUartGetTxFifo();
 
 		slvParams.regMap.pRegs				= g_mbRegs;
 		slvParams.regMap.nCountRegs 		= _countof(g_mbRegs);
@@ -146,7 +146,7 @@ bool GfaInitModbusSlaveApp(void)
 		slvParams.appItf.pfnPostTransmit	= NULL;
 
 		if(!(g_hMbSlv = GfaModbusRTUSlvCreate(&slvParams)))
-			MB_UART_Release();
+			GfaMbUartRelease();
 	}
 
 	return !!g_hMbSlv;

DemoSlave/mbslvapp.h

@@ -4,6 +4,7 @@
 #if !defined(AGD_MBAPP_H__45B5FF25_C1D8_4196_97EF_0101C487A999__INCLUDED_)
 #define AGD_MBAPP_H__45B5FF25_C1D8_4196_97EF_0101C487A999__INCLUDED_
 
+#include <stdbool.h>
 
 #ifdef __cplusplus
 extern "C" {

gfamodbusrtucom/fifo.c

@@ -18,7 +18,7 @@ typedef struct _FIFOHDR
 	size_t nCbSize;
 	size_t nBufferMask;
 	volatile uint32_t nFlags;
-	FIFO_BACKEND backend;
+	GFA_FIFO_BACKEND backend;
 }FIFOHDR, *LPFIFOHDR;
 typedef const FIFOHDR *LPCFIFOHDR;
 
@@ -46,7 +46,7 @@ static int _IsPowerOf2(size_t x)
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////
 
-HFIFO FifoCreate(int nFifoIndex, LPCFIFO_BACKEND pBackend)
+HFIFO GfaMbFifoCreate(int nFifoIndex, LPCGFA_FIFO_BACKEND pBackend)
 {
 	LPFIFO p;
 	if((nFifoIndex <  0) || (nFifoIndex >= FIFO_COUNT))
@@ -58,19 +58,19 @@ HFIFO FifoCreate(int nFifoIndex, LPCFIFO_BACKEND pBackend)
 	p->hdr.nCbSize		= FIFO_BUFFER_SIZE;
 	p->hdr.nBufferMask	= FIFO_BUFFER_MASK;
 
-	memcpy(&p->hdr.backend, pBackend, sizeof(FIFO_BACKEND));
+	memcpy(&p->hdr.backend, pBackend, sizeof(GFA_FIFO_BACKEND));
 	return (HFIFO)p;
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
-void FifoRelease(HFIFO hFifo)
+void GfaMbFifoRelease(HFIFO hFifo)
 {
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
-void FifoReset(HFIFO hFifo, bool bLock)
+void GfaMbFifoReset(HFIFO hFifo, bool bLock)
 {
 	bool bPrevLocked;
 	register LPFIFO pf = (LPFIFO)hFifo;
@@ -85,7 +85,7 @@ void FifoReset(HFIFO hFifo, bool bLock)
 
 /////////////////////////////////////////////////////////////////////////////
 
-size_t FifoRead(HFIFO hFifo, void *pData, size_t nCbData, bool bLock)
+size_t GfaMbFifoRead(HFIFO hFifo, void *pData, size_t nCbData, bool bLock)
 {
 	size_t nToRead;
 	uint8_t *pByte = (uint8_t*)pData;
@@ -110,7 +110,7 @@ size_t FifoRead(HFIFO hFifo, void *pData, size_t nCbData, bool bLock)
 
 /////////////////////////////////////////////////////////////////////////////
 
-size_t FifoWrite(HFIFO hFifo, const void *pData, size_t nCbData, bool bLock)
+size_t GfaMbFifoWrite(HFIFO hFifo, const void *pData, size_t nCbData, bool bLock)
 {
 	size_t nToWrite;
 	const uint8_t *pByte = (const uint8_t*)pData;
@@ -135,7 +135,7 @@ size_t FifoWrite(HFIFO hFifo, const void *pData, size_t nCbData, bool bLock)
 
 /////////////////////////////////////////////////////////////////////////////
 
-bool FifoPop(HFIFO hFifo, uint8_t *b, bool bLock)
+bool GfaMbFifoPop(HFIFO hFifo, uint8_t *b, bool bLock)
 {
 	bool bRet;
 	register LPFIFO pf = (LPFIFO)hFifo;
@@ -167,7 +167,7 @@ bool FifoPop(HFIFO hFifo, uint8_t *b, bool bLock)
 
 /////////////////////////////////////////////////////////////////////////////
 
-bool FifoPush(HFIFO hFifo, uint8_t b, bool bLock)
+bool GfaMbFifoPush(HFIFO hFifo, uint8_t b, bool bLock)
 {
 	bool bRet;
 	register LPFIFO pf = (LPFIFO)hFifo;
@@ -199,7 +199,7 @@ bool FifoPush(HFIFO hFifo, uint8_t b, bool bLock)
 
 /////////////////////////////////////////////////////////////////////////////
 
-size_t FifoPeek(HFIFO hFifo, bool bLock)
+size_t GfaMbFifoPeek(HFIFO hFifo, bool bLock)
 {
 	bool bPrevLocked;
 	size_t nAvail;
@@ -218,7 +218,7 @@ size_t FifoPeek(HFIFO hFifo, bool bLock)
 
 /////////////////////////////////////////////////////////////////////////////
 
-bool FifoCanWrite(HFIFO hFifo, bool bLock)
+bool GfaMbFifoCanWrite(HFIFO hFifo, bool bLock)
 {
 	bool bPrevLocked, bCanWrite;
 	register LPFIFO pf = (LPFIFO)hFifo;
@@ -236,7 +236,7 @@ bool FifoCanWrite(HFIFO hFifo, bool bLock)
 
 /////////////////////////////////////////////////////////////////////////////
 
-bool FifoEmpty(HFIFO hFifo, bool bLock)
+bool GfaMbFifoEmpty(HFIFO hFifo, bool bLock)
 {
 	bool bPrevLocked, bEmpty;
 	register LPFIFO pf = (LPFIFO)hFifo;
@@ -254,7 +254,7 @@ bool FifoEmpty(HFIFO hFifo, bool bLock)
 
 /////////////////////////////////////////////////////////////////////////////
 
-bool FifoRxPrepare(HFIFO hFifo, bool bLock)
+bool GfaMbFifoRxPrepare(HFIFO hFifo, bool bLock)
 {
 	bool bPrevLocked, bRet = false;
 	register LPFIFO pf = (LPFIFO)hFifo;
@@ -276,7 +276,7 @@ bool FifoRxPrepare(HFIFO hFifo, bool bLock)
 
 /////////////////////////////////////////////////////////////////////////////
 
-void FifoRxStart(HFIFO hFifo, bool bLock)
+void GfaMbFifoRxStart(HFIFO hFifo, bool bLock)
 {
 	bool bPrevLocked;
 	register LPFIFO pf = (LPFIFO)hFifo;
@@ -296,7 +296,7 @@ void FifoRxStart(HFIFO hFifo, bool bLock)
 
 /////////////////////////////////////////////////////////////////////////////
 
-bool FifoRxFinalize(HFIFO hFifo, bool bLock)
+bool GfaMbFifoRxFinalize(HFIFO hFifo, bool bLock)
 {
 	bool bPrevLocked, bRet = false;
 	register LPFIFO pf = (LPFIFO)hFifo;
@@ -318,7 +318,7 @@ bool FifoRxFinalize(HFIFO hFifo, bool bLock)
 
 /////////////////////////////////////////////////////////////////////////////
 
-bool FifoTxPrepare(HFIFO hFifo, bool bLock)
+bool GfaMbFifoTxPrepare(HFIFO hFifo, bool bLock)
 {
 	bool bPrevLocked, bRet = false;
 	register LPFIFO pf = (LPFIFO)hFifo;
@@ -340,7 +340,7 @@ bool FifoTxPrepare(HFIFO hFifo, bool bLock)
 
 /////////////////////////////////////////////////////////////////////////////
 
-void FifoTxStart(HFIFO hFifo, bool bLock)
+void GfaMbFifoTxStart(HFIFO hFifo, bool bLock)
 {
 	bool bPrevLocked;
 	register LPFIFO pf = (LPFIFO)hFifo;
@@ -360,7 +360,7 @@ void FifoTxStart(HFIFO hFifo, bool bLock)
 
 /////////////////////////////////////////////////////////////////////////////
 
-bool FifoTxFinalize(HFIFO hFifo, bool bLock)
+bool GfaMbFifoTxFinalize(HFIFO hFifo, bool bLock)
 {
 	bool bPrevLocked, bRet = false;
 	register LPFIFO pf = (LPFIFO)hFifo;
@@ -382,7 +382,7 @@ bool FifoTxFinalize(HFIFO hFifo, bool bLock)
 
 /////////////////////////////////////////////////////////////////////////////
 
-void FifoSetFlags(HFIFO hFifo, uint32_t nFlags, bool bLock)
+void GfaMbFifoSetFlags(HFIFO hFifo, uint32_t nFlags, bool bLock)
 {
 	bool bPrevLocked;
 	register LPFIFO pf = (LPFIFO)hFifo;
@@ -399,7 +399,7 @@ void FifoSetFlags(HFIFO hFifo, uint32_t nFlags, bool bLock)
 
 /////////////////////////////////////////////////////////////////////////////
 
-void FifoClearFlags(HFIFO hFifo, uint32_t nFlags, bool bLock)
+void GfaMbFifoClearFlags(HFIFO hFifo, uint32_t nFlags, bool bLock)
 {
 	bool bPrevLocked;
 	register LPFIFO pf = (LPFIFO)hFifo;
@@ -416,7 +416,7 @@ void FifoClearFlags(HFIFO hFifo, uint32_t nFlags, bool bLock)
 
 /////////////////////////////////////////////////////////////////////////////
 
-uint32_t FifoGetFlags(HFIFO hFifo, bool bLock)
+uint32_t GfaMbFifoGetFlags(HFIFO hFifo, bool bLock)
 {
 	uint32_t nFlags;
 	bool bPrevLocked;
@@ -433,7 +433,7 @@ uint32_t FifoGetFlags(HFIFO hFifo, bool bLock)
 		return pf->hdr.nFlags;
 }
 
-bool FifoMatchFlags(HFIFO hFifo, uint32_t nFlags, bool bLock)
+bool GfaMbFifoMatchFlags(HFIFO hFifo, uint32_t nFlags, bool bLock)
 {
 	bool bMatch;
 	bool bPrevLocked;
@@ -450,7 +450,7 @@ bool FifoMatchFlags(HFIFO hFifo, uint32_t nFlags, bool bLock)
 		return (pf->hdr.nFlags & nFlags) == nFlags;
 }
 
-uint16_t FifoCalcCRC(HFIFO hFifo, bool bLock)
+uint16_t GfaMbFifoCalcCRC(HFIFO hFifo, bool bLock)
 {
 	bool bPrevLocked = false;
 	register LPFIFO pf = (LPFIFO)hFifo;

gfamodbusrtucom/gfambrtucom.h

@@ -94,7 +94,6 @@ extern "C" {
 
 #define MODBUS_BROADCAST_ADDRESS						0
 #define MODBUS_MAX_SLAVE_ID								247
-
 #define MODBUS_MAX_READ_BITS							2000
 #define MODBUS_MAX_WRITE_BITS							1968
 #define MODBUS_MAX_READ_REGISTERS						125
@@ -128,69 +127,69 @@ typedef const MODBUS_RTU_ADU *LPCMODBUS_RTU_ADU;
 // Fifo
 
 typedef void									*HFIFO;
-typedef bool (*PFN_INT_ENABLE)(bool);
-typedef bool (*PFN_RX_PREPARE)(void);
-typedef void (*PFN_RX_START)(void);
-typedef bool (*PFN_RX_FINALIZE)(void);
-typedef bool (*PFN_TX_PREPARE)(void);
-typedef void (*PFN_TX_START)(void);
-typedef bool (*PFN_TX_FINALIZE)(void);
+typedef bool (*PFN_GFA_INT_ENABLE)(bool);
+typedef bool (*PFN_GFA_RX_PREPARE)(void);
+typedef void (*PFN_GFA_RX_START)(void);
+typedef bool (*PFN_GFA_RX_FINALIZE)(void);
+typedef bool (*PFN_GFA_TX_PREPARE)(void);
+typedef void (*PFN_GFA_TX_START)(void);
+typedef bool (*PFN_GFA_TX_FINALIZE)(void);
 
 /////////////////////////////////////////////////////////////////////////////
 
-typedef struct _FIFO_BACKEND
+typedef struct _GFA_FIFO_BACKEND
 {
-	PFN_INT_ENABLE	pfnLockBackend;
-	PFN_RX_PREPARE	pfnRxPrepare;
-	PFN_RX_START	pfnRxStart;
-	PFN_RX_FINALIZE	pfnRxFinalize;
-	PFN_TX_PREPARE	pfnTxPrepare;
-	PFN_TX_START	pfnTxStart;
-	PFN_TX_FINALIZE	pfnTxFinalize;
-}FIFO_BACKEND, *LPFIFO_BACKEND;
-typedef const FIFO_BACKEND *LPCFIFO_BACKEND;
+	PFN_GFA_INT_ENABLE	pfnLockBackend;
+	PFN_GFA_RX_PREPARE	pfnRxPrepare;
+	PFN_GFA_RX_START	pfnRxStart;
+	PFN_GFA_RX_FINALIZE	pfnRxFinalize;
+	PFN_GFA_TX_PREPARE	pfnTxPrepare;
+	PFN_GFA_TX_START	pfnTxStart;
+	PFN_GFA_TX_FINALIZE	pfnTxFinalize;
+}GFA_FIFO_BACKEND, *LPGFA_FIFO_BACKEND;
+typedef const GFA_FIFO_BACKEND *LPCGFA_FIFO_BACKEND;
 
 /////////////////////////////////////////////////////////////////////////////
 
-HFIFO		FifoCreate(int nFifoIndex, LPCFIFO_BACKEND pBackend);
-void		FifoRelease(HFIFO hFifo);
-void		FifoReset(HFIFO hFifo, bool bLock);
-size_t		FifoRead(HFIFO hFifo, void *pData, size_t nCbData, bool bLock);
-size_t		FifoWrite(HFIFO hFifo, const void *pData, size_t nCbData, bool bLock);
-bool		FifoPop(HFIFO hFifo, uint8_t *b, bool bLock);
-bool		FifoPush(HFIFO hFifo, uint8_t b, bool bLock);
-size_t		FifoPeek(HFIFO hFifo, bool bLock);
-bool		FifoCanWrite(HFIFO hFifo, bool bLock);
-bool		FifoEmpty(HFIFO hFifo, bool bLock);
-void		FifoSetFlags(HFIFO hFifo, uint32_t nFlags, bool bLock);
-void		FifoClearFlags(HFIFO hFifo, uint32_t nFlags, bool bLock);
-uint32_t	FifoGetFlags(HFIFO hFifo, bool bLock);
-bool		FifoMatchFlags(HFIFO hFifo, uint32_t nFlags, bool bLock);
-bool		FifoRxPrepare(HFIFO hFifo, bool bLock);
-void		FifoRxStart(HFIFO hFifo, bool bLock);
-bool		FifoRxFinalize(HFIFO hFifo, bool bLock);
-bool		FifoTxPrepare(HFIFO hFifo, bool bLock);
-void		FifoTxStart(HFIFO hFifo, bool bLock);
-bool		FifoTxFinalize(HFIFO hFifo, bool bLock);
-uint16_t	FifoCalcCRC(HFIFO hFifo, bool bLock);
+HFIFO		GfaMbFifoCreate(int nFifoIndex, LPCGFA_FIFO_BACKEND pBackend);
+void		GfaMbFifoRelease(HFIFO hFifo);
+void		GfaMbFifoReset(HFIFO hFifo, bool bLock);
+size_t		GfaMbFifoRead(HFIFO hFifo, void *pData, size_t nCbData, bool bLock);
+size_t		GfaMbFifoWrite(HFIFO hFifo, const void *pData, size_t nCbData, bool bLock);
+bool		GfaMbFifoPop(HFIFO hFifo, uint8_t *b, bool bLock);
+bool		GfaMbFifoPush(HFIFO hFifo, uint8_t b, bool bLock);
+size_t		GfaMbFifoPeek(HFIFO hFifo, bool bLock);
+bool		GfaMbFifoCanWrite(HFIFO hFifo, bool bLock);
+bool		GfaMbFifoEmpty(HFIFO hFifo, bool bLock);
+void		GfaMbFifoSetFlags(HFIFO hFifo, uint32_t nFlags, bool bLock);
+void		GfaMbFifoClearFlags(HFIFO hFifo, uint32_t nFlags, bool bLock);
+uint32_t	GfaMbFifoGetFlags(HFIFO hFifo, bool bLock);
+bool		GfaMbFifoMatchFlags(HFIFO hFifo, uint32_t nFlags, bool bLock);
+bool		GfaMbFifoRxPrepare(HFIFO hFifo, bool bLock);
+void		GfaMbFifoRxStart(HFIFO hFifo, bool bLock);
+bool		GfaMbFifoRxFinalize(HFIFO hFifo, bool bLock);
+bool		GfaMbFifoTxPrepare(HFIFO hFifo, bool bLock);
+void		GfaMbFifoTxStart(HFIFO hFifo, bool bLock);
+bool		GfaMbFifoTxFinalize(HFIFO hFifo, bool bLock);
+uint16_t	GfaMbFifoCalcCRC(HFIFO hFifo, bool bLock);
 
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////
 // UART
 
-typedef enum _UART_Parity
+typedef enum _GfA_UART_Parity
 {
 	P_None,
 	P_Even,
 	P_Odd,
 	P_Zero,
 	P_One
-}UART_Parity;
+}GfA_UART_Parity;
 
 /////////////////////////////////////////////////////////////////////////////
 
-typedef struct _UART_CONFIG
+typedef struct _GFA_UART_CONFIG
 {
 	uint32_t	P_UART_BASE;
 	uint32_t	P_UART_BASE_SYSCTL;
@@ -208,15 +207,15 @@ typedef struct _UART_CONFIG
 	uint32_t	nBaud;
 	int			nDatabits;
 	int			nStopbits;
-	UART_Parity	parity;
+	GfA_UART_Parity	parity;
 	int			nFifoIndexRx;
 	int			nFifoIndexTx;
-}UART_CONFIG, *LPUART_CONFIG;
-typedef const UART_CONFIG *LPCUART_CONFIG;
+}GFA_UART_CONFIG, *LPGFA_UART_CONFIG;
+typedef const GFA_UART_CONFIG *LPCGFA_UART_CONFIG;
 
 /////////////////////////////////////////////////////////////////////////////
 
-typedef struct _UART_STATUS_COUNTERS
+typedef struct _GFA_UART_STATUS_COUNTERS
 {
 	uint64_t nCharsReceived;
 	uint64_t nCharsTransmitted;
@@ -224,8 +223,8 @@ typedef struct _UART_STATUS_COUNTERS
 	uint32_t nBreakErrors;
 	uint32_t nParityErrors;
 	uint32_t nFramingErrors;
-}UART_STATUS_COUNTERS, *LPUART_STATUS_COUNTERS;
-typedef const UART_STATUS_COUNTERS *LPCUART_STATUS_COUNTERS;
+}GFA_UART_STATUS_COUNTERS, *LPGFA_UART_STATUS_COUNTERS;
+typedef const GFA_UART_STATUS_COUNTERS *LPCGFA_UART_STATUS_COUNTERS;
 
 /////////////////////////////////////////////////////////////////////////////
 
@@ -240,12 +239,12 @@ typedef const UART_STATUS_COUNTERS *LPCUART_STATUS_COUNTERS;
 
 /////////////////////////////////////////////////////////////////////////////
 
-bool	MB_UART_Init(LPCUART_CONFIG pCfg);
-void	MB_UART_Release(void);
-HFIFO	MB_UART_GetRxFifo(void);
-HFIFO	MB_UART_GetTxFifo(void);
-void	MB_UART_GetStatusCounters(LPUART_STATUS_COUNTERS pSc);
-void	MB_UART_ResetStatusCounters(void);
+bool	GfaMbUartInit(LPCGFA_UART_CONFIG pCfg);
+void	GfaMbUartRelease(void);
+HFIFO	GfaMbUartGetRxFifo(void);
+HFIFO	GfaMbUartGetTxFifo(void);
+void	GfaMbUartGetStatusCounters(LPGFA_UART_STATUS_COUNTERS pSc);
+void	GfaMbUartResetStatusCounters(void);
 
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

gfamodbusrtucom/mbuart.c

@@ -15,8 +15,8 @@
 static HFIFO					g_hFifoTX = NULL, g_hFifoRX = NULL;
 static volatile uint32_t		g_nTxEchoCount	= 0;
 static volatile uint64_t		g_nTimerTick	= 0;
-static UART_STATUS_COUNTERS		g_statCnt	= {0};
-static UART_CONFIG				g_uartCfg = {0};
+static GFA_UART_STATUS_COUNTERS	g_statCnt	= {0};
+static GFA_UART_CONFIG			g_uartCfg = {0};
 static uint64_t					g_MODBUS_RTU_FRAME_TIMEOUT_US = 0;
 static uint64_t					g_MODBUS_RTU_CHAR_TIMEOUT_US = 0;
 
@@ -87,7 +87,7 @@ static void _OnTxStart(void)
 {
 	uint8_t b;
 
-	if(!UARTBusy(UART_BASE) && FifoPop(g_hFifoTX, &b, false))
+	if(!UARTBusy(UART_BASE) && GfaMbFifoPop(g_hFifoTX, &b, false))
 	{
 		g_nTxEchoCount++;
 		GPIOPinWrite(EN_485_PORT, EN_485_PIN, EN_485_PIN); // enable the bus
@@ -106,15 +106,15 @@ static bool _OnTxFinalize(void)
 
 /////////////////////////////////////////////////////////////////////////////
 
-static void UART_RX_ISR(void)
+static void _UART_RX_ISR(void)
 {
 	uint8_t b;
 
 	if(g_nTxEchoCount)
 	{
 		UARTCharGetNonBlocking(UART_BASE);	// discard transmit echo chars
-		_FrameTimerStart();
 		--g_nTxEchoCount;
+		_FrameTimerStart();
 		return;
 	}
 
@@ -122,39 +122,39 @@ static void UART_RX_ISR(void)
 
 	if(_TimerElapsed()) // check, if the time since the last character was received, is greater than 3.5/1.5 characters
 	{
-		FifoReset(g_hFifoRX, false);
-		FifoSetFlags(g_hFifoRX, MB_RTU_FLAG_FRAME_GAP_DETECT, false);
-		if(FifoMatchFlags(g_hFifoRX, MB_RTU_FLAG_IGNORE_FRAME, false))
+		GfaMbFifoReset(g_hFifoRX, false);
+		GfaMbFifoSetFlags(g_hFifoRX, MB_RTU_FLAG_FRAME_GAP_DETECT, false);
+		if(GfaMbFifoMatchFlags(g_hFifoRX, MB_RTU_FLAG_IGNORE_FRAME, false))
 		{
-			FifoClearFlags(g_hFifoRX, MB_RTU_FLAG_IGNORE_FRAME, false);
+			GfaMbFifoClearFlags(g_hFifoRX, MB_RTU_FLAG_IGNORE_FRAME, false);
 		}
-		FifoClearFlags(g_hFifoTX, MB_RTU_FLAG_TRANSMIT_END, false);
+		GfaMbFifoClearFlags(g_hFifoTX, MB_RTU_FLAG_TRANSMIT_END, false);
 	}
-	else if(FifoMatchFlags(g_hFifoRX, MB_RTU_FLAG_IGNORE_FRAME, false))
+	else if(GfaMbFifoMatchFlags(g_hFifoRX, MB_RTU_FLAG_IGNORE_FRAME, false))
 	{
 		UARTCharGetNonBlocking(UART_BASE);	// discard chars
 		_FrameTimerStart();
 		return;
 	}
-	else if(FifoMatchFlags(g_hFifoTX, MB_RTU_FLAG_TRANSMIT_END, false))
+	else if(GfaMbFifoMatchFlags(g_hFifoTX, MB_RTU_FLAG_TRANSMIT_END, false))
 	{
 		UARTCharGetNonBlocking(UART_BASE);	// discard chars
-		FifoReset(g_hFifoRX, false);
+		GfaMbFifoReset(g_hFifoRX, false);
 		return;
 	}
 
 	b = (uint8_t)UARTCharGetNonBlocking(UART_BASE);
-	FifoPush(g_hFifoRX, b, false);
+	GfaMbFifoPush(g_hFifoRX, b, false);
 	_CharTimerStart();
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
-static void UART_TX_ISR(void)
+static void _UART_TX_ISR(void)
 {
 	uint8_t b;
 
-	if(FifoPop(g_hFifoTX, &b, false))
+	if(GfaMbFifoPop(g_hFifoTX, &b, false))
 	{
 		++g_nTxEchoCount;
 		UARTCharPutNonBlocking(UART_BASE, b);
@@ -164,62 +164,62 @@ static void UART_TX_ISR(void)
 	{
 		UARTIntDisable(UART_BASE, UART_INT_TX);
 		GPIOPinWrite(EN_485_PORT, EN_485_PIN, 0); // disable the bus
-		FifoClearFlags(g_hFifoTX, MB_RTU_FLAG_TRANSMIT_IN_PROGRESS, false);
-		FifoSetFlags(g_hFifoTX, MB_RTU_FLAG_TRANSMIT_END, false);
+		GfaMbFifoClearFlags(g_hFifoTX, MB_RTU_FLAG_TRANSMIT_IN_PROGRESS, false);
+		GfaMbFifoSetFlags(g_hFifoTX, MB_RTU_FLAG_TRANSMIT_END, false);
 		_FrameTimerStart();
 	}
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
-static void UART_OE_ISR(void)
+static void _UART_OE_ISR(void)
 {
 	++g_statCnt.nOverrunErrors;
-	FifoSetFlags(g_hFifoRX, MB_RTU_FLAG_OVERRUN_ERROR, false);
+	GfaMbFifoSetFlags(g_hFifoRX, MB_RTU_FLAG_OVERRUN_ERROR, false);
 }
 
-static void UART_BE_ISR(void)
+static void _UART_BE_ISR(void)
 {
 	++g_statCnt.nBreakErrors;
-	FifoSetFlags(g_hFifoRX, MB_RTU_FLAG_BREAK_ERROR, false);
+	GfaMbFifoSetFlags(g_hFifoRX, MB_RTU_FLAG_BREAK_ERROR, false);
 }
 
-static void UART_PE_ISR(void)
+static void _UART_PE_ISR(void)
 {
 	++g_statCnt.nParityErrors;
-	FifoSetFlags(g_hFifoRX, MB_RTU_FLAG_PARITY_ERROR, false);
+	GfaMbFifoSetFlags(g_hFifoRX, MB_RTU_FLAG_PARITY_ERROR, false);
 }
 
-static void UART_FE_ISR(void)
+static void _UART_FE_ISR(void)
 {
 	++g_statCnt.nFramingErrors;
-	FifoSetFlags(g_hFifoRX, MB_RTU_FLAG_FRAMING_ERROR, false);
+	GfaMbFifoSetFlags(g_hFifoRX, MB_RTU_FLAG_FRAMING_ERROR, false);
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
-static void UART_ISR(void)
+static void _UART_ISR(void)
 {
 	uint32_t nStatus = UARTIntStatus(UART_BASE, true);	// Get the interrrupt status.
     UARTIntClear(UART_BASE, nStatus);					// Clear the asserted interrupts.
 
     if(nStatus & UART_INT_TX)
-    	UART_TX_ISR();
+    	_UART_TX_ISR();
     if(nStatus & UART_INT_RX)
-    	UART_RX_ISR();
+    	_UART_RX_ISR();
 	if(nStatus & UART_INT_OE)	// UART Overrun Error
-		UART_OE_ISR();
+		_UART_OE_ISR();
 	if(nStatus & UART_INT_BE)	// UART Break Error
-		UART_BE_ISR();
+		_UART_BE_ISR();
 	if(nStatus & UART_INT_PE)	// UART Parity Error
-		UART_PE_ISR();
+		_UART_PE_ISR();
 	if(nStatus & UART_INT_FE)	// UART Framing Error
-		UART_FE_ISR();
+		_UART_FE_ISR();
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
-static bool EnableRxInt(bool bEnable)
+static bool _EnableRxInt(bool bEnable)
 {
 	bool bIsEnabled = IS_INT_ENABLED(UART_INT_RX);
 	if(bEnable && !bIsEnabled)
@@ -231,7 +231,7 @@ static bool EnableRxInt(bool bEnable)
 
 /////////////////////////////////////////////////////////////////////////////
 
-static bool EnableTxInt(bool bEnable)
+static bool _EnableTxInt(bool bEnable)
 {
 	bool bIsEnabled = IS_INT_ENABLED(UART_INT_TX);
 	if(bEnable && !bIsEnabled)
@@ -277,7 +277,7 @@ static uint32_t _GetStopbits(int nStopbits)
 
 /////////////////////////////////////////////////////////////////////////////
 
-static uint32_t _GetParity(UART_Parity parity)
+static uint32_t _GetParity(GfA_UART_Parity parity)
 {
 	switch(parity)
 	{
@@ -296,48 +296,50 @@ static uint32_t _GetParity(UART_Parity parity)
 	}
 }
 
+/////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////
 
-bool MB_UART_Init(LPCUART_CONFIG pCfg)
+bool GfaMbUartInit(LPCGFA_UART_CONFIG pCfg)
 {
 	uint32_t nData, nStop, nPar;
-
-	if(!pCfg)
-		return false;
-	memcpy(&g_uartCfg, pCfg, sizeof(g_uartCfg));
+	GFA_FIFO_BACKEND backend;
 
 	/////////////////////////////////////////////////////////////////////////
 	// validate parameters
 
+	if(!pCfg)
+		return false;
 	if((nData = _GetDatabits(pCfg->nDatabits)) == (uint32_t)-1)
 		return false;
 	if((nStop = _GetStopbits(pCfg->nStopbits)) == (uint32_t)-1)
 		return false;
 	if((nPar = _GetParity(pCfg->parity)) == (uint32_t)-1)
 		return false;
+	if(pCfg->nFifoIndexTx == pCfg->nFifoIndexRx)
+		return false;
+
+	memcpy(&g_uartCfg, pCfg, sizeof(g_uartCfg));
 
 	/////////////////////////////////////////////////////////////////////////
 	// Fifos
 
-	FIFO_BACKEND backend;
-
 	memset(&backend, 0, sizeof(backend));
-	backend.pfnLockBackend	= EnableTxInt;
+	backend.pfnLockBackend	= _EnableTxInt;
 	backend.pfnTxPrepare	= _OnTxPrepare;
 	backend.pfnTxStart		= _OnTxStart;
 	backend.pfnTxFinalize	= _OnTxFinalize;
 
-	if(!(g_hFifoTX = FifoCreate(pCfg->nFifoIndexTx, &backend)))
+	if(!(g_hFifoTX = GfaMbFifoCreate(pCfg->nFifoIndexTx, &backend)))
 		return false;
 
 	memset(&backend, 0, sizeof(backend));
-	backend.pfnLockBackend	= EnableRxInt;
+	backend.pfnLockBackend	= _EnableRxInt;
 	backend.pfnRxFinalize	= _OnRxFinalize;
 
-	if(!(g_hFifoRX = FifoCreate(pCfg->nFifoIndexRx, &backend)))
+	if(!(g_hFifoRX = GfaMbFifoCreate(pCfg->nFifoIndexRx, &backend)))
 	{
-		FifoRelease(g_hFifoTX);
+		GfaMbFifoRelease(g_hFifoTX);
 		g_hFifoTX = NULL;
 		return false;
 	}
@@ -350,7 +352,7 @@ bool MB_UART_Init(LPCUART_CONFIG pCfg)
 	/////////////////////////////////////////////////////////////////////////
 	// UART
 
-	if(pCfg->nBaud)
+	if(pCfg->nBaud <= 19200)
 	{
 		g_MODBUS_RTU_FRAME_TIMEOUT_US	= (350000000 / pCfg->nBaud + 5) / 10;
 		g_MODBUS_RTU_CHAR_TIMEOUT_US	= (150000000 / pCfg->nBaud + 5) / 10;
@@ -394,7 +396,7 @@ bool MB_UART_Init(LPCUART_CONFIG pCfg)
 
 	// Enable the UART interrupt.
 	IntPrioritySet(UART_INT, MODBUS_RTU_UART_INT_PRIORITY); // priority must be lower than system tick
-	UARTIntRegister(UART_BASE, UART_ISR);
+	UARTIntRegister(UART_BASE, _UART_ISR);
 	UARTIntEnable(UART_BASE, (UART_INT_RX | UART_INT_OE | UART_INT_BE | UART_INT_PE | UART_INT_FE));
 
 	// Enable the UART.
@@ -406,7 +408,7 @@ bool MB_UART_Init(LPCUART_CONFIG pCfg)
 
 /////////////////////////////////////////////////////////////////////////////
 
-void MB_UART_Release(void)
+void GfaMbUartRelease(void)
 {
 	UARTIntDisable(UART_BASE, UART_INT_RX | UART_INT_TX | UART_INT_OE | UART_INT_BE | UART_INT_PE | UART_INT_FE);
 
@@ -419,34 +421,34 @@ void MB_UART_Release(void)
 
 	if(g_hFifoRX)
 	{
-		FifoRelease(g_hFifoRX);
+		GfaMbFifoRelease(g_hFifoRX);
 		g_hFifoRX = NULL;
 	}
 
 	if(g_hFifoTX)
 	{
-		FifoRelease(g_hFifoTX);
+		GfaMbFifoRelease(g_hFifoTX);
 		g_hFifoTX = NULL;
 	}
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
-HFIFO MB_UART_GetRxFifo(void)
+HFIFO GfaMbUartGetRxFifo(void)
 {
 	return g_hFifoRX;
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
-HFIFO MB_UART_GetTxFifo(void)
+HFIFO GfaMbUartGetTxFifo(void)
 {
 	return g_hFifoTX;
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
-void MB_UART_GetStatusCounters(LPUART_STATUS_COUNTERS pSc)
+void GfaMbUartGetStatusCounters(LPGFA_UART_STATUS_COUNTERS pSc)
 {
 	if(pSc)
 	{
@@ -459,7 +461,7 @@ void MB_UART_GetStatusCounters(LPUART_STATUS_COUNTERS pSc)
 
 /////////////////////////////////////////////////////////////////////////////
 
-void MB_UART_ResetStatusCounters(void)
+void GfaMbUartResetStatusCounters(void)
 {
 	uint32_t nIrMask = INT_MASK_REGISTER;
 	UARTIntDisable(UART_BASE, nIrMask);

gfamodbusrtuslv/mbrtuslv.c

@@ -89,28 +89,28 @@ bool GfaModbusRTUSlvStateMachine(HMBRTUSLV hMbSlv)
 			pSlv->slaveID = pSlv->newSlaveID;
 			pSlv->newSlaveID = 0;
 		}
-		if(!FifoMatchFlags(pSlv->hFifoRX, MB_RTU_FLAG_FRAME_GAP_DETECT, true))
+		if(!GfaMbFifoMatchFlags(pSlv->hFifoRX, MB_RTU_FLAG_FRAME_GAP_DETECT, true))
 			break;
 		pSlv->state			= MB_RTU_SLV_RxSlvID;
 		pSlv->nCbToRead		= 0;
 		pSlv->nCbToWrite	= 0;
 		pSlv->nDataPtr		= 0;
 		pSlv->bCRCOk		= false;
-		FifoClearFlags(pSlv->hFifoRX, MB_RTU_FLAG_FRAME_GAP_DETECT, true);
+		GfaMbFifoClearFlags(pSlv->hFifoRX, MB_RTU_FLAG_FRAME_GAP_DETECT, true);
 		// fall through
 
 	case MB_RTU_SLV_RxSlvID:
 		_PeekStateChange(pSlv);
-		if(!FifoPop(pSlv->hFifoRX, &b, true))
+		if(!GfaMbFifoPop(pSlv->hFifoRX, &b, true))
 		{
-			if(FifoMatchFlags(pSlv->hFifoRX, MB_RTU_FLAG_FRAME_GAP_DETECT, true))
+			if(GfaMbFifoMatchFlags(pSlv->hFifoRX, MB_RTU_FLAG_FRAME_GAP_DETECT, true))
 				pSlv->state	= MB_RTU_SLV_Idle;
 			break;
 		}
 		if(pSlv->slaveID != b) // ignore broadcasts as well
 		{
-			FifoSetFlags(pSlv->hFifoRX, MB_RTU_FLAG_IGNORE_FRAME, true);
-			FifoReset(pSlv->hFifoRX, true);
+			GfaMbFifoSetFlags(pSlv->hFifoRX, MB_RTU_FLAG_IGNORE_FRAME, true);
+			GfaMbFifoReset(pSlv->hFifoRX, true);
 			pSlv->state		= MB_RTU_SLV_Idle;
 			++pSlv->diag.nBusMsgCount;
 			break;
@@ -122,17 +122,17 @@ bool GfaModbusRTUSlvStateMachine(HMBRTUSLV hMbSlv)
 
 	case MB_RTU_SLV_RxFunc:
 		_PeekStateChange(pSlv);
-		if(!FifoPop(pSlv->hFifoRX, &b, true))
+		if(!GfaMbFifoPop(pSlv->hFifoRX, &b, true))
 		{
-			if(FifoMatchFlags(pSlv->hFifoRX, MB_RTU_FLAG_FRAME_GAP_DETECT, true))
+			if(GfaMbFifoMatchFlags(pSlv->hFifoRX, MB_RTU_FLAG_FRAME_GAP_DETECT, true))
 				pSlv->state	= MB_RTU_SLV_Idle;
 			break;
 		}
 		else if(!GfaModbusRequestFunctionKnown(b))
 		{
 			pSlv->adu.pdu.func = b;
-			FifoSetFlags(pSlv->hFifoRX, MB_RTU_FLAG_IGNORE_FRAME, true);
-			FifoReset(pSlv->hFifoRX, true);
+			GfaMbFifoSetFlags(pSlv->hFifoRX, MB_RTU_FLAG_IGNORE_FRAME, true);
+			GfaMbFifoReset(pSlv->hFifoRX, true);
 			GfaModbusRequestCreateExceptionResponse(&pSlv->adu.pdu, MB_ERROR_ILLEGAL_FUNCTION);
 			GfaModbusRequestSetCRC(&pSlv->adu, 3, &pSlv->adu.pdu.b[1]);
 			pSlv->nCbToWrite = 5;
@@ -149,9 +149,9 @@ bool GfaModbusRTUSlvStateMachine(HMBRTUSLV hMbSlv)
 		_PeekStateChange(pSlv);
 		if(pSlv->nCbToRead)
 		{
-			if(!(nRead = FifoRead(pSlv->hFifoRX, &pSlv->adu.pdu.b[pSlv->nDataPtr], pSlv->nCbToRead, true)))
+			if(!(nRead = GfaMbFifoRead(pSlv->hFifoRX, &pSlv->adu.pdu.b[pSlv->nDataPtr], pSlv->nCbToRead, true)))
 			{
-				if(FifoMatchFlags(pSlv->hFifoRX, MB_RTU_FLAG_FRAME_GAP_DETECT, true))
+				if(GfaMbFifoMatchFlags(pSlv->hFifoRX, MB_RTU_FLAG_FRAME_GAP_DETECT, true))
 					pSlv->state	= MB_RTU_SLV_Idle;
 				break;
 			}
@@ -170,8 +170,8 @@ bool GfaModbusRTUSlvStateMachine(HMBRTUSLV hMbSlv)
 				if(!GfaModbusRequestSubFunctionKnown(pSlv->nSubFunc))
 				{
 					pSlv->adu.pdu.func = b;
-					FifoSetFlags(pSlv->hFifoRX, MB_RTU_FLAG_IGNORE_FRAME, true);
-					FifoReset(pSlv->hFifoRX, true);
+					GfaMbFifoSetFlags(pSlv->hFifoRX, MB_RTU_FLAG_IGNORE_FRAME, true);
+					GfaMbFifoReset(pSlv->hFifoRX, true);
 					GfaModbusRequestCreateExceptionResponse(&pSlv->adu.pdu, MB_ERROR_ILLEGAL_FUNCTION);
 					GfaModbusRequestSetCRC(&pSlv->adu, 3, &pSlv->adu.pdu.b[1]);
 					pSlv->nCbToWrite = 5;
@@ -189,9 +189,9 @@ bool GfaModbusRTUSlvStateMachine(HMBRTUSLV hMbSlv)
 		_PeekStateChange(pSlv);
 		if(pSlv->nCbToRead)
 		{
-			if(!(nRead = FifoRead(pSlv->hFifoRX, &pSlv->adu.pdu.b[pSlv->nDataPtr], pSlv->nCbToRead, true)))
+			if(!(nRead = GfaMbFifoRead(pSlv->hFifoRX, &pSlv->adu.pdu.b[pSlv->nDataPtr], pSlv->nCbToRead, true)))
 			{
-				if(FifoMatchFlags(pSlv->hFifoRX, MB_RTU_FLAG_FRAME_GAP_DETECT, true))
+				if(GfaMbFifoMatchFlags(pSlv->hFifoRX, MB_RTU_FLAG_FRAME_GAP_DETECT, true))
 					pSlv->state	= MB_RTU_SLV_Idle;
 				break;
 			}
@@ -212,9 +212,9 @@ bool GfaModbusRTUSlvStateMachine(HMBRTUSLV hMbSlv)
 		_PeekStateChange(pSlv);
 		if(pSlv->nCbToRead)
 		{
-			if(!(nRead = FifoRead(pSlv->hFifoRX, &pSlv->adu.pdu.b[pSlv->nDataPtr], pSlv->nCbToRead, true)))
+			if(!(nRead = GfaMbFifoRead(pSlv->hFifoRX, &pSlv->adu.pdu.b[pSlv->nDataPtr], pSlv->nCbToRead, true)))
 			{
-				if(FifoMatchFlags(pSlv->hFifoRX, MB_RTU_FLAG_FRAME_GAP_DETECT, true))
+				if(GfaMbFifoMatchFlags(pSlv->hFifoRX, MB_RTU_FLAG_FRAME_GAP_DETECT, true))
 					pSlv->state	= MB_RTU_SLV_Idle;
 				break;
 			}
@@ -246,7 +246,7 @@ bool GfaModbusRTUSlvStateMachine(HMBRTUSLV hMbSlv)
 				pSlv->state			= MB_RTU_SLV_TxStart;
 				if(bIsExeption)
 					++pSlv->diag.nExcErrCount;
-				FifoRxFinalize(pSlv->hFifoRX, true);
+				GfaMbFifoRxFinalize(pSlv->hFifoRX, true);
 				// fall through
 			}
 			else
@@ -264,15 +264,15 @@ bool GfaModbusRTUSlvStateMachine(HMBRTUSLV hMbSlv)
 
 	case MB_RTU_SLV_TxStart:
 		_PeekStateChange(pSlv);
-		if(	FifoEmpty(pSlv->hFifoTX, true) &&
-			FifoTxPrepare(pSlv->hFifoTX, true))
+		if(	GfaMbFifoEmpty(pSlv->hFifoTX, true) &&
+			GfaMbFifoTxPrepare(pSlv->hFifoTX, true))
 		{
-			FifoSetFlags(pSlv->hFifoTX, MB_RTU_FLAG_TRANSMIT_IN_PROGRESS, true);
-			FifoWrite(pSlv->hFifoTX, &pSlv->adu, pSlv->nCbToWrite, true);
+			GfaMbFifoSetFlags(pSlv->hFifoTX, MB_RTU_FLAG_TRANSMIT_IN_PROGRESS, true);
+			GfaMbFifoWrite(pSlv->hFifoTX, &pSlv->adu, pSlv->nCbToWrite, true);
 
 			if(pSlv->appItf.pfnPreTransmit)
 				(*pSlv->appItf.pfnPreTransmit)(&pSlv->adu);
-			FifoTxStart(pSlv->hFifoTX, false);
+			GfaMbFifoTxStart(pSlv->hFifoTX, false);
 			pSlv->state = MB_RTU_SLV_TxWaitEnd;
 			// fall through
 		}
@@ -281,7 +281,7 @@ bool GfaModbusRTUSlvStateMachine(HMBRTUSLV hMbSlv)
 
 	case MB_RTU_SLV_TxWaitEnd:
 		_PeekStateChange(pSlv);
-		if(!FifoMatchFlags(pSlv->hFifoTX, MB_RTU_FLAG_TRANSMIT_IN_PROGRESS, true))
+		if(!GfaMbFifoMatchFlags(pSlv->hFifoTX, MB_RTU_FLAG_TRANSMIT_IN_PROGRESS, true))
 		{
 			if(pSlv->appItf.pfnPostTransmit)
 				(*pSlv->appItf.pfnPostTransmit)(&pSlv->adu);