void Awake()
{
MyDebugger.enabled = debug;
//Debug.unityLogger.logEnabled = false;
triggerClassPath = @".\Assets\Scripts\Trigger.cs";
if (!Directory.Exists(@"Assets\Scripts"))
{
Directory.CreateDirectory(@"Assets\Scripts");
}
if (ASPFilePath is null)
{
ASPFilePath = @".\Assets\Resources\" + gameObject.name + ".asp";
}
actuatorsManager = ActuatorsManager.GetInstance();
sensorManager = SensorsManager.GetInstance();
if (Application.isEditor && !File.Exists(triggerClassPath))
{
using (FileStream fs = File.Create(triggerClassPath))
{
string triggerClassContent = "using System;\n";
triggerClassContent += "using UnityEngine;\n\n";
triggerClassContent += @"// every method of this class returning a bool value can be used to trigger the sensors update.";
triggerClassContent += "\n public class Trigger:ScriptableObject{\n\n";
triggerClassContent += "}";
Byte[] info = new UTF8Encoding(true).GetBytes(triggerClassContent);
fs.Write(info, 0, info.Length);
}
AssetDatabase.Refresh();
}
//MyDebugger.MyDebug("FINISH WITH AWAKE");
}
// Update is called once per frame
void LateUpdate()
{
//Debug.Break();
if (!ready)
{
return;
}
if (executeRepeteadly)
{
if (gameObject.GetComponent <MonoBehaviourSensorsManager>().brain.elapsedMS < frequency)
{
return;
}
}
else if (!(bool)updateMethod.Invoke(triggerClass, null))
{
return;
}
//MyDebugger.MyDebug("updating " + sensorName);
ReadProperty();
if (propertyValues.Count == 100)
{
propertyValues.RemoveAt(0);
}
SensorsManager.AddUpdatedSensor(brain);
}
void Awake()
{
triggerClassPath = @".\Assets\Scripts\Trigger.cs";
if (!Directory.Exists("Assets/Scripts"))
{
Directory.CreateDirectory("Assets/Scripts");
}
if (ASPFilePath.Equals(null))
{
ASPFilePath = @".\Assets\Resources\" + gameObject.name + ".asp";
}
actuatorsManager = ActuatorsManager.GetInstance();
sensorManager = SensorsManager.GetInstance();
if (Application.isEditor && !File.Exists(triggerClassPath))
{
using (FileStream fs = File.Create(triggerClassPath))
{
string triggerClassContent = "using System;\n";
triggerClassContent += "using UnityEngine;\n\n";
triggerClassContent += @"// every method of this class returning a bool value can be used to trigger the sensors update.";
triggerClassContent += "\n public class Trigger:ScriptableObject{\n\n";
triggerClassContent += "}";
Byte[] info = new UTF8Encoding(true).GetBytes(triggerClassContent);
fs.Write(info, 0, info.Length);
}
}
else if (Application.isPlaying && enableBrain)
{
initBrain();
}
}
public void ReturnGetValueModel()
{
var sensorId = Guid.Parse(SENSOR_ONE_ID);
var nameValueType = "NAMEVALUETYPE1";
var sensorValueTypeRepo = new Mock <IValueTypesRepository>();
sensorValueTypeRepo.Setup(s => s.GetAll()).Returns(GetSensorsValueTypes);
var valueType = GetSensorsValueTypes()
.FirstOrDefault(r => r.SensorId == sensorId && r.Name == nameValueType.ToUpper());
Assert.NotNull(valueType);
var sensorValuesRepo = new Mock <IValuesRepository>();
sensorValuesRepo.Setup(s => s.GetValues(valueType.Id))
.Returns(GetValues().Where(v => v.ValueTypeId == valueType.Id).ToArray);
var _sensorsManager = new SensorsManager(null, sensorValueTypeRepo.Object, sensorValuesRepo.Object);
var sensorController = new SensorController(_sensorsManager, null);
var result = sensorController.GetValue(sensorId, nameValueType).Result;
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsType <SensorValuesList>(viewResult.ViewData.Model);
Assert.Equal(valueType.SensorId, model.SensorId);
Assert.Equal(valueType.Name, model.ValueName);
Assert.Equal(valueType.Type, model.ValueType);
Assert.Equal(valueType.Values.Count(), model.Values.Count());
}
void Update()
{
if (manager is null)
{
manager = SensorsManager.GetInstance();
}
}
public void ReturnInfoModel(string id)
{
var sensorId = Guid.Parse(id);
var sensorRepo = new Mock <ISensorsRepository>();
sensorRepo.Setup(s => s.GetById(sensorId)).Returns(GetSensors().FirstOrDefault(s => s.Id == sensorId));
var sensorValueTypeRepo = new Mock <IValueTypesRepository>();
sensorValueTypeRepo.Setup(s => s.GetValueTypesForSensor(sensorId))
.Returns(GetSensorsValueTypes().Where(v => v.SensorId == sensorId).ToArray);
var _sensorsManager = new SensorsManager(sensorRepo.Object, sensorValueTypeRepo.Object, null);
var sensorController = new SensorController(_sensorsManager, null);
var result = sensorController.Info(sensorId).Result;
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsType <SensorInfoViewModel>(viewResult.ViewData.Model);
var expectedSensorInfo = GetSensors().FirstOrDefault(s => s.Id == sensorId);
Assert.NotNull(expectedSensorInfo);
Assert.Equal(expectedSensorInfo.Id, model.Id);
Assert.Equal(expectedSensorInfo.Description, model.Description);
Assert.Equal(expectedSensorInfo.Name, model.Name);
Assert.Equal(expectedSensorInfo.Values.Count(), model.Values.Count());
}
static void Main(string[] args)
{
var sensorManager = new SensorsManager();
var imperialCreator = new ImperialSensorCreator();
var siCreator = new InternationalSystemSensorCreator();
sensorManager.AddSensor(imperialCreator.CreatePressureSensor());
sensorManager.AddSensor(siCreator.CreateTempSensor());
sensorManager.AddSensor(imperialCreator.CreateTempSensor());
}
private void enlargedList(string property, int newSize, Type propertyType, Type collectionElementType)
{
for (int i = sizeToTrack[property][0]; i < newSize; i++)
{
IMonoBehaviourSensor newSensor = addSensor(sensorNameForCollectionProperty[property], property, 0, propertyType);
newSensor.indexes.Add(i);
newSensor.collectionElementProperty = currentSubProperty;
newSensor.collectionElementType = collectionElementType.Name;
newSensor.done();
SensorsManager.GetInstance().addSensor(brain, newSensor);
}
}
public void DeleteSensor(string id)
{
var sensorId = Guid.Parse(id);
var sensorRepo = new Mock <ISensorsRepository>();
sensorRepo.Setup(s => s.Delete(sensorId)).Returns(true);
var _sensorManager = new SensorsManager(sensorRepo.Object, null, null);
var result = _sensorManager.DeleteSensor(sensorId);
Assert.True(result);
}
public void ReturnUserSensors()
{
var sensorRepo = new Mock <ISensorsRepository>();
sensorRepo.Setup(s => s.GetAll()).Returns(GetSensors);
var _sensorManager = new SensorsManager(sensorRepo.Object, null, null);
var userId = Guid.Parse(USER_ONE_ID);
var expectedSensors = GetSensors().Where(s => s.UserId == userId);
var userSensors = _sensorManager.GetSensorsForUser(userId);
Assert.Equal(expectedSensors.Count(), userSensors.Count());
Assert.True(userSensors.All(s => s.UserId == userId));
}
private void ApplyNewConfiguration()
{
foreach (var sensor in Sensors)
{
if (sensor.SensorId == -1)
{
sensor.SensorId = SensorsStorage.GetNewSensorId(sensor.Name);
}
}
SensorsConfiguration.Sensors = new List <SensorConfiguration>(Sensors);
SensorsConfiguration.Save();
SensorsManager.ReloadConfiguration();
}
public void ReturnStoreValue()
{
var sensorValueRepo = new Mock <IValuesRepository>();
sensorValueRepo.Setup(s => s.Create(It.IsAny <Value>())).Returns(true);
var _sensorManager = new SensorsManager(null, null, sensorValueRepo.Object);
var apiPlaylod = new ApiPayload
{
DateTime = DateTime.Now,
Data = DateTime.Today.ToString()
};
var result = _sensorManager.StoreValue(Guid.Parse("89740433-0A86-463A-9430-9A570D145B51"), apiPlaylod);
Assert.True(result);
}
public void ReturnNameValueType(string id, string nameValueType)
{
var sensorId = Guid.Parse(id);
var sensorValueTypeRepo = new Mock <IValueTypesRepository>();
sensorValueTypeRepo.Setup(s => s.GetAll()).Returns(GetSensorsValueTypes);
var _sensorManager = new SensorsManager(null, sensorValueTypeRepo.Object, null);
var valueTypeId = _sensorManager.GetValueType(sensorId, nameValueType).Id;
var expectedToLowerValueTypeId = _sensorManager.GetValueType(sensorId, nameValueType.ToLower()).Id;
var expectedToUpperValueTypeId = _sensorManager.GetValueType(sensorId, nameValueType.ToUpper()).Id;
Assert.Equal(valueTypeId, expectedToLowerValueTypeId);
Assert.Equal(valueTypeId, expectedToUpperValueTypeId);
}
public void ReturnSensorValueTypes()
{
var sensorId = Guid.Parse(SENSOR_ONE_ID);
var sensorValueTypeRepo = new Mock <IValueTypesRepository>();
sensorValueTypeRepo.Setup(s => s.GetValueTypesForSensor(sensorId))
.Returns(GetSensorsValueTypes().Where(s => s.SensorId == sensorId).ToArray);
var _sensorManager = new SensorsManager(null, sensorValueTypeRepo.Object, null);
var sensorValueTypes = _sensorManager.GetValueTypes(sensorId);
var expectedSensorsValueTypes = GetSensorsValueTypes().Where(s => s.SensorId == sensorId);
Assert.Equal(expectedSensorsValueTypes.Count(), sensorValueTypes.Count());
Assert.True(sensorValueTypes.All(s => s.SensorId == sensorId));
}
public void CreateValueTypeNotNameEmpty(string id, string name, PayloadType type)
{
var sensorId = Guid.Parse(id);
var sensorRepo = new Mock <ISensorsRepository>();
sensorRepo.Setup(s => s.GetById(sensorId)).Returns(GetSensors().FirstOrDefault(s => s.Id == sensorId));
var sensorValueTypeRepo = new Mock <IValueTypesRepository>();
sensorValueTypeRepo.Setup(s => s.Create(It.IsAny <ValueType>())).Returns(true);
var _sensorManager = new SensorsManager(sensorRepo.Object, sensorValueTypeRepo.Object, null);
var actualValueType = _sensorManager.CreateValueType(sensorId, name, type);
Assert.Null(actualValueType);
}
public void ReturnDeleteSensorModel(string id)
{
var sensorId = Guid.Parse(id);
var sensorRepo = new Mock <ISensorsRepository>();
sensorRepo.Setup(s => s.Delete(sensorId)).Returns(true);
var _sensorManager = new SensorsManager(sensorRepo.Object, null, null);
var sensorController = new SensorController(_sensorManager, null);
var result = sensorController.Delete(sensorId).Result;
var redirectToActionResult = Assert.IsType <RedirectToActionResult>(result);
Assert.Equal("Index", redirectToActionResult.ActionName);
Assert.Equal("Sensor", redirectToActionResult.ControllerName);
}
public void ReturnSensorOnCreate()
{
var sensorRepo = new Mock <ISensorsRepository>();
sensorRepo.Setup(s => s.Create(It.IsAny <Sensor>())).Returns(true);
var _sensorManager = new SensorsManager(sensorRepo.Object, null, null);
var userId = Guid.NewGuid();
var name = " TemperatureSensor ";
var description = "The sensor of storing temperature and humidity";
var actualSensor = _sensorManager.CreateSensor(userId, name, description);
Assert.NotNull(actualSensor);
Assert.Equal(userId, actualSensor.UserId);
Assert.Equal("TemperatureSensor", actualSensor.Name);
Assert.NotNull(actualSensor.Description);
Assert.Equal(description, actualSensor.Description);
}
private void ReadSimpleListProperty(string path, Type type, object obj)
{
object[] listValue = SensorsUtility.GetListProperty(path, collectionElementProperty, type, obj, indexes[0]);
if (listValue[0] != null && listValue[1] != null)
{
FieldOrProperty toRead = (FieldOrProperty)listValue[1];
IList list = (IList)listValue[0];
propertyValues.Add((T)Convert.ChangeType(toRead.GetValue(list[indexes[0]]), typeof(T)));
}
else
{
MyDebugger.MyDebug("Destroing " + path);
SensorsManager.GetInstance().removeSensor(brain, this);
Destroy(this);
return;
}
}
private void MainForm_Load(object sender, EventArgs e)
{
isMainScreen = true;
isRecording = false;
isExperimentNow = true;
Enabled = false;
persistButton.Enabled = false;
webView.UseJavaScript = true;
string path = Path.GetDirectoryName(Application.ExecutablePath);
webView.DocumentCompleted += new WebBrowserDocumentCompletedEventHandler(documentCompleted);
webView.UseDefaultContextMenu = false;
webView.Url = new Uri(path + "/web/index.html");
sensorManager = new SensorsManager();
SensorCallback webViewCallback = new SensorCallback(this);
sensorManager.setCallback(webViewCallback, webView);
}
public Robot()
{
sensorsMan = new SensorsManager();
hardwareMan = new HardwareManager();
modules = new SortedList<string, Module>();
head = new HeadHW(1, -1);
torso = new TorsoHW(MathUtil.PiOver2, -MathUtil.PiOver2);
RightArmIsEmpty = true;
LeftArmIsEmpty = true;
skeletons = new Skeleton[0];
humanList = new List<Human>();
objectsList = new SortedList<string, WorldObject>();
lastObjectsFounded = new SortedList<string, WorldObject>();
LoadModules();
}
public void ReturnAddValueTypeModel(ValueTypeViewModel model)
{
var sensorRepo = new Mock <ISensorsRepository>();
sensorRepo.Setup(s => s.GetById(model.SensorId)).Returns(GetSensors().FirstOrDefault(s => s.Id == model.SensorId));
var sensorValueTypeRepo = new Mock <IValueTypesRepository>();
sensorValueTypeRepo.Setup(s => s.Create(It.IsAny <ValueType>())).Returns(true);
var _sensorsManager = new SensorsManager(sensorRepo.Object, sensorValueTypeRepo.Object, null);
var sensorController = new SensorController(_sensorsManager, null);
var result = sensorController.AddValueType(model).Result;
var redirectToActionResult = Assert.IsType <RedirectToActionResult>(result);
Assert.Equal("Info", redirectToActionResult.ActionName);
}
public void ReturnValues(string id, string nameValueType)
{
var sensorId = Guid.Parse(id);
var valueType = GetSensorsValueTypes()
.FirstOrDefault(r => r.SensorId == sensorId && r.Name == nameValueType.ToUpper());
Assert.NotNull(valueType);
var sensorValuesRepo = new Mock <IValuesRepository>();
sensorValuesRepo.Setup(s => s.GetValues(valueType.Id)).Returns(GetValues().Where(v => v.ValueTypeId == valueType.Id).ToArray);
var _sensorManager = new SensorsManager(null, null, sensorValuesRepo.Object);
var values = _sensorManager.GetValues(valueType.Id);
var expectedValues = GetValues().Where(v => v.ValueTypeId == valueType.Id);
Assert.Equal(expectedValues.Count(), values.Count());
}
public void ReturnAddValueType(string id)
{
var sensorId = Guid.Parse(id);
var sensorRepo = new Mock <ISensorsRepository>();
sensorRepo.Setup(s => s.GetById(sensorId)).Returns(GetSensors().FirstOrDefault(s => s.Id == sensorId));
var _sensorsManager = new SensorsManager(sensorRepo.Object, null, null);
var sensorController = new SensorController(_sensorsManager, null);
var result = sensorController.AddValueType(sensorId).Result;
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsType <ValueTypeViewModel>(viewResult.ViewData.Model);
Assert.Null(model.Name);
Assert.Equal(Guid.Empty, model.Id);
Assert.Equal(sensorId, model.SensorId);
Assert.Equal(PayloadType.String, model.Type);
}
public void ReturnValueType(string id, string nameValueType)
{
var sensorId = Guid.Parse(id);
var sensorRepo = new Mock <ISensorsRepository>();
sensorRepo.Setup(s => s.GetById(sensorId)).Returns(GetSensors().FirstOrDefault(s => s.Id == sensorId));
var sensorValueTypeRepo = new Mock <IValueTypesRepository>();
sensorValueTypeRepo.Setup(s => s.GetAll()).Returns(GetSensorsValueTypes);
var _sensorManager = new SensorsManager(sensorRepo.Object, sensorValueTypeRepo.Object, null);
var expectedValueTypeId = GetSensorsValueTypes()
.FirstOrDefault(r => r.SensorId == sensorId && r.Name == nameValueType.ToUpper())?.SensorId;
var sesnorValueTypeId = _sensorManager.GetSensorById(sensorId).Id;
Assert.Equal(expectedValueTypeId, sensorId);
Assert.Equal(sesnorValueTypeId, sensorId);
}
private void ReadSimpleArrayProperty(string path, Type type, object obj)
{
//MyDebugger.MyDebug("READING");
object[] matrixValue = SensorsUtility.GetArrayProperty(path, collectionElementProperty, type, obj, indexes[0], indexes[1]);
//MyDebugger.MyDebug("Matrix: " + matrixValue[0]);
//MyDebugger.MyDebug("Property: " + matrixValue[1]);
if (matrixValue[0] != null && matrixValue[1] != null)
{
FieldOrProperty toRead = (FieldOrProperty)matrixValue[1];
Array matrix = (Array)matrixValue[0];
//MyDebugger.MyDebug("Casting " + toRead.GetValue(matrix.GetValue(indexes[0], indexes[1])).GetType() + " to " + typeof(T));
propertyValues.Add((T)Convert.ChangeType(toRead.GetValue(matrix.GetValue(indexes[0], indexes[1])), typeof(T)));
}
else
{
SensorsManager.GetInstance().removeSensor(brain, this);
Destroy(this);
return;
}
}
public void Run()
{
reason = true;
IMapper sensorMapper = mapper.getMapper(typeof(AdvancedSensor));
while (reason)
{
if (!brain.executeReasonerOn.Equals("When Sensors are ready"))
{
lock (brain.toLock)
{
MyDebugger.MyDebug("going to wait for pulse by brain");
brain.solverWaiting = true;
Monitor.Wait(brain.toLock);
}
}
try
{
factsPath = Path.GetTempFileName();
using (StreamWriter fs = new StreamWriter(factsPath, true))
{
string toAppend = SensorsManager.GetSensorsMapping(brain);
if (!reason)
{
return;
}
fs.Write(toAppend);
fs.Close();
}
}
catch (Exception e)
{
MyDebugger.MyDebug("CAUGHT EXECPTION!!!!");
MyDebugger.MyDebug(e.Message);
MyDebugger.MyDebug(e.StackTrace);
}
Handler handler = new DesktopHandler(new DLV2DesktopService(@".\lib\dlv2.exe"));
//With DLV2DesktopService I get a Error during parsing: --> Invalid #show directive: setOnActuator/1--competition-output.
//With DLVDesktopService the AS, obviously, are wrongly parsed
InputProgram encoding = new ASPInputProgram();
MyDebugger.MyDebug("adding encoding");
encoding.AddFilesPath(Path.GetFullPath(brain.ASPFilePath));
InputProgram facts = new ASPInputProgram();
MyDebugger.MyDebug("adding facts");
facts.AddFilesPath(factsPath);
handler.AddProgram(encoding);
handler.AddProgram(facts);
handler.AddOption(new OptionDescriptor("--filter=setOnActuator/1 "));
stopwatch.Restart();
MyDebugger.MyDebug("starting sync");
Output o = handler.StartSync();
if (!o.ErrorsString.Equals(""))
{
MyDebugger.MyDebug(o.ErrorsString + " " + o.OutputString);
}
AnswerSets answers = (AnswerSets)o;
stopwatch.Stop();
brain.asSteps++;
brain.asTotalMS += stopwatch.ElapsedMilliseconds;
MyDebugger.MyDebug("num of AS " + answers.Answersets.Count);
if (answers.Answersets.Count > 0)
{
lock (brain.toLock)
{
foreach (SimpleActuator actuator in brain.getActuators())
{
actuator.parse(answers.Answersets[0]);
}
brain.setActuatorsReady(true);
}
}
if (!brain.maintainFactFile)
{
File.Delete(factsPath);
}
}
}
void LateUpdate()
{
SensorsManager.pulseBrainsIfNeeded();
}
void Awake()
{
manager = SensorsManager.GetInstance();
base.Awake();
}
public ISensorsProtocol CreateSensorsProtocol(SensorsManager sensorsManager)
{
return(new BasicSensorsProtocol(sensorsManager));
}
