examples/Max7456Write/Max7456Write.ino

@@ -1416,8 +1416,8 @@ void setup() {
     Serial.print(number);
     Serial.println(F(" of 255"));
     MAX7456::getCARACFromProgMem(tableOfAllCharacters, i, currentChar); //Because the table is too big for ram memory
-    MAX7456::printCharacterToSerial(tableOfAllCharacters[i], true);
-    osd->sendCharacter(currentChar, i); //We send currentChar at address i.
+
+    osd->sendCharacter(currentChar, i & 0xF0, i & 0xF0); //We send currentChar at address i.
   }
   Serial.println(F("---------- DONE! ----------"));
   Serial.println(F("please unplug your arduino."));

examples/WriteMCM/WriteMCM.ino

@@ -74,7 +74,7 @@ void setup()
 {
   byte spi_junk;
   int x;
-  Serial.begin(115200);
+  Serial.begin(38400);
   Serial.flush();
 
   digitalWrite(USBSELECT,HIGH); //disable USB chip

src/MAX7456.cpp

@@ -2,6 +2,7 @@
 #include <Arduino.h>
 #include <SPI.h>
 
+
 //-----------------------------------------------------------------------------
 // Implements MAX7456::MAX7456
 //-----------------------------------------------------------------------------
@@ -17,12 +18,13 @@ void MAX7456::setBlinkParams(byte blinkBase, byte blinkDC)
 {
 	_regVm1.bits.blinkingTime = blinkBase;
 	_regVm1.bits.blinkingDutyCycle = blinkDC;
-	digitalWrite(_pinCS, LOW);
+	digitalWrite(_pinCS,LOW);
 	SPI.transfer(VM1_ADDRESS_WRITE);
 	SPI.transfer(_regVm1.whole);
-	digitalWrite(_pinCS, HIGH);
+	digitalWrite(_pinCS,HIGH);	
 }
 
+
 //-----------------------------------------------------------------------------
 // Implements MAX7456::setDisplayOffsets
 //----------------------------------------------------------------------------
@@ -35,14 +37,14 @@ void MAX7456::setDisplayOffsets(byte horizontal, byte vertical)
 	_regHos.bits.horizontalPositionOffset = horizontal;
 	_regVos.bits.verticalPositionOffset = vertical;
 	
-	digitalWrite(_pinCS, LOW);
+	digitalWrite(_pinCS,LOW);
 	SPI.transfer(HOS_ADDRESS_WRITE);
 	SPI.transfer(_regHos.whole);
 
 	SPI.transfer(VOS_ADDRESS_WRITE);
 	SPI.transfer(_regVos.whole);
 
-	digitalWrite(_pinCS, HIGH);
+	digitalWrite(_pinCS,HIGH);	
 }
 	
 //-----------------------------------------------------------------------------
@@ -52,18 +54,24 @@ MAX7456::MAX7456()
 {
 }
 
+
 //-----------------------------------------------------------------------------
 // Implements MAX7456::sendCharacter
 //-----------------------------------------------------------------------------
-void MAX7456::sendCharacter(const charact chara, char address)
+void MAX7456::sendCharacter(const charact chara, byte x, byte y)
 {
+	byte charAddress;
+	if(y<0)
+		charAddress = x;
+	else
+		charAddress = x + (y<<4);
 	activateOSD(false);
 	//datasheet p38
-	digitalWrite(_pinCS, LOW);
+	digitalWrite(_pinCS,LOW);
 	SPI.transfer(CMAH_ADDRESS_WRITE);
-	SPI.transfer(address);
+	SPI.transfer(charAddress);
 
-	for (byte i = 0; i < 54; i++)
+	for(byte i = 0 ; i < 54 ; i++)
 	{
 		SPI.transfer(CMAL_ADDRESS_WRITE);
 		SPI.transfer(i);
@@ -76,15 +84,17 @@ void MAX7456::sendCharacter(const charact chara, char address)
 	SPI.transfer(_regCmm);
 	//while STAT[5] is not good, we wait.
 	_regStat.bits.characterMemoryStatus = 1;
-	while (_regStat.bits.characterMemoryStatus == 1)
+	while(  _regStat.bits.characterMemoryStatus ==1)
 	{
 		SPI.transfer(STAT_ADDRESS_READ);
 		_regStat.whole = SPI.transfer(0x00);
 	}
 
-	digitalWrite(_pinCS, HIGH);
+
+	digitalWrite(_pinCS,HIGH);
 }
 
+
 //-----------------------------------------------------------------------------
 // Implements MAX7456::getCharacter
 //-----------------------------------------------------------------------------
@@ -92,14 +102,16 @@ void MAX7456::getCharacter(charact chara, byte x, byte y)
 {
 	byte charAddress;
 
-	if (y <= 0)
+
+	if(y<=0)
 		charAddress = x;
 	else
-		charAddress = x + y * 16;
+		charAddress = x + y*16;
 
 	activateOSD(false);
 	//datasheet p38
-	digitalWrite(_pinCS, LOW);
+	digitalWrite(_pinCS,LOW);
+
 
 	SPI.transfer(CMAH_ADDRESS_WRITE);
 	SPI.transfer(charAddress);
@@ -108,7 +120,8 @@ void MAX7456::getCharacter(charact chara, byte x, byte y)
 	SPI.transfer(CMM_ADDRESS_WRITE);
 	SPI.transfer(_regCmm);
 
-	for (byte i = 0; i < 54; i++)
+
+	for(byte i = 0 ; i < 54 ; i++)
 	{
 		SPI.transfer(CMAL_ADDRESS_WRITE);
 		SPI.transfer(i);
@@ -117,22 +130,24 @@ void MAX7456::getCharacter(charact chara, byte x, byte y)
 		chara[i] = SPI.transfer(0x00);
 	}
 
-	digitalWrite(_pinCS, HIGH);
+	digitalWrite(_pinCS,HIGH);
+
 }
 //-----------------------------------------------------------------------------
 // Implements Max7456::printCharacterToSerial
 //-----------------------------------------------------------------------------
 void MAX7456::printCharacterToSerial(const charact array, bool img)
 {
-	if (img)
+
+	if(img)
 	{
-		CARACT car;
+		CARACT car ;
 		car = MAX7456::byteArray2CARACT(array);
 
 		Serial.println("------------");
-		for (int i = 0; i < 18; i++)
+		for(int i = 0 ; i < 18 ; i++)
 		{
-			for (int j = 0; j < 3; j++)
+			for(int j = 0 ; j < 3 ; j++)
 			{
 				printPixel(car.line[i].pixels[j].pix0);
 				printPixel(car.line[i].pixels[j].pix1);
@@ -148,26 +163,26 @@ void MAX7456::printCharacterToSerial(const charact array, bool img)
 	else
 	{
 		Serial.print("{");
-		for (unsigned int i = 0; i < 53; i++)
+		for(unsigned int i = 0 ; i < 53 ; i++)
 		{
 			Serial.print("0x");
-			Serial.print(String(array[i], HEX));
+			Serial.print(String(array[i],HEX));
 			Serial.print(", ");
 		}
 		Serial.print("0x");
-		Serial.print(String(array[53], HEX));
+		Serial.print(String(array[53],HEX));
 		Serial.println("};");
 	}
 }
 
 void MAX7456::printPixel(byte value)
 {
-	switch (value)
+	switch(value )
 	{
-	case COLOR_BLACK:
+	case COLOR_BLACK :
 		Serial.print("#");
 		return;
-	case COLOR_WHITE:
+	case COLOR_WHITE :
 		Serial.print("*");
 		return;
 	default:
@@ -176,54 +191,55 @@ void MAX7456::printPixel(byte value)
 	}
 }
 
+
 //-----------------------------------------------------------------------------
 // Implements MAX7456::print
 //-----------------------------------------------------------------------------
-void MAX7456::print(const char string[], byte x, byte y, byte blink, byte inv)
+void MAX7456::print(const char string[], byte x, byte y, byte blink,byte inv)
 {
 	char          currentChar;
 	byte          size;
 	byte *chars = NULL;
 
-	if (!string)
-		return;
+	if(!string) return;
 
 	size = 0;
 	currentChar = string[0];
 
-	while (currentChar != '\0')
+	while(currentChar != '\0')
 	{
 		currentChar = string[++size];
 	}
 
-	chars = (byte *)malloc(size * sizeof(byte));
+	chars = (byte*) malloc(size * sizeof(byte));
 
-	for (byte i = 0; i < size; i++)
+	for(byte i = 0 ; i < size ; i++)
 	{
 		chars[i] = MAX7456::giveMAX7456CharFromAsciiChar(string[i]);
 	}
 
-	printMAX7456Chars(chars, size, x, y, blink, inv);
+	printMAX7456Chars(chars, size, x,  y,  blink , inv );
 	free(chars);
 }
 
+
 void MAX7456::printMAX7456Char(const byte address, byte x, byte y, byte blink, byte inv)
 {
 	byte ad = address;
-	printMAX7456Chars(&ad, 1, x, y, blink, inv);
+	printMAX7456Chars(&ad,1,x,y,blink,inv);
 }
 
 //-----------------------------------------------------------------------------
 // Implements MAX7456::printMAX7456Chars
 //-----------------------------------------------------------------------------
-void MAX7456::printMAX7456Chars(byte chars[], byte size, byte x, byte y, byte blink, byte inv)
+void MAX7456::printMAX7456Chars(byte chars[],byte size,byte x, byte y, byte blink ,byte inv )
 {
 	byte          currentChar;
 	byte          posAddressLO;
 	byte          posAddressHI;
 	unsigned int  posAddress;
 
-	posAddress = 30 * y + x;
+	posAddress = 30*y+x;
 
 	posAddressHI = posAddress >> 8;
 	posAddressLO = posAddress;
@@ -233,63 +249,77 @@ void MAX7456::printMAX7456Chars(byte chars[], byte size, byte x, byte y, byte bl
 	_regDmm.bits.INV = inv;
 	_regDmm.bits.BLK = blink;
 
-	digitalWrite(_pinCS, LOW);
+	digitalWrite(_pinCS,LOW);
 	SPI.transfer(DMM_ADDRESS_WRITE);
 
+
+
 	SPI.transfer(_regDmm.whole);
 
+
 	SPI.transfer(DMAH_ADDRESS_WRITE); // set start address high
 	SPI.transfer(posAddressHI);
 
 	SPI.transfer(DMAL_ADDRESS_WRITE); // set start address low
 	SPI.transfer(posAddressLO);
 
-	for (int i = 0; i < size; i++)
+
+	for(int i = 0; i < size ; i++)
 	{
 		currentChar = chars[i];
 		SPI.transfer(DMDI_ADDRESS_WRITE);
 		SPI.transfer(currentChar);
+
 	}
 
 	//end character (we're done).
 	SPI.transfer(DMDI_ADDRESS_WRITE);
 	SPI.transfer(0xff);
 
-	digitalWrite(_pinCS, HIGH);
+/*
+	_regVm0.bits.
+	SPI.transfer(VM0_ADDRESS_WRITE);
+	SPI.transfer(0x4c);*/
+
+
+	digitalWrite(_pinCS,HIGH);
 }
 
+
 //-----------------------------------------------------------------------------
 // Implements MAX7456::print
 //-----------------------------------------------------------------------------
 
-void MAX7456::print(double value, byte x, byte y, byte before, byte after, byte blink, byte inv)
+void MAX7456::print(double value, byte x, byte y, byte before, byte after, byte blink,byte inv)
 {
 	char *strValue = NULL;
 
-	strValue = (char *)malloc((before + after + 2) * sizeof(char));
+	strValue = (char*) malloc((before+after+2)* sizeof(char));
 
-	if (after == 0)
-		dtostrf(value, before + after, after, strValue);
+
+	if(after==0)
+		dtostrf(value,before+after,after,strValue);
 	else
-		dtostrf(value, before + after + 1, after, strValue);
+		dtostrf(value,before+after+1,after,strValue);
 
-	for (int i = 0; i < before + after + 1; i++)
+	for(int i = 0 ; i < before+after+1;i++)
 		{
-		if (strValue[i] == ' ' || strValue[i] == '-')
-			strValue[i] = '0';
+			if(strValue[i] == ' ' || strValue[i] == '-')
+				strValue[i]='0';
 		}
-	if (value < 0)
-		strValue[0] = '-';
-	if (after == 0) //If the result is bigger, we truncate it so the OSD won't be falsed.
-		strValue[before] = '\0';
+	if(value < 0)
+		strValue[0]='-';
+	if(after==0) //If the result is bigger, we truncate it so the OSD won't be falsed.
+		strValue[before]='\0';
 	else
-		strValue[before + after + 1] = '\0';
+		strValue[before+after+1]='\0';
 
-	print(strValue, x, y, blink, inv);
+	print(strValue,x,y,blink,inv);
 
 	free(strValue);
 }
 
+
 //-----------------------------------------------------------------------------
 // Implements MAX7456::giveMAX7456CharFromAsciiChar
 //-----------------------------------------------------------------------------
@@ -297,8 +327,8 @@ byte MAX7456::giveMAX7456CharFromAsciiChar(char ascii)
 {
 #ifdef MAX7456_TABLE_ASCII
 #error Do not be here
-	if (ascii >= ' ' && ascii <= 'z')
-		return ascii - ' ';
+	if(ascii >= ' ' && ascii <= 'z')
+		return ascii-' ';
 	else
 		return ascii;
 #else
@@ -306,12 +336,13 @@ byte MAX7456::giveMAX7456CharFromAsciiChar(char ascii)
 #endif
 }
 
+
 //-----------------------------------------------------------------------------
 // Implements MAX7456::clearScreen
 //-----------------------------------------------------------------------------
 void MAX7456::clearScreen()
 {
-	_regDmm.bits.clearDisplayMemory = 1;
+	_regDmm.bits.clearDisplayMemory = 1 ;
 
 	digitalWrite(_pinCS, LOW);
 
@@ -319,7 +350,7 @@ void MAX7456::clearScreen()
 	SPI.transfer(_regDmm.whole);
 
 	//wait for operation to be complete.
-	while (_regDmm.bits.clearDisplayMemory == 1)
+	while(_regDmm.bits.clearDisplayMemory == 1 )
 	{
 		SPI.transfer(DMM_ADDRESS_READ);
 		_regDmm.whole = SPI.transfer(0x00);
@@ -327,6 +358,7 @@ void MAX7456::clearScreen()
     digitalWrite(_pinCS, HIGH); //disable device
 }
 
+
 //-----------------------------------------------------------------------------
 // Implements MAX7456::init
 //-----------------------------------------------------------------------------
@@ -340,22 +372,23 @@ void MAX7456::init(byte iPinCS)
     digitalWrite(iPinCS, HIGH); //disable device
     delay(100); //power up time
 
-	digitalWrite(_pinCS, LOW);
+	digitalWrite(_pinCS,LOW);
 	SPI.transfer(VM0_ADDRESS_WRITE);
 
 	_regVm0.whole = 0x00;
-	_regVm0.bits.videoSelect = 1; //PAL
+	_regVm0.bits.videoSelect=1; //PAL
 	_regVm0.bits.softwareResetBit = 1;
 	SPI.transfer(_regVm0.whole);
-	digitalWrite(_pinCS, HIGH);
+	digitalWrite(_pinCS,HIGH);
 	delay(500);
 
-	digitalWrite(_pinCS, LOW);
-	for (int x = 0; x < 16; x++)
+
+	digitalWrite(_pinCS,LOW);
+	for(int x = 0 ; x < 16 ; x++)
 	{
 		_regRb[x].whole = 0x00;
 		_regRb[x].bits.characterWhiteLevel = 2;
-		SPI.transfer(x + RB0_ADDRESS_WRITE);
+		SPI.transfer(x+RB0_ADDRESS_WRITE);
 		SPI.transfer(_regRb[x].whole);
 	}
 
@@ -367,72 +400,77 @@ void MAX7456::init(byte iPinCS)
 
 	SPI.transfer(_regVm0.whole);
 
-	digitalWrite(_pinCS, HIGH);
+	digitalWrite(_pinCS,HIGH);
 }
 
+
 //-----------------------------------------------------------------------------
 // Implements MAX7456::activateOSD
 //-----------------------------------------------------------------------------
 void MAX7456::activateOSD(bool act)
 {
-	if (_isActivatedOsd != act)
+	if(_isActivatedOsd != act)
 	{
 
 		_regVm0.bits.videoSelect = 1;
-		if (act)
+		if(act)
 			_regVm0.bits.enableOSD = 1;
 		else
 			_regVm0.bits.enableOSD = 0;
 
-		digitalWrite(_pinCS, LOW);
+		digitalWrite(_pinCS,LOW);
 		SPI.transfer(VM0_ADDRESS_WRITE);
 		SPI.transfer(_regVm0.whole);
-		digitalWrite(_pinCS, HIGH);
+		digitalWrite(_pinCS,HIGH);
 		_isActivatedOsd = act;
 	}
 }
 
+
 //-----------------------------------------------------------------------------
 // Implements MAX7456::activateExternalVideo
 //-----------------------------------------------------------------------------
 void MAX7456::activateExternalVideo(bool activExtVid)
 {
-	if (!activExtVid)
+	if(!activExtVid)
 		_regVm0.bits.synchSelect = 3; //11
 	else
 		_regVm0.bits.synchSelect = 0; //0
 
-	digitalWrite(_pinCS, LOW);
+	digitalWrite(_pinCS,LOW);
 	SPI.transfer(VM0_ADDRESS_WRITE);
 	SPI.transfer(_regVm0.whole);
-	digitalWrite(_pinCS, HIGH);
+	digitalWrite(_pinCS,HIGH);
 }
 
+
 //-----------------------------------------------------------------------------
 // Implements MAX7456::CARACT2ByteArray
 //-----------------------------------------------------------------------------
-byte *MAX7456::CARACT2ByteArray(const CARACT car)
+byte* MAX7456::CARACT2ByteArray(const CARACT car)
 {
 	byte *array = NULL;
 	array = new charact;
-	for (int i = 0; i < 54; i++)
-		array[i] = car.whole[i];
+	for(int i = 0 ; i < 54 ; i++)
+		array[i]= car.whole[i];
 
 	return array;
 }
 
+
 //-----------------------------------------------------------------------------
 // Implements MAX7456::byteArray2CARACT
 //-----------------------------------------------------------------------------
 CARACT MAX7456::byteArray2CARACT(const charact array)
 {
 	CARACT car;
-	for (int i = 0; i < 54; i++)
+	for(int i = 0 ; i < 54 ; i++)
 		car.whole[i] = array[i];
 
 	return car;
 }
 
+
 //-----------------------------------------------------------------------------
 // Implements MAX7456::getCARACFromProgMem
 //-----------------------------------------------------------------------------
@@ -440,10 +478,10 @@ void MAX7456::getCARACFromProgMem(const char *table, byte i, charact car)
 {
 	unsigned long index;
 	byte read;
-	index = i * 54;
-	for (unsigned long j = 0; j < 54; j++)
+	index = i*54;
+	for(unsigned long j = 0 ; j < 54 ; j++)
 	{
-		read = pgm_read_byte_near(table + index + j);
+		read = pgm_read_byte_near(table +index+j );
 		car[j] = read;
 		if (car[j] == 0x55)
 			car[j] = 0xff;

src/MAX7456.h

@@ -9,6 +9,7 @@
 #ifndef MAX7456_H
 #define MAX7456_H
 
+
 //def next only if you changed your table for an ascii one
 //i.e address 0x00 -> ' '
 //....
@@ -18,10 +19,13 @@
 
 #include "MAX7456Registers.h"
 
+
+
 /**
  *  @mainpage MAX7456 Arduino library
  */
 
+
 /**
  *  @class MAX7456
  *  @brief Represents a MAX7456 device communicating through SPI port
@@ -29,11 +33,14 @@
 class MAX7456
 {
 public:
+
+
 	/**
 	 *  Default constructor
 	 */
 	MAX7456();
 
+
 	/**
 	 *  Constructor
 	 *  Initialize communications and device
@@ -41,6 +48,7 @@ public:
 	 */
 	MAX7456(byte pinCS);
 
+
 	/**
 	 *  Initialize communications and device
 	 *  @param pinCS : pin ~CS of the arduino where MAX7456 is plugged.
@@ -58,6 +66,7 @@ public:
 	 */
 	void setBlinkParams(byte blinkBase, byte blinkDC);
 
+	
 	/**
 	 * Set Horizontal and Vertical display offset
 	 * @param horizontal : the horizontal offset in pixels (between 0 and 63).
@@ -65,11 +74,13 @@ public:
 	 */	 
 	void setDisplayOffsets(byte horizontal, byte vertical);
 
+	
 	/**
 	 *  Erase Display Memory.
 	 */
 	void clearScreen();
 
+
 	/**
 	 *  Activate osd on screen
 	 *  @param act :
@@ -78,6 +89,7 @@ public:
 	 */
 	void activateOSD(bool act = true);
 
+
 	/**
 	 *  Activate input video as a background
 	 *  @param activExtVid :
@@ -86,17 +98,20 @@ public:
 	 */
 	void activateExternalVideo(bool activExtVid = true);
 
+
 	/**
-	 *  Put a character in the memory character of MAX7456
+	 *  Put a character in the memory character of max7456
 	 *  @param array : the byte array representing the character (54 bytes long)
-	 *  @param adress : the address of character in memory
+	 *  @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,0x54); //put c at 4th line 5th column ie. address 54.
+	 *  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, char address);
+	void sendCharacter(const charact array, byte x, byte y);
+
 
 	/**
 	 *  Get a character from the character memory of max7456
@@ -106,6 +121,7 @@ public:
 	 */
 	void getCharacter(charact array, byte x, byte y);
 
+
 	/**
 	 *  Put a string in the display memory of max7456
 	 *  @param string : The string to be displayed
@@ -118,7 +134,9 @@ public:
 	 *  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);
+	void print(const char string[], byte x, byte y, byte blink = 0,byte inv = 0);
+
+
 
 	/**
 	 *  Put a float in the display memory of max7456
@@ -138,7 +156,8 @@ public:
 	 *  //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);
+	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.
@@ -155,7 +174,8 @@ public:
 	 *  max.printMAX7456Chars(chars,3,x,y);
 	 *  @endcode
 	 */
-	void printMAX7456Chars(byte chars[], byte size, byte x, byte y, byte blink = 0, byte inv = 0);
+	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
@@ -165,7 +185,7 @@ public:
 	 *  @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);
+	void printMAX7456Char(const byte address, byte x, byte y, byte blink=0, byte inv=0);
 
 	/**
 	 *  Print a character to Serial port
@@ -176,12 +196,14 @@ public:
 	 */
 	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);
+	static byte* CARACT2ByteArray(const CARACT car);
+
 
 	/**
 	 *  Converts a byte array to a CARACT character.
@@ -190,6 +212,7 @@ public:
 	 */
 	static CARACT byteArray2CARACT(const charact array);
 
+
 	/**
 	 * Get the ith character from program memory
 	 * @param table the address of the array in prog memory
@@ -199,9 +222,10 @@ public:
 	 * @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 char *table, byte i, charact c);
+	static void getCARACFromProgMem(const char *table, byte i,charact c);
 
 private:
+
 	byte giveMAX7456CharFromAsciiChar(char ascii);
 	static void printPixel(byte value);
 
@@ -228,4 +252,6 @@ private:
 	REG_CMDO  _regCmdo; // not used yet
 };
 
+
 #endif /* MAX7456_H_ */
+

src/MAX7456Registers.h

@@ -8,8 +8,10 @@
 #ifndef MAX7456REGISTERS_H_
 #define MAX7456REGISTERS_H_
 
+
 #include <Arduino.h>
 
+
 /**
  * @typedef charact
  * @brief Represents a character as stored in MAX7456 character memory.
@@ -26,7 +28,7 @@ typedef byte charact[54];
 union REG_VM0
 {
 	/**@brief The whole value*/
-	unsigned char whole;
+	unsigned char whole ;
 	/**
 	 * @var bits
 	 * @brief access to individual bits*/
@@ -36,7 +38,7 @@ union REG_VM0
 		 * @li 0 = Enable
 		 * @li 1 = Disable(VOUT is high impedance)
 		 */
-		unsigned char videoBuffer : 1;
+		unsigned char videoBuffer :1;
 
 		/**@brief Software Reset Bit
 		 * @li When bit set all register are set to default.
@@ -66,7 +68,7 @@ union REG_VM0
 		 * @li 0 = NTSC
 		 * @li 1 = PAL
 		 */
-		unsigned char videoSelect : 1;
+		unsigned char videoSelect :1;
 
 		/**@brief don't care*/
 		unsigned char unused : 1;
@@ -74,6 +76,7 @@ union REG_VM0
 	} bits;
 };
 
+
 #define VM1_ADDRESS_WRITE 0x01
 #define VM1_ADDRESS_READ 0x81
 
@@ -98,6 +101,7 @@ union REG_VM1
 		 */
 		unsigned char blinkingDutyCycle : 2;
 
+
 		/**@brief Blinking Time (BT)
 		 * @li b00 (0) = 2 fields (NTSC = 33ms ; PAL = 40ms)
 		 * @li b01 (1) = 4 fields (NTSC = 67ms ; PAL = 80ms)
@@ -106,6 +110,7 @@ union REG_VM1
 		 */
 		unsigned char blinkingTime : 2;
 
+
 		/**@brief Background Mode Brightness
 		 * @li b000 (0) = 0%
 		 * @li b001 (1) = 7%
@@ -158,6 +163,7 @@ union REG_HOS
 	} bits;
 };
 
+
 #define VOS_ADDRESS_WRITE 0x03
 #define VOS_ADDRESS_READ 0x83
 
@@ -258,9 +264,12 @@ union REG_DMM
 		/**@brief Don't care*/
 		unsigned char unsused : 1;
 
+
+
 	} bits;
 };
 
+
 #define DMAH_ADDRESS_WRITE 0x05
 #define DMAH_ADDRESS_READ 0x85
 /**@union REG_DMAH
@@ -284,10 +293,12 @@ union REG_DMAH
 	} bits;
 };
 
+
 #define DMAL_ADDRESS_WRITE 0x06
 #define DMAL_ADDRESS_READ 0x86
 typedef unsigned char REG_DMAL;
 
+
 #define DMDI_ADDRESS_WRITE 0x07
 #define DMDI_ADDRESS_READ 0x87
 typedef unsigned char REG_DMDI;
@@ -342,6 +353,7 @@ union REG_CMDI
 	} bits;
 };
 
+
 #define OSDM_ADDRESS_WRITE 0x0C
 #define OSDM_ADDRESS_READ 0x8C
 
@@ -368,6 +380,7 @@ union REG_OSDM
 		 */
 		unsigned char osdInsertionMuxSwitchingTime : 3;
 
+
 		/**@brief OSD Rise And Fall Time
 		 * @li b000 (0) : 20ns (maximum sharpness/maximum crosscolor artifacts )
 		 * @li b001 (1) : 30ns
@@ -378,12 +391,14 @@ union REG_OSDM
 		 */
 		unsigned char osdRiseAndFallTime : 3;
 
+
 		/**@brief don't care*/
 		unsigned char unused : 2;
 
 	} bits;
 };
 
+
 #define RB0_ADDRESS_WRITE 0x10
 #define RB0_ADDRESS_READ 0x90
 
@@ -547,6 +562,7 @@ union REG_STAT
 	} bits;
 };
 
+
 #define DMDO_ADDRESS_READ 0xB0
 
 /**@typedef DMDO
@@ -579,26 +595,33 @@ union REG_CMDO
 	} bits;
 };
 
+
+
+
 /**\def COLOR_BLACK
  * \brief Black value for a pixel (2bits)
  */
 #define COLOR_BLACK       0
 
+
 /**\def COLOR_WHITE
  * \brief White value for a pixel (2bits)
  */
 #define COLOR_WHITE       2
 
+
 /**\def COLOR_TRANSPARENT
  * \brief Transparent value for a pixel (2bits)
  */
 #define COLOR_TRANSPARENT 1
 
+
 /**\def COLOR_GREY
  * \brief Grey value for a pixel (2bits)
  */
 #define COLOR_GREY COLOR_TRANSPARENT
 
+
 /**@struct PIXEL
  * @brief represent a 4-pixels value
  */
@@ -611,8 +634,10 @@ struct PIXEL
 	/**@brief 2nd pixel*/
 	byte pix1 : 2;
 
+
 	/**@brief 1st pixel*/
 	byte pix0 : 2;
+
 };
 
 /**@union LINE
@@ -626,6 +651,7 @@ union LINE
 	struct PIXEL pixels[3];
 };
 
+
 /**
  * @union CARACT
  * @brief Represents a character with lines and pixels.
@@ -639,20 +665,20 @@ union CARACT
 	union LINE line[18];
 };
 
-enum
-{
-	_BT_BT = 0,
-	_BT_2BT,
-	_BT_3BT,
-	_3BT_BT
+
+enum{
+_BT_BT=0,
+_BT_2BT,
+_BT_3BT,
+_3BT_BT
 };
 
-enum
-{
-	_2fields = 0,
-	_4fields,
-	_6fields,
-	_8fields
+enum{
+_2fields=0,
+_4fields,
+_6fields,
+_8fields
 };
 
+
 #endif /* MAX7456REGISTERS_H_ */