SmartPDCode/truing_control/STS_FreeRTOS/MODBUS/BARE/port/port.c

/*
 * FreeModbus Libary: BARE Demo Application
 * Copyright (C) 2006 Christian Walter <wolti@sil.at>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * File: $Id$
 */

/* ----------------------- Modbus includes ----------------------------------*/
#include "mb.h"
#include "mbport.h"
#include "string.h"
#include "main.h"


/* ----------------------- Defines ------------------------------------------*/
//输入寄存器
#define REG_INPUT_START  3000
#define REG_INPUT_NREGS  1

//保持寄存器
#define REG_HOLD_START   STS_R_START
#define REG_HOLD_NREGS   500

//线圈
#define REG_COILS_START  0
#define REG_COILS_NREGS  1

//开关寄存器
#define REG_DISCRETE_START 0
#define REG_DISCRETE_NREGS 1
/* ----------------------- Static variables ---------------------------------*/
static USHORT   usRegInputStart = REG_INPUT_START;
static USHORT   usRegInputBuf[REG_INPUT_NREGS];


static USHORT   usRegHoldStart = REG_HOLD_START;
static USHORT   usRegHoldBuf[128];

static USHORT   usRegCoilsStart = REG_COILS_START;
static uint8_t  usRegCoilsBuf[REG_COILS_NREGS];

static USHORT   usRegDiscreteStart = REG_DISCRETE_START;
static uint8_t  usRegDiscreteBuf[REG_DISCRETE_NREGS];

extern unsigned long int Delay_Ms;
extern unsigned char detection_value;



/* ----------------------- Start implementation -----------------------------*/
//int
//main( void )
//{
//    eMBErrorCode    eStatus;

//    eStatus = eMBInit( MB_RTU, 0x0A, 0, 38400, MB_PAR_EVEN );

//    /* Enable the Modbus Protocol Stack. */
//    eStatus = eMBEnable(  );

//    for( ;; )
//    {
//        ( void )eMBPoll(  );

//        /* Here we simply count the number of poll cycles. */
//        usRegInputBuf[0]++;
//    }
//}
/****************************************************************************
* 名	  称：eMBRegInputCB
* 功    能：读取输入寄存器，对应功能码是 04 eMBFuncReadInputRegister
* 入口参数：pucRegBuffer: 数据缓存区，用于响应主机
*						usAddress: 寄存器地址
*						usNRegs: 要读取的寄存器个数
* 出口参数：
* 注	  意：上位机发来的 帧格式是: SlaveAddr(1 Byte)+FuncCode(1 Byte)
*								+StartAddrHiByte(1 Byte)+StartAddrLoByte(1 Byte)
*								+LenAddrHiByte(1 Byte)+LenAddrLoByte(1 Byte)+
*								+CRCAddrHiByte(1 Byte)+CRCAddrLoByte(1 Byte)
*							3 区
****************************************************************************/
eMBErrorCode
eMBRegInputCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs )
{
    eMBErrorCode    eStatus = MB_ENOERR;
    int             iRegIndex;
		usAddress = usAddress - 1;
	
    if( ( usAddress >= REG_INPUT_START ) && ( usAddress + usNRegs <= REG_INPUT_START + REG_INPUT_NREGS ) )
    {
        iRegIndex = ( int )( usAddress - usRegInputStart );
        while( usNRegs > 0 )
        {
            *pucRegBuffer++ = ( unsigned char )( usRegInputBuf[iRegIndex] >> 8 );
            *pucRegBuffer++ = ( unsigned char )( usRegInputBuf[iRegIndex] & 0xFF );
            iRegIndex++;
            usNRegs--;
        }
				{
					
				}
    }
    else
    {
        eStatus = MB_ENOREG;
    }

    return eStatus;
}
/****************************************************************************
* 名	  称：eMBRegHoldingCB
* 功    能：对应功能码有：06 写保持寄存器 eMBFuncWriteHoldingRegister
*													16 写多个保持寄存器 eMBFuncWriteMultipleHoldingRegister
*													03 读保持寄存器 eMBFuncReadHoldingRegister
*													23 读写多个保持寄存器 eMBFuncReadWriteMultipleHoldingRegister
* 入口参数：pucRegBuffer: 数据缓存区，用于响应主机
*						usAddress: 寄存器地址
*						usNRegs: 要读写的寄存器个数
*						eMode: 功能码
* 出口参数：
* 注	  意：4 区
****************************************************************************/
unsigned char Chal_num;
uint16_t WusNRegs;
uint16_t WiRegIndex;
unsigned int WeeiRegIndex;



eMBErrorCode
eMBRegHoldingCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNRegs, eMBRegisterMode eMode )
{
    eMBErrorCode    eStatus = MB_ENOERR;
    uint16_t             iRegIndex;
		usAddress = usAddress - 1;
		
		sts_data_t *t_data = get_sts();
		md_data_t *data = &t_data->m_data;
    if((usAddress >= REG_HOLD_START) && ((usAddress+usNRegs) <= (REG_HOLD_START + 200)))
    {
        iRegIndex = (uint16_t)(usAddress - usRegHoldStart);
				WiRegIndex = iRegIndex;
        switch(eMode)
        {
        case MB_REG_READ://读寄存器
					{
						{
							uint16_t *start = (uint16_t*)data;
							memcpy(&usRegHoldBuf[0],(uint8_t*)(start+iRegIndex),usNRegs*2);
						}
						int i = 0;
            while(usNRegs > 0)
            {
                *pucRegBuffer++ = (uint8_t)(usRegHoldBuf[i] >> 8);
                *pucRegBuffer++ = (uint8_t)(usRegHoldBuf[i] & 0xFF);
                i++;
                usNRegs--;
            }
					}
            break;
        case MB_REG_WRITE://写寄存器
				{
						WusNRegs = usNRegs;
						int i = 0;
            while(usNRegs > 0)
            {
                usRegHoldBuf[i] = *pucRegBuffer++ << 8;
                usRegHoldBuf[i] |= *pucRegBuffer++;
                i++;
                usNRegs--;
            }
						{
							if(usAddress == STS_RW_CHIOSE_START)
							{
								(usRegHoldBuf[0]== 0) ? t_data->choise_input(INPUT_CHANNEL_1) : t_data->choise_input(INPUT_CHANNEL_2);						
							}else if(usAddress >= STS_RW_EEP_STATUS_START && usAddress < STS_RW_EEP_ELE_CLEAR_CONSUMER)
							{
								WeeiRegIndex = (uint16_t)(usAddress - STS_RW_EEP_STATUS_START);
								uint16_t *p_start = (uint16_t *)(&(data->m_rw.rw_data.md_eep));
								memcpy(p_start+WeeiRegIndex,&usRegHoldBuf[0],WusNRegs*2);
								if(usAddress == STS_RW_EEP_STATUS_START)
								{
									usRegHoldBuf[0] ? t_data->open_output():t_data->close_output();	
								}else if(usAddress > STS_RW_EEP_INPUT_TH_START && usAddress <=STS_RW_EEP_OUTPUT_TH_START)
								{
									for(int i =0 ; i < 2; i++) {
										if(data->m_rw.rw_data.md_eep.input_th[i].voltage_max_1 <= SMALL_VALUE)
											t_data->input_wanning_en[i].vmax_en = 0;
										else
											t_data->input_wanning_en[i].vmax_en = 1;	
										if(data->m_rw.rw_data.md_eep.input_th[i].voltage_min_1 <= SMALL_VALUE)
											t_data->input_wanning_en[i].vmin_en = 0;
										else
											t_data->input_wanning_en[i].vmin_en = 1;
										if(data->m_rw.rw_data.md_eep.input_th[i].freq_max_1 <= SMALL_VALUE)
											t_data->input_wanning_en[i].freqmax_en = 0;
										else
											t_data->input_wanning_en[i].freqmax_en = 1;
										if(data->m_rw.rw_data.md_eep.input_th[i].freq_min_1 <= SMALL_VALUE)
											t_data->input_wanning_en[i].freqmin_en = 0;
										else
											t_data->input_wanning_en[i].freqmin_en = 1;
									}								
								}else if(usAddress >= STS_RW_EEP_OUTPUT_TH_START && usAddress < STS_RW_EEP_TEMP_TH_START)
								{
									if(t_data->m_data.m_rw.rw_data.md_eep.output_th.voltage_max_1 <= SMALL_VALUE)
										t_data->output_wanning_en.vmax_en = 0;
									else
										t_data->output_wanning_en.vmax_en = 1;
									
									if(t_data->m_data.m_rw.rw_data.md_eep.output_th.voltage_min_1 <= SMALL_VALUE)
										t_data->output_wanning_en.vmin_en = 0;
									else
										t_data->output_wanning_en.vmin_en = 1;

									if(t_data->m_data.m_rw.rw_data.md_eep.output_th.current_max_1 <= SMALL_VALUE)
										t_data->output_wanning_en.imax_en = 0;
									else
										t_data->output_wanning_en.imax_en = 1;

									if(t_data->m_data.m_rw.rw_data.md_eep.output_th.power_max_1 <= SMALL_VALUE)
										t_data->output_wanning_en.pmax_en = 0;
									else
										t_data->output_wanning_en.pmax_en = 1;

									if(t_data->m_data.m_rw.rw_data.md_eep.output_th.consumer_max_1 <= SMALL_VALUE)
										t_data->output_wanning_en.cmax_en = 0;
									else
										t_data->output_wanning_en.cmax_en = 1;												
								}else if(usAddress >= STS_RW_EEP_TEMP_TH_START  && usAddress < STS_RW_EEP_ELE_V_I_ARGV)
								{
									if(t_data->m_data.m_rw.rw_data.md_eep.temp_th.max_temp > 0x7fff) t_data->m_data.m_rw.rw_data.md_eep.temp_th.max_temp = 0; 
									if(t_data->m_data.m_rw.rw_data.md_eep.temp_th.min_temp > 0x7fff) t_data->m_data.m_rw.rw_data.md_eep.temp_th.min_temp = 0; 
								}
								t_data->write_eeprom_page(EEP_MD_START+(WeeiRegIndex*2),&usRegHoldBuf[0],WusNRegs*2);
							}else if(usAddress == STS_RW_EEP_ELE_CLEAR_CONSUMER)
							{
								t_data->iic_consumer = 0;
							}else if(usAddress ==  STS_RW_EEP_ELE_CLEAR_BEEP)
							{
								t_data->beep_flag = 0;
								t_data->i_beep_flag[0].beep_waning = 0;
								t_data->i_beep_flag[1].beep_waning = 0;
								t_data->o_beep_flag.beep_waning = 0;
								beep_timer_stop();
								t_data->clear_beep();
							}
							else
							{
								eStatus = MB_ENOREG;
							}
						}
						
        }
			}
    }
    else//错误
    {
        eStatus = MB_ENOREG;
    }

    return eStatus;
}

/****************************************************************************
* 名	  称：eMBRegCoilsCB
* 功    能：对应功能码有：01 读线圈 eMBFuncReadCoils
*													05 写线圈 eMBFuncWriteCoil
*													15 写多个线圈 eMBFuncWriteMultipleCoils
* 入口参数：pucRegBuffer: 数据缓存区，用于响应主机
*						usAddress: 线圈地址
*						usNCoils: 要读写的线圈个数
*						eMode: 功能码
* 出口参数：
* 注	  意：如继电器
*						0 区
****************************************************************************/
eMBErrorCode
eMBRegCoilsCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNCoils, eMBRegisterMode eMode )
{
    eMBErrorCode    eStatus = MB_ENOERR;
    USHORT          iRegIndex;
    USHORT usCoilGroups = ((usNCoils - 1) / 8 + 1);
    UCHAR  ucStatus     = 0;
    UCHAR  ucBits       = 0;
    UCHAR  ucDisp       = 0;
		usAddress = usAddress - 1;
	
    if((usAddress >= REG_COILS_START) &&	((usAddress + usNCoils) <= (REG_COILS_START + REG_COILS_NREGS)))
    {
        iRegIndex = (int)(usAddress - usRegCoilsStart);
        switch(eMode)
        {
        case MB_REG_READ://读线圈
            while(usCoilGroups--)
            {
                ucDisp = 0;
                ucBits = 8;
                while((usNCoils--) != 0 && (ucBits--) != 0)
                {
                    ucStatus |= (usRegCoilsBuf[iRegIndex++] << (ucDisp++));
                }
                *pucRegBuffer++ = ucStatus;
            }
            break;
        case MB_REG_WRITE://写线圈
            while(usCoilGroups--)
            {
                ucStatus = *pucRegBuffer++;
                ucBits   = 8;
                while((usNCoils--) != 0 && (ucBits--) != 0)
                {
                    usRegCoilsBuf[iRegIndex++] = ucStatus & 0X01;
                    ucStatus >>= 1;
                }
            }
        }
    }
    else//错误
    {
        eStatus = MB_ENOREG;
    }

    return eStatus;
}
/****************************************************************************
* 名	  称：eMBRegDiscreteCB 
* 功    能：读取离散寄存器，对应功能码有：02 读离散寄存器 eMBFuncReadDiscreteInputs
* 入口参数：pucRegBuffer: 数据缓存区，用于响应主机   
*						usAddress: 寄存器地址
*						usNDiscrete: 要读取的寄存器个数
* 出口参数：
* 注	  意：1 区
****************************************************************************/
eMBErrorCode
eMBRegDiscreteCB( UCHAR * pucRegBuffer, USHORT usAddress, USHORT usNDiscrete )
{
    eMBErrorCode    eStatus = MB_ENOERR;
    USHORT          iRegIndex;
    USHORT usDiscreteGroups = ((usNDiscrete - 1) / 8 + 1);
    UCHAR  ucStatus     = 0;
    UCHAR  ucBits       = 0;
    UCHAR  ucDisp       = 0;
		usAddress = usAddress - 1;
	
    if((usAddress >= REG_DISCRETE_START) &&	((usAddress + usNDiscrete) <= (REG_DISCRETE_START + REG_DISCRETE_NREGS)))
    {
        iRegIndex = (int)(usAddress - usRegDiscreteStart);

				while(usDiscreteGroups--)
				{
						ucDisp = 0;
						ucBits = 8;
						while((usNDiscrete--) != 0 && (ucBits--) != 0)
						{
								if(usRegDiscreteBuf[iRegIndex])
								{
										ucStatus |= (1 << ucDisp);
								}
								ucDisp++;
						}
						*pucRegBuffer++ = ucStatus;
				}
    }
    else//错误
    {
        eStatus = MB_ENOREG;
    }

    return eStatus;
}