/// <summary>
/// Retrieves the Hardware Version from a Morning Star Charge Controller
/// </summary>
/// <param name="messenger">The ModbusMessenger to perform the transaction on</param>
/// <returns>The hardware version as reported by the charge controller</returns>
public static string GetHardwareVersion(ModbusMessenger messenger)
{
ModbusMessenger.TransportEncoding te = messenger.TransportEndoing;
messenger.TransportEndoing = ModbusMessenger.TransportEncoding.Binary;
ModbusMessage registers = messenger.ReadHoldingRegisters(0xf00a, 0x0001);
messenger.TransportEndoing = te;
return(registers.DataPoints[0] + "." + registers.DataPoints[1]);
}
/// <summary>
/// Retrieves the Serial Number from a Morning Star Charge Controller
/// </summary>
/// <param name="messenger">The ModbusMessenger to perform the transaction on</param>
/// <returns>The serial number of the charge controller</returns>
public static string GetSerialNumber(ModbusMessenger messenger)
{
//remember the old transport encoding
ModbusMessenger.TransportEncoding te = messenger.TransportEndoing;
//set the new transport encoding
messenger.TransportEndoing = ModbusMessenger.TransportEncoding.Binary;
ModbusMessage registers = messenger.ReadHoldingRegisters(0xf000, 0x0004);//was 0x0008
messenger.TransportEndoing = te;
return(System.Text.Encoding.ASCII.GetString(registers.DataPoints.ToArray()));//needed substring 0, 8
}
/// <summary>
/// Instructs the Morning Star Charge Controller to reset the Alarm Table
/// </summary>
/// <param name="messenger">The ModbusMessenger to perform the transaction on</param>
/// <returns>True if the controller has reset the Alarm Table</returns>
public static bool ClearAlarms(ModbusMessenger messenger)
{
try
{
ModbusMessage result = messenger.WriteSingleCoil(0x0015, true);
return(true);
}
catch
{
return(false);
}
}
/// <summary>
/// Instructs the Morning Star Charge Controller to reset the Battery Service Reminder Alarm
/// </summary>
/// <param name="messenger">The ModbusMessenger to perform the transaction on</param>
/// <returns>True if the controller has reset the Battery Service Reminder</returns>
public static bool ResetBatteryServiceReminder(ModbusMessenger messenger)
{
try
{
ModbusMessage result = messenger.WriteSingleCoil(0x0013, true);
return(true);
}
catch
{
return(false);
}
}
/// <summary>
/// Instructs the Morning Star Charge Controller to reset the Resetable Amp Hours Counter
/// </summary>
/// <param name="messenger">The ModbusMessenger to perform the transaction on</param>
/// <returns>True if the controller has reset the Resetable Amp Hours Counter</returns>
public static bool ClearResetableAmpHours(ModbusMessenger messenger)
{
try
{
ModbusMessage result = messenger.WriteSingleCoil(0x0010, true);
return(true);
}
catch
{
return(false);
}
}
/// <summary>
/// Instructs the Morning Star Charge Controller to reset the Killowatt Hours Counter
/// </summary>
/// <param name="messenger">The ModbusMessenger to perform the transaction on</param>
/// <returns>True if the controller has reset the Killowatt Hours Counter</returns>
public static bool ClearKillowattHours(ModbusMessenger messenger)
{
try
{
ModbusMessage result = messenger.WriteSingleCoil(0x0012, true);
return(true);
}
catch
{
return(false);
}
}
/// <summary>
/// Instructs the Morning Star Charge Controller to forcefully update it's EEPROM
/// </summary>
/// <param name="messenger">The ModbusMessenger to perform the transaction on</param>
/// <returns>True if the controller has updated EEPROM</returns>
public static bool ForceEEPROMUpdate(ModbusMessenger messenger)
{
try
{
ModbusMessage result = messenger.WriteSingleCoil(0x0016, true);
return(true);
}
catch
{
return(false);
}
}
/// <summary>
/// Retrieves the amount of days since the last battery service from a Morning Star Change Controller
/// </summary>
/// <param name="messenger">The ModbusMessenger to perform the transaction on</param>
/// <returns>The amount of days since the last day the batteries were serviced as reported by the charge controller</returns>
public static int GetDaysSinceLastBatteryService(ModbusMessenger messenger)
{
//remember the old transport encoding
ModbusMessenger.TransportEncoding te = messenger.TransportEndoing;
//set the new transport encoding
messenger.TransportEndoing = ModbusMessenger.TransportEncoding.Binary;
ModbusMessage registers = messenger.ReadHoldingRegisters(0xe023, 0x0001);
short v = BitConverter.ToInt16(registers.DataPoints.ToArray(), 0);
messenger.TransportEndoing = te;
return(v);
}
/// <summary>
/// Instructs the Morning Star Charge Controller to force it's software into CONNECT state. Turns off MOSFETs and waits.
/// </summary>
/// <param name="messenger">The ModbusMessenger to perform the transaction on</param>
/// <returns>True if the controller has been connected</returns>
public static bool ConnectController(ModbusMessenger messenger)
{
try
{
ModbusMessage result = messenger.WriteSingleCoil(0x0001, true);
return(true);
}
catch
{
return(false);
}
}
/// <summary>
/// Instructs the Morning Star Charge Controller to enter Low Voltage Disconnect for 1 Cycle
/// </summary>
/// <param name="messenger">The ModbusMessenger to perform the transaction on</param>
/// <returns>True if the controller has entered Low Voltage Disconnect for 1 Cycle</returns>
public static bool LVDOverrideOneCycle(ModbusMessenger messenger)
{
try
{
ModbusMessage result = messenger.WriteSingleCoil(0x0017, true);
return(true);
}
catch
{
return(false);
}
}
/// <summary>
/// Retrieves the Faults from a Morning Star Charge Controller
/// </summary>
/// <param name="messenger">The ModbusMessenger to perform the transaction on</param>
/// <returns>The Fault Readings reported by the charge controller</returns>
public static FaultReading GetFaults(ModbusMessenger messenger)
{
//remember the old transport encoding
ModbusMessenger.TransportEncoding te = messenger.TransportEndoing;
//set the new transport encoding
messenger.TransportEndoing = ModbusMessenger.TransportEncoding.Binary;
ModbusMessage registers = messenger.ReadHoldingRegisters(0x001a, 0x0001);
//get registers.DataPoints into a short v
short v = System.Net.IPAddress.NetworkToHostOrder(BitConverter.ToInt16(registers.DataPoints.ToArray(), 0));
messenger.TransportEndoing = te;
return(new FaultReading(v));
}
/// <summary>
/// Retrieves the Killowatt Hours Counter From a Morning Star Charge Controller
/// </summary>
/// <param name="messenger">The ModbusMessenger to perform the transaction on</param>
/// <returns>The Killowatt Hours Counter reported by the Charge Controller</returns>
public static int GetKilowattHours(ModbusMessenger messenger)
{
//remember the old transport encoding
ModbusMessenger.TransportEncoding te = messenger.TransportEndoing;
//set the new transport encoding
messenger.TransportEndoing = ModbusMessenger.TransportEncoding.Binary;
//obtain totalAmpHours - scale via stdScalar6
ModbusMessage registers = messenger.ReadHoldingRegisters(0xe02a, 0x0001);
//get registers.DataPoints into a short v
short v = System.Net.IPAddress.NetworkToHostOrder(BitConverter.ToInt16(registers.DataPoints.ToArray(), 0));
//return v * stdScalar6
messenger.TransportEndoing = te;
return(v);
}
/// <summary>
/// Retirves the maximium battery voltage from a Morning Star Charge Controller
/// </summary>
/// <param name="messenger">The ModbusMessenger to perform the transaction on</param>
/// <returns>The maximum battery voltage as reported by the charge controller</returns>
public static double GetMaximumBatteryVoltage(ModbusMessenger messenger)
{
//remember the old transport encoding
ModbusMessenger.TransportEncoding te = messenger.TransportEndoing;
//set the new transport encoding
messenger.TransportEndoing = ModbusMessenger.TransportEncoding.Binary;
//obtain minBatteryVoltage - scale via stdScalar3
ModbusMessage registers = messenger.ReadHoldingRegisters(0xe02c, 0x0001);
//get registers.DataPoints into a short v
short v = BitConverter.ToInt16(registers.DataPoints.ToArray(), 0);
//return v * stdScalar3
messenger.TransportEndoing = te;
return((double)v * stdScalar3);
}
/// <summary>
/// Retrieves the Load Current from a Morning Star Charge Controller
/// </summary>
/// <param name="messenger">The ModbusMessenger to perform the transaction on</param>
/// <returns>The Load Current reported by the charge controller</returns>
public static double GetLoadCurrent(ModbusMessenger messenger)
{
//remember the old transport encoding
ModbusMessenger.TransportEncoding te = messenger.TransportEndoing;
//set the new transport encoding
messenger.TransportEndoing = ModbusMessenger.TransportEncoding.Binary;
//obtain loadCurrent - scale via stdScalar4
ModbusMessage registers = messenger.ReadHoldingRegisters(0x000c, 0x001);
//get registers.DataPoints into a short v
short v = System.Net.IPAddress.NetworkToHostOrder(BitConverter.ToInt16(registers.DataPoints.ToArray(), 0));
//return v * stdScalar4
messenger.TransportEndoing = te;
return((double)v * stdScalar4);
}
/// <summary>
/// Retrieves the Control State from a Morning Star Charge Controller
/// </summary>
/// <param name="messenger">The ModbusMessenger to perform the transaction on</param>
/// <returns>The ControlState the Charge controller is operating under</returns>
public static ControlState GetControlState(ModbusMessenger messenger, ControlMode controlMode)
{
//remember the old transport encoding
ModbusMessenger.TransportEncoding te = messenger.TransportEndoing;
//set the new transport encoding
messenger.TransportEndoing = ModbusMessenger.TransportEncoding.Binary;
ModbusMessage registers = messenger.ReadHoldingRegisters(0x001a, 0x0001);
//get registers.DataPoints into a short v
short v = System.Net.IPAddress.NetworkToHostOrder(BitConverter.ToInt16(registers.DataPoints.ToArray(), 0));
messenger.TransportEndoing = te;
if (controlMode == ControlMode.Charge || controlMode == ControlMode.Diversion)
{
return((ControlState)v);
}
else
{
return((ControlState)(8 + v));
}
}
/// <summary>
/// Retrieves the Resetable Amp Hours Counter From a Morning Star Charge Controller
/// </summary>
/// <param name="messenger">The ModbusMessenger to perform the transaction on</param>
/// <returns>The Resetable Amp Hours Counter reported by the Charge Controller</returns>
public static double GetResetableAmpHours(ModbusMessenger messenger)
{
//remember the old transport encoding
ModbusMessenger.TransportEncoding te = messenger.TransportEndoing;
//set the new transport encoding
messenger.TransportEndoing = ModbusMessenger.TransportEncoding.Binary;
//obtain totalAmpHours - scale via stdScalar6
ModbusMessage registers = messenger.ReadHoldingRegisters(0xe026, 0x0002);
//get registers.DataPoints into a short v
byte[] data = registers.DataPoints.ToArray();
short v = System.Net.IPAddress.NetworkToHostOrder(BitConverter.ToInt16(data, 0));
if (data.Length > 2)
{
v += System.Net.IPAddress.NetworkToHostOrder(BitConverter.ToInt16(data, 2));
}
//return v * stdScalar6
messenger.TransportEndoing = te;
return((double)v * stdScalar6);
}
/// <summary>
/// Retrieves the Vendor Name from a Morning Star Charge Controller
/// </summary>
/// <param name="messenger">The ModbusMessenger to perform the transaction on</param>
/// <returns>The Vendor Name of the charge controller</returns>
public static string GetVendorName(ModbusMessenger messenger)
{
ModbusMessage vn = messenger.ReadDeviceInformation(0, 1);
return(System.Text.Encoding.ASCII.GetString(vn.DataPoints.ToArray()));
}
/// <summary>
/// Retrieves the Product Code from a Morning Star Charge Controller
/// </summary>
/// <param name="messenger">The ModbusMessenger to perform the transaction on</param>
/// <returns>The Product Code of the charge controller</returns>
public static string GetProductCode(ModbusMessenger messenger)
{
ModbusMessage pc = messenger.ReadDeviceInformation(1, 1);
return(System.Text.Encoding.ASCII.GetString(pc.DataPoints.ToArray()));
}
public static double GetHeatSinkTemperature(ModbusMessenger messenger)
{
throw new NotImplementedException();
}
/// <summary>
/// Retrieves the Software Version from a Morning Star Charge Controller
/// </summary>
/// <param name="messenger">The ModbusMessenger to perform the transaction on</param>
/// <returns>The Software Version of the charge controller</returns>
public static string GetSoftwareVersion(ModbusMessenger messenger)
{
ModbusMessage mmr = messenger.ReadDeviceInformation(2, 1);
return(System.Text.Encoding.ASCII.GetString(mmr.DataPoints.ToArray()));
}
