public new async Task Refresh()
{
CurrentPowerUsage = new PowerData(await ExecuteAsync("emeter", "get_realtime"), HardwareVersion);
_gainData = await ExecuteAsync("emeter", "get_vgain_igain");
await base.Refresh();
}
public static PowerDataDto ToPowerDataDto(this PowerData pd)
{
return(new PowerDataDto
{
Id = pd.Key, Pbat = pd.Pbat, PmeterDc = pd.PmeterDc, PmeterL1 = pd.PmeterL1, PmeterL2 = pd.PmeterL2, PmeterL3 = pd.PmeterL3, Ppv1 = pd.Ppv1, Ppv2 = pd.Ppv2,
PrealL1 = pd.PrealL1, PrealL2 = pd.PrealL2, PrealL3 = pd.PrealL3, Pva = pd.Sva, Sn = pd.Sn, UploadTime = pd.UploadTime, VarAC = pd.VarAC, VarDC = pd.VarDC
});
}
/// <summary>
/// Read realtime power data of specified plug index
/// </summary>
/// <param name="plugId">Plug index start from one</param>
/// <returns>Power data</returns>
public PowerData ReadRealtimePowerData(int plugId)
{
var pd = new PowerData(Execute("emeter", "get_realtime", childIdS: new List <string> {
Plugs[plugId - 1].Id
}));
return(pd);
}
/// <summary>
/// 解析功率数据
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public static List<PowerData> GetPowerData(MeterList data)
{
List<PowerData> powerDataList = new List<PowerData>();
foreach (var item in data.Meters)
{
PowerData power = new PowerData();
power.BuildID = data.BuildId;
power.MeterCode = item.MeterId;
power.Time = data.CollectTime;
MeterParam p = item.MeterParams.Find(m => m.ParamName.ToLower() == "P".ToLower());
MeterParam pa = item.MeterParams.Find(m => m.ParamName.ToLower() == "Pa".ToLower());
MeterParam pb = item.MeterParams.Find(m => m.ParamName.ToLower() == "Pb".ToLower());
MeterParam pc = item.MeterParams.Find(m => m.ParamName.ToLower() == "Pc".ToLower());
MeterParam q = item.MeterParams.Find(m => m.ParamName.ToLower() == "Q".ToLower());
MeterParam qa = item.MeterParams.Find(m => m.ParamName.ToLower() == "Qa".ToLower());
MeterParam qb = item.MeterParams.Find(m => m.ParamName.ToLower() == "Qb".ToLower());
MeterParam qc = item.MeterParams.Find(m => m.ParamName.ToLower() == "Qc".ToLower());
MeterParam s = item.MeterParams.Find(m => m.ParamName.ToLower() == "S".ToLower());
MeterParam sa = item.MeterParams.Find(m => m.ParamName.ToLower() == "Sa".ToLower());
MeterParam sb = item.MeterParams.Find(m => m.ParamName.ToLower() == "Sb".ToLower());
MeterParam sc = item.MeterParams.Find(m => m.ParamName.ToLower() == "Sc".ToLower());
if (p != null)
power.P = p.ParamValue;
if (pa != null)
power.Pa = pa.ParamValue;
if (pb != null)
power.Pb = pb.ParamValue;
if (pc != null)
power.Pc = pc.ParamValue;
if (q != null)
power.Q = q.ParamValue;
if (qa != null)
power.Qa = qa.ParamValue;
if (qb != null)
power.Qb = qb.ParamValue;
if (qc != null)
power.Qc = qc.ParamValue;
if (s != null)
power.S = s.ParamValue;
if (sa != null)
power.Sa = sa.ParamValue;
if (sb != null)
power.Sb = sb.ParamValue;
if (sc != null)
power.Sc = sc.ParamValue;
powerDataList.Add(power);
}
return powerDataList;
}
public new async Task Refresh()
{
dynamic powerdata = await Execute("emeter", "get_realtime").ConfigureAwait(false);
CurrentPowerUsage = new PowerData(powerdata, HardwareVersion);
_gainData = await Execute("emeter", "get_vgain_igain").ConfigureAwait(false);
await base.Refresh().ConfigureAwait(false);
}
// Use this for initialization
void Start()
{
//Debug.Log("ayyysdasd");
listener = new UDPListener(12003, handleOSC);
powerData = new PowerData();
//filename = Application.dataPath + "/PowerLog/AlphaLog/"+ GameManager.instance.settings.subjectName+ "_" + DateTime.Now.ToFileTimeUtc() + ".csv";
//Debug.Log(Application.dataPath);
writeHeader();
}
public static void SavePower(PowerUI pow)
{
BinaryFormatter formatter = new BinaryFormatter();
string path = Application.persistentDataPath + "/Power.dat";
FileStream stream = new FileStream(path, FileMode.Create);
PowerData data = new PowerData(pow);
formatter.Serialize(stream, data);
stream.Close();
}
private void Start()
{
powerData = FindObjects.GameLogic.GetComponent <PowerData>();
if (!LoadedActorData)
{
powerDict = new Dictionary <PowerSlotTag, PowerTag>();
foreach (PowerSlotTag slot in Enum.GetValues(typeof(PowerSlotTag)))
{
powerDict.Add(slot, PowerTag.INVALID);
}
}
}
private void LoadPowerData()
{
string filePath = Path.Combine(Application.streamingAssetsPath, m_PowerSource);
m_PowerTable = JsonUtility.FromJson <PowerTable>(File.ReadAllText(filePath));
foreach (PowerData data in m_PowerTable.powertypes)
{
if (data.name == m_PowerType)
{
m_PowerData = data;
break;
}
}
}
public void PowerDataProcesing(ref PowerData dataInstance, byte CMD, byte eventAdr = 0x00, byte _event = 0x00)
{
if (CMD == 0x30)
{
int dataLength;
int _bytes;
byte[] _dataBytes = { eventAdr, _event };
powerDataresponsePaket = PowerClient.TCPrequest(BuildPacket(0x01, 0x11, 2, CMD, _dataBytes, out dataLength), dataLength, out _bytes);
if (_bytes > 7)
{
dataInstance.EM_1 = powerDataresponsePaket[6];
dataInstance.EM_2 = powerDataresponsePaket[7];
dataInstance.EM_3 = powerDataresponsePaket[8];
dataInstance.EM_4 = powerDataresponsePaket[9];
}
}
if (CMD == 0x31)
{
int dataLength;
int _bytes;
byte[] _dataBytes = { eventAdr, _event };
powerDataresponsePaket = PowerClient.TCPrequest(BuildPacket(0x01, 0x11, 0, CMD, _dataBytes, out dataLength), dataLength, out _bytes);
if (_bytes > 7)
{
dataInstance.EM_1 = powerDataresponsePaket[6];
dataInstance.EM_2 = powerDataresponsePaket[7];
dataInstance.EM_3 = powerDataresponsePaket[8];
dataInstance.EM_4 = powerDataresponsePaket[9];
}
}
else if (CMD == 0x32)
{
byte[] _dataBytes = { eventAdr, _event };
PowerClient.TCPrequest(BuildPacket(0x01, 0x11, 2, CMD, _dataBytes, out int dataLength), dataLength, out int _bytes);
}
else if (CMD == 0x33)
{
byte[] _dataBytes = { eventAdr, _event };
powerDataresponsePaket = PowerClient.TCPrequest(BuildPacket(0x01, 0x11, 2, CMD, _dataBytes, out int dataLength), dataLength, out int _bytes);
dataInstance.SupplyType = powerDataresponsePaket[6];
}
else if (CMD == 0x35)
{
byte[] _dataBytes = { eventAdr, _event };
powerDataresponsePaket = PowerClient.TCPrequest(BuildPacket(0x01, 0x11, 2, CMD, _dataBytes, out int dataLength), dataLength, out int _bytes);
}
}
protected override void ReadValues()
{
byte[] retVoltage, retCurrent, retPower, retPowerIn;
using (var localMutexLock = CorsairRootDevice.usbGlobalMutex.GetLock())
{
SetPage();
retVoltage = ReadRegister(0x88, 2);
if (psuDevice is LinkDevicePSUHX)
{
retCurrent = null;
retPowerIn = null;
}
else
{
retCurrent = ReadRegister(0x89, 2);
retPowerIn = ReadRegister(0x97, 2);
}
retPower = ReadRegister(0xEE, 2);
}
cachedVoltage = BitCodec.ToFloat(retVoltage);
cachedPower = BitCodec.ToFloat(retPower);
if (retCurrent == null)
{
cachedCurrent = cachedPower / cachedVoltage;
}
else
{
cachedCurrent = BitCodec.ToFloat(retCurrent);
}
if (retPowerIn == null)
{
cachedPowerIn = 0;
}
else
{
cachedPowerIn = (BitCodec.ToFloat(retPowerIn) + (cachedCurrent * cachedVoltage)) / 2.0;
}
PowerData adjustedData = PowerCurves.Interpolate(new PowerData(cachedPowerIn, cachedPower), cachedVoltage, psuDevice);
cachedEfficiency = adjustedData.efficiency;
cachedPowerIn = adjustedData.powerIn;
cachedPower = adjustedData.powerOut;
}
public IActionResult Power([FromBody] PowerData data)
{
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
data.ValidateAndThrow();
var result = Math.Pow(data.Operand1, data.Operand2);
_logger.LogInformation($"{data.Operand1} ^ {data.Operand2} = {result}");
return(Ok(new DataModel()
{
Result = result
}));
}
private PaginatedList <PowerData> GetLastPowerDataBySn(string api_Account, long timeStamp, string sign, string sn, int pIndex, int pSize, out int totalCount)
{
IList <PowerData> result = new List <PowerData>();
PowerData cd = _powerRepository.GetAll().Where(x => x.Sn == sn).OrderByDescending(x => x.UploadTime).FirstOrDefault();
if (cd != null)
{
result.Add(cd);
totalCount = result.Count;
return(new PaginatedList <PowerData>(pIndex, pSize, result.AsQueryable()));
}
else
{
totalCount = 0;
return(new PaginatedList <PowerData>(pIndex, pSize, null));
}
}
public static PowerData LoadPower()
{
string path = Application.persistentDataPath + "/Power.dat";
if (File.Exists(path))
{
BinaryFormatter formatter = new BinaryFormatter();
FileStream stream = new FileStream(path, FileMode.Open);
PowerData data = formatter.Deserialize(stream) as PowerData;
stream.Close();
return(data);
}
else
{
Debug.LogError("Save File Not Found in " + path);
return(null);
}
}
public void LoadData()
{
string path = Application.persistentDataPath + "/Power.dat";
if (File.Exists(path))
{
PowerData data = SaveSystem.LoadPower();
for (int i = 0; i < power.Length; i++)
{
for (int k = 0; k < data.P.Count; k++)
{
if (power[i].id == data.P[k].id)
{
power[i].amount = data.P[k].number;
}
}
}
}
}
public PowerViewModel()
{
_dataStorage = new PowerData();
}
//HERE are my sources for this
//https://books.google.com/books?id=_2brYQqb_RYC&pg=PA26&lpg=PA26&dq=average+watts/m%5E2+surface+peak&source=bl&ots=ImzfwuObq1&sig=oWaRpcitRVbF5M0YApRiLwb-qoA&hl=en&sa=X&ved=0ahUKEwi41IKkxLPaAhUBWK0KHXLbB3EQ6AEIiQEwBw#v=onepage&q=average%20watts%2Fm%5E2%20surface%20peak&f=false
//https://solarpowerrocks.com/solar-basics/how-do-solar-panels-work-in-cloudy-weather/
/*
* Assumptions:
* 1kw/m^2 during sunlight
* 25% efficiency during cloudy day
* 100% efficiency during sunny day
*
* panel is 15% efficient at converting power
*
* full power during daylight
*
* */
public static PowerData MakePredictionAndGetAngles(string weather)
{
const double wattsPerM2 = 1000;
const double coefficientForClouds = 0.25;
const double panelAreaInM2 = 0.0687;
const double panelEfficiency = 0.15;
//Get the minutes of the day that are avaiulable
ExcelPackage package = new ExcelPackage(new System.IO.FileInfo("wwwroot/xls/NOAA_Solar_Calculations_day.xlsx"));
ExcelWorksheet sheet = package.Workbook.Worksheets[1];
var start = sheet.Dimension.Start;
var end = sheet.Dimension.End;
//double solarMinutes = Convert.ToDouble(sheet.Cells[27, 2].Text);
//DateTime sunrise = Convert.ToDateTime(sheet.Cells[25, 2].Text);
//DateTime sunset = Convert.ToDateTime(sheet.Cells[26, 2].Text);
double solarMinutes;
PowerData data = new PowerData();
//Now get all teh angle data
List <DateTime> TimeFractions = new List <DateTime>();
List <double> AngleH = new List <double>();
List <double> AngleA = new List <double>();
//Also get the coordinates
var lat = Convert.ToDouble(sheet.Cells[3, 2].Text);
var lng = Convert.ToDouble(sheet.Cells[4, 2].Text);
int row = start.Row;
//Get sunrise and sunset
double sunrise = Convert.ToDouble(sheet.Cells[2, 25].Text);
double sunset = Convert.ToDouble(sheet.Cells[2, 26].Text);
solarMinutes = (sunset - sunrise) * 24 * 60;
//Skip headers
row++;
//Parse rows one by one
while (row < end.Row)
{
if (row < 180 && row > 90)
{
//Add the thing from this row to each
TimeFractions.Add(Convert.ToDateTime(sheet.Cells[row, 5].Text));
AngleH.Add(Convert.ToDouble(sheet.Cells[row, 33].Text));
AngleA.Add(Convert.ToDouble(sheet.Cells[row, 34].Text));
}
//increment row
row++;
}
//Closes package
package.Dispose();
//Now get the weather
OpenWeatherMap.OpenWeatherMapClient client = new OpenWeatherMap.OpenWeatherMapClient("933839ed82ba0ad5f89513a943b6f71c");
OpenWeatherMap.Coordinates coord = new OpenWeatherMap.Coordinates();
coord.Latitude = lat;
coord.Longitude = lng;
//This is lowkey a little bit dangerous
var currentWeather = client.CurrentWeather.GetByCoordinates(coord).Result;
double cloudyNess = currentWeather.Clouds.Value;
data.City = currentWeather.City.Name;
data.UrlForIcon = "http://openweathermap.org/img/w/" + currentWeather.Weather.Icon + ".png";
data.CurrentWeather = currentWeather.Weather.Value;
//Make the predictions
if (cloudyNess < 50)
{
data.DailyPower = wattsPerM2 * panelAreaInM2 * panelEfficiency * (solarMinutes / 60.0) * ((100 - cloudyNess) / 100);
data.CurrentPower = wattsPerM2 * panelAreaInM2 * panelEfficiency;
}
else
{
data.DailyPower = wattsPerM2 * panelAreaInM2 * panelEfficiency * solarMinutes / 60.0;
data.CurrentPower = wattsPerM2 * panelAreaInM2 * panelEfficiency;
}
data.Times = TimeFractions;
//Process 3d angles
if (cloudyNess < 50)
{
data.AngleA = AngleA;
data.AngleH = AngleH;
}
else
{
data.AngleH = new List <double>();
data.AngleA = new List <double>();
foreach (var t in data.Times)
{
data.AngleA.Add(0);
data.AngleH.Add(0);
}
}
data.X = new List <double>();
data.Y = new List <double>();
data.Z = new List <double>();
foreach (var angle in AngleA)
{
data.X.Add(5 * Math.Sin(angle));
data.Z.Add(5 * Math.Cos(angle));
}
foreach (var angle in AngleH)
{
data.Y.Add(5 * Math.Tan(angle));
}
data.countAngs = data.Y.Count;
data.HoursOfSun = (int)solarMinutes / 60;
return(data);
}
// [Route("ProjectPowerController/PersonAuthorise")]
//[WriteLog(EComLib_ActionEnum.用户授权)]
public async Task <IActionResult> PersonAuthorise(PowerData powerData)
{
throw new NotImplementedException();
}
