/// <summary>
/// Remove fields with given values
/// </summary>
/// <param name="analog">Analog to remove fields from</param>
private void RemoveFields(Analog analog)
{
if (DatItemFields.Contains(DatItemField.Analog_Mask))
{
analog.Mask = null;
}
}
public void MergeFrom(Sensor other)
{
if (other == null)
{
return;
}
if (other.Pin != 0)
{
Pin = other.Pin;
}
switch (other.TypeCase)
{
case TypeOneofCase.Digital:
if (Digital == null)
{
Digital = new global::SensorsAndEngines.ProtobufModels.DigitalSensor();
}
Digital.MergeFrom(other.Digital);
break;
case TypeOneofCase.Analog:
if (Analog == null)
{
Analog = new global::SensorsAndEngines.ProtobufModels.AnalogSensor();
}
Analog.MergeFrom(other.Analog);
break;
}
_unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
}
/// <summary>
/// Creates a buffer to be used with Video4Linux streaming I/O.
/// </summary>
/// <param name="adapter">The parental Video4Linux device.</param>
/// <param name="buffer">The struct holding the buffer information.</param>
internal Buffer(Analog.Adapter adapter, v4l2_buffer buffer)
{
this.adapter = adapter;
this.buffer = buffer;
mapMemory();
}
public void Update(Analog meas, UInt32 index, String id)
{
if (this.AllAnalogUpdate != null)
{
sync.BeginInvoke(new Action(() => AllAnalogUpdate(meas, index, id)), null);
}
}
public OMSSCADACommon.Responses.Response ReadSingleAnalog(string id)
{
Analog analog = null;
OMSSCADACommon.Responses.Response response = new OMSSCADACommon.Responses.Response();
ProcessVariable pv;
if (dbContext.GetProcessVariableByName(id, out pv))
{
analog = (Analog)pv;
}
// does this ID exist in the database
if (analog == null)
{
response.ResultMessage = ResultMessage.INVALID_ID;
return(response);
}
AnalogVariable analogVariable = new AnalogVariable()
{
Id = id,
Value = analog.AcqValue
};
response.Variables.Add(analogVariable);
return(response);
}
void IDatabase.Update(Analog update, ushort index)
{
foreach (var db in databases)
{
db.Update(update, index);
}
}
public void ConfigureEngine(Dictionary <string, DataPointsListConfiguration> configuration)
{
foreach (KeyValuePair <string, DataPointsListConfiguration> dataPointsConfig in configuration)
{
DNP3Device dNP3Device = new DNP3Device();
dNP3Device.Name = dataPointsConfig.Key;
dNP3Device.Protocol = IndustryProtocols.DNP3TCP;
dbContext.AddRTU(dNP3Device);
foreach (AnalogInputPoint analogInput in dataPointsConfig.Value.AnalogInputPoints)
{
Analog analog = new Analog()
{
Name = analogInput.Name,
Type = VariableTypes.ANALOG,
RelativeAddress = (ushort)analogInput.Index,
ProcContrName = dataPointsConfig.Key,
MinValue = analogInput.MinIntegerTransmittedValue,
MaxValue = analogInput.MaxIntegerTransmittedValue,
UnitSymbol = (UnitSymbol)Enum.Parse(typeof(UnitSymbol), analogInput.Units, true),
IsInit = true,
Scale = analogInput.ScaleFactor,
Offset = analogInput.ScaleOffset
};
dbContext.AddProcessVariable(analog);
}
}
}
public List <KeyValuePair <long, float> > ReadAnalog(List <long> gids)
{
List <KeyValuePair <long, float> > result = new List <KeyValuePair <long, float> >(gids.Count);
foreach (long gid in gids)
{
Analog a = model.GetAnalog(gid);
if (a == null || a.BaseAddress < 0 || a.BaseAddress > ushort.MaxValue / 2)
{
continue;
}
ushort address = (ushort)(a.BaseAddress * 2);
ushort high, low;
if (!inputRegisters.TryGetValue(address, out high) || !inputRegisters.TryGetValue((ushort)(address + 1), out low))
{
continue;
}
float value;
GetValues(high, low, out value, out _);
result.Add(new KeyValuePair <long, float>(gid, value));
}
return(result);
}
public Form1()
{
InitializeComponent();
WindowState = FormWindowState.Maximized;
Bar_clb.SetItemChecked(0, true);
_curBarItem = "-1-50";
GraphChart.Series.RemoveAt(0);
/*Will not work with phidgets*/
/*
_samplesPrSecTimer.Interval =Convert.ToDouble(1000)/Convert.ToDouble(SamplePrSecTxtBox.Text);
_samplesPrSecTimer.Elapsed += UpdateGraph;
*/
Analog analog = new Analog();
//Hook the basic event handlers
analog.Attach += new AttachEventHandler(accel_Attach);
analog.Detach += new DetachEventHandler(accel_Detach);
analog.Error += new ErrorEventHandler(accel_Error);
//Add devices old
//_InitializeBackgroundWorker();
}
public DeviceAnalog(Analog a)
{
log.DebugFormat("DeviceAnalog()");
dataAnalog = a;
hardwareAnalog = new SPIAnalog(a.Id, a.Name, a.Multiplier, a.Units, a.Address);
log.DebugFormat("DeviceAnalog() {0}", a.Name);
}
static void Main(string[] args)
{
//creacion de los objetos de prueba
Laptop laptop = new Laptop();
Desktop desktop = new Desktop();
Analog analog = new Analog();
Computer[] computers = new Computer[3];
computers[0] = laptop;
computers[1] = desktop;
computers[2] = analog;
Random random = new Random();
//Darle un trato diferente dependiendo de con que computadora estes trabajando
switch (computers[random.Next(3)])
{
case Laptop lap: Console.WriteLine("Trabajando con laptop...");
break;
case Desktop des: Console.WriteLine("Trabajando con computadora de escritorio...");
break;
case Analog an: Console.WriteLine("Trabajando con computadora analogica...");
break;
}
Console.WriteLine("Presione cualquier tecla para salir.....");
Console.ReadKey();
}
private void Find(string original, string toFind, int steps)
{
FillAnalogsList();
_goodsList = Repository.Goods.ToList();
_producerList = Repository.Producers.ToList();
_originalGoods = GetGoodsByFindLinkString(original); //находим исходный товар
_toFindGoods = GetGoodsByFindLinkString(toFind); //находим искомый товар
int currentStep = 0; //устанавливаем начальные праметры
_result = false;
_errorMessage = "Исходный или искомый товар не найден."; //устанавливается такая обшибка сразу, чтобы не обрабатывать случай, когда один из товаров не найден
if (_originalGoods != null && _toFindGoods != null)
{ //если товары найдены, ищем между ними маршрут
Analog first = _analogsList.FirstOrDefault(x => x.OriginalGoodslD == _originalGoods.ID); //находим первый аналог
if (first != null)
{ //если он есть, начинаем искать
_fis = new List <FindIteration>() //список для запоминания группы аналогов на каждом шаге
{
new FindIteration()
{
Step = currentStep++ + 1, //запоминаем первый аналог
Analogs = new List <Analog>()
{
first
}
}
};
while (!_result && currentStep < steps)
{//по последней записи из списка циклов поиска ищем новую группу аналогов
var currentFI = _fis.Last();
if (!CheckFindIteration(currentFI, _toFindGoods.ID))
{ //если искомый товар не был найден, то продолжаем
var analogs = GetAnalogs(currentFI.Analogs); //получаем список аналогов по переданному списку аналогов
if (analogs.Count > 0)
{
_fis.Add(new FindIteration()
{
Step = currentStep++ + 1,
Analogs = analogs
});
}
else //если новых аналогов больше нет, то прерываем цикл
{
break;
}
}
else
{ //если искомый товар найден, то помечаем это и очищаем сообщение об ошибке
_result = true;
_errorMessage = "";
}
}
if (!_result) //если искомый товар не найден, то выводим сообщение об ощибке
{
_errorMessage = string.Format("Искомый товар «{0}» не найден за {1} шагов.", ToFind.VendorCode, TotalSteps);
}
}
}
}
private Measurement ConvertAnalog(Analog meas, uint id, String source)
{
var m = new Measurement();
m.Metadata = MeasurementKey.LookUpOrCreate(source, id).Metadata;
m.Value = meas.Value;
m.Timestamp = meas.Timestamp;
return(m);
}
private Measurement ConvertAnalog(Analog meas, uint id, String source)
{
var m = new Measurement();
m.Key = MeasurementKey.LookUpOrCreate(source, id);
m.Value = meas.Value;
m.Timestamp = DateTime.UtcNow;
return(m);
}
private Measurement ConvertAnalog(Analog measurement, uint id, string source)
{
return(new Measurement
{
Metadata = MeasurementKey.LookUpOrCreate(source, id).Metadata,
Value = measurement.Value,
Timestamp = measurement.Timestamp.Value
});
}
private LinkData GetLinkData(Analog analog, int step)
{//формируем информацию для вывода в таблицу о маршруте
return(new LinkData()
{
Route = string.Format("маршрут {0}", step),
Content = string.Format("{0} -> {1}",
DB.GetGoods(analog.OriginalGoodslD).VendorCode,
DB.GetGoods(analog.AnalogGoodsID).VendorCode)
});
}
public static bool CreateAnalog(Analog analog)
{
if (analog.ID == 0)
{
DC.Analogs.InsertOnSubmit(analog);
DC.Analogs.Context.SubmitChanges();
return(true);
}
return(false);
}
/// <summary>
/// Calculates a Work Point value for setting, in dependence of Analog properties,
/// returns true if should command to Sim.
/// </summary>
/// <param name="analog"></param>
/// <returns></returns>
public static bool InitialWorkPointAnalog(Analog analog)
{
bool retVal = true;
// ovde uvek treba da se komanduje za sada, posto na simulatoru NISTA nije inicijalno podeseno... za switcheve smo imali da odgovara ako je 0, ne mora komanda onda
// mozda nekad kasnije bude neka logika
return(retVal);
}
public void Deserialize(LEReader br)
{
FrameId = br.ReadUInt32();
Timestamp = br.ReadUInt64();
CreatedTimestamp = br.ReadUInt64();
Buttons.Deserialize(br);
Analog.Deserialize(br);
Extension.Deserialize(br);
}
public void Serialize(LEWriter bw)
{
bw.Write(FrameId);
bw.Write(Timestamp);
bw.Write(CreatedTimestamp);
Buttons.Serialize(bw);
Analog.Serialize(bw);
Extension.Serialize(bw);
}
private void Form1_Load(object sender, EventArgs e)
{
analog = new Phidgets.Analog();
analog.Attach += new AttachEventHandler(analog_Attach);
analog.Detach += new DetachEventHandler(analog_Detach);
analog.Error += new ErrorEventHandler(analog_Error);
openCmdLine(analog);
}
private void OnAnalogAddedEvent(object sender, EventArgs e)
{
Console.WriteLine("OnAnalogEventAdded started");
Analog analog = (Analog)e;
IORequestBlock iorb = new IORequestBlock()
{
RequestType = RequestType.SEND,
ProcessControllerName = analog.ProcContrName
};
DBContext dbContext = new DBContext();
RTU rtu;
if ((rtu = dbContext.GetRTUByName(analog.ProcContrName)) != null)
{
iorb.ReqAddress = (ushort)rtu.GetCommandAddress(analog);
bool shouldCommand = false;
switch (rtu.Protocol)
{
case IndustryProtocols.ModbusTCP:
ModbusHandler mdbHandler = new ModbusHandler();
mdbHandler.Header = new ModbusApplicationHeader()
{
TransactionId = 0,
Length = 5,
ProtocolId = (ushort)IndustryProtocols.ModbusTCP,
DeviceAddress = rtu.Address
};
mdbHandler.Request = new WriteRequest()
{
StartAddr = (ushort)rtu.GetCommandAddress(analog)
};
if (shouldCommand = AnalogProcessor.InitialWorkPointAnalog(analog))
{
mdbHandler.Request.FunCode = FunctionCodes.WriteSingleRegister;
AnalogProcessor.EGUToRawValue(analog);
((WriteRequest)mdbHandler.Request).Value = analog.RawCommValue;
iorb.SendBuff = mdbHandler.PackData();
iorb.SendMsgLength = iorb.SendBuff.Length;
Console.WriteLine(BitConverter.ToString(iorb.SendBuff, 0, 12));
IORequests.EnqueueRequest(iorb);
analog.IsInit = true;
}
break;
}
}
Console.WriteLine("OnAnalogEventAdded finished");
}
/// <summary>
/// Check if new work point is different than current work point, returns true if is, otherwise false
/// </summary>
/// <param name="analog"></param>
/// <returns></returns>
public static bool SetNewWorkPoint(Analog analog, float newWorkPointValue)
{
bool retVal = false;
if (newWorkPointValue != analog.CommValue)
{
analog.CommValue = newWorkPointValue;
retVal = true;
}
return(retVal);
}
public bool ContainsMrid(Analog analog, List <AnalogLocation> list)
{
foreach (AnalogLocation al in list)
{
if (al.Analog.Mrid.Equals(analog.Mrid))
{
return(true);
}
}
return(false);
}
static void Main(string[] args)
{
try
{
//Declare an analog object
Analog analog = new Analog();
//Hook the basic event handlers
analog.Attach += new AttachEventHandler(accel_Attach);
analog.Detach += new DetachEventHandler(accel_Detach);
analog.Error += new ErrorEventHandler(accel_Error);
//open the acclerometer object for device connections
analog.open();
//get the program to wait for an analog device to be attached
Console.WriteLine("Waiting for analog to be attached....");
analog.waitForAttachment();
//enabled each output at max voltage.
for (int i = 0; i < analog.outputs.Count; i++)
{
analog.outputs[i].Voltage = analog.outputs[i].VoltageMax;
analog.outputs[i].Enabled = true;
}
//Get the program to wait for user input before moving on so that we can
//watch for some events
Console.WriteLine("Press any key to end");
Console.Read();
//Disable them all
for (int i = 0; i < analog.outputs.Count; i++)
{
analog.outputs[i].Enabled = false;
}
//If user input has been read, we can now terminate the program, so
//close the phidget object
analog.close();
//set the object to null to clear it from memory
analog = null;
//if no exceptions have been trhown at this point, the program can
//terminate safely
Console.WriteLine("ok");
}
catch (PhidgetException ex)
{
Console.WriteLine(ex.Description);
}
}
static void Main(string[] args)
{
try
{
//Declare an analog object
Analog analog = new Analog();
//Hook the basic event handlers
analog.Attach += new AttachEventHandler(accel_Attach);
analog.Detach += new DetachEventHandler(accel_Detach);
analog.Error += new ErrorEventHandler(accel_Error);
//open the acclerometer object for device connections
analog.open();
//get the program to wait for an analog device to be attached
Console.WriteLine("Waiting for analog to be attached....");
analog.waitForAttachment();
//enabled each output at max voltage.
for (int i = 0; i < analog.outputs.Count; i++)
{
analog.outputs[i].Voltage = analog.outputs[i].VoltageMax;
analog.outputs[i].Enabled = true;
}
//Get the program to wait for user input before moving on so that we can
//watch for some events
Console.WriteLine("Press any key to end");
Console.Read();
//Disable them all
for (int i = 0; i < analog.outputs.Count; i++)
{
analog.outputs[i].Enabled = false;
}
//If user input has been read, we can now terminate the program, so
//close the phidget object
analog.close();
//set the object to null to clear it from memory
analog = null;
//if no exceptions have been trhown at this point, the program can
//terminate safely
Console.WriteLine("ok");
}
catch (PhidgetException ex)
{
Console.WriteLine(ex.Description);
}
}
public static bool UpdateAnalog(Analog analog)
{
var cache = DC.Analogs.FirstOrDefault(x => x.ID == analog.ID);
if (cache != null)
{
cache.OriginalGoodslD = analog.OriginalGoodslD;
cache.AnalogGoodsID = analog.AnalogGoodsID;
cache.Reliance = analog.Reliance;
DC.Analogs.Context.SubmitChanges();
return(true);
}
return(false);
}
private ResourceDescription CreateAnalogResourceDescription(Analog cimAnalog)
{
ResourceDescription rd = null;
if (cimAnalog != null)
{
long gid = ModelCodeHelper.CreateGlobalId(0, (short)DMSType.ANALOG, importHelper.CheckOutIndexForDMSType(DMSType.ANALOG));
rd = new ResourceDescription(gid);
importHelper.DefineIDMapping(cimAnalog.ID, gid);
SCADAConverter.PopulateAnalogProperties(cimAnalog, rd, importHelper, report);
}
return(rd);
}
static void AdapterPattern()
{
Console.WriteLine("Adapter Pattern");
Console.WriteLine("---------------");
Analog analogValue = new Analog(new decimal(3.142));
// Digital digitalValue = new Digital(20);
IAdapter adapter = new AnalogToDigitalAdapter();
adapter.ConvertToDigital(analogValue);
Console.WriteLine("**********************");
Console.ReadLine();
}
// linear conversion
public static void EGUToRawValue(Analog analog)
{
var rawMin = analog.RawBandLow;
var rawMax = analog.RawBandHigh;
var EGUCurrentAcq = analog.AcqValue;
var EGUCurrentComm = analog.CommValue;
var EGUMin = analog.MinValue;
var EGUMax = analog.MaxValue;
// sve ce biti celobrojno, i na simulatoru je celobrojno...
analog.RawAcqValue = (ushort)((((rawMax - rawMin) * (EGUCurrentAcq - EGUMin)) / (EGUMax - EGUMin)) + rawMin);
analog.RawCommValue = (ushort)((((rawMax - rawMin) * (EGUCurrentComm - EGUMin)) / (EGUMax - EGUMin)) + rawMin);
}
// linear conversion
public static void RawValueToEGU(Analog analog, ushort inputValue, out float result)
{
var rawMin = analog.RawBandLow;
var rawMax = analog.RawBandHigh;
var rawCurrentAcq = analog.RawAcqValue;
var rawCurrentComm = analog.RawCommValue;
var EGUMin = analog.MinValue;
var EGUMax = analog.MaxValue;
var temp = ((inputValue - rawMin) * (EGUMax - EGUMin));
var temp1 = (double)(temp / (rawMax - rawMin));
result = (float)(Math.Ceiling(temp1) + EGUMin);
}
Complex GetVoltageFromEnergySource(EnergySource es)
{
float re = float.NaN;
float im = float.NaN;
for (int i = 0; i < es.Measurements.Count; ++i)
{
Analog analog = Get(es.Measurements[i]) as Analog;
if (analog == null)
{
continue;
}
switch (analog.MeasurementType)
{
case MeasurementType.VoltageR:
if (!analogs.TryGetValue(analog.GID, out re))
{
re = analog.NormalValue;
}
break;
case MeasurementType.VoltageI:
if (!analogs.TryGetValue(analog.GID, out im))
{
im = analog.NormalValue;
}
break;
}
}
if (float.IsNaN(re) || float.IsNaN(im))
{
BaseVoltage bv = Get(es.BaseVoltage) as BaseVoltage;
if (bv != null)
{
re = bv.NominalVoltage;
im = 0;
}
}
return(new Complex(re, im));
}
public OMSSCADACommon.Responses.Response ReadAll()
{
Console.WriteLine("Response ReadAll");
// to do:
// while (!Database.IsConfigurationRunning)
List <ProcessVariable> pvs = dbContext.GetProcessVariable().ToList();
OMSSCADACommon.Responses.Response response = new OMSSCADACommon.Responses.Response();
foreach (ProcessVariable pv in pvs)
{
switch (pv.Type)
{
case VariableTypes.DIGITAL:
Digital digital = (Digital)pv;
response.Variables.Add(new DigitalVariable()
{
VariableType = ResponseVarType.Digital, Id = digital.Name, State = (OMSSCADACommon.States)digital.State
});
break;
case VariableTypes.ANALOG:
Analog analog = (Analog)pv;
// to do: fix this
response.Variables.Add(new AnalogVariable()
{
VariableType = ResponseVarType.Analog, Id = analog.Name, Value = analog.AcqValue, UnitSymbol = "w"
});
break;
case VariableTypes.COUNTER:
Counter counter = (Counter)pv;
response.Variables.Add(new CounterVariable()
{
VariableType = ResponseVarType.Counter, Id = counter.Name, Value = counter.Value
});
break;
}
}
response.ResultMessage = ResultMessage.OK;
return(response);
}
//Servo servo;
//Timer updateTimer;
public PhidgetController(PolhemusController inPolhemusController)
{
polhemusController = inPolhemusController;
if (Program.usePens)
{
penKit = new InterfaceKit();
setUpInterfaceKit(penKit);
}
Analog analog1 = new Analog();
setUpAnalog(analog1);
/*
for (int i = 0; i < analog1.outputs.Count; i++)
{
analog1.outputs[i].Voltage = analog1.outputs[i].VoltageMax;
analog1.outputs[i].Enabled = true;
}*/
}
/// <summary>
///
/// </summary>
/// <param name="leftAnalog"></param>
public void ThirdPersonMove(Analog leftAnalog)
{
AnimatorStateInfo = Animator.GetCurrentAnimatorStateInfo(0);
AnimatorTransitionInfo = Animator.GetAnimatorTransitionInfo(0);
Direction = Angle = 0;
var isInPivot = IsInPivot();
//Debug.Log(isInPivot);
leftAnalog.AnalogToWorldSpace(DirectionSpeed, transform, PlayerCamera, ref Direction, ref Speed, isInPivot, ref Angle);
Animator.SetFloat(HashIDs.SpeedFloat, Speed, SpeedDampTime, Time.deltaTime);
Animator.SetFloat(HashIDs.DirectionFloat, Direction, DirectionDampTime, Time.deltaTime);
if (Speed > LocomationThreshold && !isInPivot)
Animator.SetFloat(HashIDs.AngleFloat, Angle);
//Debug.Log(Direction.ToString());
if (!(Speed < LocomationThreshold) || !(Mathf.Abs(leftAnalog.Horizontal) < 0.05)) return;
Animator.SetFloat(HashIDs.AngleFloat, 0);
Animator.SetFloat(HashIDs.DirectionFloat, 0);
}
internal Input(Analog.Adapter adapter, v4l2_audio input)
{
this.adapter = adapter;
this.input = input;
}
void IDatabase.Update(Analog update, ushort index, EventMode mode)
{
analogs.Update(update.ToMeasurement(index, TimestampMode.SYNCHRONIZED));
}
public static bool AddAnalogValue(Analog button, int analogVal, ref Input input)
{
if (analogVal > (short)Xim.Stick.Max)
analogVal = (short)Xim.Stick.Max;
else if (analogVal < -(short)Xim.Stick.Max)
analogVal = -(short)Xim.Stick.Max;
switch (button)
{
case Analog.LeftStickX:
input.LeftStickX = AddStickValue(input.LeftStickX, (short)analogVal);
break;
case Analog.LeftStickY:
input.LeftStickY = AddStickValue(input.LeftStickY, (short)analogVal);
break;
case Analog.RightStickX:
input.RightStickX = AddStickValue(input.RightStickX, (short)analogVal);
break;
case Analog.RightStickY:
input.RightStickY = AddStickValue(input.RightStickY, (short)analogVal);
break;
case Analog.LeftTrigger:
input.LeftTrigger = AddStickValue(input.LeftTrigger, (short)analogVal);
break;
case Analog.RightTrigger:
input.RightTrigger = AddStickValue(input.RightTrigger, (short)analogVal);
break;
default:
return false;
}
return true;
}
public void ThirdPersonMovePhysics(Analog leftAnalog)
{
if ((AnimatorStateInfo.fullPathHash == HashIDs.LocomotionState) &&
(Direction > 0 && leftAnalog.Horizontal > 0) || (Direction < 0 && leftAnalog.Horizontal < 0))
{
var rotationAmount = Vector3.Lerp(Vector3.zero,
new Vector3(0f, RotationDegreePerSeckend * (leftAnalog.Horizontal < 0f ? -1f : 1f), 0f),
Mathf.Abs(leftAnalog.Horizontal));
var deltaRatation = Quaternion.Euler(rotationAmount * Time.deltaTime);
Transform.rotation = Transform.rotation * deltaRatation;
}
}
public void SetFormat(Analog.Video.BaseFormat fmt) {
fmt.Set(this);
}
void IDatabase.Update(Analog update, ushort index, EventMode mode)
{
this.Add(update.ToMeasurement(index, TimestampMode.SYNCHRONIZED), "Analog");
}
//When the form is being close, make sure to shutdown all the outputs and close the Phidget.
private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
analog.Attach -= new AttachEventHandler(analog_Attach);
analog.Detach -= new DetachEventHandler(analog_Detach);
analog.Error -= new ErrorEventHandler(analog_Error);
if (analog.Attached)
{
foreach (Phidgets.AnalogOutput channel in analog.outputs)
{
channel.Enabled = false;
}
}
//run any events in the message queue - otherwise close will hang if there are any outstanding events
Application.DoEvents();
analog.close();
analog = null;
}
void setUpAnalog(Analog analog)
{
analog.Attach += new AttachEventHandler(analog1_Attach);
analog.Error += new ErrorEventHandler(analog_Error);
analog.open();
Console.WriteLine("Waiting for analog output to be attached...");
analog.waitForAttachment();
}
void analog1_Attach(object sender, AttachEventArgs e)
{
analogKit1 = (Analog)sender;
Console.WriteLine("AnalogOutput {0} attached!", e.Device.SerialNumber.ToString());
analogKit1.outputs[0].Enabled = true;
analogKit1.outputs[1].Enabled = true;
analogKit1.outputs[2].Enabled = true;
analogKit1.outputs[3].Enabled = true;
analogKit1.outputs[0].Voltage = 0;
analogKit1.outputs[1].Voltage = 0;
analogKit1.outputs[2].Voltage = 0;
analogKit1.outputs[3].Voltage = 0;
}
public static bool SetAnalogState(Analog button, int analogVal, ref Input input)
{
if (analogVal > (short)Xim.Stick.Max)
{
analogVal = (short)Xim.Stick.Max;
}
else if( analogVal < -(short)Xim.Stick.Max )
{
analogVal = -(short)Xim.Stick.Max;
}
switch (button)
{
case Analog.LeftStickX:
input.LeftStickX = (short)analogVal;
break;
case Analog.LeftStickY:
input.LeftStickY = (short)analogVal;
break;
case Analog.RightStickX:
input.RightStickX = (short)analogVal;
break;
case Analog.RightStickY:
input.RightStickY = (short)analogVal;
break;
case Analog.LeftTrigger:
input.LeftTrigger = (short)analogVal;
break;
case Analog.RightTrigger:
input.RightTrigger = (short)analogVal;
break;
default:
return false;
}
return true;
}
public OverlayCaptureFormat(Analog.Video.Rectangle win)
: base(win)
{
format.type = v4l2_buf_type.VideoOverlay;
}
public OverlayOutputFormat(Analog.Video.Rectangle win)
: base(win)
{
format.type = v4l2_buf_type.VideoOutputOverlay;
}
/// <summary>
/// Creates a video overlay format.
/// </summary>
internal OverlayFormat(Analog.Video.Rectangle win)
: base()
{
format.fmt.win.w = win.ToStruct();
}
private void Print(Analog value, UInt16 index)
{
Console.WriteLine(_scadaDev.Name + ": Analog[" + index + "] " + value.ToString());
}
private void Start()
{
var player = GameObject.FindGameObjectWithTag("Player");
if (_follow == null)
_follow = player.GetComponent<ThirdPersonPlayerController>();
_loockDirection = _curentLookDirection = _follow.Transform.forward;
var pim = player.GetComponent<PlayerInputMenager>();
_leftAnalog = pim.LeftAnalog;
_rightAnalog = pim.RightAnalog;
}
public Stream(Analog.Adapter adapter)
: base()
{
this.adapter = adapter;
}
internal void Set(Analog.Adapter adapter)
{
if (adapter.IoControl.SetFormat(ref format) < 0)
throw new Exception("VIDIOC_S_FMT");
}
private void Form1_Load(object sender, EventArgs e)
{
analog = new Phidgets.Analog();
analog.Attach += new AttachEventHandler(analog_Attach);
analog.Detach += new DetachEventHandler(analog_Detach);
analog.Error += new ErrorEventHandler(analog_Error);
openCmdLine(analog);
}
