N1568.c

Go to the documentation of this file.

// File includes
#include <string.h>
#include <memory.h>
#include <stdlib.h>
#include "N1568.h"

// File local defines

// Static variables declaration



static const cmd_table N1568_CMD_TABLE[ ]=
{
        { "M",          0,              16},                    
        { "N",          0,              15},                    
        { "C",          0,              255},                   
        { "W",          0,              255},                   
        { "P",          0,              255},                   
        { "g",          0,              127},                   
        { "G",          0,              3},                             
        { "S",          0,              3},                             
        { "T",          0,              3},                             
        { "I",          0,              1},                             
        { "E",          0,              1},                             
        { "X",          1,              1},                             
};

// Static methods declaration



static BOOL parse_channel_status( N1568_data* p_data, N1568_channel_status* channel_status)
{
        const char* ASW_FORMAT_STRING= "CH%2d CFth=%3d CFWdt=%3d P/Z=%3d FG=%3d SH=%1d CG=%1d CGT=%1d %1sIn STR%3s";
        int CH, CFth, CFWdt, P_Z, FG, SH, CG, CGT;
        char In[ 20], STR[ 20];
        char *buff= ( char *)N1568_get_last_answer( p_data);
        // Strip away command echo (if any)
        if( !strncmp( buff, p_data->m_common_data.m_p_last_sent_cmd, strlen( p_data->m_common_data.m_p_last_sent_cmd)))
        {
                buff+= strlen( p_data->m_common_data.m_p_last_sent_cmd);
        }
        if( *buff== '\n')
                ++buff;
        if( !strnicmp( buff, "Error", sizeof( "Error")))
        {
                return FALSE;
        }
        if( sscanf( buff, ASW_FORMAT_STRING, &CH, &CFth, &CFWdt, &P_Z, &FG, &SH, &CG, &CGT, In, STR)!= 10)
        {
                return FALSE;
        }

        channel_status->m_channel_id= CH;
        channel_status->m_cfd_out_width= CFWdt;
        channel_status->m_coarse_gain= CG;
        channel_status->m_discr_thr= CFth;
        channel_status->m_fine_gain= FG;
        channel_status->m_gain_timing= CGT;
        channel_status->m_is_polarity_negative= !strnicmp( In, "N", 1);
        channel_status->m_is_strecher_enabled= !strnicmp( STR, "en", 2);
        channel_status->m_pole_zero_adj= P_Z;
        channel_status->m_shape_setting= SH;
        return TRUE;
}

// Global visible variables declaration

//
//     B O A R D S   H A N D L I N G
//

// 
BOOL N1568_open( N1568_data* p_data, const char *com_str)
{
        CPLConfig cpl_config;
        memset( p_data, 0, sizeof( N1568_data));

        p_data->m_p_asw_buff= malloc( ASW_BUFF_SIZE);
        p_data->m_p_tmp_asw_buff= malloc( ASW_BUFF_SIZE);
        *p_data->m_p_asw_buff= '\0';
        *p_data->m_p_tmp_asw_buff= '\0';

        // Communication device setup
        // COM:9600,N,8,1 Hw flow control
        memset( &cpl_config, 0, sizeof( CPLConfig));
        cpl_config.m_device= CPL_COM;
        strncpy( cpl_config.m_device_config.m_com_device.m_com_str, com_str, sizeof( cpl_config.m_device_config.m_com_device.m_com_str)- 1);
        cpl_config.m_device_config.m_com_device.m_com_str[ sizeof( cpl_config.m_device_config.m_com_device.m_com_str)- 1]= '\0';
        cpl_config.m_device_config.m_com_device.m_baudrate= SERBAUD_9600;
        cpl_config.m_device_config.m_com_device.m_dataBit= DATA_EIGHT;
        cpl_config.m_device_config.m_com_device.m_parity= SERPARITY_NONE;
        cpl_config.m_device_config.m_com_device.m_DTRFlow= DTR_DISABLE;
        cpl_config.m_device_config.m_com_device.m_RTSFlow= RTS_HANDSHAKE;
        cpl_config.m_device_config.m_com_device.m_stopBit= STOP_ONE;

        // basic data iN1568ToolBoxnitialization
        if( !board_open( &p_data->m_common_data, &cpl_config, N1568_CMD_TABLE)) {
                free( p_data->m_p_asw_buff);
                p_data->m_p_asw_buff= (char*)0;
                free( p_data->m_p_tmp_asw_buff);
                p_data->m_p_tmp_asw_buff= (char*)0;
                return FALSE;
        }
        //
        // board specific data initialization
        p_data->m_asw_buff_len= 0;
        memset( p_data->m_p_asw_buff, 0, ASW_BUFF_SIZE);

        return TRUE;
}

// 
BOOL N1568_close( N1568_data* p_data)
{
        BOOL ret_val= TRUE;
        if( !board_close( &p_data->m_common_data)) {
                ret_val= FALSE;
        }
        if( p_data->m_p_asw_buff){

                free( p_data->m_p_asw_buff);
                p_data->m_p_asw_buff= (char*)0;
        }
        if( p_data->m_p_tmp_asw_buff){

                free( p_data->m_p_tmp_asw_buff);
                p_data->m_p_tmp_asw_buff= (char*)0;
        }
        return ret_val;
}

//
//     L E V E L   0   A P I s
//

//
const char* N1568_get_last_answer( N1568_data* p_data) 
{
        int buff_len= p_data->m_asw_buff_len;
        char *src_buff= p_data->m_p_asw_buff;
        char *dest_buff= p_data->m_p_tmp_asw_buff;
        // strip away null chars from the last read buffer
        while( buff_len--)
        {
                if( *src_buff)
                {
                        *dest_buff++= *src_buff;
                }
                ++src_buff;
        }
        *dest_buff++= '\0';
        return p_data->m_p_tmp_asw_buff;
}
//
DLL_API BOOL N1568_send_cmd( N1568_data* p_data, N1568_COMMANDS cmd, UINT8 value, N1568_channel_status* channel_status)
{
        UINT16 asw_buff_size= ASW_BUFF_SIZE- 1;

        // 
        // Send command
        if( !send_cmd( &p_data->m_common_data, cmd, value))
        {
                return FALSE;
        }
        //
        // Receive answer 
        if( !receive_buffer( &p_data->m_common_data, (UINT8*)p_data->m_p_asw_buff, &asw_buff_size, 40)) 
        {
                return FALSE;
        }
        p_data->m_asw_buff_len= asw_buff_size;
        //
        // Parse the output to get actual channel status
        if( channel_status)
        {
                if( !parse_channel_status( p_data, channel_status))
                {
                        return FALSE;
                }
        }
        return TRUE;
}

//
//     L E V E L   1   A P I s
//

//
BOOL N1568_set_module( N1568_data* p_data, UINT8 value)
{
        UINT16 asw_buff_size= ASW_BUFF_SIZE- 1;

        // 
        // Send command
        if( !send_cmd( &p_data->m_common_data, N1568_CMD_MOD, value))
        {
                return FALSE;
        }
        //
        // Receive answer : just to update the board answer buffer
        if( !receive_buffer( &p_data->m_common_data, (UINT8*)p_data->m_p_asw_buff, &asw_buff_size, 3000)) 
        {
                return FALSE;
        }
        p_data->m_asw_buff_len= asw_buff_size;
        return TRUE;
}
        
//
BOOL N1568_set_channel( N1568_data* p_data, UINT8 value, N1568_channel_status* channel_status)
{
        return N1568_send_cmd( p_data, N1568_CMD_CH, value, channel_status);
}
        
//
BOOL N1568_set_input_polarity( N1568_data* p_data, BOOL negative_polarity, N1568_channel_status* channel_status)
{
        return N1568_send_cmd( p_data, N1568_CMD_IN, negative_polarity? 1: 0, channel_status);
}

//
BOOL N1568_set_shape( N1568_data* p_data, UINT8 value, N1568_channel_status* channel_status)
{
        return N1568_send_cmd( p_data, N1568_CMD_SH, value, channel_status);
}

//
BOOL N1568_set_pole_zero_adj( N1568_data* p_data, UINT8 value, N1568_channel_status* channel_status)
{
        return N1568_send_cmd( p_data, N1568_CMD_PZ, value, channel_status);
}

//
BOOL N1568_set_fine_gain( N1568_data* p_data, UINT8 value, N1568_channel_status* channel_status)
{
        return N1568_send_cmd( p_data, N1568_CMD_FG, value, channel_status);
}

//
BOOL N1568_set_coarse_gain( N1568_data* p_data, UINT8 value, N1568_channel_status* channel_status)
{
        return N1568_send_cmd( p_data, N1568_CMD_CG, value, channel_status);
}

//
BOOL N1568_set_discr_thr( N1568_data* p_data, UINT8 value, N1568_channel_status* channel_status)
{
        return N1568_send_cmd( p_data, N1568_CMD_CF_TH, value, channel_status);
}

//
BOOL N1568_set_gain_of_timing( N1568_data* p_data, UINT8 value, N1568_channel_status* channel_status)
{
        return N1568_send_cmd( p_data, N1568_CMD_CGT, value, channel_status);
}

//
BOOL N1568_set_stretcher( N1568_data* p_data, BOOL enable, N1568_channel_status* channel_status)
{
        return N1568_send_cmd( p_data, N1568_CMD_STR, enable? 1: 0, channel_status);
}

//
BOOL N1568_set_cfd_out_width( N1568_data* p_data, UINT8 value, N1568_channel_status* channel_status)
{
        return N1568_send_cmd( p_data, N1568_CMD_CFW, value, channel_status);
}

//
BOOL N1568_export( N1568_data* p_data)
{
        UINT16 asw_buff_size= ASW_BUFF_SIZE- 1;

        // 
        // Send command
        if( !send_cmd( &p_data->m_common_data, N1568_CMD_EXP, 1))
        {
                return FALSE;
        }
        //
        // Receive answer : just to update the board answer buffer
        if( !receive_buffer( &p_data->m_common_data, (UINT8*)p_data->m_p_asw_buff, &asw_buff_size, 3000)) 
        {
                return FALSE;
        }
        p_data->m_asw_buff_len= asw_buff_size;
        return TRUE;
}

//
//     L E V E L   2   A P I s
//

//
//     M I S C E L L A N E O U S   A P I s
//
//
const char* N1568_SW_rev( void)
{
        return "N1568SDK Rev. 1.0";
}

---