yatemodem.h

C++ modem驱动代码

/*
 * yatemodem.h
 * This file is part of the YATE Project http://YATE.null.ro
 *
 * Yet Another Modem
 *
 * Yet Another Telephony Engine - a fully featured software PBX and IVR
 * Copyright (C) 2004-2006 Null Team
 *
 * 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.
 */

#ifndef __YATEMODEM_H
#define __YATEMODEM_H

#include <yateclass.h>

#ifdef _WINDOWS

#ifdef LIBYMODEM_EXPORTS
#define YMODEM_API __declspec(dllexport)
#else
#ifndef LIBYMODEM_STATIC
#define YMODEM_API __declspec(dllimport)
#endif
#endif

#endif /* _WINDOWS */

#ifndef YMODEM_API
#define YMODEM_API
#endif


/** 
 * Holds all Telephony Engine related classes.
 */
namespace TelEngine {

class BitAccumulator;                    // 1-byte length bit accumulator
class FSKModem;                          // Frequency Shift Keying modulator/demodulator
class UART;                              // UART receiver/transmitter
class UARTBuffer;                        // A byte accumulator used by an UART
class ETSIModem;                         // An analog signal processor as defined by ETSI
// Internal forward declarations
class BitBuffer;                         // Used to accumulate all bits to be printed to output
class FSKFilter;                         // The internal signal filter


/**
 * This class encapsulates an 8 bits length buffer used to accumulate bits
 * @short A 1-byte length bit accumulator
 */
class YMODEM_API BitAccumulator
{
public:
    /**
     * Constructor
     * @param dataBits The buffer size. Values interval 1..8
     */
    inline BitAccumulator(unsigned char dataBits)
	: m_crtByte(0), m_crtPos(0), m_dataBits(dataBits), m_oddParity(false)
	{}

    /**
     * Get the buffer size
     * @return The buffer size
     */
    inline unsigned char dataBits() const
	{ return m_dataBits; }

    /**
     * Set the buffer size. Reset the accumulator
     * @param value The new buffer size. Values interval 1..8
     */
    inline void dataBits(unsigned char value) {
	    m_dataBits = value;
	    reset();
	}

    /**
     * Reset the accumulator. Returns the old data
     * @param oddParity Optional pointer to get the parity of old data
     * @return The old data
     */
    inline unsigned char reset(bool* oddParity = 0) {
	    unsigned char tmp = m_crtByte;
	    m_crtByte = m_crtPos = 0;
	    if (oddParity)
		*oddParity = m_oddParity;
	    m_oddParity = false;
	    return tmp;
	}

    /**
     * Accumulate a bit. Reset accumulator when full
     * @param bit The bit value to accumulate
     * @param oddParity Optional pointer to get the data parity when full
     * @return The accumulated byte or a value greater then 255 if incomplete
     */
    inline unsigned int accumulate(bool bit, bool* oddParity = 0) {
	    if (bit) {
		m_crtByte |= (1 << m_crtPos);
		m_oddParity = !m_oddParity;
	    }
	    m_crtPos++;
	    if (m_crtPos != m_dataBits)
		return 0xffff;
	    return reset(oddParity);
	}

private:
    unsigned char m_crtByte;             // Current partial byte
    unsigned char m_crtPos;              // Current free bit position
    unsigned char m_dataBits;            // The length of a data byte (interval: 1..8)
    bool m_oddParity;                    // The parity of the current byte value (true: odd)
};


/**
 * This is a modulator/demodulator class attached to an UART. Used to demodulate bits
 *  from frequency modulated signal and send them to an UART
 * @short A Frequency Shift Keying modem
 */
class YMODEM_API FSKModem
{
public:
    /**
     * Modem type enumeration
     */
    enum Type {
	ETSI = 0,                        // ETSI caller id signal: MARK:1200 SPACE:2200 BAUDRATE:1200
	                                 //  SAMPLERATE:8000 SAMPLES/BIT:7 STOPBITS:1 PARITY:NONE
	TypeCount = 1
	// NOTE: Don't change these values: they are used as array indexes
    };

    /**
     * Constructor
     * @param params Modem parameters (including modemtype)
     * @param uart The UART attached to this modem
     */
    FSKModem(const NamedList& params, UART* uart);

    /**
     * Destructor
     */
    ~FSKModem();

    /**
     * Check if this modem is terminated. Need reset if so.
     * The modem can terminate processing on UART's request
     * @return True if this modem is terminated
     */
    inline bool terminated() const
	{ return m_terminated; }

    /**
     * Get the type of this modem
     * @return The modem type
     */
    inline int type() const
	{ return m_type; }

    /**
     * Reset modem to its initial state
     */
    void reset();

    /**
     * Data processor. Demodulate received data. Feed the UART with received bits
     * @param data The data to process
     * @return False to stop feedding data (terminated)
     */
    bool demodulate(const DataBlock& data);

    /**
     * Create a buffer containing the modulated representation of a message.
     * A data pattern (depending on modem's type) will be added before the message.
     * A mark pattern (2ms long) will be added after the message.
     * Reset the modem before each request to modulate
     * @param dest Destination buffer
     * @param data Message data (each byte will be enclosed in start/stop/parity bits)
     */
    void modulate(DataBlock& dest, const DataBlock& data);

    /**
     * Append a raw buffer to a data block
     * @param dest Destination buffer
     * @param buf Buffer to append to destination
     * @param len the number of bytes to append starting with buf
     */
    static inline void addRaw(DataBlock& dest, void* buf, unsigned int len) {
	    DataBlock tmp(buf,len,false);
	    dest += tmp;
	    tmp.clear(false);
	}

    /**
     * Keep the modem type names. Useful to configure the modem
     */
    static TokenDict s_typeName[];

private:
    int m_type;                          // Modem type
    bool m_terminated;                   // Terminated flag (need reset if true)
    FSKFilter* m_filter;                 // Internal filter used to demodulate received data
    UART* m_uart;                        // The UART using this modem's services
    DataBlock m_buffer;                  // Partial input buffer when used to demodulate or modulate data
    BitBuffer* m_bits;                   // Bit buffer used when debugging
};


/**
 * Accumulate data bits received from a modem
 * @short An UART receiver/transmitter
 */
class YMODEM_API UART : public DebugEnabler
{
public:
    /**
     * UART state enumeration
     */
    enum State {
	Idle,                            // Not started
	BitStart,                        // Waiting for start bit (SPACE)
	BitData,                         // Accumulate data bits
	BitParity,                       // Waiting for parity bit(s)
	BitStop,                         // Waiting for stop bit (MARK)
	UARTError,                       // Error
    };

    /**
     * UART error enumeration
     */
    enum Error {
	EFraming,                        // Frame error: invalid stop bit(s)
	EParity,                         // Parity error
	EChksum,                         // Message checksum error
	EInvalidData,                    // Invalid (inconsistent) data
	EUnknown,                        // Unknown error
	EStopped,                        // Aborted by descendants
	ENone
    };

    /**
     * Constructor
     * @param state The initial state of this UART
     * @param params The UART's parameters
     * @param name The name of this debug enabler
     */
    UART(State state, const NamedList& params, const char* name = 0);

    /**
     * Destructor
     */
    virtual ~UART()
	{}

    /**
     * Get the current state of this UART
     * @return The current state of this UART as enumeration
     */
    inline State state() const
	{ return m_state; }

    /**
     * Get the current error state of this UART, if any
     * @return The current error state of this UART as enumeration
     */
    inline Error error() const
	{ return m_error; }

    /**
     * Get the type of this UART's modem
     * @return The type of this UART's modem
     */
    inline int modemType() const
	{ return m_modem.type(); }

    /**
     * Get the data bit accumulator used by this UART
     * @return The data bit accumulator used by this UART
     */
    inline const BitAccumulator& accumulator() const
	{ return m_accumulator; }

    /**
     * Reset this UART
     * @param newState The state to reset to
     */
    virtual void reset(State newState = Idle);

    /**
     * Send data to the enclosed modem to be demodulated
     * @param data The data to process
     * @return False to stop processing