yatemodem.h

 
#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
 

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
 

class YMODEM_API BitAccumulator
{
public:
    inline BitAccumulator(unsigned char dataBits)
        : m_crtByte(0), m_crtPos(0), m_dataBits(dataBits), m_oddParity(false)
        {}

    inline unsigned char dataBits() const
        { return m_dataBits; }

    inline void dataBits(unsigned char value) {
            m_dataBits = value;
            reset();
        }

    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;
        }

    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)
};
 

class YMODEM_API FSKModem
{
public:
    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
    };

    FSKModem(const NamedList& params, UART* uart);

    ~FSKModem();

    inline bool terminated() const
        { return m_terminated; }

    inline int type() const
        { return m_type; }

    void reset();

    bool demodulate(const DataBlock& data);

    void modulate(DataBlock& dest, const DataBlock& data);

    static inline void addRaw(DataBlock& dest, void* buf, unsigned int len) {
            DataBlock tmp(buf,len,false);
            dest += tmp;
            tmp.clear(false);
        }

    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
};
 

class YMODEM_API UART : public DebugEnabler
{
public:
    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
    };

    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
    };

    UART(State state, const NamedList& params, const char* name = 0);

    virtual ~UART()
        {}

    inline State state() const
        { return m_state; }

    inline Error error() const
        { return m_error; }

    inline int modemType() const
        { return m_modem.type(); }

    inline const BitAccumulator& accumulator() const
        { return m_accumulator; }

    virtual void reset(State newState = Idle);

    inline bool demodulate(const DataBlock& data)
        { return m_modem.demodulate(data); }

    inline bool modulate(DataBlock& dest, NamedList& params) {
            DataBlock data;
            if (!createMsg(params,data))
                return false;
            m_modem.modulate(dest,data);
            return true;
        }

    inline void modulate(DataBlock& dest, const DataBlock& src)
        { m_modem.modulate(dest,src); }

    bool recvBit(bool value);

    virtual bool recvByte(unsigned char data)
        { return false; }

    virtual bool fskStarted()
        { return true; }

    static TokenDict s_errors[];
 
protected:
    virtual int idleRecvByte(unsigned char data)
        { return false; }

    virtual bool createMsg(NamedList& params, DataBlock& data)
        { return false; }

    bool error(Error e);
 
private:
    // Change this UART's state
    void changeState(State newState);
 
    FSKModem m_modem;                    // The modem used by this UART
    State m_state;                       // The state of this UART
    Error m_error;                       // The error type if state is error
    int m_parity;                        // Used parity: 0=none, -1=odd, 1=even
    bool m_expectedParity;               // The expected value of the parity bit if used
    BitAccumulator m_accumulator;        // The data bits accumulator
};
 

class YMODEM_API UARTBuffer
{
public:
    inline UARTBuffer(UART* client)
        : m_client(client)
        { reset(); }

    inline const DataBlock& buffer() const
        { return m_buffer; }

    inline unsigned int free() const
        { return m_free; }

    inline void reset(unsigned int len = 0) {
            m_buffer.clear();
            m_crtIdx = m_free = 0;
            if (len) {
                m_buffer.assign(0,len);
                m_free = len;
            }
        }

    inline bool accumulate(unsigned char value) {
            if (m_free) {
                ((unsigned char*)m_buffer.data())[m_crtIdx++] = value;
                m_free--;
                return true;
            }
            Debug(m_client,DebugNote,"Buffer overflow");
            return false;
        }
 
private:
    UART* m_client;                      // The client
    unsigned int m_crtIdx;               // Current index n buffer
    unsigned int m_free;                 // Free buffer length
    DataBlock m_buffer;                  // The buffer
};
 

class YMODEM_API ETSIModem : public UART
{
public:
    enum State {
        StateError,                      // Error encountered: need reset
        WaitFSKStart,                    // Waiting for data start pattern
        WaitMark,                        // Waiting for mark pattern
        WaitMsg,                         // Wait a message
        WaitMsgLen,                      // Received message: wait length
        WaitParam,                       // Wait a parameter
        WaitParamLen,                    // Received parameter: wait length
        WaitData,                        // Received parameter length: wait data
        WaitChksum,                      // Wait checksum
    };

    enum MsgType {
        MsgCallSetup = 0x80,             // Call setup
        MsgMWI       = 0x82,             // Message waiting indicator
        MsgCharge    = 0x86,             // Advise of charge
        MsgSMS       = 0x89,             // Short message service
    };

    enum MsgParam {
        DateTime         = 0x01,         // 8           Date and Time
        CallerId         = 0x02,         // max. 20     Calling Line Identity
        CalledId         = 0x03,         // max. 20     Called Line Identity
        CallerIdReason   = 0x04,         // 1           Reason for Absence of Calling Line Identity
        CallerName       = 0x07,         // max. 50     Calling Party Name
        CallerNameReason = 0x08,         // 1           Reason for absence of Calling Party Name
        VisualIndicator  = 0x0B,         // 1           Visual Indicator
        MessageId        = 0x0D,         // 3           Message Identification
        LastMsgCLI       = 0x0E,         // max. 20     Last Message CLI
        CompDateTime     = 0x0F,         // 8 or 10     Complementary Date and Time
        CompCallerId     = 0x10,         // max. 20     Complementary Calling Line Identity
        CallType         = 0x11,         // 1           Call type
        FirstCalledId    = 0x12,         // max. 20     First Called Line Identity
        MWICount         = 0x13,         // 1           Number of Messages
        FwdCallType      = 0x15,         // 1           Type of Forwarded call
        CallerType       = 0x16,         // 1           Type of Calling user
        RedirNumber      = 0x1A,         // max. 20     Redirecting Number
        Charge           = 0x20,         // 14          Charge
        AdditionalCharge = 0x21,         // 14          Additional Charge
        Duration         = 0x23,         // 6           Duration of the Call
        NetworkID        = 0x30,         // max. 20     Network Provider Identity
        CarrierId        = 0x31,         // max. 20     Carrier Identity
        SelectFunction   = 0x40,         // 2-21        Selection of Terminal Function
        Display          = 0x50,         // max. 253    Display Information
        ServiceInfo      = 0x55,         // 1           Service Information
        Extension        = 0xE0,         // 10          Extension for network operator use
        Unknown
    };

    ETSIModem(const NamedList& params, const char* name = 0);

    virtual ~ETSIModem();

    virtual void reset();

    virtual bool recvByte(unsigned char data);

    static TokenDict s_msg[];

    static TokenDict s_msgParams[];
 
protected:
    virtual int idleRecvByte(unsigned char data);

    virtual bool recvParams(MsgType msg, const NamedList& params)
        { return false; }

    virtual bool decode(MsgType msg, const DataBlock& buffer);

    virtual bool createMsg(NamedList& params, DataBlock& data);
 
private:
    // Change decoder's state
    void changeState(State newState);
 
    UARTBuffer m_buffer;                 // The buffer used to accumulate messages
    State m_state;                       // Decoder state
    unsigned char m_waitSeizureCount;    // Expected number of channel seizure bytes in a row
    unsigned char m_crtSeizureCount;     // Current number of channel seizure bytes in a row
    unsigned char m_crtMsg;              // Current message id
    unsigned char m_crtParamLen;         // Current receiving parameter length
    unsigned int m_chksum;               // Current calculated checksum
};
 
}
 
#endif /* __YATEMODEM_H */
 
/* vi: set ts=8 sw=4 sts=4 noet: */