private PortEvent SendPortRequest(PortRequest request)
{
request.RequestId = _ports.NextRequestId();
_pendingRequests.AnnounceRequest(request.RequestId);
WriteMessage(request);
return(_pendingRequests.WaitForResponse(request.RequestId) as PortEvent);
}
/// <summary>
/// Reads the value of the digital input.
/// </summary>
/// <param name="port">the digital input's port ID</param>
/// <returns>the input value</returns>
public bool ReadDigitalPin(int port)
{
Port p = _ports.GetPort(port);
if (p == null)
{
throw new WirekiteException(String.Format("Invalid port ID {0}", port));
}
PortType type = p.Type;
if (type == PortType.DigitalInputPrecached || type == PortType.DigitalInputTriggering)
{
return(p.LastSample != 0);
}
PortRequest request = new PortRequest {
PortId = (UInt16)port,
Action = Message.PortActionGetValue
};
SubmitPortRequest(request);
PortEvent evt = p.WaitForEvent();
return(evt.Value1 != 0);
}
/// <summary>
/// Send data to and request data from an I2C slave in a single operation
/// </summary>
/// <remarks>
/// <para>
/// The operation performs a complete I2C transaction, starting with a START condition,
/// a RESTART condition when switching from transmission to receipt, and ending with
/// a STOP condition.
/// </para>
/// <para>
/// The request is executed sychnronously, i.e. the call blocks until the data
/// has been transmitted and received, or the transmission has failed.
/// </para>
/// <para>
/// If less than the specified number of bytes are transmitted, `nil` is returned and
/// <see cref="GetLastI2CResult(int)"/> returns the associated reason.
/// </para>
/// </remarks>
/// <param name="port">the I2C port ID</param>
/// <param name="data">the data to transmit</param>
/// <param name="slave">the slave address</param>
/// <param name="receiveLength">the number of bytes of data request from the slave</param>
/// <returns>the received data or <c>null</c> if the transaction fails</returns>
public byte[] SendAndRequestOnI2CPort(int port, byte[] data, int slave, int receiveLength)
{
Port p = _ports.GetPort(port);
if (p == null)
{
throw new WirekiteException(String.Format("Invalid port ID {0}", port));
}
PortRequest request = new PortRequest
{
PortId = (UInt16)port,
Action = Message.PortActionTxNRxData,
Data = data,
ActionAttribute2 = (UInt16)slave,
Value1 = (UInt16)receiveLength
};
WaitUntilAvailable(request);
WriteMessage(request);
PortEvent response = _pendingRequests.WaitForResponse(request.RequestId) as PortEvent;
p.LastSample = response.EventAttribute1; // status code
return(response.Data);
}
/// <summary>
/// Reset the I2C bus
/// </summary>
/// <remarks>
/// If an I2C transaction is interrupted, a slave can still hold on to SDA
/// because it believes to be in the middle of a byte.
/// By toggling SCL up to 9 times, most slaves let go of SDA.
/// This method can be used if an I2C operation returns a "bus busy" error.
/// </remarks>
/// <param name="port">hte I2C port ID</param>
public void ResetBusOnI2CPort(int port)
{
if (_deviceState == DeviceState.Closed)
{
return; // silently ignore
}
Port p = _ports.GetPort(port);
if (p == null)
{
return;
}
PortRequest request = new PortRequest
{
Action = Message.PortActionReset,
PortId = (UInt16)port
};
WaitUntilAvailable(request);
PortEvent response = _pendingRequests.WaitForResponse(request.RequestId) as PortEvent;
p.LastSample = response.EventAttribute1; // status code
}
/// <summary>
/// Request data from an SPI slave
/// </summary>
/// <para>
/// The operation performs a complete SPI transaction, i.e. enables the clock for the duration of
/// transation and receives the data.
/// </para>
/// <para>
/// The operation is executed sychnronously, i.e.the call blocks until the
/// transaction has been completed or has failed. If the transaction fails,
/// use <see cref="GetLastSPIResult(int)"/> to retrieve the reason.
/// </para>
/// <para>
/// SPI is a full-duplex protocol at all times. Unless they use additional connections, slaves
/// cannot distinguish between read and write transactions.
/// This member functions send a configurable value on the MOSI line during the read.
/// Default value is 0xff.
/// </para>
/// <param name="port">the SPI port ID</param>
/// <param name="length">the number of bytes of data requested from the slave</param>
/// <param name="chipSelect">the digital output port ID to use as chip select (or <see cref="InvalidPortId"/> if not used)</param>
/// <param name="mosiValue">byte value sent on MOSI signal during reading</param>
/// <returns>the received data or <c>null</c> if it fails</returns>
public byte[] RequestOnSPIPort(int port, int length, int chipSelect, int mosiValue = 0xff)
{
Port p = _ports.GetPort(port);
if (p == null)
{
throw new WirekiteException(String.Format("Invalid port ID {0}", port));
}
PortRequest request = new PortRequest
{
PortId = (UInt16)port,
Action = Message.PortActionRxData,
ActionAttribute1 = (byte)mosiValue,
ActionAttribute2 = (UInt16)chipSelect,
Value1 = (uint)length,
RequestId = _ports.NextRequestId()
};
WaitUntilAvailable(request);
WriteMessage(request);
PortEvent response = _pendingRequests.WaitForResponse(request.RequestId) as PortEvent;
p.LastSample = response.EventAttribute1; // status code
return(response.Data);
}
private void SubmitPortRequest(PortRequest request, bool throttle = false)
{
request.RequestId = _ports.NextRequestId();
if (throttle)
{
WaitUntilAvailable(request);
}
WriteMessage(request);
}
/// <summary> Adds pObjRecord. </summary>
/// <remarks> Ranaya, 08/05/2017. </remarks>
/// <param name="pObjRecord"> The Object record to add. </param>
/// <returns> An int. </returns>
public int Add(PortRequest pObjRecord)
{
int lIntResult = 0;
//CREAR
if (!mObjPermissionsDAO.ExistRequest(pObjRecord.RequestId))
{
lIntResult = mObjPortRequestDAO.Add(pObjRecord);
if (lIntResult == 0)
{
LogService.WriteSuccess("[PortRequest CREATED]");
if (mObjPermissionsDAO.IsRequestPreparedToCreateSaleOrder(pObjRecord.RequestId))
{
lIntResult = mObjPermissionsDAO.CreateSaleOrder(pObjRecord.RequestId);
}
}
else
{
LogService.WriteError("[PortRequest NO CREATED]");
}
}
//EDITAR
else
{
// New portRequest line
if (mObjPermissionsDAO.IsPortExist(pObjRecord.RequestId, pObjRecord.PortId, pObjRecord.PortType) == "0")
{
lIntResult = mObjPortRequestDAO.Add(pObjRecord);
if (lIntResult == 0)
{
LogService.WriteSuccess("[PortRequest UPDATE ADDPORT]");
}
}
// Update portRequest line
else
{
pObjRecord.RowCode = mObjPermissionsDAO.GetRowCodeByPort(pObjRecord.RequestId, pObjRecord.PortId, pObjRecord.PortType);
lIntResult = mObjPortRequestDAO.Update(pObjRecord);
if (lIntResult == 0)
{
LogService.WriteSuccess("[PortRequest UPDATE]");
lIntResult = mObjPermissionsDAO.UpdateSaleOrder(pObjRecord.RequestId);
if (lIntResult == 0)
{
LogService.WriteSuccess("[PortRequest SaleOrder UPDATE]");
}
}
}
}
return(lIntResult);
}
/// <summary>
/// Sets the duty cycle of a PWM output
/// </summary>
/// <param name="port">the PWM output's port ID</param>
/// <param name="dutyCycle">the duty cycle between 0.0 (for 0%) and 1.0 (for 100%)</param>
public void WritePWMPin(int port, double dutyCycle)
{
PortRequest request = new PortRequest
{
PortId = (UInt16)port,
Action = Message.PortActionSetValue,
Value1 = (UInt32)(dutyCycle * 2147483647 + 0.5)
};
SubmitPortRequest(request);
}
/// <summary>
/// Writes a value to the digial output pins and synchronizes it with an SPI port
/// </summary>
/// <remarks>
/// Writing a value is an asynchronous operation. The function returns immediately without awaiting
/// a confirmation that it has succeeded. However, the action is not executed until all already
/// all SPI actions submitted to the same SPI port have been executed and before any later submitted action.
/// This is useful to change a signal relevant for the SPI communication such as a data/command signal.
/// </remarks>
/// <param name="port">digital output port ID</param>
/// <param name="value">the output value (true for high, false for low)</param>
/// <param name="spiPort">SPI port ID</param>
public void WriteDigitalPinSynchronizedWithSPI(int port, bool value, int spiPort)
{
PortRequest request = new PortRequest
{
PortId = (UInt16)port,
Action = Message.PortActionSetValue,
Value1 = value ? (uint)1 : 0,
ActionAttribute2 = (UInt16)spiPort
};
SubmitPortRequest(request, spiPort != 0);
}
/// <summary> Updates the given pObjRecord. </summary>
/// <remarks> Ranaya, 08/05/2017. </remarks>
/// <param name="pObjRecord"> The Object record to add. </param>
/// <returns> An int. </returns>
public int Update(PortRequest pObjRecord)
{
int lIntResult = 0;
lIntResult = mObjPortRequestDAO.Update(pObjRecord);
if (lIntResult == 0 &&
mObjPermissionsDAO.ExistsSaleOrder(pObjRecord.RequestId))
{
lIntResult = mObjPermissionsDAO.UpdateSaleOrder(pObjRecord.RequestId);
}
return(lIntResult);
}
private UInt16 SubmitI2CTx(int port, byte[] data, int slave)
{
PortRequest request = new PortRequest
{
PortId = (UInt16)port,
Action = Message.PortActionTxData,
Data = data,
ActionAttribute2 = (UInt16)slave
};
WaitUntilAvailable(request);
WriteMessage(request);
return(request.RequestId);
}
private UInt16 SubmitSPITx(int port, byte[] data, int chipSelect, byte action)
{
PortRequest request = new PortRequest
{
PortId = (UInt16)port,
Action = action,
Data = data,
ActionAttribute2 = (UInt16)chipSelect,
RequestId = _ports.NextRequestId()
};
WaitUntilAvailable(request);
WriteMessage(request);
return(request.RequestId);
}
/// <summary>
/// Reads the value of the analog input.
/// </summary>
/// <param name="port">the analog input's port ID</param>
/// <returns>the input value in the range between -1.0 and 1.0</returns>
public double ReadAnalogPin(int port)
{
Port p = _ports.GetPort(port);
if (p == null)
{
throw new WirekiteException(String.Format("Invalid port ID {0}", port));
}
PortRequest request = new PortRequest
{
PortId = (UInt16)port,
Action = Message.PortActionGetValue
};
SubmitPortRequest(request);
PortEvent evt = p.WaitForEvent();
Int32 v = (Int32)evt.Value1;
return(v < 0 ? v / 2147483648.0 : v / 2147483647.0);
}