// I2C SMBus Test
const SMBUS_MANUFACTURERACCES 			= 0x00;
const SMBUS_REMAININGCAPACITYALARM		= 0x01;
const SMBUS_REMAININGTIMEALARM			= 0x02;
const SMBUS_BATTERYMODE					= 0x03;
const SMBUS_ATRATE						= 0x04;
const SMBUS_ATRATETIMETOFULL			= 0x05;
const SMBUS_ATRATETIMETOEMPTY			= 0x06;
const SMBUS_ATRATEOK					= 0x07;
const SMBUS_TEMPERATURE					= 0x08;
const SMBUS_VOLTAGE						= 0x09;
const SMBUS_CURRENT						= 0x0A;
const SMBUS_AVERAGECURRENT				= 0x0B;
const SMBUS_MAXERROR					= 0x0C;
const SMBUS_RELATIVESTATEOFCHARGE		= 0x0D;
const SMBUS_ABSOLUTESTATEOFCHARGE		= 0x0E;
const SMBUS_REMAININGCAPACITY			= 0x0F;
const SMBUS_FULLCHARGECAPACITY			= 0x10;
const SMBUS_RUNTIMETOEMPTY				= 0x11;
const SMBUS_AVERAGETIMETOEMPTY			= 0x12;
const SMBUS_AVERAGETIMETOFULL			= 0x13;
const SMBUS_CHARGINGCURRENT				= 0x14;
const SMBUS_CHARGINGVOLTAGE				= 0x15;
const SMBUS_BATTERYSTATUS				= 0x16;
const SMBUS_CYCLECOUNT					= 0x17;
const SMBUS_DESIGNCAPACITY				= 0x18;
const SMBUS_DESIGNVOLTAGE				= 0x19;
const SMBUS_SPECIFICATIONINFO			= 0x1A;
const SMBUS_MANUFACTURERDATE			= 0x1B;
const SMBUS_SERIALNUMBER				= 0x1C;
//0X1D-0X1F RESERVED
const SMBUS_MANUFACTURERNAME			= 0x20;
const SMBUS_DEVICENAME					= 0x21;
const SMBUS_DEVICECHEMISTRY				= 0x22;
const SMBUS_MANUFACTURERDATA			= 0x23;

const SMBUS_LASTMESG					= 0x23;

class MyInput extends InputPort
{
    constructor()
    {
        base.constructor();
    }
 
    function set(val)
    {
         server.log("CMD("+typeof(val)+")="+val);
         local a = split(val, " ");
         local i = 0;
         
         local sendcnt = 0;
         local readcnt = 0;
         
         local i2c_addr = 0;
         local i2c_send = "";
         
         for (i=0;i<a.len();i++)
         {
            local to_send = 0;
            if (a[i] == "XX")
                readcnt++;
            else
            {
                sendcnt++;
                
                local hi = 0;
                local lo = 0;
                if (a[i].len() == 2)
                {
                    hi = tohex(a[i][0]);
                    lo = tohex(a[i][1]);
                }
                to_send = (hi << 4) | lo;
                if (i==0)
                     i2c_addr = to_send;
                else i2c_send = i2c_send + format("%c",to_send);
            }
            //server.log("["+i+"]="+a[i]+format(" ==%x",to_send));
         }
         
         //server.log("wr="+sendcnt+" rd="+readcnt);
         
         if (readcnt != 0)
         {
             local toprint = format("TXr: [%x]",i2c_addr);
             for (i=0;i<i2c_send.len();i++) toprint = toprint + format(" %02x",i2c_send[i]);
             for (i=0;i<readcnt;i++) toprint = toprint + " XX";
             server.log(toprint);
             
             local result = i2cPort.read(i2c_addr, i2c_send, readcnt);
             //server.log("RX:"+result+" "+typeof(result));
             if (result != null)
             {
                 toprint = "RX: ";
                 for (i=0;i<result.len();i++) toprint = toprint + format(" %02x",result[i]);
                 server.log(toprint);
                 
                 parseValue(i2c_send[0], result);
             }
             else server.log("RX: null");
         }
         else
         {
             local toprint = format("TXw: [%x]",i2c_addr);
             for (i=0;i<i2c_send.len();i++) toprint = toprint + format(" %x",i2c_send[i]);
             server.log(toprint);
             
             i2cPort.write(i2c_addr, i2c_send);
         }
    }
}

function tohex(val)
{
    switch (val)
    {
        case '0': return 0;
        case '1': return 1;
        case '2': return 2;
        case '3': return 3;
        case '4': return 4;
        case '5': return 5;
        case '6': return 6;
        case '7': return 7;
        case '8': return 8;
        case '9': return 9;
        case 'A':
        case 'a': return 0xa;
        case 'B':
        case 'b': return 0xb;
        case 'C':
        case 'c': return 0xc;
        case 'D':
        case 'd': return 0xd;
        case 'E':
        case 'e': return 0xe;
        case 'F':
        case 'f': return 0xf;
    }
    return 0;
}

function getHex(buffer)
{
    local str = format("0x%02x%02x", buffer[1], buffer[0]);
	return str;
}

function getUShort(buffer)
{
	local str;
	local sh = buffer[1] << 8;
	sh = sh | buffer[0];
	str = format("%u", sh);
	return str;
}

function getUShortAsNumber(buffer)
{
	local sh = buffer[1] << 8;
	sh = sh | buffer[0];
	return sh;
}

function getShort(buffer)
{
	local str;
	
	local sh = buffer[1] << 8;
	sh = sh | buffer[0];
    //server.log("numval="+sh);
    if (sh & 0x8000) sh = sh - 65536;//add sign
	str = format("%d", sh);
    
	return str;
}

function getString(buffer)
{
	local str = format("%c%c", buffer[1], buffer[0]);
	return str;
}

function parseValue(mesg, attrval)
{
    local name = "ERROR";
    local strVal = "ERROR";
    local comment = "ERROR";
    
    switch (mesg)
    {
    	case SMBUS_MANUFACTURERACCES:
			{
				strVal = getHex(attrval);
				name = "MANUFACTURERACCES";
                comment = "";
			}break;
		case SMBUS_REMAININGCAPACITYALARM:
			{
				strVal = getShort(attrval);
				name = "REMAININGCAPACITYALARM";
                comment = "mAh (0 to 65,535)";
			}break;
		case SMBUS_REMAININGTIMEALARM:
			{
				strVal = getUShort(attrval);
				name = "REMAININGTIMEALARM";
                comment = "min (0 to 65,535)";
			}break;
		case SMBUS_BATTERYMODE:
			{
				strVal = getHex(attrval);
				name = "BATTERYMODE";
                comment = "";
                local nval = getUShortAsNumber(attrval);
                if (nval & 0x0001)
                     comment = comment + "INTERNAL_CHARGE_CONTROLLER=SUP";
                else comment = comment + "INTERNAL_CHARGE_CONTROLLER=NOTSUP";
                if (nval & 0x0002)
                     comment = comment + " PRIMARY_BATTERY_SUPPORT=SUP";
                else comment = comment + " PRIMARY_BATTERY_SUPPORT=NOTSUP";
                if (nval & 0x0080)
                     comment = comment + " CONDITION_FLAG=CondCycleReq";
                else comment = comment + " CONDITION_FLAG=BATOK";
                if (nval & 0x0100)
                     comment = comment + " CHARGE_CONTROLLER_ENABLED=EN";
                else comment = comment + " CHARGE_CONTROLLER_ENABLED=DIS";
                if (nval & 0x0200)
                     comment = comment + " PRIMARY_BATTERY=YES";
                else comment = comment + " PRIMARY_BATTERY=NO";
                if (nval & 0x2000)
                     comment = comment + " ALARM_MODE=DIS_Broadcast";
                else comment = comment + " ALARM_MODE=EN_Broadcast";
                if (nval & 0x4000)
                     comment = comment + " CHARGER_MODE=DIS_Broadcast";
                else comment = comment + " CHARGER_MODE=EN_Broadcast";
                if (nval & 0x4000)
                     comment = comment + " CAPACITY_MODE=Report10mW/10mWh";
                else comment = comment + " CAPACITY_MODE=ReportmA/mAh";
			}break;
		case SMBUS_ATRATE:
			{
				strVal = getShort(attrval);
				name = "ATRATE";
                comment = "mA/10mW [CAPACITY_MODE bit] charge:1 to 32,767 discharge:-1 to –32,768";
			}break;
		case SMBUS_ATRATETIMETOFULL:
			{
				strVal = getUShort(attrval);
				name = "ATRATETIMETOFULL";
                comment = "min (0 to 65,534) 65,535 indicates the battery is not being charged";
			}break;
		case SMBUS_ATRATETIMETOEMPTY:
			{
				strVal = getUShort(attrval);
				name = "ATRATETIMETOEMPTY";
                comment = "min (0 to 65,534) 65,535 indicates the battery is not being discharged";
			}break;
		case SMBUS_ATRATEOK:
			{
				strVal = getHex(attrval);
				name = "ATRATEOK";
                comment = "TRUE (non-zero), FALSE (zero)";
			}break;
		case SMBUS_TEMPERATURE:
			{
				strVal = getUShort(attrval);
				name = "TEMPERATURE";
                comment = "*0.1°K (0 to +6553.5°K)";
			}break;
		case SMBUS_VOLTAGE:
			{
				strVal = getUShort(attrval);
				name = "VOLTAGE";
                comment = "mV (0 to 65,535)";
			}break;
		case SMBUS_CURRENT:
			{
				strVal = getShort(attrval);// + "="+getHex(attrval);
				name = "CURRENT";
                comment = "mA (charge:1 to 32,767 discharge:-1 to –32,768)";
			}break;
		case SMBUS_AVERAGECURRENT:
			{
				strVal = getShort(attrval);// + "="+getHex(attrval);
				name = "AVERAGECURRENT";
                comment = "mA (charge:1 to 32,767 discharge:-1 to –32,768)";
			}break;
		case SMBUS_MAXERROR:
			{
				strVal = getUShort(attrval);
				name = "MAXERROR";
                comment = "% (0-100%)";
			}break;
		case SMBUS_RELATIVESTATEOFCHARGE:
			{
				strVal = getUShort(attrval);
				name = "RELATIVESTATEOFCHARGE";
                comment = "% (0-100%)";
			}break;
		case SMBUS_ABSOLUTESTATEOFCHARGE:
			{
				strVal = getUShort(attrval);
				name = "ABSOLUTESTATEOFCHARGE";
                comment = "% (0-100%)";
			}break;
		case SMBUS_REMAININGCAPACITY:
			{
				strVal = getUShort(attrval);
				name = "REMAININGCAPACITY";
                comment = "mA/10mW [CAPACITY_MODE bit] 0 to 65,535";
			}break;
		case SMBUS_FULLCHARGECAPACITY:
			{
				strVal = getUShort(attrval);
				name = "FULLCHARGECAPACITY";
                comment = "mA/10mW [CAPACITY_MODE bit] 0 to 65,535";
			}break;
		case SMBUS_RUNTIMETOEMPTY:
			{
				strVal = getUShort(attrval);
				name = "RUNTIMETOEMPTY";
                comment = "min (0 to 65,534) 65,535 indicates battery is not being discharged";
			}break;
		case SMBUS_AVERAGETIMETOEMPTY:
			{
				strVal = getUShort(attrval);
				name = "AVERAGETIMETOEMPTY";
                comment = "min (0 to 65,534) 65,535 indicates battery is not being discharged";
			}break;
		case SMBUS_AVERAGETIMETOFULL:
			{
				strVal = getUShort(attrval);
				name = "AVERAGETIMETOFULL";
                comment = "min (0 to 65,534) 65,535 indicates the battery is not being charged";
			}break;
		case SMBUS_BATTERYSTATUS:
			{
				strVal = getHex(attrval);
				name = "BATTERYSTATUS";
                local nval = getUShortAsNumber(attrval);
                comment = "";
                if (nval & 0x8000)
                     comment = comment + "OVER_CHARGED_ALARM=ON";
                else comment = comment + "OVER_CHARGED_ALARM=OFF";
                if (nval & 0x4000)
                     comment = comment + " TERMINATE_CHARGE_ALARM=ON";
                else comment = comment + " TERMINATE_CHARGE_ALARM=OFF";
                if (nval & 0x1000)
                     comment = comment + " OVER_TEMP_ALARM=ON";
                else comment = comment + " OVER_TEMP_ALARM=OFF";
                if (nval & 0x0800)
                     comment = comment + " TERMINATE_DISCHARGE_ALARM=ON";
                else comment = comment + " TERMINATE_DISCHARGE_ALARM=OFF";
                if (nval & 0x0200)
                     comment = comment + " REMAINING_CAPACITY_ALARM=ON";
                else comment = comment + " REMAINING_CAPACITY_ALARM=OFF";
                if (nval & 0x0100)
                     comment = comment + " REMAINING_TIME_ALARM=ON";
                else comment = comment + " REMAINING_TIME_ALARM=OFF";
                if (nval & 0x0080)
                     comment = comment + " INITIALIZED=YES";
                else comment = comment + " INITIALIZED=NO";
                if (nval & 0x0040)
                     comment = comment + " DISCHARGING=YES";
                else comment = comment + " DISCHARGING=NO";
                if (nval & 0x0020)
                     comment = comment + " FULLY_CHARGED=YES";
                else comment = comment + " FULLY_CHARGED=NO";
                if (nval & 0x0010)
                     comment = comment + " FULLY_DISCHARGED=YES";
                else comment = comment + " FULLY_DISCHARGED=NO";
                comment = comment + format(" Error=0x%x", nval & 0x000f);
			}break;
		case SMBUS_CYCLECOUNT:
			{
				strVal = getUShort(attrval);
				name = "CYCLECOUNT";
                comment = "cycles (0 to 65,534) 65,535 indicates battery has experienced 65,535 or more cycles";
			}break;
		case SMBUS_DESIGNCAPACITY:
			{
				strVal = getUShort(attrval);
				name = "DESIGNCAPACITY";
                comment = "mAh (0 to 65,535)";
			}break;
		case SMBUS_DESIGNVOLTAGE:
			{
				strVal = getUShort(attrval);
				name = "DESIGNVOLTAGE";
                comment = "mV (0 to 65,535)";
			}break;
		case SMBUS_SPECIFICATIONINFO:
			{
				local sh = getUShortAsNumber(attrval);

				strVal = format("0x%04x Rev:0x%02x Ver:0x%02x Vscale:0x%02x IPScale:0x%02x", sh, sh & 0xF, (sh >> 4) & 0xF,  (sh >> 8) & 0xF, (sh >> 12) & 0xF);

				name = "SPECIFICATIONINFO";
                comment = "";
			}break;
		case SMBUS_MANUFACTURERDATE:
			{
				local sh = getUShortAsNumber(attrval);

				strVal = format("%02d:%02d:%02d",sh & 0x1F, (sh >> 5) & 0xF,  (sh >> 9) & 0x7F);

				name = "MANUFACTURERDATE";
                comment = " day:month:year";
			}break;
		case SMBUS_SERIALNUMBER:
			{
				strVal = getUShort(attrval);
				name = "SERIALNUMBER";
                comment = "(uint)";
			}break;
		//0X1D-0X1F RESERVED
		case SMBUS_MANUFACTURERNAME:
			{
				strVal = getString(attrval);
				name = "MANUFACTURERNAME";
                comment = "(string)";
			}break;
		case SMBUS_DEVICENAME:
			{
				strVal = getString(attrval);
				name = "DEVICENAME";
                comment = "(string)";
			}break;
		case SMBUS_DEVICECHEMISTRY:
			{
				strVal = getString(attrval);
				name = "DEVICECHEMISTRY";
                comment = "(string)";
			}break;
		case SMBUS_MANUFACTURERDATA:
			{
				strVal = getHex(attrval);
				name = "MANUFACTURERDATA";
                comment = "";
			}break;

		case SMBUS_CHARGINGCURRENT:
			{
				strVal = getUShort(attrval);
				name = "CHARGINGCURRENT";
                comment = "mA (0 to 65,534) 65,535 indicates the Smart Battery Charger should operate as a voltage source outside its maximum regulated current range";
			}break;
		case SMBUS_CHARGINGVOLTAGE:
			{
				strVal = getUShort(attrval);
				name = "CHARGINGVOLTAGE";
                comment = "mV (0 to 65,534) 65,535 indicates the Smart Battery Charger should operate as a current source outside its maximum regulated voltage range";
			}break;
	}
    
    server.log(name+"="+strVal+" "+comment);
}

///////////////////////////////////////////////////////////////////////////
input <- MyInput();

imp.configure("SMBus Test",[input],[]);
server.show("SMBus Test");
imp.enableblinkup(true);

i2cPort <- hardware.i2c89;
server.log("Initializing I2C ...");
hardware.configure(I2C_89);
i2cPort.configure(CLOCK_SPEED_100_KHZ);

fixed_message<- -1;//SMBUS_MANUFACTURERDATA;
perform_loop <- 2;
last_message <- 0;
if (fixed_message != -1) last_message = fixed_message;

function loop()
{
    if (perform_loop)  imp.wakeup(perform_loop, loop);
    
    local result = i2cPort.read(0x71, format("%c",last_message), 2);
    if (result != null)
         parseValue(last_message, result);
    else server.log("Received null");
    
    if (fixed_message == -1)
    {
        last_message = last_message + 1; 
        if (last_message == 0X1D) last_message = 0x20;
        if (last_message > SMBUS_LASTMESG) last_message = 0;
    }
}
loop();