max7456.h

/**
 * @file
 * max7456.h
 *
 *  Created on: 10 oct. 2012
 *      Author: Benoit
 */

#ifndef MAX7456_H
#define MAX7456_H


//def next only if you changed your table for an ascii one
//i.e address 0x00 -> ' '
//....
//    address 0x5A -> 'z'
//#define MAX7456_TABLE_ASCII

#include "max7456registers.h"



/**
 *  @mainpage Max7456 Arduino library
 */

/**
 *  @example Max7456WriteTable.cpp
 */


/**
 *  @class Max7456
 *  @brief Represents a max7456 device communicating through SPI port
 */
class Max7456
{
  public:


    /**
     *  Default constructor
     */
    Max7456();


    /**
     *  Constructor
     *  Initialize communications and device
     *  @param pinCS : pin ~CS of the arduino where max7456 is plugged.
     */
    Max7456(byte pinCS);


    /**
     *  Initialize communications and device
     *  @param pinCS : pin ~CS of the arduino where max7456 is plugged.
     *  @code
     *  Max7456 osd;
     *  osd.init(9); //Note it's that it's the same than usinge constructor Max7456(byte pinCS).
     *  @endcode
     */
    void init(byte pinCS);

    /**
     * Set the base time for blink.
     * @param blinkBase : the base time (see datasheet)
     * @param blinkDC : blink Duty cycle (see datasheet).
     */
    void setBlinkParams(byte blinkBase, byte blinkDC);


    /**
     * Set Horizontal and Vertical display offset
     * @param horizontal : the horizontal offset in pixels (between 0 and 63).
     * @param vertical : the vertical offset in pixels (between 0 and 31).
     */
    void setDisplayOffsets(byte horizontal, byte vertical);


    /**
     *  Erase Display Memory.
     */
    void clearScreen();


    /**
     *  Activate osd on screen
     *  @param act :
     *  @li if true OSD is activated
     *  @li if false OSD is deactivated
     */
    void activateOSD(bool act = true);


    /**
     *  Activate input video as a background
     *  @param activExtVid :
     *  @li if true external video is displayed
     *  @li if false external video is not displayed (bakground = grey)
     */
    void activateExternalVideo(bool activExtVid = true);


    /**
     *  Put a character in the memory character of max7456
     *  @param array : the byte array representing the character (54 bytes long)
     *  @param x : the horizontal position of character in memory
     *  @param y : the vertical position of character in memory.
     *  @code
     *  charact c={0x44,....} //Whatever charact here
     *  max.sendCharacter(c,4,5); //put c at 4th line 5th column ie. address 54.
     *  max.sendCharacter(c,0x43); //put c in mem at address 43.
     *  @endcode
     */
    void sendCharacter(const charact array, byte x, byte y);


    /**
     *  Get a character from the character memory of max7456
     *  @param array : the byte array representing the character (54 bytes long)
     *  @param x : the horizontal position of character in character memory
     *  @param y : the vertical position of character in character memory
     */
    void getCharacter(charact array, byte x, byte y);


    /**
     *  Put a string in the display memory of max7456
     *  @param string : The string to be displayed
     *  @param x : the horizontal position of the string on screen
     *  @param y : the vertical position of the string on screen
     *  @param blink : if 1 then character will blink
     *  @param inv : if 1 then color character will be inverted
     *  @note : In order to have this function working,
     *  you must rewrite your Max7456 Eeprom memory and make the first
     *  characters the ascii characters between ' ' and 'z'
     *  (' ' being at address 0x00, z being at address 'z'-' ').
     */
    void print(const char string[], byte x, byte y, byte blink = 0, byte inv = 0);



    /**
     *  Put a float in the display memory of max7456
     *  @param value : The value to be displayed
     *  @param x : the horizontal position of the value on screen
     *  @param y : the vertical position of the value on screen
     *  @param before : number of digits before comma
     *  @param after : number of digits after comma
     *  @param blink : if 1 then character will blink
     *  @param inv : if 1 then color character will be inverted
     *  @note The number of printed characters will be : before + after + 1.
     *  @note Be aware of having a coherence between the number of digits you
     *  enter in the function and the max. value of your double. If not may
     *  result in unpredictable printed string.
     *  @code
     *  max.print(3.14,x,y,3,4);
     *  //Will print "003.1400" on screen
     *  @endcode
     */
    void print(double value, byte x, byte y, byte before, byte after, byte blink = 0, byte inv = 0);


    /**
     *  Put some characters in the display memory of max7456.
     *    The characters are given by their address in the
     *    character memory of the max7456.
     *  @param chars : The characters address array to display
     *  @param size : the array size
     *  @param x : the horizontal position of the value on screen
     *  @param y : the vertical position of the value on screen
     *  @param blink : if 1 then character will blink
     *  @param inv : if 1 then color character will be inverted
     *  @code
     *  char chars[0x04,0x45,0x54]; //the chars addresses array to be send to function.
     *  max.printMax7456Chars(chars,3,x,y);
     *  @endcode
     */
    void printMax7456Chars(byte chars[], byte size, byte x, byte y, byte blink = 0, byte inv = 0);


    /**
     *  Put one character from the character memory in the display memory of max7456
     *  @param address : The address in character memory of the character to be displayed
     *  @param x : the horizontal position of the string on screen
     *  @param y : the vertical position of the string on screen
     *  @param blink : if 1 then character will blink
     *  @param inv : if 1 then color character will be inverted
     */
    void printMax7456Char(const byte address, byte x, byte y, byte blink = 0, byte inv = 0);

    /**
     *  Print a character to Serial port
     *  @param array : the byte array representing the character (54 bytes long)
     *  @param img :
     *  @li true : the character will be displayed as a picture
     *  @li false : the character will be displayed as a byte array
     */
    static void printCharacterToSerial(const charact array, bool img = true);


    /**
     *  Converts a CARACT character to a byte array representation.
     *  @param car : the CARACT character
     *  @return : the byte array representing the character (54 bytes long)
     */
    static byte* CARACT2ByteArray(const CARACT car);


    /**
     *  Converts a byte array to a CARACT character.
     *  @param array : the byte array representing the character (54 bytes long)
     *  @return : the CARACT character
     */
    static CARACT byteArray2CARACT(const charact array);


    /**
     * Get the ith character from program memory
     * @param table the address of the array in prog memory
     * @param i the index of character.
     * @param c the returned character.
     * @note The table must be in program memory as an array of bytes (a multiple of 54).
     * @note When accessing this array, 0x55 are interpreted as 0xFF (you can't have 0xFF in program memory.
     * @note See file example for more informations.
     */
    static void getCARACFromProgMem(const prog_uchar *table, byte i, charact c);

  private:

    byte giveMax7456CharFromAsciiChar(char ascii);
    static void printPixel(byte value);

    byte _pinCS;
    bool _isActivatedOsd;
    //registers (only here for convenience : not forced to be used).
    REG_VM0   _regVm0;
    REG_VM1   _regVm1;
    REG_HOS   _regHos;
    REG_VOS   _regVos;
    REG_DMM   _regDmm;
    REG_DMAH  _regDmah; // not used yet
    REG_DMAL  _regDmal; // not used yet
    REG_DMDI  _regDmdi; // not used yet
    REG_CMM   _regCmm;
    REG_CMAH  _regCmah; // not used yet
    REG_CMAL  _regCmal; // not used yet
    REG_CMDI  _regCmdi; // not used yet
    REG_OSDM  _regOsdm; // not used yet
    REG_RBN   _regRb[16];  // not used yet
    REG_OSDBL _regOsdbl; // not used yet
    REG_STAT  _regStat; // not used yet
    DMDO  _regDmdo; // not used yet
    REG_CMDO  _regCmdo; // not used yet
};


#endif /* MAX7456_H_ */