/**
 * Texas Instruments HDQ implementation for the Arduino API
 * (cleft) Matthieu Lalonde 2008 (matth@mlalonde.net)
 * Creative Commons BY-SA-NC
 * 
 * http://trac.mlalonde.net/cral/browser/HDQ/
 * 
 * Revision 1
 *
**/

/* ***************** *
 * HDQ Usage example *
** ***************** *

#include "hdq.h"
HDQ HDQ(HDQ_DEFAULT_PIN);

uint8_t r;

for (uint8_t jj = 0; jj < 0x10; jj++) {
	r = HDQ.read(jj);

	Serial.print("Register 0x");
	Serial.print(jj, HEX);
	Serial.print(": ");
	Serial.print(r, BIN);
	Serial.print(" 0x");
	Serial.println(r, HEX);
}

r = HDQ.read(0x1e);

Serial.print("Register 0x1e: ");
Serial.print(r, BIN);
Serial.print(" 0x");
Serial.println(r, HEX);

r = HDQ.read(0x7e);

Serial.print("Register 0x7e: ");
Serial.print(r, BIN);
Serial.print(" 0x");
Serial.println(r, HEX);

HDQ.write(0x05, B11011101);

r = HDQ.read(0x05);

Serial.print("Register 0x05: ");
Serial.print(r, BIN);
Serial.print(" 0x");
Serial.println(r, HEX);

HDQ.write(0x05, B00111001);

r = HDQ.read(0x05);

Serial.print("Register 0x05: ");
Serial.print(r, BIN);
Serial.print(" 0x");
Serial.println(r, HEX);

*/

extern "C" {
	#include "WConstants.h"
	#include "pins_arduino.h"
}

#include "avrmacros.h"
#include "hdq.h"

#define _HDQ_readPin() (*inputReg & bitmask)>>pin	/* Change me to inline!*/

/**
 * Constructor
 * @param pinArg: pin number to attach to
**/
HDQ::HDQ(uint8_t pinArg)
{
	pin			= pinArg;
	port		= digitalPinToPort(pin);
	bitmask		= digitalPinToBitMask(pin);
	outputReg	= portOutputRegister(port);
	inputReg	= portInputRegister(port);
	modeReg		= portModeRegister(port);
}

/**
 * sendBreak: writes a break to the HDQ line
**/
void HDQ::doBreak(void)
{
	sbi(*modeReg, pin);		// Set pin as output
	
	// Singal a break on the line
	cbi(*outputReg, pin);	// Bring pin low
	delayMicroseconds(HDQ_DELAY_TB);
	
	// Make sure we leave enough time for the slave to recover
	cbi(*modeReg, pin);		// Release pin
	delayMicroseconds(HDQ_DELAY_TBR);
}

/**
 * writeByte: write a raw byte of data to the bus
 * @param payload: the byte to send
 * 
**/
void HDQ::writeByte(uint8_t payload)
{
	sbi(*modeReg, pin);		// Set pin as output
	
	for (uint8_t ii = 0; ii < 8; ii++)
	{
		// Start bit
		cbi(*outputReg, pin);	// Bring pin low
		delayMicroseconds(HDQ_DELAY_BIT_START);
		
		// Toggle the pin for this bit, LSB first
		if (payload>>ii & 0x01) {
			sbi(*outputReg, pin); // High
		}
		else {
			cbi(*outputReg, pin); // Low
		}
		
		// Bit time
		delayMicroseconds(HDQ_DELAY_BIT_WRITE);
		
		// Stop bit
		sbi(*outputReg, pin);	// Bring the pin high
		delayMicroseconds(HDQ_DELAY_BIT_END);
	}
	
	return;
}

/**
 * write: send a payload to the device
 * @param reg: the address of the register to write to
 * @param payload: data to be sent
 * @return: false, unless if verif is set, then 
 * 			it will read back the register and 
 * 			return true if it matches the payload
**/
boolean HDQ::write(uint8_t reg, uint8_t payload)
{
	// Singal a break
	HDQ::doBreak();
	
	// Write the register to write
	HDQ::writeByte((reg |= HDQ_ADDR_MASK_WRITE));
	
	// Wait for the slave to finish reading the register
	delayMicroseconds((HDQ_DELAY_TRSPS_MAX - HDQ_DELAY_BIT_TOTAL) / 2);
	
	// Write the payload
	HDQ::writeByte(payload);
	
	// Wait for the slave to finish writing the payload
	delayMicroseconds((HDQ_DELAY_TRSPS_MAX - HDQ_DELAY_BIT_TOTAL) / 2);
	
	cbi(*modeReg, pin);		// Release pin
	
	return true;
}

/**
 * Write with verification
**/
boolean HDQ::write(uint8_t reg, uint8_t payload, boolean verif)
{
	// Write the payload
	HDQ::write(reg, payload);

	// Verify the write
	if (payload == HDQ::read(reg)) return true;

	return false;
}


/**
 * read: read from the device
 * @param register: address of the register to read
 * @return a uint8_t integer
**/
uint8_t HDQ::read(uint8_t reg)
{
	uint8_t result		= 0;
	uint8_t maxTries	= HDQ_DELAY_FAIL_TRIES; // ~128uS at 8Mhz with 8 instructions per loop
	uint8_t ii;
	
	// Singal a break
	HDQ::doBreak();
	
	// Write the register to read
	HDQ::writeByte((reg |= HDQ_ADDR_MASK_READ));
	
	for (ii = 0; ii < 8; ii++)
	{
		// Wait for the slave to toggle a low, or fail
		maxTries = HDQ_DELAY_FAIL_TRIES;
		while (_HDQ_readPin() != 0 && maxTries-- > 0)
			if (maxTries == 1) return 0xFF;
		
		// Wait until Tdsub and half or one bit has passed
		delayMicroseconds(HDQ_DELAY_BIT_WRITE / 2 + HDQ_DELAY_BIT_START);
		
		// Read the bit
		result |= _HDQ_readPin()<<ii;
		
		// Wait until Tssub has passed
		delayMicroseconds(HDQ_DELAY_TSSUB - (HDQ_DELAY_BIT_WRITE / 2 + HDQ_DELAY_BIT_START) + 10);
		
		// Wait for the slave to toggle a high, or fail
		maxTries = HDQ_DELAY_FAIL_TRIES;
		while (_HDQ_readPin() != 1 && maxTries-- > 0)
			if (maxTries == 1) return 0xFF;
	}
	
	return result;
}