T168_111\system\Comm：Commlibry.c

最新推荐文章于 2024-07-20 19:39:28 发布

qq_33772147

最新推荐文章于 2024-07-20 19:39:28 发布

阅读量835

点赞数 21

文章标签： c语言前端 java

本文链接：https://blog.csdn.net/qq_33772147/article/details/137545347

版权

/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/

#define COMMLIBRY_C

/******************************************************************************
* *
* C O M P I L E R D E F I N E D I N C L U D E F I L E S *
* *
******************************************************************************/

#include <stdio.h>
#include <stdarg.h>
#include <string.h>

/******************************************************************************
* *
* U S E R D E F I N E D I N C L U D E F I L E S *
* *
******************************************************************************/

#include "Common.h"
#include "XCore.h"
#include "XNutOS.h"
#include "XTimer.h"
#include "XUART.h"
#include "XUSB.h"
#include "XCentronic.h"
#include "XEthernet.h"
#include "CommLibry.h"
#include "XBt.h"

/******************************************************************************
* *
* L O C A L D E F I N E S *
* *
******************************************************************************/

#define USER_RECEIVE_BUF_SIZE 256

#define COMM_YIELD_TIME (20 / PERIOD_TIMES)

#define COMM_WAIT_TIME 3000

/******************************************************************************
* *
* L O C A L T Y P E D E F S *
* *
******************************************************************************/

/* None */

/******************************************************************************
* *
* L O C A L F U N C T I O N P R O T O T Y P E S *
* *
******************************************************************************/

/* None */

/******************************************************************************
* *
* L O C A L I N I T I A L I Z E D D A T A D E F I N I T I O N S *
* *
******************************************************************************/

/* None */

/******************************************************************************
* *
* L O C A L U N I T I A L I Z E D D A T A D E F I N I T I O N S *
* *
******************************************************************************/

STATIC INT DataOutPort;

STATIC BYTE UserRxBuffer[USER_RECEIVE_BUF_SIZE];
STATIC BYTE *pUserRxBegin;
STATIC BYTE *pUserRxEnd;
STATIC BYTE *pUserRxInput;
STATIC BYTE *pUserRxOutput;
STATIC INT UserRxLength;

STATIC UINT CommYieldTick;

VOID CommYieldTimer(VOID)
{
if (CommYieldTick)
CommYieldTick -= 1;
}

#if defined(__HITACHI__)
#pragma section ISR
#endif

/******************************************************************************
*
* Function:
* InitialCommLibry
*
* Description:
*       This global function initializes the Communication libry.
*
* Input:
*     None
*
* Output:
*     None.
*
******************************************************************************/
VOID InitialCommLibry(VOID)
{
#if defined(UART2_DEVICE)
   InitialUart2Drv();
#endif

   InitialUartDrv();
   InitialCenDrv();
   InitialUsbLibry();
   //SetDirectUart();

DataOutPort = UART_PORT;

   pUserRxBegin = UserRxBuffer;
   pUserRxEnd = UserRxBuffer + USER_RECEIVE_BUF_SIZE - 1;
   pUserRxInput = UserRxBuffer;
   pUserRxOutput = UserRxBuffer;
   UserRxLength = 0;

#if defined(NUTOS)
StartPeriodFunc(CommYieldTimer);
#endif
}

INT GetCommPort(VOID)
{
return DataOutPort;
}

/******************************************************************************
*
* Function:
* GetByte
*
* Description:
*       This global function to get byte from communication.
*
* Input:
*     None
*
* Output:
*     None.
*
******************************************************************************/
BOOL GetByte(BYTE *data)
{
   // check uart buffer data
   if (UartRxDataOut(data))
   {
       DataOutPort = UART_PORT;
       return TRUE;
   }

   // check usb buffer data
   if (UsbRxDataOut(data))
   {
       DataOutPort = USB_PORT;
       return TRUE;
   }

#if defined(NUTNET)
   // check ethernet buffer data
   if (NetRxDataOut(data))
   {
       DataOutPort = ETHERNET_PORT;
       return TRUE;
   }
#endif
#if defined(UART2_BUFFER)
#if defined(UART2_BT)
if (Uart2BtRxDataOut(data))
   {
       DataOutPort = BT_PORT;
       return TRUE;
   }
#elif defined(UART2_WIFI)
   if (Uart2WifiRxDataOut(data))
   {
       DataOutPort = WIFI_PORT;
       return TRUE;
   }
#endif
#endif

   // check centronic data
   if (GetCenData(data))
   {
#if defined(NUTOS)
       CommYieldTick = COMM_YIELD_TIME;
#endif
       DataOutPort = PARALLEL_PORT;
       return TRUE;
   }
   // check user data
   if (UserDataOut(data))
       return TRUE;

#if defined(NUTOS)
if (CommYieldTick == 0)
NutThreadYield();
#endif

return FALSE;
}

/******************************************************************************
*
* Function:
* GetBufferLength
*
* Description:
*       How many the buffer of data.
*
* Input:
*     None
*
* Output:
*     None.
*
******************************************************************************/
INT GetBufferLength(VOID)
{
   INT Length = 0;

   Length += UserDataLength();           // get user buffer length
   Length += UartRxDataLength();       // get uart buffer length
   Length += UsbRxDataLength();       // get usb buffer length
#if defined(NUTNET)
   Length += NetRxDataLength();       // get ethernet buffer length
#endif

#if defined(UART2_BUFFER)
Length += Uart2ButterRxDataLength(); // get uart buffer length
#endif
Length += CenDataCheck() ? 1 : 0; // check centronic data

#if defined(NUTOS)
if (Length == 0 && CommYieldTick == 0)
NutThreadYield();
#endif

return Length;
}

/******************************************************************************
*
* Function:
* CheckCommBuffer
*
* Description:
*
*
* Input:
*     None
*
* Output:
*     None.
*
******************************************************************************/
BOOL CheckCommBuffer(VOID)
{
#if defined(UART2_BUFFER)
   // check uart buffer data
   if (Uart2ButterRxDataLength() != 0)
       return TRUE;
#endif

   // check uart buffer data
   if (UartRxDataLength() != 0)
       return TRUE;

   // check usb buffer data
   if (UsbRxDataLength() != 0)
       return TRUE;

#if defined(NUTNET)
   // check ethernet buffer data
   if (NetRxDataLength() != 0)
       return TRUE;
#endif
   if (CenDataCheck())
       return TRUE;
   // check user data
   if (UserDataLength() != 0)
       return TRUE;

#if defined(NUTOS)
if (CommYieldTick == 0)
NutThreadYield();
#endif

return FALSE;
}

BOOL UserDataIn(BYTE data)
{
if (UserRxLength >= USER_RECEIVE_BUF_SIZE)
return FALSE;

   *pUserRxInput++ = data;
   if (pUserRxInput > pUserRxEnd)
       pUserRxInput = pUserRxBegin;
   UserRxLength += 1;

return TRUE;
}

BOOL UserDataOut(BYTE *data)
{
if (UserRxLength == 0)
return FALSE;

   *data = *pUserRxOutput++;
   if (pUserRxOutput > pUserRxEnd)
       pUserRxOutput = pUserRxBegin;
   UserRxLength -= 1;

return TRUE;
}

INT UserDataLength(VOID)
{
return UserRxLength;
}

INT CommWrite(INT port, CONST VOID *buf, INT size, INT timeout)
{
   INT time = 0;
   INT rc = 0;
   INT bite = (-1);

while (rc < size)
   {
       if (port == USB_PORT)
           bite = UsbWrite((BYTE *)buf + rc, size - rc);
       else if (port == UART_PORT || port == PARALLEL_PORT)
           bite = UartWrite((BYTE *)buf + rc, size - rc);
#if defined(NUTNET)
       else if (port == ETHERNET_PORT)
           bite = NetWrite((BYTE *)buf + rc, size - rc);
#endif
#if defined(UART2_BUFFER)

else if (port == BT_PORT||port == WIFI_PORT)
bite = Uart2ButterWrite(port,(BYTE *)buf + rc, size - rc);
#endif
else
bite = size - rc;
if (bite < 0)
return (-1);

rc += bite;

       if (bite == 0)
       {
           if (time >= timeout && timeout != WAIT_INFINITE)
               break;
           time += 1;
           DelayTime(DELAY_MILLISECOND);
       }
       else
           time = 0;
}
return rc;
}

INT SendBuffer(CONST VOID *buf, INT size)
{
return CommWrite(DataOutPort, buf, size, COMM_WAIT_TIME);
}

VOID SendChar(BYTE data)
{
CommWrite(DataOutPort, &data, sizeof(BYTE), COMM_WAIT_TIME);
}

VOID SendString(CONST CHAR *str)
{
CommWrite(DataOutPort, str, strlen(str), COMM_WAIT_TIME);
}

VOID SendPrintf(CONST CHAR *fmt, ...)
{
va_list args;
CHAR printbuf[512];

   va_start(args, fmt);
   vsprintf(printbuf, fmt, args);
   va_end(args);

SendString(printbuf);

sysprintf(printbuf);

}

// Transfer int to number string, and send it to rs232
VOID SendNum(INT Num)
{
   BYTE NumString[10];
   BOOL empty;
   INT i;

   if (Num < 0)
   {
       UartChar('-');
       Num = -Num;
   }

   for (i = 9; i >= 0; i--)
   {
       NumString[i] = (Num % 10) + 0x30;
       Num = Num / 10;
   }

   empty = TRUE;
   for (i = 0; i < 10; i++)
   {
       if (empty)
       {
           if (NumString[i] != '0')
           {
               UartChar(NumString[i]);
               empty = FALSE;
           }
       }
       else
       {
           UartChar(NumString[i]);
       }
   }
   if (empty)
       UartChar('0');
}

VOID SendNum16(INT Num, INT Length)
{
INT i;
BYTE *num, data;

   num = (BYTE *)&Num;
#if defined(BIG_ENDIAN)
   num += 4 - Length;
#else
   num += Length - 1;
#endif

   for (i = 0; i < Length; i++)
   {
       data = (*num) >> 4;
       if (data > 9)
           data += 'A' - 10;
       else
           data += '0';

UartChar(data);

       data = (*num) & 0x0F;
       if (data > 9)
           data += 'A' - 10;
       else
           data += '0';

UartChar(data);

#if defined(BIG_ENDIAN)
       num += 1;
#else
       num -= 1;
#endif
   }
   UartChar('h');
}

#if defined(UART2_DEVICE)

INT Uart2GetByte(BYTE *data)
{
   if (Uart2RxDataOut(data))
        return TRUE;
   NutThreadYield();
   return FALSE;
}

#endif

Commlibry.h 、、、、、、、、、、、、、、、、、、、、、、、、、、、

#ifndef COMMLIBRY_H

/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/

#define COMMLIBRY_H

#include <stdarg.h>

#include "XUART.h"
#include "XUSB.h"

#ifdef __cplusplus
extern "C" { /* Assume C declarations for C++ */
#endif /* __cplusplus */

/******************************************************************************
* *
* G L O B A L D E F I N E S *
* *
******************************************************************************/

#define WAIT_INFINITE (-1)

/******************************************************************************
* *
* S T R U C T U R E D E F I N I T I O N S *
* *
******************************************************************************/

enum {
   USB_PORT,
   UART_PORT,
   PARALLEL_PORT,
   ETHERNET_PORT,
   BT_PORT,
   WIFI_PORT,
};

/******************************************************************************
* *
* G L O B A L V A R I A B L E S - N O I N I T I A L I Z E R S *
* *
******************************************************************************/

/* None */

/******************************************************************************
* *
* G L O B A L V A R I A B L E S - I N I T I A L I Z E R S *
* *
******************************************************************************/

/* None */

/******************************************************************************
* *
* F U N C T I O N P R O T O T Y P E S *
* *
******************************************************************************/

VOID InitialCommLibry(VOID);
INT GetCommPort(VOID);
BOOL GetByte(BYTE *);
INT GetBufferLength(VOID);
BOOL CheckCommBuffer(VOID);
BOOL UserDataIn(BYTE);
BOOL UserDataOut(BYTE *);
INT UserDataLength(VOID);
INT CommWrite(INT, CONST VOID *, INT, INT);
INT SendBuffer(CONST VOID *, INT);
VOID SendChar(BYTE);
VOID SendString(CONST CHAR *);
VOID SendPrintf(CONST CHAR *, ...);
//VOID SendNum(INT);
//VOID SendNum16(INT, INT);
int __get_CPSR(void);

void __disable_interrupt(void);

void __enable_interrupt(void);

int usiWriteEnable(void);

INT Uart2GetByte(BYTE *);

#ifdef __cplusplus
} /* End of extern "C" { */
#endif /* __cplusplus */

#endif

qq_33772147

关注

21
点赞
踩
12

收藏

觉得还不错? 一键收藏
0
评论
T168_111\system\Comm：Commlibry.c

* None *//* None *//* None */#endif* Input:* Output:#endif#endif* Input:* Output:#endif。
复制链接

扫一扫