private void SendBatteryHeartBeat(CanService canService, Battery battery)
{
CanPacket bmuOne = new CanPacket(0x600);
CanPacket bmuTwo = new CanPacket(0x200);
CanPacket cmuOne = new CanPacket(0x601);
CanPacket cmuTwo = new CanPacket(0x201);
canService.SendMessage(bmuOne);
canService.SendMessage(bmuTwo);
canService.SendMessage(cmuOne);
canService.SendMessage(cmuTwo);
if (battery.GetBMU(0) != null)
{
battery.GetBMU(0).CanPacketReceived(bmuOne);
}
if (battery.GetBMU(1) != null)
{
battery.GetBMU(1).CanPacketReceived(bmuTwo);
}
if (battery.GetBMU(0) != null)
{
battery.GetBMU(0).GetCMU(0).CanPacketReceived(cmuOne);
}
if (battery.GetBMU(1) != null)
{
battery.GetBMU(1).GetCMU(0).CanPacketReceived(cmuTwo);
}
}
public async Task BasicChargeStartStopTest()
{
BatteryChargeService batteryChargeService = BatteryChargeService.NewInstance;
batteryChargeService.UseTimerUpdateLoop = false;
CanService canService = CanService.NewInstance;
canService.ConnectViaLoopBack();
TDKService tdkService = NewTDKService();
tdkSimulator.BatteryConnected = true;
batteryChargeService.SetCharger(NewTDKService());
batteryChargeService.BatteryService.BatteryData.ComponentCanService = canService;
if (batteryChargeService.BatteryService.BatteryData.GetBMU(0) != null)
{
batteryChargeService.BatteryService.BatteryData.GetBMU(0).ComponentCanService = canService;
}
if (batteryChargeService.BatteryService.BatteryData.GetBMU(1) != null)
{
batteryChargeService.BatteryService.BatteryData.GetBMU(1).ComponentCanService = canService;
}
uint state = batteryChargeService.ChargerState;
Assert.IsTrue(state != CanReceivingNode.STATE_NA, "Charger does not seem to be there");
Assert.IsFalse(batteryChargeService.IsCharging, "Battery is charging when it should not be as it has not yet been started");
// Bit out of order but we simulate the contactors engaging now as we can't insert it during the call to StartCharge
EngageContactors(batteryChargeService.BatteryService.BatteryData);
// Battery is now setup in normal state, run the charge loop
batteryChargeService.RequestedCurrent = 5;
batteryChargeService.RequestedVoltage = 32;
batteryChargeService.BatteryService.BatteryData.ParallelStrings = 1;
SetCellVoltages(batteryChargeService.BatteryService.BatteryData, 4100);
SendBatteryHeartBeat(canService, batteryChargeService.BatteryService.BatteryData);
Assert.IsTrue(await batteryChargeService.StartCharge(), "Charger start failed");
Assert.IsTrue(batteryChargeService.IsCharging, "Battery is not charging when it should be");
// Bit out of order but we simulate the contactors disengaging now as we can't insert it during the call to StartCharge
DisengageContactors(batteryChargeService.BatteryService.BatteryData);
await batteryChargeService.StopCharge();
Assert.IsFalse(batteryChargeService.IsCharging, "Battery is charging when it should not be");
}
public void ConnectTest()
{
CanService canService = CanService.NewInstance;
canService.ConnectViaLoopBack();
Assert.IsTrue(canService.IsConnected(), "Can Service is Not Connected");
canService.Disconnect();
Assert.IsFalse(canService.IsConnected(), "Can Service is Not Disconnected");
}
public void SendAt10HzTest()
{
CanService canService = CanService.NewInstance;
canService.ConnectViaLoopBack();
canService.ClearLastCanPacket();
Assert.IsTrue(canService.IsConnected());
CanPacket canPacket = new CanPacket(0x800);
Assert.IsNull(canService.LastestCanPacketById(0x800));
canService.SetCanToSendAt10Hertz(canPacket);
Thread.Sleep(250);
// Normally you would see one every 1/10 of a second
// first one arrives instantly as we are on local loopback
Assert.IsNotNull(canService.LastestCanPacketById(0x800));
Thread.Sleep(250);
canService.ClearLastCanPacket();
Assert.IsNull(canService.LastestCanPacketById(0x800));
Thread.Sleep(250);
// Normally you would see one every 1/10 of a second
// so we wait for the seoncd one
Assert.IsNotNull(canService.LastestCanPacketById(0x800));
canService.ClearLastCanPacket();
canService.StopSendingCanAt10Hertz(canPacket);
Thread.Sleep(250);
Assert.IsNull(canService.LastestCanPacketById(0x800));
canService.Disconnect();
Assert.IsFalse(canService.IsConnected());
}
public void SendMessage()
{
CanService canService = CanService.NewInstance;
canService.ConnectViaLoopBack();
Assert.IsTrue(canService.IsConnected(), "Can Service is Not Connected");
CanPacket canPacket = new CanPacket(0x400);
Assert.IsNull(canService.LastestCanPacketById(0x400), "A Can Packet exists when it should not");
canService.SendMessage(canPacket);
Assert.IsNotNull(canService.LastestCanPacketById(0x400), "Can Packet does not appear to have been sent and received");
canService.Disconnect();
Assert.IsFalse(canService.IsConnected(), "Can Service is Not Disconnected");
}
protected override async Task <bool> OnDelete(OfferModel offer)
{
bool ok;
if (Offer.type == OfferType.Can)
{
ok = await CanService.DeleteCan(Offer.id);
}
else
{
ok = await WantService.DeleteWant(Offer.id);
}
if (ok)
{
SendOfferActionMessage(MessengerOfferActionType.Delete);
}
return(ok);
}
protected override async Task <bool> OnSave(OfferModel offer)
{
bool ok;
if (Offer.type.Equals(_initialType))
{
if (_initialType.Equals(OfferType.Can))
{
ok = await CanService.UpdateCan(Offer);
}
else
{
ok = await WantService.UpdateWant(Offer);
}
}
else
{
if (_initialType.Equals(OfferType.Can))
{
ok = await CanService.DeleteCan(Offer.id);
if (ok)
{
ok = await WantService.CreateWant(Offer);
}
}
else
{
ok = await WantService.DeleteWant(Offer.id);
if (ok)
{
ok = await CanService.CreateCan(Offer);
}
}
}
return(ok);
}
protected override async Task <bool> OnSave(OfferModel offer)
{
var img = Constants.ImagePlaceholderUrl + new Random().Next(1, 1000);
Offer.imgurl = img;
bool ok;
if (Offer.type.Equals(OfferType.Can))
{
ok = await CanService.CreateCan(Offer);
}
else
{
ok = await WantService.CreateWant(Offer);
}
if (ok)
{
SendOfferActionMessage(MessengerOfferActionType.Create);
}
return(ok);
}
public async Task BalancingChargeTest()
{
BatteryChargeService batteryChargeService = BatteryChargeService.NewInstance;
batteryChargeService.UseTimerUpdateLoop = false;
CanService canService = CanService.NewInstance;
canService.ConnectViaLoopBack();
TDKService tdkService = NewTDKService();
tdkSimulator.BatteryConnected = true;
batteryChargeService.SetCharger(NewTDKService());
batteryChargeService.BatteryService.BatteryData.ComponentCanService = canService;
if (batteryChargeService.BatteryService.BatteryData.GetBMU(0) != null)
{
batteryChargeService.BatteryService.BatteryData.GetBMU(0).ComponentCanService = canService;
}
if (batteryChargeService.BatteryService.BatteryData.GetBMU(1) != null)
{
batteryChargeService.BatteryService.BatteryData.GetBMU(1).ComponentCanService = canService;
}
Assert.IsFalse(batteryChargeService.IsCharging, "Battery is charging when it should not be - Point 1");
// Bit out of order but we simulate the contactors engaging now as we can't insert it during the call to StartCharge
EngageContactors(batteryChargeService.BatteryService.BatteryData);
// Battery is now setup in normal state, run the charge loop
batteryChargeService.RequestedCurrent = 5;
batteryChargeService.RequestedVoltage = 32;
batteryChargeService.BatteryService.BatteryData.ParallelStrings = 1;
SetCellVoltages(batteryChargeService.BatteryService.BatteryData, 4100);
SendBatteryHeartBeat(canService, batteryChargeService.BatteryService.BatteryData);
Assert.IsTrue(await batteryChargeService.StartCharge(), "Charger start failed");
Assert.IsTrue(batteryChargeService.IsCharging, "Battery is not charging when it should be");
SetChargeVoltageError(batteryChargeService.BatteryService.BatteryData, 100, -50);
SendBatteryHeartBeat(canService, batteryChargeService.BatteryService.BatteryData);
batteryChargeService.ChargerUpdateInner();
tdkService.ChargerUpdateInner();
tdkService.ChargerUpdateInner();
Assert.IsTrue(batteryChargeService.IsCharging, "Battery is not charging when it should be - Mark 2");
// Keep sending heartbeats so we don't time out
SendBatteryHeartBeat(canService, batteryChargeService.BatteryService.BatteryData);
Assert.IsTrue(batteryChargeService.IsCharging, "Battery is not charging when it should be - Mark 3");
Assert.AreEqual(batteryChargeService.RequestedVoltage, batteryChargeService.ChargerActualVoltage, "Requested Voltage has not flowed through");
Assert.IsTrue(batteryChargeService.ChargerService.RequestedCurrent > 0, "Battery does not appear to be charging");
Assert.IsTrue(batteryChargeService.IsCharging, "Battery is not charging when it should be - Mark 4");
for (int i = 0; i < 10; i++)
{
batteryChargeService.ChargerUpdateInner();
tdkService.ChargerUpdateInner();
SendBatteryHeartBeat(canService, batteryChargeService.BatteryService.BatteryData);
}
Assert.IsTrue(batteryChargeService.IsCharging, "Battery is not charging when it should be - Mark 3");
float batteryChargerCurrent = batteryChargeService.ChargerService.RequestedCurrent;
// Battery over charged
SetChargeVoltageError(batteryChargeService.BatteryService.BatteryData, -35, -50);
for (int i = 0; i < 10; i++)
{
batteryChargeService.ChargerUpdateInner();
tdkService.ChargerUpdateInner();
SendBatteryHeartBeat(canService, batteryChargeService.BatteryService.BatteryData);
}
Assert.IsTrue(batteryChargeService.IsCharging, "Battery is not charging when it should be - Mark 4");
Assert.IsTrue(batteryChargeService.ChargerService.RequestedCurrent < batteryChargerCurrent, "Current should be going down as we are balancing, but it is not");
// Bit out of order but we simulate the contactors disengaging now as we can't insert it during the call to StartCharge
DisengageContactors(batteryChargeService.BatteryService.BatteryData);
Assert.IsTrue(await batteryChargeService.StopCharge(), "Battery did not stop as expected");
Assert.IsFalse(batteryChargeService.IsCharging, "Battery is charging when it should not be as it has been shutdown");
}
