/// <summary>
/// Nastavení adresy a rychlosti. Bezprostředně před nastavením rychlosti musí být povolena konfugurace pomocí funkce <see cref="CmdAllowConfiguration"/>
/// </summary>
/// <param name="newaddr">Nová adresa. Musí být z rozsahu 0 až 253.</param>
/// <param name="newbaudrate">Nová komunikační rychlost v Baudech. Musí být jednou ze standardních komunikačních rychlostí jak jsou uvedeny v <see cref="Baudrates"/>. Pokud jde o jinou nestandardní rychlost, uveďte přímo kód rychlosti.</param>
/// <returns>Vrací standardní kód odpovědi z výčtu <see cref="ResponseACK"/>.</returns>
public ResponseACK CmdSetCommParams(byte newaddr, int newbaudrate)
{
if ((ci != null) && (ci.Active))
{
if ((newaddr == 0xFF) || (newaddr == 0xFE))
{
return(ResponseACK.InvalidData);
}
int speedcode = Array.IndexOf <int>(Baudrates, newbaudrate);
if ((speedcode == -1) && (newbaudrate > 0xFF))
{
return(ResponseACK.InvalidData);
}
if (speedcode == -1)
{
speedcode = newbaudrate;
}
byte[] data = { newaddr, (byte)speedcode };
PacketSpinel97 txPacket = new PacketSpinel97(S97_INST_SetCommParams, data);
txPacket.ADR = this.ADR;
PacketSpinel97 rxPacket;
if (SendAndReceive(ref txPacket, out rxPacket))
{
return((ResponseACK)rxPacket.INST);
}
}
return(ResponseACK.OtherCommError);
}
/// <summary>
/// Čtení stavu vstupů
/// </summary>
/// <param name="inputs">pole logických stavů vstupů</param>
/// <returns>vrací True pokud je přijata a zpracována korektní odpověď</returns>
public Boolean CmdGetInputs(out Boolean[] inputs)
{
inputs = null;
PacketSpinel97 txPacket = new PacketSpinel97(S97_INST_QUIDO_GetInputs);
txPacket.ADR = this.ADR;
PacketSpinel97 rxPacket;
if (SendAndReceive(ref txPacket, out rxPacket) && (rxPacket.INST == (byte)ResponseACK.AllIsOk))
{
if (rxPacket.SDATA != null)
{
inputs = new Boolean[(InputCount > -1) ? InputCount : rxPacket.SDATA.Length * 8];
byte index = 0;
while ((index < inputs.Length) && ((index / 8) < rxPacket.SDATA.Length))
{
inputs[index] = (((rxPacket.SDATA[rxPacket.SDATA.Length - (index / 8) - 1]) & (1 << (index % 8))) != 0);
index++;
}
return(true);
}
}
return(false);
}
/// <summary>
/// Nastavení samovolného vysílání
/// </summary>
/// <param name="enabled">je-li True, pak je samovolné vysílání aktivní</param>
/// <returns>vrací True pokud je přijata a zpracována korektní odpověď</returns>
public Boolean CmdGetAutoNotify(out byte format, out bool[] mask)
{
format = 0;
mask = null;
PacketSpinel97 txPacket = new PacketSpinel97(S97_INST_QUIDO_GetAutoNotify);
txPacket.ADR = this.ADR;
PacketSpinel97 rxPacket;
if (SendAndReceive(ref txPacket, out rxPacket) && (rxPacket.INST == (byte)ResponseACK.AllIsOk))
{
if ((rxPacket.SDATA != null) && (rxPacket.SDATA.Length > 1))
{
format = (rxPacket.SDATA[0]);
mask = new bool[8 * (rxPacket.SDATA.Length - 1)];
for (int i = 0; i < mask.Length; i++)
{
mask[i] = ((rxPacket.SDATA[(i / 8) + 1] & (1 << (i % 8))) != 0);
}
return(true);
}
}
return(false);
}
/// <summary>
/// Přečte datum a čas z displeje.
/// </summary>
/// <param name="date">Datum a čas ze zařízení.</param>
/// <returns></returns>
public bool CmdGetDateTime(out DateTime date)
{
byte[] data = { };
PacketSpinel97 txPacket = new PacketSpinel97(S97_INST_TDS_GetDateTime, data);
txPacket.ADR = this.ADR;
PacketSpinel97 rxPacket;
if ((SendAndReceive(ref txPacket, out rxPacket)) && (rxPacket.INST == (byte)ResponseACK.AllIsOk))
{
if ((rxPacket.SDATA != null) && (rxPacket.SDATA.Length == 7))
{
date = new DateTime();
date = date.AddHours(rxPacket.SDATA[0]);
date = date.AddMinutes(rxPacket.SDATA[1]);
date = date.AddSeconds(rxPacket.SDATA[2]);
date = date.AddDays(rxPacket.SDATA[4] - 1);
date = date.AddMonths(rxPacket.SDATA[5] - 1);
int yy = DateTime.Now.Year - (DateTime.Now.Year % 100) + (rxPacket.SDATA[6] - 1);
date = date.AddYears(yy);
return(true);
}
}
date = DateTime.MinValue;
return(false);
}
/// <summary>
/// Instrukce umožňuje nastavit adresu podle unikátního sériového čísla zařízení.
/// Tato instrukce je praktická v případě, že nadřazený systém nebo obsluha ztratí adresu zařízení,
/// které je na stejné komunikační lince s dalšími zařízeními.
/// </summary>
/// <param name="newaddr">Nová adresa. Musí být z rozsahu 0 až 253.</param>
/// <param name="devicenumber">Typ zařízení. Kompletní S/N zařízení má tvar 1234/4567. Typ zařízení je číslo před lomítkem.</param>
/// <param name="serialnumber">Sériové číslo. Kompletní S/N zařízení má tvar 1234/4567. Sériové číslo je číslo za lomítkem.</param>
/// <returns></returns>
public Boolean CmdSetAddressBySerialNumber(byte newaddr, UInt16 devicenumber, UInt16 serialnumber)
{
if ((ci != null) && (ci.Active))
{
if ((newaddr == 0xFF) || (newaddr == 0xFE))
{
return(false);
}
byte[] data = new byte[5];
data[0] = newaddr;
data[1] = (byte)((devicenumber & 0xFF00) >> 8);
data[2] = (byte)(devicenumber & 0x00FF);
data[3] = (byte)((serialnumber & 0xFF00) >> 8);
data[4] = (byte)(serialnumber & 0x00FF);
PacketSpinel97 txPacket = new PacketSpinel97(S97_INST_SetAddrBySN, data);
txPacket.ADR = 0xFE;
PacketSpinel97 rxPacket;
if (SendAndReceive(ref txPacket, out rxPacket) && (rxPacket.INST == (byte)ResponseACK.AllIsOk))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Čtení čítače
/// </summary>
/// <param name="index">pořadové číslo vstupu/čítače (indexováno od 1)</param>
/// <param name="counter">vrací přečtenou hodnotu čítače</param>
/// <param name="erase">je-li true, dojde při přečten k nulování tohoto čítače</param>
/// <returns>vrací True pokud je přijata a zpracována korektní odpověď</returns>
public Boolean CmdGetCounter(byte index, out int counter, bool erase = false)
{
counter = 0;
byte[] data = new byte[1];
data[0] = (byte)((index & 0x7F) | ((erase) ? 0x80 : 0x00));
PacketSpinel97 txPacket = new PacketSpinel97(S97_INST_QUIDO_GetCounter, data);
txPacket.ADR = this.ADR;
PacketSpinel97 rxPacket;
if (SendAndReceive(ref txPacket, out rxPacket) && (rxPacket.INST == (byte)ResponseACK.AllIsOk))
{
if ((rxPacket.SDATA != null) && (rxPacket.SDATA.Length > 1))
{
int len = rxPacket.SDATA[0]; // počet bitů counteru
int i = 1;
while ((i <= (len / 8)) && (i < rxPacket.SDATA.Length))
{
counter = ((counter * 0x100) + rxPacket.SDATA[i]);
i++;
}
return(true);
}
}
return(false);
}
/// <summary>
/// Zjistí počet segmentovek, vstupů a teplotních senzorů.
/// </summary>
/// <param name="SegCount">Počet znakovek.</param>
/// <param name="InCount">Počet vstupů.</param>
/// <param name="SnsCount">Počet teplotních senzorů.</param>
/// <returns></returns>
public bool CmdGetHwInfo(out int SegCount, out int InCount, out int SnsCount)
{
SegCount = -1;
InCount = -1;
SnsCount = -1;
byte[] data = { 0x01 };
PacketSpinel97 txPacket = new PacketSpinel97(S97_INST_ReadInfo, data);
txPacket.ADR = this.ADR;
PacketSpinel97 rxPacket;
if ((SendAndReceive(ref txPacket, out rxPacket)) && (rxPacket.INST == (byte)ResponseACK.AllIsOk))
{
if ((rxPacket.SDATA != null) && (rxPacket.SDATA.Length == 5))
{
SegCount = rxPacket.SDATA[0];
InCount = rxPacket.SDATA[2];
SnsCount = rxPacket.SDATA[4];
return(true);
}
}
return(false);
}
/// <summary>
/// Nastavení výstupu
/// </summary>
/// <param name="outid">výstup (indexováno od 1)</param>
/// <param name="value">požadovaný stav</param>
/// <param name="timer">čas po který bude výstup nastaven do požadovaného stavu, poté dojde ke změně na opačný stav. ( 1-255 * 0.5s )</param>
/// <returns>vrací True v případě potvrzení příkazu modulem</returns>
public Boolean CmdSetOutput(byte outid, Boolean value, byte timer = 0)
{
PacketSpinel97 txPacket = new PacketSpinel97();
byte[] data;
if (timer == 0)
{
txPacket.INST = S97_INST_QUIDO_SetOutput;
data = new byte[1];
data[0] = (byte)(((value) ? 0x80 : 0x00) | (outid & 0x7F));
}
else
{
txPacket.INST = S97_INST_QUIDO_SetOutputTimered;
data = new byte[2];
data[0] = timer;
data[1] = (byte)(((value) ? 0x80 : 0x00) | (outid & 0x7F));
}
txPacket.ADR = this.ADR;
txPacket.SDATA = data;
PacketSpinel97 rxPacket;
if (this.SendAndReceive(ref txPacket, out rxPacket) && (rxPacket.INST == (byte)ResponseACK.AllIsOk))
{
return(true);
}
return(false);
}
/// <summary>
/// Vrací typ aktuálně nastaveného senzoru. (Nejedná se o autodetekci typu aktuálně připojeného senzoru. Typ senzoru se detekuje jen při zapnutí.)
/// </summary>
/// <param name="sensor">Typ senzoru detekovaného při zapnutí.</param>
/// <returns>Výčet <see cref="ResponseACK"/>.</returns>
public ResponseACK CmdGetSensorType(out SensorType sensor)
{
byte[] data = { };
sensor = SensorType.Other;
PacketSpinel97 txPacket = new PacketSpinel97(S97_INST_Tht2Th2e_GetSensorType, data);
txPacket.ADR = this.ADR;
PacketSpinel97 rxPacket;
if (SendAndReceive(ref txPacket, out rxPacket))
{
if (rxPacket.INST == (byte)ResponseACK.AllIsOk)
{
if ((rxPacket.SDATA != null) && (rxPacket.SDATA.Length == 1))
{
if (rxPacket.SDATA[0] <= 4)
{
sensor = (SensorType)(rxPacket.SDATA[0]);
}
return(ResponseACK.AllIsOk);
}
}
else
{
return((ResponseACK)rxPacket.INST);
}
}
return(ResponseACK.OtherCommError);
}
/// <summary>
/// Ovládání automatického nastavování jasu displeje.
/// </summary>
/// <param name="enable">Automtika zapnuta = true.</param>
/// <param name="min">Minimální jas na který může automatika jít (rozsah 6-36).</param>
/// <param name="max">Maximální jas na který může automatika jít (rozsah 6-36).</param>
/// <returns></returns>
public bool CmdSetBrightnessAuto(bool enable, byte min, byte max)
{
if ((min > 36) || (min < 6))
{
return(false);
}
if ((max > 36) || (max < 6))
{
return(false);
}
byte[] data = { Convert.ToByte(enable), min, max, 0 };
PacketSpinel97 txPacket = new PacketSpinel97(S97_INST_TDS_SetBrightnessAuto, data);
txPacket.ADR = this.ADR;
PacketSpinel97 rxPacket;
if ((SendAndReceive(ref txPacket, out rxPacket)) && (rxPacket.INST == (byte)ResponseACK.AllIsOk))
{
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Zjistí adresu a komunikační rychlost zařízení. (Má význam jen u zařízení komunikujících po sériovém rozhraní.)
/// </summary>
/// <param name="addr">Adresa.</param>
/// <param name="baudrate">Komunikační rychlost v Baudech. Pokud je číslo menší než 110, jde o neznámý kód komunikační rychlosti.</param>
/// <returns></returns>
public Boolean CmdGetCommParams(out byte addr, out int baudrate)
{
if ((ci != null) && (ci.Active))
{
byte[] data = { };
PacketSpinel97 txPacket = new PacketSpinel97(S97_INST_GetCommParams, data);
txPacket.ADR = this.ADR;
PacketSpinel97 rxPacket;
if (SendAndReceive(ref txPacket, out rxPacket) && (rxPacket.INST == (byte)ResponseACK.AllIsOk))
{
if ((rxPacket.SDATA != null) && (rxPacket.SDATA.Length == 2))
{
addr = rxPacket.SDATA[0];
byte speedcode = rxPacket.SDATA[1];
if (speedcode < Baudrates.Length)
{
baudrate = Baudrates[speedcode];
}
else
{
baudrate = speedcode;
}
return(true);
}
}
}
addr = 0xFF;
baudrate = 0xFF;
return(false);
}
/// <summary>
/// Čtení teploty z teplotního senzoru
/// </summary>
/// <param name="temp">Aktuálně naměřená teplota. Pokud z nějakého důvodu není dostupná, je zde konstanta float.NaN.</param>
/// <returns>Výčet <see cref="ResponseACK"/>.</returns>
public ResponseACK CmdGetTemperature(out float temp)
{
byte[] data = {};
PacketSpinel97 txPacket = new PacketSpinel97(S97_INST_TQS_GetTemperature, data);
txPacket.ADR = this.ADR;
PacketSpinel97 rxPacket;
if (SendAndReceive(ref txPacket, out rxPacket))
{
if (rxPacket.INST == (byte)ResponseACK.AllIsOk)
{
if ((rxPacket.SDATA != null) && (rxPacket.SDATA.Length == 2))
{
temp = (float)(rxPacket.SDATA[0] * 256 + rxPacket.SDATA[1]) / 32;
return(ResponseACK.AllIsOk);
}
}
else
{
temp = float.NaN;
return((ResponseACK)rxPacket.INST);
}
}
temp = float.NaN;
return(ResponseACK.OtherCommError);
}
public bool CheckReceivePacket(ref PacketSpinel97 rxPacket)
{
if ((rxPacket.INST < 0x10) && (rxPacket.SIG == this.tx_packet.SIG))
{
this.rx_packet = rxPacket;
this.notify_rx_packet_receive.Set();
return(true);
}
return(false);
}
public override void PacketReceive(ref PacketSpinel97 packet)
{
base.PacketReceive(ref packet);
if (packet.INST == 0x0D)
{
Debug.Print("Quido Autonotify Message");
if ((OnInputsChange != null) || (OnInputChange != null))
{
Boolean[] inputs = null;
if (packet.SDATA != null)
{
inputs = new Boolean[(InputCount > -1) ? InputCount : packet.SDATA.Length * 8];
byte index = 0;
while ((index < inputs.Length) && ((index / 8) < packet.SDATA.Length))
{
inputs[index] = (((packet.SDATA[packet.SDATA.Length - (index / 8) - 1]) & (1 << (index % 8))) != 0);
index++;
}
if (OnInputsChange != null)
{
OnInputsChange(this, inputs);
}
if (OnInputChange != null)
{
if (last_input_status == null)
{
last_input_status = new Boolean[inputs.Length];
for (int i = 0; (i < last_input_status.Length); i++)
{
OnInputChange(this, i, inputs[i], inputs[i]);
last_input_status[i] = inputs[i];
}
}
else
{
for (int i = 0; (i < last_input_status.Length); i++)
{
if (last_input_status[i] != inputs[i])
{
OnInputChange(this, i, last_input_status[i], inputs[i]);
last_input_status[i] = inputs[i];
}
}
}
}
}
}
}
}
/// <summary>
/// Měření aktuálních hodnot
/// </summary>
/// <param name="values">Třída se statusy a hodnotami jednotlivých veličin.</param>
/// <returns>Výčet <see cref="ResponseACK"/>.</returns>
public ResponseACK CmdGetMeasure(out MeasuredValues values)
{
values = new MeasuredValues();
byte[] data = { 0x00 };
PacketSpinel97 txPacket = new PacketSpinel97(S97_INST_Tht2Th2e_GetMeasure, data);
txPacket.ADR = this.ADR;
PacketSpinel97 rxPacket;
if (SendAndReceive(ref txPacket, out rxPacket))
{
if (rxPacket.INST == (byte)ResponseACK.AllIsOk)
{
if ((rxPacket.SDATA != null) && (rxPacket.SDATA.Length > 0) && (rxPacket.SDATA.Length % 4 == 0))
{
int SectionIndex = FindSectionById(QuantityType.Temperature, ref rxPacket.SDATA);
if (SectionIndex > -1)
{
values.TemperatureStatus = (FlagsStatus)rxPacket.SDATA[SectionIndex + 1];
values.Temperature = (float)(rxPacket.SDATA[SectionIndex + 2] * 256 + rxPacket.SDATA[SectionIndex + 3]) / 10;
}
SectionIndex = FindSectionById(QuantityType.DewPoint, ref rxPacket.SDATA);
if (SectionIndex > -1)
{
values.DewPointStatus = (FlagsStatus)rxPacket.SDATA[SectionIndex + 1];
values.DewPoint = (float)(rxPacket.SDATA[SectionIndex + 2] * 256 + rxPacket.SDATA[SectionIndex + 3]) / 10;
}
SectionIndex = FindSectionById(QuantityType.Humidity, ref rxPacket.SDATA);
if (SectionIndex > -1)
{
values.HumidityStatus = (FlagsStatus)rxPacket.SDATA[SectionIndex + 1];
values.Humidity = (float)(rxPacket.SDATA[SectionIndex + 2] * 256 + rxPacket.SDATA[SectionIndex + 3]) / 10;
}
if ((int)values.TemperatureStatus + (int)values.TemperatureStatus + (int)values.DewPointStatus > 0)
{
return(ResponseACK.AllIsOk);
}
}
}
else
{
return((ResponseACK)rxPacket.INST);
}
}
return(ResponseACK.OtherCommError);
}
/// <summary>
/// Zobrazení dat na displeji - vstupem je pole bytů. První byte jsou kontrolky.
/// </summary>
/// <param name="data">Binární data k zobrazení. První byte jsou kontrolky. Délka musí být počet segmentovek + 1.</param>
/// <returns></returns>
public bool CmdSetDataBin(byte[] data)
{
PacketSpinel97 txPacket = new PacketSpinel97(S97_INST_TDS_SetDataBin, data);
txPacket.ADR = this.ADR;
PacketSpinel97 rxPacket;
if ((SendAndReceive(ref txPacket, out rxPacket)) && (rxPacket.INST == (byte)ResponseACK.AllIsOk))
{
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Čtení nastavení samovolného vysílání
/// </summary>
/// <param name="enabled">je li True, pak je samovolné vysílání zapnuto</param>
/// <returns>vrací True pokud je přijata a zpracována korektní odpověď</returns>
public Boolean CmdSetAutoNotify(bool enabled)
{
byte[] data = new byte[1];
data[0] = (byte)((enabled) ? 0x01 : 0x00);
PacketSpinel97 txPacket = new PacketSpinel97(S97_INST_QUIDO_SetAutoNotify, data);
txPacket.ADR = this.ADR;
PacketSpinel97 rxPacket;
if (SendAndReceive(ref txPacket, out rxPacket) && (rxPacket.INST == (byte)ResponseACK.AllIsOk))
{
return(true);
}
return(false);
}
/// <summary>
/// Nastavení čítače
/// </summary>
/// <param name="index">pořadové číslo vstupu/čítače (indexováno od 1)</param>
/// <param name="rising">čítač reaguje na náběžnou hranu</param>
/// <param name="falling">čítač reaguje na sestupnou hranu</param>
/// <returns>vrací True pokud modul potvrdí zpracování příkazu</returns>
public Boolean CmdSetCounterSettings(byte index, bool rising, bool falling)
{
byte[] data = new byte[1];
data[0] = (byte)((index & 0x3F) | ((rising) ? 0x80 : 0x00) | ((falling) ? 0x40 : 0x00));
PacketSpinel97 txPacket = new PacketSpinel97(S97_INST_QUIDO_SetCounterSettings, data);
txPacket.ADR = this.ADR;
PacketSpinel97 rxPacket;
if (SendAndReceive(ref txPacket, out rxPacket) && (rxPacket.INST == (byte)ResponseACK.AllIsOk))
{
return(true);
}
return(false);
}
public virtual void PacketReceive(ref PacketSpinel97 packet)
{
Debug.Print("Receive packet {0}", packet.INST);
OnPacketReceive?.Invoke(packet);
if (packet.INST < 0x10)
{
foreach (SpinelStackRec ssr in packets_to_receive)
{
if (ssr.CheckReceivePacket(ref packet))
{
packets_to_receive.Remove(ssr);
return;
}
}
}
}
/// <summary>
/// Nastavení více výstupů najednou. Může obsahovat nastavení jednoho nebo až všech výstupů do požadovaného stavu. Stav může být pro každý výstup jiný.
/// </summary>
/// <param name="outs">List struktur <see cref="OutputState"/>. (Obsahují byte číslo výstupu a bool stav výstupu.)</param>
/// <param name="timer">čas po který bude výstup nastaven do požadovaného stavu, poté dojde ke změně na opačný stav. ( 1-255 * 0.5s )</param>
/// <returns>vrací True v případě potvrzení příkazu modulem</returns>
public Boolean CmdSetOutputs(List <OutputState> outs, byte timer = 0)
{
PacketSpinel97 txPacket = new PacketSpinel97();
byte[] data;
if (outs.Count == 0)
{
return(false);
}
if (timer == 0)
{
txPacket.INST = S97_INST_QUIDO_SetOutput;
data = new byte[outs.Count];
for (int i = 0; i < outs.Count; i++)
{
data[i] = (byte)(((outs[i].state) ? 0x80 : 0x00) | (outs[i].id & 0x7F));
}
}
else
{
txPacket.INST = S97_INST_QUIDO_SetOutputTimered;
data = new byte[outs.Count + 1];
data[0] = timer;
for (int i = 0; i < outs.Count; i++)
{
data[i + 1] = (byte)(((outs[i].state) ? 0x80 : 0x00) | (outs[i].id & 0x7F));
}
}
txPacket.ADR = this.ADR;
txPacket.SDATA = data;
PacketSpinel97 rxPacket;
if (this.SendAndReceive(ref txPacket, out rxPacket) && (rxPacket.INST == (byte)ResponseACK.AllIsOk))
{
return(true);
}
return(false);
}
/// <summary>
/// Nastaví platnost dat na displeji.
/// </summary>
/// <param name="sec">Doba platnosti ve vteřinách (max. 65535).</param>
/// <returns></returns>
public bool CmdSetDataValidity(UInt16 sec)
{
byte[] data = { (byte)(sec >> 8), (byte)sec };
PacketSpinel97 txPacket = new PacketSpinel97(S97_INST_TDS_SetDataValidity, data);
txPacket.ADR = this.ADR;
PacketSpinel97 rxPacket;
if ((SendAndReceive(ref txPacket, out rxPacket)) && (rxPacket.INST == (byte)ResponseACK.AllIsOk))
{
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Zobrazení dat na displeji - vstupem je string.
/// </summary>
/// <param name="ascii"></param>
/// <returns></returns>
public bool CmdSetDataAscii(string ascii)
{
byte[] data = Encoding.UTF8.GetBytes(ascii);
PacketSpinel97 txPacket = new PacketSpinel97(S97_INST_TDS_SetDataAscii, data);
txPacket.ADR = this.ADR;
PacketSpinel97 rxPacket;
if ((SendAndReceive(ref txPacket, out rxPacket)) && (rxPacket.INST == (byte)ResponseACK.AllIsOk))
{
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Nastavení parametrů času a zobrazení.
/// </summary>
/// <param name="flags">Parametry složené ze <see cref="SetFlags"/>.</param>
/// <param name="offset">Posun oproti UTC v minutách (jen pro TDS ETH).</param>
/// <param name="zone">Identifikátor časové zóny (jen pro TDS ETH).</param>
/// <returns></returns>
public bool CmdSetFlags(UInt16 flags, UInt16 offset, UInt16 zone = 0)
{
byte[] data = { (byte)(flags >> 8), (byte)flags, (byte)(offset >> 8), (byte)offset, (byte)(zone >> 8), (byte)zone };
PacketSpinel97 txPacket = new PacketSpinel97(S97_INST_TDS_SetFlags, data);
txPacket.ADR = this.ADR;
PacketSpinel97 rxPacket;
if ((SendAndReceive(ref txPacket, out rxPacket)) && (rxPacket.INST == (byte)ResponseACK.AllIsOk))
{
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Nastaví uživatelsky definované číslo, které lze využít k zjištění stavu přístroje.
/// </summary>
/// <param name="dev_status">Po zapnutí přístroje, nebo po resetu (i softwarovém) je
/// automaticky nastaven status 0x00. Pokud je touto funkcí status přestaven na jinou
/// hodnotu, lze později snadno identifikovat, v jakém stavu se přístroj nachází.</param>
/// <returns></returns>
public Boolean CmdSetStatus(byte dev_status)
{
if ((ci != null) && (ci.Active))
{
byte[] data = { dev_status };
PacketSpinel97 txPacket = new PacketSpinel97(S97_INST_SetStatus, data);
txPacket.ADR = this.ADR;
PacketSpinel97 rxPacket;
if (SendAndReceive(ref txPacket, out rxPacket) && (rxPacket.INST == (byte)ResponseACK.AllIsOk))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Povoluje provedení konfigurace. Musí předcházet bezprostředně před některými instrukcemi pro nastavení
/// komunikačních parametrů. Po následující instrukci (i neplatné) je konfigurace automaticky zakázána.
/// (U této instrukce není možné použít univerzální adresu 0xFE.)
/// </summary>
/// <returns></returns>
public Boolean CmdAllowConfiguration()
{
if ((ci != null) && (ci.Active))
{
byte[] data = { };
PacketSpinel97 txPacket = new PacketSpinel97(S97_INST_AllowConfig, data);
txPacket.ADR = this.ADR;
PacketSpinel97 rxPacket;
if (SendAndReceive(ref txPacket, out rxPacket) && (rxPacket.INST == (byte)ResponseACK.AllIsOk))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Nastavit datum a čas na zadaný čas.
/// </summary>
/// <param name="date">Datum a čas, které se má nastavit do displeje.</param>
/// <returns></returns>
public bool CmdSetDateTime(DateTime date)
{
byte yy = (byte)(date.Year % 100);
byte[] data = { (byte)date.Hour, (byte)date.Minute, (byte)date.Second, (byte)date.Day, (byte)date.Month, yy };
PacketSpinel97 txPacket = new PacketSpinel97(S97_INST_TDS_SetDateTime, data);
txPacket.ADR = this.ADR;
PacketSpinel97 rxPacket;
if ((SendAndReceive(ref txPacket, out rxPacket)) && (rxPacket.INST == (byte)ResponseACK.AllIsOk))
{
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Přečte stavy binárních vstupů.
/// </summary>
/// <param name="inputs">Pole 4 bytů se stavem vstupů. MSB je IN1. V každém bajtu je LSb (bit 0) aktuální stav vstupu. Bit 1 je v jedničce pokud byl od posledního čtení zaznamenána na vstupu úroveň 1 (stisk tlačítka).</param>
/// <returns></returns>
public bool CmdGetInputs(out byte[] inputs)
{
inputs = new byte[4];
byte[] data = { };
PacketSpinel97 txPacket = new PacketSpinel97(S97_INST_TDS_GetInputs, data);
txPacket.ADR = this.ADR;
PacketSpinel97 rxPacket;
if ((SendAndReceive(ref txPacket, out rxPacket)) && (rxPacket.INST == (byte)ResponseACK.AllIsOk))
{
if ((rxPacket.SDATA != null) && (rxPacket.SDATA.Length == 4))
{
inputs = rxPacket.SDATA;
return(true);
}
}
return(false);
}
/// <summary>
/// Čtení teploty z připojeného teplotního senzoru
/// </summary>
/// <param name="temp">Aktuálně naměřená teplota. Pokud z nějakého důvodu není dostupná, je zde konstanta float.NaN.</param>
/// <param name="index">Číslo teploměru, číslováno od 1. Ve standardních Quidech je zde vždy 1.</param>
/// <returns>Teplota v aktuálně nastavené teplotní jednotce.</returns>
public Boolean CmdGetTemperature(out float temp, byte index = 0x01)
{
byte[] data = { index };
PacketSpinel97 txPacket = new PacketSpinel97(S97_INST_QUIDO_GetTemperature, data);
txPacket.ADR = this.ADR;
PacketSpinel97 rxPacket;
if (SendAndReceive(ref txPacket, out rxPacket) && (rxPacket.INST == (byte)ResponseACK.AllIsOk))
{
if ((rxPacket.SDATA != null) && (rxPacket.SDATA.Length == 3))
{
temp = (float)(rxPacket.SDATA[1] * 256 + rxPacket.SDATA[2]) / 10;
return(true);
}
}
temp = float.NaN;
return(false);
}
public Boolean CmdGetInfo(out SpinelDeviceVersion version)
{
version = null;
if ((ci != null) && (ci.Active))
{
PacketSpinel97 txPacket = new PacketSpinel97(S97_INST_ReadInfo);
txPacket.ADR = this.ADR;
PacketSpinel97 rxPacket;
if (this.SendAndReceive(ref txPacket, out rxPacket))
{
version = new SpinelDeviceVersion(Encoding.ASCII.GetString(rxPacket.SDATA));
return(version.Valid);
}
}
return(false);
}
public Boolean CmdGetSN(out SpinelDeviceSN dev_sn)
{
dev_sn = null;
if ((ci != null) && (ci.Active))
{
PacketSpinel97 txPacket = new PacketSpinel97(S97_INST_ReadSN);
txPacket.ADR = this.ADR;
PacketSpinel97 rxPacket;
if (this.SendAndReceive(ref txPacket, out rxPacket))
{
dev_sn = new SpinelDeviceSN(rxPacket.SDATA);
return(dev_sn.Valid);
}
}
return(false);
}
