322 lines
11 KiB
C#
322 lines
11 KiB
C#
using Aurora.Api.DataType;
|
|
using Aurora.Api.Devices;
|
|
using Hermes;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
|
|
namespace AuroraLight.LvsPn
|
|
{
|
|
internal class LvsPnLight : SerialConn, ILvsPnLight
|
|
{
|
|
public const byte CMD_SINGLE_CHANNEL_OFF = 0x45; // E
|
|
public const byte CMD_SINGLE_CHANNEL_BRIGHTNESS = 0x4C; // L
|
|
public const byte CMD_ALL_CHANNEL_BRIGHTNESS = 0x41; // A
|
|
public const byte CMD_VALUE_SEPARATOR = 0x2C; // ,
|
|
|
|
public const byte BYTE_ACK = 0x06; // 06
|
|
public const byte BYTE_NAK = 0x15; // 21
|
|
public const byte BYTE_CR = 0x0D; // 13
|
|
public const byte BYTE_LF = 0x0A; // 10
|
|
public const byte BYTE_0 = 0x30; // 48
|
|
|
|
public const byte LENGTH_SINGLE_CHANNEL_OFF_REQUEST_MSG = 4;
|
|
public const byte LENGTH_SINGLE_CHANNEL_BRIGHTNESS_REQUEST_MSG = 7;
|
|
public const byte LENGTH_ALL_CHANNEL_BRIGHTNESS_REQUEST_MSG = 18;
|
|
public const byte LENGTH_RESPONSE_MSG = 1;
|
|
|
|
public const int MAX_BRIGHTNESS = 255;
|
|
protected readonly object LockThis;
|
|
|
|
LvsPnLightConfig _config;
|
|
private string _deviceId;
|
|
public bool _commError { get; set; } = false;
|
|
|
|
public LvsPnLight(string deviceId, bool isSimul, LightConfig config) : base(deviceId, isSimul)
|
|
{
|
|
if (config is LvsPnLightConfig) {
|
|
_config = config as LvsPnLightConfig;
|
|
} else {
|
|
Log.E("Config Type Error!");
|
|
throw new NotImplementedException();
|
|
}
|
|
LightValue = Enumerable.Repeat(0, 4).ToArray<int>();
|
|
_deviceId = deviceId;
|
|
}
|
|
public int[] LightValue { get; set; }
|
|
|
|
/// <summary>
|
|
/// Initialize AllOffLight() and LightValue initialize
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public bool InitInternal(SerialConnConfig conn)
|
|
{
|
|
LightValue = Enumerable.Repeat(0, 4).ToArray<int>();
|
|
bool bRet = false;
|
|
bRet = Open(conn) == E1.OK;
|
|
if (bRet) {
|
|
bRet = OffLightInternal() == E1.OK;
|
|
if (bRet)
|
|
Log.D(string.Format("[ {0} CONNECTED ]", _deviceId));
|
|
_commError = !bRet;
|
|
} else {
|
|
_commError = true;
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
public int GetMaxValueInternal()
|
|
{
|
|
return MAX_BRIGHTNESS;
|
|
}
|
|
|
|
public bool IsPortErrorInternal()
|
|
{
|
|
return _commError;
|
|
}
|
|
|
|
/// <summary>
|
|
/// All Channel Light off
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public int OffLightInternal()
|
|
{
|
|
lock (LockThis) {
|
|
var denormalValues = Enumerable.Repeat(0, 4).ToList<int>();
|
|
byte[] requestMsg = CreateAllChannelBrightnessReqMsg(denormalValues);
|
|
if (Write(requestMsg)) {
|
|
byte[] responseMsg = new byte[LENGTH_RESPONSE_MSG];
|
|
if (Read(responseMsg) <= 0) {
|
|
Log.E("ReadError");
|
|
return E2.INTERNAL_ERROR;
|
|
}
|
|
var isValid = ValidateResponse(responseMsg);
|
|
if (!isValid) {
|
|
Log.E("NAK");
|
|
return E2.INTERNAL_ERROR;
|
|
}
|
|
LightValueSet(0);
|
|
}
|
|
}
|
|
return E1.OK;
|
|
}
|
|
public int OffLightInternal(int iChannel)
|
|
{
|
|
if (!IsValidChannel(iChannel)) {
|
|
Log.E(string.Format("Argument Error! Ch : {0}", iChannel.ToString()));
|
|
return E2.INVALID_ARGUMENT;
|
|
}
|
|
|
|
lock (LockThis) {
|
|
byte[] requestMsg = CreateSingleChannelOffReqMsg(iChannel);
|
|
if (Write(requestMsg)) {
|
|
byte[] responseMsg = new byte[LENGTH_RESPONSE_MSG];
|
|
if (Read(responseMsg) <= 0) {
|
|
Log.E("ReadError");
|
|
return E2.INTERNAL_ERROR;
|
|
}
|
|
|
|
var isValid = ValidateResponse(responseMsg);
|
|
if (!isValid) {
|
|
Log.E("NAK");
|
|
return E2.INTERNAL_ERROR;
|
|
}
|
|
LightValueSet(iChannel, 0);
|
|
}
|
|
}
|
|
return E1.OK;
|
|
}
|
|
|
|
public int SetLightValueInternal(List<int> values)
|
|
{
|
|
if (values.Count != 4) {
|
|
return E2.INVALID_ARGUMENT;
|
|
}
|
|
|
|
var denormalValues = DenormailzeBrightness(values);
|
|
|
|
for (int i = 0; i < denormalValues.Count; i++) {
|
|
if (!IsValidBrightness(denormalValues[i])) {
|
|
Log.E(string.Format("Argument Error! Ch : {0}, Value : {1}({2})", (i + 1), values[i], denormalValues[i]));
|
|
return E2.INVALID_ARGUMENT;
|
|
}
|
|
}
|
|
|
|
lock (LockThis) {
|
|
byte[] requestMsg = CreateAllChannelBrightnessReqMsg(denormalValues);
|
|
if (Write(requestMsg)) {
|
|
byte[] responseMsg = new byte[LENGTH_RESPONSE_MSG];
|
|
if (Read(responseMsg) <= 0) {
|
|
Log.E("ReadError");
|
|
return E2.INTERNAL_ERROR;
|
|
}
|
|
var isValid = ValidateResponse(responseMsg);
|
|
if (!isValid) {
|
|
Log.E("NAK");
|
|
return E2.INTERNAL_ERROR;
|
|
}
|
|
LightValueSet(values);
|
|
}
|
|
}
|
|
return E1.OK;
|
|
}
|
|
|
|
public int SetLightValueInternal(int iChannel, int iValue)
|
|
{
|
|
var denormalValue = DenormailzeBrightness(iValue);
|
|
|
|
if (!IsValidChannel(iChannel) || !IsValidBrightness(denormalValue)) {
|
|
Log.E(string.Format("Argument Error! Ch : {0}, Value : {1}({2})", iChannel, iValue, denormalValue));
|
|
return E2.INVALID_ARGUMENT;
|
|
}
|
|
|
|
lock (LockThis) {
|
|
byte[] requestMsg = CreateSingleChannelBrightnessReqMsg(iChannel, denormalValue);
|
|
if (Write(requestMsg)) {
|
|
byte[] responseMsg = new byte[LENGTH_RESPONSE_MSG];
|
|
if (Read(responseMsg) <= 0) {
|
|
Log.E("ReadError");
|
|
return E2.INTERNAL_ERROR;
|
|
}
|
|
var isValid = ValidateResponse(responseMsg);
|
|
if (!isValid) {
|
|
Log.E("NAK");
|
|
return E2.INTERNAL_ERROR;
|
|
}
|
|
LightValueSet(iChannel, iValue);
|
|
}
|
|
}
|
|
return E1.OK;
|
|
}
|
|
|
|
#region UtilLvsPnLight
|
|
private void LightValueSet(int iChannel, int iValue)
|
|
{
|
|
LightValue[iChannel] = iValue;
|
|
}
|
|
private void LightValueSet(int iValue)
|
|
{
|
|
for (int i = 0; i < 4; i++) {
|
|
LightValue[i] = iValue;
|
|
}
|
|
}
|
|
private void LightValueSet(List<int> iValues)
|
|
{
|
|
for (int i = 0; i < 4; i++) {
|
|
LightValue[i] = iValues[i];
|
|
}
|
|
}
|
|
private bool IsValidChannel(int iChannel)
|
|
{
|
|
return 1 <= iChannel && iChannel <= 4;
|
|
}
|
|
|
|
private bool IsValidBrightness(int iValue)
|
|
{
|
|
return 0 <= iValue && iValue <= 255;
|
|
}
|
|
|
|
private byte[] CreateSingleChannelBrightnessReqMsg(int iChannel, int iValue)
|
|
{
|
|
byte[] requestMsg = new byte[LENGTH_SINGLE_CHANNEL_BRIGHTNESS_REQUEST_MSG];
|
|
byte[] valueByte = ConvertBrightnessIntToBytes(iValue);
|
|
|
|
requestMsg[0] = CMD_SINGLE_CHANNEL_BRIGHTNESS;
|
|
requestMsg[1] = ConvertChannelIntToByte(iChannel);
|
|
Array.Copy(valueByte, 0, requestMsg, 2, valueByte.Length);
|
|
requestMsg[requestMsg.Length - 2] = BYTE_CR;
|
|
requestMsg[requestMsg.Length - 1] = BYTE_LF;
|
|
|
|
return requestMsg;
|
|
}
|
|
|
|
private byte ConvertChannelIntToByte(int iChannel)
|
|
{
|
|
return (byte)(iChannel + BYTE_0);
|
|
}
|
|
|
|
private byte[] ConvertBrightnessIntToBytes(int iValue)
|
|
{
|
|
return Encoding.Default.GetBytes(ConvertBrightnessIntToString(iValue));
|
|
}
|
|
|
|
private string ConvertBrightnessIntToString(int iValue)
|
|
{
|
|
return string.Format("{0:000}", iValue);
|
|
}
|
|
|
|
private bool ValidateResponse(byte[] msg)
|
|
{
|
|
return msg[0] == BYTE_ACK;
|
|
}
|
|
|
|
|
|
private byte[] CreateAllChannelBrightnessReqMsg(List<int> values)
|
|
{
|
|
byte[] requestMsg = new byte[LENGTH_ALL_CHANNEL_BRIGHTNESS_REQUEST_MSG];
|
|
byte[] valueByte = ConvertBrightnessIntToBytes(values);
|
|
|
|
requestMsg[0] = CMD_ALL_CHANNEL_BRIGHTNESS;
|
|
Array.Copy(valueByte, 0, requestMsg, 1, valueByte.Length);
|
|
requestMsg[requestMsg.Length - 2] = BYTE_CR;
|
|
requestMsg[requestMsg.Length - 1] = BYTE_LF;
|
|
|
|
return requestMsg;
|
|
}
|
|
|
|
private byte[] ConvertBrightnessIntToBytes(List<int> values)
|
|
{
|
|
string valueStr = string.Format("{0},{1},{2},{3}",
|
|
ConvertBrightnessIntToString(values[0]),
|
|
ConvertBrightnessIntToString(values[1]),
|
|
ConvertBrightnessIntToString(values[2]),
|
|
ConvertBrightnessIntToString(values[3]));
|
|
|
|
return Encoding.Default.GetBytes(valueStr);
|
|
}
|
|
|
|
|
|
|
|
private byte[] CreateSingleChannelOffReqMsg(int iChannel)
|
|
{
|
|
byte[] requestMsg = new byte[LENGTH_SINGLE_CHANNEL_OFF_REQUEST_MSG];
|
|
|
|
requestMsg[0] = CMD_SINGLE_CHANNEL_OFF;
|
|
requestMsg[1] = ConvertChannelIntToByte(iChannel);
|
|
requestMsg[requestMsg.Length - 2] = BYTE_CR;
|
|
requestMsg[requestMsg.Length - 1] = BYTE_LF;
|
|
|
|
return requestMsg;
|
|
}
|
|
|
|
private List<int> DenormailzeBrightness(List<int> values)
|
|
{
|
|
if (_config.UseNormalizedBrightness) {
|
|
var normalizedValues = new List<int>();
|
|
foreach (var value in values) {
|
|
normalizedValues.Add(DenormailzeBrightness(value));
|
|
}
|
|
|
|
return normalizedValues;
|
|
}
|
|
|
|
return new List<int>(values);
|
|
}
|
|
|
|
private int DenormailzeBrightness(int brightness)
|
|
{
|
|
if (_config.UseNormalizedBrightness) {
|
|
var maxNormal = 100.0;
|
|
var maxDenormal = GetMaxValueInternal();
|
|
|
|
return Convert.ToInt32(Math.Round(brightness * maxDenormal / maxNormal));
|
|
}
|
|
|
|
return brightness;
|
|
}
|
|
#endregion
|
|
|
|
}
|
|
}
|