cinossiotft.h

Go to the documentation of this file.

//******************************************************************************
//******************************************************************************
 
 
#if !defined(_CINOSSIOTFT)
#define _CINOSSIOTFT
 
 
//------------------------------------------------------------------------------
// includes
//------------------------------------------------------------------------------
 
#include <cinoscontainer.h>
#include <xmlparser.h>
 
class CINOSSerialInOut;
 
 
//------------------------------------------------------------------------------
// defines
//------------------------------------------------------------------------------
 
#define DF_SIO_TFT_MOD_XDB              "xcfg-mod-sio-tft"
 
// ascii chars 0-31 don't produce an output and can be used for special meanings
#define DF_SIOTFT_KEY_NOP                   0
#define DF_SIOTFT_KEY_ENTER                 1
#define DF_SIOTFT_KEY_DELETE                2
#define DF_SIOTFT_KEY_UP                    3
#define DF_SIOTFT_KEY_DOWN                  4
#define DF_SIOTFT_KEY_LEFT                  5
#define DF_SIOTFT_KEY_RIGHT                 6
#define DF_SIOTFT_KEY_CLEAR                 7
#define DF_SIOTFT_KEY_ESCAPE                8
#define DF_SIOTFT_KEY_LAYOUT                9
 
#define DF_SIOTFT_EVENT_QUEUE_SIZE          16
 
// text styles such as stretch, invert etc
#define DF_SIOTFT_NORMAL                    0x00000000
#define DF_SIODIS_STRETCHX                  0x00000001
#define DF_SIODIS_STRETCHY                  0x00000002
#define DF_SIOTFT_STRETCH                   (DF_SIODIS_STRETCHX|DF_SIODIS_STRETCHY)
#define DF_SIODIS_INVERT                    0x00000004
 
#define DF_SIOTFT_Pix_X                     480
#define DF_SIOTFT_Pix_Y                     272
 
// special chars for tft
#define DF_SIOTFT_DC1                       0x11
#define DF_SIOTFT_DC2                       0x12
#define DF_SIOTFT_ESC                       0x1B
#define DF_SIOTFT_ACK                       0x06
#define DF_SIOTFT_NAK                       0x15
 
#define DF_SIOTFT_CMD_AREA                  0xD0
 
// tft pre defined colors
#define DF_SIOTFT_Col_transparent           0
#define DF_SIOTFT_Col_black                 1
#define DF_SIOTFT_Col_blue                  2
#define DF_SIOTFT_Col_red                   3
#define DF_SIOTFT_Col_green                 4
#define DF_SIOTFT_Col_magenta               5
#define DF_SIOTFT_Col_cyan                  6
#define DF_SIOTFT_Col_yellow                7
#define DF_SIOTFT_Col_white                 8
#define DF_SIOTFT_Col_dark_gray             9
#define DF_SIOTFT_Col_orange                10
#define DF_SIOTFT_Col_purple                11
#define DF_SIOTFT_Col_light_red             12
#define DF_SIOTFT_Col_dark_cyan             13
#define DF_SIOTFT_Col_light_green           14
#define DF_SIOTFT_Col_light_blue            15
#define DF_SIOTFT_Col_gray                  16
 
// terminal cursor
#define DF_SIOTFT_Cursor_OFF                0
#define DF_SIOTFT_Cursor_ON                 1
 
// Define touch button inversion.
enum ETouchInvert
{
    eTIClear=0,
    eTISet=1,
    eTIToggle=2
};
 
// Define touch reaction.
enum ETouchReaction
{
    eTRInvert,
    eTRSummer
};
 
// Define text alignment.
enum ETextAlignment
{
    eTALeft=0x4C,           // "L"
    eTACenter=0x43,         // "C"
    eTARight=0x52           // "R"
};
 
 
enum EBlockTextAlignment
{
    eBTUpperLeft=1,
    eBTUpperCenter=2,
    eBTUpperRight=3,
    eBTMiddleLeft=4,
    eBTMiddleCenter=5,
    eBTMiddleRight=6,
    eBTLowerLeft=7,
    eBTLowerCenter=8,
    eBTLowerRight=9
};
 
 
enum ETftError
{
    eErrNoError=0,
    eErrFrameErrorACK,
    eErrFrameErrorESC,
    eErrFrameErrorDC1,
    eErrFrameErrorDC2,
    eErrFrameErrorLen,
    eErrTimeout,
    eErrChecksum
};
 
enum ETftReply
{
    eTftRplAnaTouch =       0x00000001
    , eTftRplMatrix =       0x00000002
    , eTftRplTouchArea =    0x00000004
    , eTftRplProjectName =  0x00000008
    , eTftRplInternalInfo = 0x00000010
    , eTftRplHardCopy     = 0x00000020
};
 
// Hold event from display
struct STFTEvent
{
    uint8 m_uCode;          // touch code, free touch event, matrix keyboard etc
    uint8 m_uInfo;          // pressed, released etc
    uint16 m_uXCoord;       // X coord if free touch event
    uint16 m_uYCoord;       // Y coord if free touch event
};
 
struct STFTCharMap
{
    char m_cASCII;
    char m_cLCD;
};
 
struct STFTInternalInfo
{
    uint16 m_uSizeX;
    uint16 m_uSizeY;
    uint8 m_uSoftwareVersion;
    char m_cHardwareRevision [2];
    char m_cTouchInfoX [2];
    char m_cTouchInfoY [2];
    uint16 m_uCRCRom;
    uint16 m_uCRCRomS;
    uint16 m_uCRCDataFlash;
    uint16 m_uCRCDataFlashS;
    uint32 m_uDataFlashSize;
    uint32 m_uDataFlashUsed;
};
 
struct STFTHardcopy
{
    int16 m_iStartXX1 = -1;
    int16 m_iStartYY1 = -1;
    int16 m_iEndXX2   = -1;
    int16 m_iEndYY2   = -1;
    bool m_bUseRLE = true;
};
 
 
//------------------------------------------------------------------------------
//  describe a touch-button
//------------------------------------------------------------------------------
 
struct SBtnFrameColor
{
    uint8 m_uOutSide;
    uint8 m_uInSide;
    uint8 m_uFill;
};
 
struct SBtnFrameShape
{
    uint8 m_uFrameNr;
    uint8 m_uOrientNr;
};
 
struct SBtnFont
{
    uint8 m_uColorNormal;
    uint8 m_uColorSelected;
    uint8 m_uFontNr;
    uint8 m_uZoomX;
    uint8 m_uZoomY;
};
 
struct STouchButton
{
    SBtnFrameColor m_FrameColorNormal;
    SBtnFrameColor m_FrameColorSelected;
    SBtnFrameShape m_FrameShape;
    SBtnFont m_ButtonFont;
    uint16 m_uSizeX;
    uint16 m_uSizeY;
};
 
 
struct STFTFontInfo
{
    uint8 m_uNumber;
    int8 m_iWidth;                  // -1 = proportional
    uint8 m_uHeight;
    uint8 m_uZoomX;
    uint8 m_uZoomY;
 
    void Init() {
        m_uNumber=0;m_iWidth=-1;m_uHeight=0;m_uZoomX=0;m_uZoomY=0;
    }
 
    uint8 GetRealWidth() {
        // there's no fixed width for proportional fonts
        ASSERT_ALWAYS(m_iWidth!=-1);
        return m_iWidth*m_uZoomX;
    }
 
    uint8 GetRealHeight() {
        return m_uHeight*m_uZoomY;
    }
};
 
 
// TX/RX buffer
struct SComBuffer {
    uint16 m_uFrameLength;
    uint8 m_uBuffer[259];       // PktNr,DC1,len,255,bcc = 259bytes
};
 
struct SComFifo {
    uint8 m_uAddrIn;
    uint8 m_uAddrOut;
    uint8 m_uBuffer[256];
 
    void Reset() {
        memset(this, 0, sizeof(SComFifo));
    }
 
    void Put(uint8 auByte) {
        // don't overflow buffer
        if ((uint16)m_uAddrIn<sizeof(m_uBuffer)) {
            m_uBuffer[m_uAddrIn++]=auByte;
        }
    }
 
    uint8 Level() {
        return m_uAddrIn-m_uAddrOut;
    }
 
    uint8 Get() {
        return m_uBuffer[m_uAddrOut++];
    }
};
 
 
//------------------------------------------------------------------------------
// variables
//------------------------------------------------------------------------------
 
 
//------------------------------------------------------------------------------
// CINOSSioTft
//------------------------------------------------------------------------------
 
class CINOSSioTft
{
    //--- user interface -------------------------------------------------------
    public:
        // Universal display-handling-functions
 
        static CINOSSioTft* Find(const char* apName) {
            if (!m_pTfts) {
                return NULL;
            }
            // return result
            return m_pTfts->Find(apName);
        }
 
        static void Add(CINOSSioTft* apTft) {
            if (!m_pTfts) {
                Create();
            }
            m_pTfts->Add(apTft);
        }
 
        static uint32 GetNumber() {
            if (!m_pTfts) {
                return 0;
            }
            return m_pTfts->GetNumber();
        }
 
        static CINOSSioTft* GetAt(uint32 auIndex) {
            if (!m_pTfts) {
                return NULL;
            }
            return m_pTfts->GetAt(auIndex);
        }
 
        const char* GetName() {
            return m_pName;
        }
 
        XMLNode GetConfig() {
            return m_xConfigNode;
        }
 
        uint16 GetWidth() {
            return m_uWidth;
        }
 
        uint16 GetHeight() {
            return m_uHeight;
        }
 
        ETftError ClearDisplay();
 
        ETftError ResetDisplay();
 
        bool GetFontInfo(uint8 auNumber, STFTFontInfo& arInfo);
 
        bool GetEvent(STFTEvent& arEvent);
 
        uint32 EditEnterValue(const char* apName, STFTFontInfo& arFontInfo,
                const char* apDefaultText, char* apInputText, uint32 auBufferSize,
                const char* apKbdDef=NULL, const char* apKbdLayoutName=NULL,
                uint32 auReqKeyBoard= 0);
 
 
        // ---------------------------------------------------------------------
        // display terminal commands
        // ---------------------------------------------------------------------
 
        ETftError TFT_TermColor(uint8 auForeColor, uint8 auBackColor);
 
        ETftError TFT_TermCursorPos(uint8 auColumn, uint8 auRow);
 
        ETftError TFT_TermCursorEnable(uint8 auSet);
 
        ETftError TFT_TermOutput(char* apText);
 
 
        // ---------------------------------------------------------------------
        // display graphical/text commands
        // ---------------------------------------------------------------------
 
        ETftError TFT_DisplayColor(uint8 auForeColor, uint8 auBackColor);
 
        ETftError TFT_DisplayClear();
 
        ETftError TFT_DisplayFill(uint8 auColorNr);
 
        ETftError TFT_TextColor(uint8 auForeColor, uint8 auBackColor);
 
        ETftError TFT_TextFont(uint8 auFontNr);
 
        ETftError TFT_TextZoom(uint8 auZoomX, uint8 auZoomY);
 
        ETftError TFT_TextOutput(ETextAlignment aeAlignment, uint16 auCoordX,
                uint16 auCoordY, char* apText, uint8 auLength=255, uint8 auEndChar=0);
 
        ETftError TFT_TextOutputBlock(uint16 auStartCoordX, uint16 auStartCoordY,
                uint16 auEndCoordX, uint16 auEndCoordY, EBlockTextAlignment aeBlockAlignment,
                char* apText, uint8 auLength=255, uint8 auEndChar=0);
 
        ETftError TFT_GraphicColor(uint8 auForeColor,uint8 auBackColor);
 
        ETftError TFT_RectangleDraw(uint16 auStartCoordX, uint16 auStartCoordY,
                uint16 auEndCoordX, uint16 auEndCoordY);
 
        ETftError TFT_LineDraw(uint16 auStartCoordX, uint16 auStartCoordY,
                uint16 auEndCoordX, uint16 auEndCoordY);
 
        ETftError TFT_LineContinue(uint16 auEndCoordX, uint16 auEndCoordY);
 
        ETftError TFT_PointDraw(uint16 auCoordX, uint16 auCoordY);
 
        ETftError TFT_GraphicZoom(uint8 auZoomX, uint8 auZoomY);
 
        ETftError TFT_GraphicPattern(uint8 auPatternNr);
 
        ETftError TFT_RectangleFill(uint16 auStartCoordX, uint16 auStartCoordY,
                uint16 auEndCoordX, uint16 auEndCoordY, uint8 auColorNo);
 
        ETftError TFT_FrameColor(uint8 auColOut, uint8 auColIn, uint8 auColFill);
 
        ETftError TFT_FrameShape(uint8 auFrameNr, uint8 auFrameOrient);
 
        ETftError TFT_FrameDraw(uint16 auStartCoordX, uint16 auStartCoordY,
                uint16 auEndCoordX, uint16 auEndCoordY);
 
        ETftError TFT_Brightness(uint16 auBrightness);
 
        // ---------------------------------------------------------------------
        // display bitmap/animation commands
        // ---------------------------------------------------------------------
 
        ETftError TFT_BitmapInternal(uint16 auStartCoordX, uint16 auStartCoordY,
                uint8 auPictureNr);
 
        ETftError TFT_BitmapLoad(uint16 auStartCoordX, uint16 auStartCoordY,
                uint8* apData, uint16 auDataLen);
 
        ETftError TFT_HardCopy(STFTHardcopy aInstr);
 
        ETftError TFT_AnimSingle(uint16 auStartCoordX, uint16 auStartCoordY,
                uint8 auAnimNr, uint8 auPictureNr);
 
 
        // ---------------------------------------------------------------------
        // display bargraph commands
        // ---------------------------------------------------------------------
 
 
        // ---------------------------------------------------------------------
        // display instrument commands
        // ---------------------------------------------------------------------
 
        ETftError TFT_InstrumentClear(uint8 auInstrumentNr=0);
 
 
        // ---------------------------------------------------------------------
        // display macro commands
        // ---------------------------------------------------------------------
 
        ETftError TFT_MacroDisable(char acTyp, uint8 auFirst, uint8 auLast);
 
        ETftError TFT_MacroStop(uint8 auStopRun);
 
 
        // ---------------------------------------------------------------------
        // display analog inputs commands
        // ---------------------------------------------------------------------
 
 
        // ---------------------------------------------------------------------
        // display general commands
        // ---------------------------------------------------------------------
 
        ETftError TFT_MatrixSize(uint8 auNrOfInp, uint8 auNrOfOut, uint8 auFilter);
 
        ETftError TFT_Beep(uint8 auStopRun);
 
        ETftError TFT_ProjectName(char* apBuffer, uint16 auSize);
 
        ETftError TFT_InternalInfos(STFTInternalInfo& arInfo);
 
        ETftError TFT_LoadMacroFile(const char* sTableName);
 
        // ---------------------------------------------------------------------
        // display touch commands
        // ---------------------------------------------------------------------
 
        ETftError TFT_TouchFrameColor(uint8 auColNormOut, uint8 auColNormIn,
                uint8 auColNormFill, uint8 auColSelOut, uint8 auColSelIn,
                uint8 auColSelFill);
 
        ETftError TFT_TouchFrameShape(uint8 auFrameNr, uint8 auFrameOrient);
 
        ETftError TFT_TouchFontColor(uint8 auColNormal, uint8 auColSelect);
 
        ETftError TFT_TouchFont(uint8 auFontNr);
 
        ETftError TFT_TouchFontZoom(uint8 auZoomX, uint8 auZoomY);
 
        ETftError TFT_TouchKey(uint16 auCoordX, uint16 auCoordY, uint16 auSizeX,
                uint16 auSizeY, uint8 auUpCode, uint8 auDownCode, char* apText,
                ETextAlignment aeAlignment=eTACenter);
 
        ETftError TFT_TouchSwitch(uint16 auCoordX, uint16 auCoordY, uint16 auSizeX,
                uint16 auSizeY, uint8 auUpCode, uint8 auDownCode, char* apText);
 
        ETftError TFT_TouchArea(uint16 auCoordX, uint16 auCoordY, uint16 auSizeX,
                uint16 auSizeY);
 
        ETftError TFT_TouchReaction(ETouchReaction aeReaction, uint8 auValue);
 
        ETftError TFT_TouchInvert(uint8 auBtnCode, ETouchInvert eSet=eTIToggle);
 
        ETftError TFT_TouchClearButton(uint8 auBtnCode=0, uint8 auValue=1);
 
        ETftError TFT_TouchClearArea(uint16 auCoordX=DF_SIOTFT_Pix_X,
                uint16 auCoordY=DF_SIOTFT_Pix_Y, uint8 auValue=1);
 
        ETftError TouchButton(STouchButton aBtn);
 
        ETftError TouchClear();
 
        /*  \brief General data send function.
            \param apData Buffer of data to send to display.
            \param auLength Length of data to send to display.
            \return Communication error.
        */
        ETftError SendData(uint8* apData, uint8 auLength);
 
 
    //--- internals ------------------------------------------------------------
 
    public:
        CINOSSioTft(XMLNode axConfig);
        virtual ~CINOSSioTft();
 
        int operator < (CINOSSioTft& aObject)
            { return (strcmp(GetName(), aObject.GetName())<0);}
        int operator == (CINOSSioTft& aObject)
            { return (strcmp(GetName(), aObject.GetName())==0);}
        int operator < (const char* aName)
            { return (strcmp(GetName(), aName)<0);}
        int operator == (const char* aName)
            { return (strcmp(GetName(), aName)==0);}
        virtual void PostCreate(void* apParent){};
        virtual bool PreDestroy(bool& bDeleteSelf)
            { return true; };
 
        static void Create() {
            if (!m_pTfts) {
                m_pTfts=new CINOSContainer<CINOSSioTft>("TFT", "CINOSSioTft");
                pINCOItems->Add(m_pTfts->GetRegister(false));
            }
        }
 
        virtual CINCOObject* GetRegister(CINCOObject* apObject=NULL);
 
        void SetWidth(uint16 auWidth) {
            m_uWidth=auWidth;
        }
 
        void SetHeight(uint16 auHeight) {
            m_uHeight=auHeight;
        }
 
    protected:
        void ComHandler();
 
        ETftError GetData(uint8 RecBuf[]);
 
        ETftError RetryGetData(uint8 RecBuf[]);
 
        ETftError GetBufferInfo(uint8 &auSend, uint8 &auReceive,
                bool abEnableRetry=false, bool abAcceptTimeout=false);
 
        void ParseReply(uint8* apRecBuffer, uint16 auRecBufferSize);
 
        char MapChar(char acChar);
 
        void ActivateKeyboard(XMLNode axKbdLayout, const char* apName);
 
        uint8 CalcBcc(uint8 auBuffer[], uint16 auStart, uint16 auLength);
 
        uint8 SendReceive(bool abSynch=true);
 
        ETftError SendData(uint16 auLength, bool abSynch=true);
 
        uint32 SendTest();
 
    protected:
        static CINOSContainer<CINOSSioTft>* m_pTfts;
        XMLNode m_xConfigNode;
        const char* m_pName;
        const char* m_pInterface;
        CINOSSerialInOut* m_pSio;
        CINCOObject* m_pRegister;
        uint16 m_uWidth;
        uint16 m_uHeight;
        char m_cInputBuffer[128];
        uint16 m_uEditCoordX;
        uint16 m_uEditCoordY;
        uint16 m_uEditSizeX;
        uint16 m_uEditSizeY;
        uint8 m_uEditBackCol;
 
        SComBuffer m_TxBuffer;
        SComFifo m_RxFifo;
        SComFifo m_TxFifo;
 
        // pointer to com handler task
        CINOSTask* m_pHandler;
 
        STFTEvent m_EventQueue[DF_SIOTFT_EVENT_QUEUE_SIZE];
        uint8 m_uEventRead;
        uint8 m_uEventWrite;
 
        uint32 m_uReplyMask;
        char m_cProjectName[256];
        STFTInternalInfo m_Info;
 
        uint8* m_pHardCopyBuffer = nullptr;
        int32 m_iHardCopyDataSize = 0;
        uint32 m_uHardCopyBufferSize = 0;
        // (because display does not always send the required data)
        uint32 m_uReadRetries = 0;
 
    // dynamic object handling
    DECLARE_DYNAMIC(CINOSSioTft);
};
 
 
//------------------------------------------------------------------------------
 
#endif // _CINOSSIOTFT
 
 
//------------------------------------------------------------------------------
// end of file