main.c

modem数据通信源码

#include <stdarg.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include "PowerManage.H"
#include "Macrodef.h"
#include "common_exp.h"
#include "exports.h"
#include "string.h"
#include "44B.h"
#include "Regist.h"
#include "IODrive.h"
#include "switch.h"
#include "Modem_IODrv.h"
//#include "Protocol_Drv.h"
#include "ISOModem.h"

ET_PROTOCOL_EXPORT_TABLE	*EG_ptProtocolExportTable;
DECLARE_EXPORT_TABLE(ET_PROTOCOL_EXPORT_TABLE, Base);
DECLARE_EXPORT_TABLE(ET_PROTOCOL_EXPORT_TABLE, 2);
int debug_msg=0;

extern EM_modem_STS    EG_modem_STS;
/**********************************************************************
* 变量作用:
*	用于引入I/O驱动统一管理模块的函数入口表
* 取值范围:
*
* 访问信息:
*
**********************************************************************/
ET_IO_EXPORT_TABLE *EG_ptIOExportTable;
DECLARE_EXPORT_TABLE(ET_IO_EXPORT_TABLE, BASE);


void EI_vProtocolError(void);
void EI_vIODriveError(void);
void EI_vProtocolError(void)
{
	EI_vReportLoadErr("TCP/IP协议栈模块");
}
void EI_vIODriveError(void)
{
    EI_vReportLoadErr("I/0模块");
}


ET_ModuleMessage Module;
ET_ModuleNode  ModuleNode;//外围设备节点
COMMON_SERVICE_TABLE        *EG_ptCommonService;
STDLIB_SERVICE_TABLE        *EG_ptStdlibService;
INTERDRIVE_SERVICE_TABLE    *EG_ptInterDriveService;
PLUS_SERVICE_TABLE          *plus_service;

E_LinkListHandle     *EG_ptIoLinkList = EM_NULL; // I/O设备链表
ET_MEMORY_POOL              *EG_ptSystemMemory;

ET_MODEM_BASE_EXPORT		EG_tModemBase;
ET_MODEM_FACTORY_EXPORT		EG_tModemFactory;

ET_MODEM_EXPORT_TABLE EG_tMODEMExportTable;
ET_MODEM_EXPORT_TABLE *EG_ptMODEMExportTable;

void *EA_Main(ET_MEMORY_POOL *ptMemPool, SVC_EXPORT_TABLE *ptSystemServices, uint uiModuleID);
void EI_vInitBaseModule(void);
void EI_vInitFactoryModule(void);
void EI_vInitModemDriveModule(UNSIGNED argc, VOID *argv);
void EA_vUartSendByte(char data);
void EA_vUartSendString(char *pt);
void EI_vUartPrintHex(int iLength, const void *pvData);
void EA_ucModemInit(void);

void EA_vExit(void)
{

}

void EI_vIntoPowerSave( void )
{
    Module.ulModuleStatus = EM_POWERDOWN_STATUS;
    EA_ucSendMessage(&Module);
}

void EI_vOutOfPowerSave( void )
{
    Module.ulModuleStatus = EM_WORK_STATUS;
    EA_ucSendMessage(&Module);
}


void EI_vModemModulePowerDown_NULL(ulong argc,void *argv)
{
}

void EI_vModemModulePowerUp_NULL(ulong argc,void *argv)
{
}

void *EA_Main(ET_MEMORY_POOL *ptMemPool, SVC_EXPORT_TABLE *ptSystemServices, uint uiModuleID)
{
//	ModuleMessage Module;// 外围设备运行信息
//	int ret;

    EG_ptSystemMemory  = ptMemPool;
    
    // 引入Nucleus提供的函数入口表
    plus_service   = ptSystemServices->plus_export_table;
    
    // 引入操作系统层提供的函数入口表
    EG_ptCommonService = ptSystemServices->user_export_table1;
    
    // 引入标准库的函数入口表
    EG_ptStdlibService = ptSystemServices->user_export_table2;
    
    // 引入内部驱动库的函数入口表
    EG_ptInterDriveService = ptSystemServices->user_export_table3;
	
    if(EI_modem_init()!=EM_SUCCESS
        ||EI_PatchInit()!=EM_SUCCESS)
        return EA_vExit;
        
	REGISTER_FUNCTION(ET_PROTOCOL_EXPORT_TABLE, 2, EI_vProtocolError);
    REGISTER_STRUCT(ET_PROTOCOL_EXPORT_TABLE, Base, 2);
	RETRIEVE_EXPORT_TABLE(ET_PROTOCOL_EXPORT_TABLE, Base, "/System/PROTOCOL", "",EG_ptProtocolExportTable);	


    
    EA_uiRegisterExportTable(&EG_tMODEMExportTable, uiModuleID);

	strcpy(ModuleNode.acModuleID,"MODEM");
	strcpy(Module.acModuleID,"MODEM");       //必须增加这一句
	ModuleNode.ulModuleStatus = EM_POWERDOWN_STATUS;
	ModuleNode.ModulePowerDown = EI_vModemModulePowerDown_NULL;// 处理函数为空
	ModuleNode.ModulePowerUp   = EI_vModemModulePowerUp_NULL;

	EA_ucRegisterModule(&ModuleNode);// 设备注册

    EG_ptMODEMExportTable = &EG_tMODEMExportTable;

	EI_vInitBaseModule();
	EI_vInitFactoryModule();
	
	EG_tMODEMExportTable.Reserved = NULL;
#ifdef  NEW_OS		
	EA_ucSetDrvInitStatus(EM_IS_INIT_MODEM, EM_DRV_INIT_PROC);
#endif 
    return EA_vExit;
}

void EI_vInitBaseModule(void)
{
	EG_tMODEMExportTable.ptBase	= &EG_tModemBase;
    
	/*EG_tModemBase.EA_ucAnswerModem		=	EA_ucAnswerModem;
	EG_tModemBase.EA_ucClrModemRecBuf	=   EA_ucClrModemRecBuf;
	EG_tModemBase.EA_ucDial				=	EA_ucDial;
	EG_tModemBase.EA_ucDialOff			=	EA_ucDialOff;
	EG_tModemBase.EA_ucGetLineStatus	=	EA_ucGetLineStatus;
	EG_tModemBase.EA_ucIfExistDialTone  =	EA_ucIfExistDialTone;
	EG_tModemBase.EA_ucIfPhoneUsed      =   EA_ucIfPhoneUsed;
	EG_tModemBase.EA_ucInitDial			=	EA_ucInitDial;
	EG_tModemBase.EA_ucInitRingDetect	=	EA_ucInitRingDetect;
	EG_tModemBase.EA_ucInitSdlc			=	EA_ucInitSdlc;
	EG_tModemBase.EA_ucReadAsys			=	EA_ucReadAsys;
	EG_tModemBase.EA_ucReadSdlc			=	EA_ucReadSdlc;
	EG_tModemBase.EA_ucRingDetect		=	EA_ucRingDetect;
	EG_tModemBase.EA_ucSendAsys			=	EA_ucSendAsys;
	EG_tModemBase.EA_ucSendSdlc			=	EA_ucSendSdlc;
	EG_tModemBase.EA_MODEM_ucDrvOpen	=	EA_MODEM_ucDrvOpen;
	EG_tModemBase.EA_MODEM_ucDrvClose	=	EA_MODEM_ucDrvClose;
    EG_tModemBase.EA_MODEM_ucInitPpp	=	EA_MODEM_ucInitPpp;
	EG_tModemBase.EA_MODEM_ucCallPpp	=	EA_MODEM_ucCallPpp;
	EG_tModemBase.EA_MODEM_ucDialOffPpp	=	EA_MODEM_ucDialOffPpp;
	EG_tModemBase.EA_MODEM_ucGetState	=	EA_MODEM_ucGetState;
	EG_tModemBase.EA_ucIfModemRecBufEmpty	=	EA_ucIfModemRecBufEmpty;
	EG_tModemBase.EA_ucModemInit	    =	EA_ucModemInit;
	EG_tModemBase.EA_ucModemIoctl       =   EA_ucModemIoctl;
	EG_tModemBase.Reserved				=	NULL;
	*/
	EG_ptMODEMExportTable->ptBase->EA_ucAnswerModem		=	EA_ucAnswerModem;
	EG_ptMODEMExportTable->ptBase->EA_ucClrModemRecBuf	=   EA_ucClrModemRecBuf;
	EG_ptMODEMExportTable->ptBase->EA_ucDial				=	EA_ucDial;
	EG_ptMODEMExportTable->ptBase->EA_ucDialOff			=	EA_ucDialOff;
	EG_ptMODEMExportTable->ptBase->EA_ucGetLineStatus	=	EA_ucGetLineStatus;
	EG_ptMODEMExportTable->ptBase->EA_ucIfExistDialTone  =	EA_ucIfExistDialTone;
	EG_ptMODEMExportTable->ptBase->EA_ucIfPhoneUsed      =   EA_ucIfPhoneUsed;
	EG_ptMODEMExportTable->ptBase->EA_ucInitDial			=	EA_ucInitDial;
	EG_ptMODEMExportTable->ptBase->EA_ucInitRingDetect	=	EA_ucInitRingDetect;
	EG_ptMODEMExportTable->ptBase->EA_ucInitSdlc			=	EA_ucInitSdlc;
	EG_ptMODEMExportTable->ptBase->EA_ucReadAsys			=	EA_ucReadAsys;
	EG_ptMODEMExportTable->ptBase->EA_ucReadSdlc			=	EA_ucReadSdlc;
	EG_ptMODEMExportTable->ptBase->EA_ucRingDetect		=	EA_ucRingDetect;
	EG_ptMODEMExportTable->ptBase->EA_ucSendAsys			=	EA_ucSendAsys;
	EG_ptMODEMExportTable->ptBase->EA_ucSendSdlc			=	EA_ucSendSdlc;
	EG_ptMODEMExportTable->ptBase->EA_MODEM_ucDrvOpen	=	EA_MODEM_ucDrvOpen;
	EG_ptMODEMExportTable->ptBase->EA_MODEM_ucDrvClose	=	EA_MODEM_ucDrvClose;
    EG_ptMODEMExportTable->ptBase->EA_MODEM_ucInitPpp	=	EA_MODEM_ucInitPpp;
	EG_ptMODEMExportTable->ptBase->EA_MODEM_ucCallPpp	=	EA_MODEM_ucCallPpp;
	EG_ptMODEMExportTable->ptBase->EA_MODEM_ucDialOffPpp	=	EA_MODEM_ucDialOffPpp;
	EG_ptMODEMExportTable->ptBase->EA_MODEM_ucGetState	=	EA_MODEM_ucGetState;
	EG_ptMODEMExportTable->ptBase->EA_ucIfModemRecBufEmpty	=	EA_ucIfModemRecBufEmpty;
	EG_ptMODEMExportTable->ptBase->EA_ucModemInit	    =	EA_ucModemInit;
	EG_ptMODEMExportTable->ptBase->EA_ucModemIoctl       =   EA_ucModemIoctl;
	EG_ptMODEMExportTable->ptBase->Reserved				=	NULL;
}

void EI_vInitFactoryModule(void)
{
	EG_tMODEMExportTable.ptFactory	= &EG_tModemFactory;
	
	EG_tModemFactory.EI_ucMnwkSendSdlc	= EI_ucMnwkSendSdlc;
	EG_tModemFactory.EI_vInitMnwk		= EI_vInitMnwk;
	EG_tModemFactory.EI_vLineToModem	= EI_vLineToModem;
	EG_tModemFactory.EI_vLineToPhone	= EI_vLineToPhone;
	EG_tModemFactory.EI_vOffHook		= EI_vOffHook;
	EG_tModemFactory.EI_vOnHook			= EI_vOnHook;
	EG_tModemFactory.EI_vUnMnwk			= EI_vUnMnwk;

	EG_tModemFactory.EA_MODEM_ucDrvOpen	= EA_MODEM_ucDrvOpen;
	EG_tModemFactory.EA_MODEM_ucDrvClose= EA_MODEM_ucDrvClose;

	EG_tModemFactory.Reserved			= NULL;
}

void EI_vInitModemDriveModule(UNSIGNED argc, VOID *argv)
{
#ifdef  NEW_OS             
    if (EA_os_ucGetResource(EM_RES_UART1, 0) == EM_SUCCESS)    //suspend
    {
      	;   //do nothing,fall through
    }
    else
    {
        uprintf("%s:get uart1 resource fail!\r\n",__FUNCTION__);
        return;
    }
#endif
    {
        DevHandle hComDevhandle;
        
        EA_ucOpenDevice("COM",EM_io_PORT1,&hComDevhandle);
        EA_ucInitRS232(hComDevhandle,EM_232_57600BPS,EM_232_NOPAR,EM_232_8DBS);
        EA_ucCloseDevice(&hComDevhandle);
    }
    if(EI_OpenSerial()!=EM_SUCCESS)
        return;	 
    EI_ResetModem();
    EI_PatchModem();
    switch(EG_modem_STS.modem)
    {
        case EM_MODEM_CX:
            if(EG_modem_STS.dev==DEV_HAND)
                EI_StopCx();
            break;        
        case EM_MODEM_SI:
            if(EG_modem_STS.dev==DEV_HAND)
                EI_StopSi();
            break;
        default:
            break;
    }
	EI_StopSerial();
#ifdef  NEW_OS    
    EA_os_ucReleaseResource(EM_RES_UART1);
    EA_ucSetDrvInitStatus(EM_IS_INIT_MODEM, EM_DRV_INIT_SUCC);
    uprintf("set modem drv status to succ\r\n"); 
#endif
}

void EA_vUartSendByte(char data)
{
	if(data=='\n')//换行必须加回车
	{
		while(!(rUTRSTAT0 & 0x2));
		WrUTXH0('\r');
	}
	while(!(rUTRSTAT0 & 0x2)); //Wait until THR is empty.	    
	WrUTXH0(data);    
}		


void EA_vUartSendString(char *pt)
{
	while(*pt)
	  	EA_vUartSendByte(*pt++);
}

char zccstring[4096];

void uprintf(char *fmt,...)
{
    if(debug_msg==1)
    {
        va_list ap;
        va_start(ap,fmt);
        vsprintf(zccstring,fmt,ap);
        EA_vUartSendString(zccstring);
        va_end(ap);
    }
}

void EI_vUartPrintHex(int iLength, const void *pvData)
{
#define SOURCESIZE  128
    #define PrintData   uprintf

    const unsigned char *pcData = (const unsigned char *)pvData;
    char SourceBuf[SOURCESIZE];
    int i;
    const char Head1[] = "┌──────────────────────────────────────┐";
    const char Head2[] = "│ OFFSET   0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F    0123456789ABCDEF│";
    const char Head3[] = "├──────────────────────────────────────┤";
    const char Head4[] = "└──────────────────────────────────────┘";
    unsigned int temp, k, m;
    char *AddrPoint, *HexPoint;

    i = 0;
    AddrPoint = SourceBuf;
    sprintf(SourceBuf, "│%08x: ", i);
    temp = strlen(SourceBuf);
    HexPoint = SourceBuf + temp;

    // 显示标题
    PrintData("\r\n%s", Head1);
    PrintData("\r\n%s", Head2);
    PrintData("\r\n%s\r\n", Head3);

    for (i = 0; i < iLength;)
    {
        sprintf(AddrPoint, "│%08x: ", i);

        // 计算一次可显示数据长度
        k = iLength - i > 16 ? 16 : iLength - i;

        // 显示前面16进制数据
        for (m = 0; m < k; m++)
        {
            sprintf(&HexPoint[m*3], "%02X ", pcData[i+m]);
        }
        for (; m < 16; m++)
        {
            memset(&HexPoint[m*3], ' ', 3);
        }

        HexPoint[16*3]   = ' ';
        HexPoint[16*3+1]   = ' ';

        // 显示正常数据
        for (m = 0; m < k; m++)
        {
            HexPoint[16*3 + 2 + m] = pcData[i+m] > 0x20 ? pcData[i+m] : ' ';
        }

        for (; m < 16; m++)
        {
            HexPoint[16*3 + 2 + m] = ' ';
        }

        strcpy(&HexPoint[16*3 + 2 + 16], "│\r\n");
        i += k;

        // 显示数据
        PrintData("%s", SourceBuf);
    }
    PrintData("%s\r\n", Head4);
}


#define EM_modeminit_TASK_STACKSIZE 1024*64
#define EM_modeminit_HISR_PRIORITY	99
uchar EG_modeminit_aucTaskStack[EM_modeminit_TASK_STACKSIZE];
NU_TASK modeminit_Task;

void EA_ucModemInit(void)
{
	char  *aucName = "si/cx";

    uprintf("%s\r\n",__FUNCTION__);
    NU_Create_Task(&modeminit_Task,aucName,EI_vInitModemDriveModule, 
		0,NU_NULL,EG_modeminit_aucTaskStack,EM_modeminit_TASK_STACKSIZE,
		EM_modeminit_HISR_PRIORITY,20,NU_PREEMPT,NU_START);
    REGISTER_FUNCTION(ET_IO_EXPORT_TABLE, BASE, EI_vIODriveError);    
    RETRIEVE_EXPORT_TABLE(ET_IO_EXPORT_TABLE, BASE, "/System/IO_DEVICE", "", EG_ptIOExportTable);
}