Renamed remotely
git-svn-id: file:///srv/dev-disk-by-uuid-17e88007-4d0c-45e0-8757-cacfcc458630/repositories/svn/Diplomarbeit@106 9fe90eed-be63-e94b-8204-d34ff4c2ff93
This commit is contained in:
Matthias
@@ -0,0 +1,680 @@
|
||||
/* ---------------------------------------------------------------------------
|
||||
* BusProtocol.c - v0.1 (c) 2008 Micro-key bv
|
||||
* ---------------------------------------------------------------------------
|
||||
* Micro-key bv
|
||||
* Industrieweg 28, 9804 TG Noordhorn
|
||||
* Postbus 92, 9800 AB Zuidhorn
|
||||
* The Netherlands
|
||||
* Tel: +31 594 503020
|
||||
* Fax: +31 594 505825
|
||||
* Email: support@microkey.nl
|
||||
* Web: www.microkey.nl
|
||||
* ---------------------------------------------------------------------------
|
||||
* Description:
|
||||
* ---------------------------------------------------------------------------
|
||||
* Version(s): 0.1, Jan 28, 2008, FSc
|
||||
* Creation.
|
||||
* ---------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
/* ---------------------------------------------------------------------------
|
||||
* System include files
|
||||
* ---------------------------------------------------------------------------
|
||||
*/
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
/* ---------------------------------------------------------------------------
|
||||
* Application include files
|
||||
* ---------------------------------------------------------------------------
|
||||
*/
|
||||
#include "BpPort.h"
|
||||
#include "BusProtocol.h"
|
||||
#include "ProtocolThread.h"
|
||||
#include "MessageHandlerQueue.h"
|
||||
#include "RemoteProcedureCalls.h"
|
||||
#include "RpcResults.h"
|
||||
#include "bus.h"
|
||||
//#include "ElecStatusCache.h"
|
||||
#include "mem_mod.h"
|
||||
|
||||
|
||||
/* ---------------------------------------------------------------------------
|
||||
* Local constant and macro definitions
|
||||
* ---------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
/* ---------------------------------------------------------------------------
|
||||
* Global variable definitions
|
||||
* ---------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
/* ---------------------------------------------------------------------------
|
||||
* Local variable definitions
|
||||
* ---------------------------------------------------------------------------
|
||||
*/
|
||||
typedef struct t_BP_ADMIN {
|
||||
UINT8 deviceId;
|
||||
UINT8 rpcRequestNr;
|
||||
int rpcHandle;
|
||||
int rpcrHandle;
|
||||
int bpthreadHandle;
|
||||
int messageHandlerHandle;
|
||||
} t_bp_admin;
|
||||
|
||||
memman *bpMessagePool;
|
||||
|
||||
/* ---------------------------------------------------------------------------
|
||||
* Local function definitions
|
||||
* ---------------------------------------------------------------------------
|
||||
*/
|
||||
static void WriteElectricStatusCallback( int handle, BOOLEAN isDigital, UINT8 device, UINT8 channel, UINT16 value );
|
||||
|
||||
/** \brief Initialises the BusProtocol
|
||||
*
|
||||
* \param bus The bus to communicate on
|
||||
* \param deviceId the bus identity for this device
|
||||
* \retval the handle for the BusProtocol-driver (0 = unsuccesfull)
|
||||
*/
|
||||
int bpInit( t_bus_devices bus, UINT8 deviceId, UINT8 highestDeviceId, UINT8 inputQueueSize )
|
||||
{
|
||||
t_bp_admin *newBusProtocol = (t_bp_admin *)pvPortMalloc( sizeof(t_bp_admin));
|
||||
|
||||
if (newBusProtocol != NULL)
|
||||
{
|
||||
// Fill administration
|
||||
newBusProtocol->deviceId = deviceId;
|
||||
newBusProtocol->rpcRequestNr = 0;
|
||||
newBusProtocol->rpcHandle = rpcInit();
|
||||
newBusProtocol->rpcrHandle = rpcrInit();
|
||||
newBusProtocol->messageHandlerHandle = mhqInit();
|
||||
|
||||
// Allocate payload queue
|
||||
bpMessagePool = Memmod_Create( inputQueueSize, 64); // Make sure size is dividable by 4
|
||||
|
||||
// Register RPC Callback
|
||||
mhqAdd( newBusProtocol->messageHandlerHandle, BPMSG_MSGID_CALLRPC, rpcRequestHandler, newBusProtocol->rpcHandle );
|
||||
|
||||
// Register RPC-result Callback
|
||||
mhqAdd( newBusProtocol->messageHandlerHandle, BPMSG_MSGID_GIVERPCRESULTS, rpcrRequestHandler, newBusProtocol->rpcrHandle );
|
||||
|
||||
// Register Write electronic status callbac )
|
||||
bpecAttachWriteCallback(newBusProtocol, WriteElectricStatusCallback);
|
||||
|
||||
// Open bus
|
||||
busInit(bus);
|
||||
|
||||
// Create & start thread to poll bus
|
||||
newBusProtocol->bpthreadHandle = bpthreadStart( bus, deviceId, highestDeviceId, (int)newBusProtocol, newBusProtocol->messageHandlerHandle );
|
||||
}
|
||||
|
||||
return (int)newBusProtocol;
|
||||
}
|
||||
|
||||
/** \brief Closes the active BusProtocol
|
||||
*
|
||||
* \post Protocol on this handle cannot be used anymore
|
||||
* \param handle The handle for the BusProtocol (received with bpInit())
|
||||
*/
|
||||
void bpDeinit( int handle )
|
||||
{
|
||||
// Stop & Destroy the bus poll thread
|
||||
|
||||
// Close bus
|
||||
/* \todo busDeinit( (t_bp_admin *)handle)->bus ); */
|
||||
|
||||
rpcDeinit( ((t_bp_admin *)handle)->rpcHandle );
|
||||
rpcrDeinit( ((t_bp_admin *)handle)->rpcrHandle );
|
||||
bpthreadStop( ((t_bp_admin *)handle)->bpthreadHandle );
|
||||
|
||||
// Free BusProtocol-administration
|
||||
vPortFree( (void *)handle );
|
||||
}
|
||||
|
||||
|
||||
/** \brief Indicates whether a message a device is received in the last 10 seconds
|
||||
* Only used by the master
|
||||
*/
|
||||
BOOLEAN bpDeviceIsDetected( int handle, UINT8 deviceId )
|
||||
{
|
||||
return bpthreadDeviceIsDetected(((t_bp_admin *)handle)->bpthreadHandle, deviceId);
|
||||
}
|
||||
|
||||
|
||||
/** \brief Sends message to pass turn (Nothing to send)
|
||||
*
|
||||
* \param handle The handle for the BusProtocol (received with bpInit())
|
||||
*/
|
||||
void bpSendPassTurn( int handle )
|
||||
{
|
||||
t_bpmsg_message sendPassTurnMessage;
|
||||
|
||||
BP_DEBUG_OUT('p');BP_DEBUG_OUT('>');
|
||||
|
||||
// Create new message
|
||||
sendPassTurnMessage.uniqueStartByte = BPMSG_STARTBYTE;
|
||||
sendPassTurnMessage.senderId = ((t_bp_admin *)handle)->deviceId;
|
||||
sendPassTurnMessage.targetId = BPMSG_BROADCAST_ID;
|
||||
sendPassTurnMessage.packetNr = 0; // packetNr filled at transmitting time
|
||||
sendPassTurnMessage.status = 0; // Clear status (filled by ProtocolThread)
|
||||
sendPassTurnMessage.messageId = BPMSG_MSGID_PASSTURN;
|
||||
sendPassTurnMessage.payloadSize = 0;
|
||||
sendPassTurnMessage.payload = NULL;
|
||||
|
||||
// Calculate CRC
|
||||
bpmsgEncodeMessage(&sendPassTurnMessage);
|
||||
|
||||
bpthreadAddMessage(((t_bp_admin *)handle)->bpthreadHandle, &sendPassTurnMessage);
|
||||
}
|
||||
|
||||
/** \brief Sends message to reset another bus device
|
||||
*
|
||||
* \param handle The handle for the BusProtocol (received with bpInit())
|
||||
* \param deviceId Identity of targeted bus device (0xFF = all devices)
|
||||
*/
|
||||
void bpSendResetClient( int handle, UINT8 deviceId )
|
||||
{
|
||||
t_bpmsg_message sendResetClientMessage;
|
||||
|
||||
// Create new message
|
||||
sendResetClientMessage.uniqueStartByte = BPMSG_STARTBYTE;
|
||||
sendResetClientMessage.senderId = ((t_bp_admin *)handle)->deviceId;
|
||||
sendResetClientMessage.targetId = deviceId;
|
||||
sendResetClientMessage.packetNr = 0; // packetNr filled at transmitting time
|
||||
sendResetClientMessage.status = 0; // Clear status (filled by ProtocolThread)
|
||||
sendResetClientMessage.messageId = BPMSG_MSGID_RESETCLIENT;
|
||||
sendResetClientMessage.payloadSize = 0;
|
||||
sendResetClientMessage.payload = NULL;
|
||||
|
||||
// Calculate CRC
|
||||
bpmsgEncodeMessage(&sendResetClientMessage);
|
||||
|
||||
bpthreadAddMessage(((t_bp_admin *)handle)->bpthreadHandle, &sendResetClientMessage);
|
||||
}
|
||||
|
||||
/** \brief Sends message with all electronic information (DAC's, ADC's and digital I/O)
|
||||
*
|
||||
* Broadcasts the electronic status of the device
|
||||
*
|
||||
* \param handle The handle for the BusProtocol (received with bpInit())
|
||||
* \param nrOfAdcValues Number of ADC-values included in the message
|
||||
* \param adcValues Pointer to a UINT16 array
|
||||
* \param nrOfDacValues Number of DAC-values included in the message
|
||||
* \param dacValues Pointer to a UINT16 array
|
||||
* \param nrOfDiValues Number of digital input values included in the message
|
||||
* \param diValues Digital input channel values (8 channels per byte)
|
||||
* \param nrOfDoValues Number of digital output values inculded in the message
|
||||
* \param doValues Digital output channel values (8 channels per byte)
|
||||
*/
|
||||
void bpSendGiveElectronicStatus( int handle,
|
||||
UINT8 nrOfAdcValues,
|
||||
UINT16 *adcValues,
|
||||
UINT8 nrOfDacValues,
|
||||
UINT16 *dacValues,
|
||||
UINT8 nrOfDiValues,
|
||||
UINT8 *diValues,
|
||||
UINT8 nrOfDoValues,
|
||||
UINT8 *doValues
|
||||
)
|
||||
{
|
||||
t_bpmsg_message sendGiveElectronicStatusMessage;
|
||||
UINT8 *payload;
|
||||
UINT16 payloadSize;
|
||||
UINT8 payloadIndex = 0;
|
||||
UINT8 index;
|
||||
|
||||
// Determine payload size
|
||||
payloadSize = BPMSG_UINT8_SIZE;
|
||||
payloadSize += nrOfAdcValues * BPMSG_UINT16_SIZE;
|
||||
payloadSize += BPMSG_UINT8_SIZE;
|
||||
payloadSize += nrOfDacValues * BPMSG_UINT16_SIZE;
|
||||
payloadSize += BPMSG_UINT8_SIZE;
|
||||
payloadSize += nrOfDiValues * BPMSG_UINT8_SIZE;
|
||||
payloadSize += BPMSG_UINT8_SIZE;
|
||||
payloadSize += nrOfDoValues * BPMSG_UINT8_SIZE;
|
||||
|
||||
payload = (UINT8 *)Memmod_Alloc( bpMessagePool );
|
||||
if (payload == 0) return;
|
||||
|
||||
// Create new message
|
||||
sendGiveElectronicStatusMessage.uniqueStartByte = BPMSG_STARTBYTE;
|
||||
sendGiveElectronicStatusMessage.senderId = ((t_bp_admin *)handle)->deviceId;
|
||||
sendGiveElectronicStatusMessage.targetId = BPMSG_BROADCAST_ID;
|
||||
sendGiveElectronicStatusMessage.packetNr = 0; // packetNr filled at transmitting time
|
||||
sendGiveElectronicStatusMessage.status = 0; // Clear status (filled by ProtocolThread)
|
||||
sendGiveElectronicStatusMessage.messageId = BPMSG_MSGID_GIVEELECTRONICSTATUS;
|
||||
sendGiveElectronicStatusMessage.payloadSize = payloadSize;
|
||||
sendGiveElectronicStatusMessage.payload = payload;
|
||||
|
||||
// Fill Payload
|
||||
payload[payloadIndex] = nrOfAdcValues;
|
||||
payloadIndex += BPMSG_UINT8_SIZE;
|
||||
for (index = 0; index < nrOfAdcValues; index++)
|
||||
{
|
||||
bpmsgAdd16bit( &payload[payloadIndex], adcValues[index]);
|
||||
payloadIndex += BPMSG_UINT16_SIZE;
|
||||
}
|
||||
|
||||
payload[payloadIndex] = nrOfDacValues;
|
||||
payloadIndex += BPMSG_UINT8_SIZE;
|
||||
for (index = 0; index < nrOfDacValues; index++)
|
||||
{
|
||||
bpmsgAdd16bit( &payload[payloadIndex], dacValues[index]);
|
||||
payloadIndex += BPMSG_UINT16_SIZE;
|
||||
}
|
||||
|
||||
payload[payloadIndex] = nrOfDiValues;
|
||||
payloadIndex += BPMSG_UINT8_SIZE;
|
||||
for (index = 0; index < nrOfDiValues; index++)
|
||||
{
|
||||
payload[payloadIndex] = diValues[index];
|
||||
payloadIndex += BPMSG_UINT8_SIZE;
|
||||
}
|
||||
|
||||
payload[payloadIndex] = nrOfDoValues;
|
||||
payloadIndex += BPMSG_UINT8_SIZE;
|
||||
for (index = 0; index < nrOfDoValues; index++)
|
||||
{
|
||||
payload[payloadIndex] = doValues[index];
|
||||
payloadIndex += BPMSG_UINT8_SIZE;
|
||||
}
|
||||
|
||||
// Calculate CRC
|
||||
bpmsgEncodeMessage(&sendGiveElectronicStatusMessage);
|
||||
|
||||
bpthreadAddMessage(((t_bp_admin *)handle)->bpthreadHandle, &sendGiveElectronicStatusMessage);
|
||||
}
|
||||
|
||||
/** \brief Sends message to set a DAC on another bus device
|
||||
*
|
||||
* \param handle The handle for the BusProtocol (received with bpInit())
|
||||
* \param deviceId Identity of targeted bus device
|
||||
* \param channelNr Number of the DAC-channel
|
||||
* \param dacMode Voltage (0) / Ampere (<> 0)
|
||||
* \param davValue New DAC value (voltage: 0-10000mV, ampere: 0-20000uA)
|
||||
*/
|
||||
void bpSendSetDacValue( int handle, UINT8 deviceId, UINT8 channelNr, UINT8 dacMode, UINT16 dacValue )
|
||||
{
|
||||
t_bpmsg_message sendSetDacMessage;
|
||||
UINT8 *payload = (UINT8 *) Memmod_Alloc( bpMessagePool );
|
||||
if (payload == 0) return;
|
||||
|
||||
BP_DEBUG_OUT('a'); BP_DEBUG_OUT('>');
|
||||
|
||||
// Create new message
|
||||
sendSetDacMessage.uniqueStartByte = BPMSG_STARTBYTE;
|
||||
sendSetDacMessage.senderId = ((t_bp_admin *)handle)->deviceId;
|
||||
sendSetDacMessage.targetId = deviceId;
|
||||
sendSetDacMessage.packetNr = 0; // packetNr filled at transmitting time
|
||||
sendSetDacMessage.status = 0; // Clear status (filled by ProtocolThread)
|
||||
sendSetDacMessage.messageId = BPMSG_MSGID_SETDACVALUE;
|
||||
sendSetDacMessage.payloadSize = 4;
|
||||
sendSetDacMessage.payload = payload;
|
||||
|
||||
// Fill Payload
|
||||
payload[0] = channelNr;
|
||||
payload[1] = dacMode;
|
||||
bpmsgAdd16bit( &payload[2], dacValue);
|
||||
|
||||
// Calculate CRC
|
||||
bpmsgEncodeMessage(&sendSetDacMessage);
|
||||
|
||||
bpthreadAddMessage(((t_bp_admin *)handle)->bpthreadHandle, &sendSetDacMessage);
|
||||
}
|
||||
|
||||
/** \brief Sends message to set the values of all DAC's on another bus device
|
||||
*
|
||||
* \param handle The handle for the BusProtocol (received with bpInit())
|
||||
* \param deviceId Identity of targeted bus device
|
||||
* \param davValue pointer to array with 4 DAC value, i.e. DAC-value position 0 for Channel 0 etc... (voltage: 0-10000mV, ampere: 0-20000uA)
|
||||
*/
|
||||
void bpSendSetAllDacValues( int handle, UINT8 deviceId, UINT16 *dacValue )
|
||||
{
|
||||
t_bpmsg_message sendSetDacMessage;
|
||||
UINT8 *payload = (UINT8 *) Memmod_Alloc( bpMessagePool );
|
||||
if (payload == 0) return;
|
||||
|
||||
BP_DEBUG_OUT('a'); BP_DEBUG_OUT('>');
|
||||
|
||||
// Create new message
|
||||
sendSetDacMessage.uniqueStartByte = BPMSG_STARTBYTE;
|
||||
sendSetDacMessage.senderId = ((t_bp_admin *)handle)->deviceId;
|
||||
sendSetDacMessage.targetId = deviceId;
|
||||
sendSetDacMessage.packetNr = 0; // packetNr filled at transmitting time
|
||||
sendSetDacMessage.status = 0; // Clear status (filled by ProtocolThread)
|
||||
sendSetDacMessage.messageId = BPMSG_MSGID_SETALLDACVALUES;
|
||||
sendSetDacMessage.payloadSize = 4 * 2;
|
||||
sendSetDacMessage.payload = payload;
|
||||
|
||||
// Fill Payload
|
||||
bpmsgAdd16bit( &payload[0], dacValue[0]);
|
||||
bpmsgAdd16bit( &payload[2], dacValue[1]);
|
||||
bpmsgAdd16bit( &payload[4], dacValue[2]);
|
||||
bpmsgAdd16bit( &payload[6], dacValue[3]);
|
||||
|
||||
// Calculate CRC
|
||||
bpmsgEncodeMessage(&sendSetDacMessage);
|
||||
|
||||
bpthreadAddMessage(((t_bp_admin *)handle)->bpthreadHandle, &sendSetDacMessage);
|
||||
}
|
||||
|
||||
|
||||
/** \brief Sends message to set a digital out on another bus device
|
||||
*
|
||||
* \param handle The handle for the BusProtocol (received with bpInit())
|
||||
* \param bitNr Number of the digital output pin
|
||||
* \param value Low-level (0) or High-level (<> 0)
|
||||
*/
|
||||
void bpSendSetDigitalOutValue( int handle, UINT8 deviceId, UINT8 bitNr, UINT8 value )
|
||||
{
|
||||
t_bpmsg_message sendSetDoMessage;
|
||||
UINT8 *payload = (UINT8 *)Memmod_Alloc( bpMessagePool );
|
||||
if (payload == 0) return;
|
||||
|
||||
BP_DEBUG_OUT('d'); BP_DEBUG_OUT('>');
|
||||
|
||||
// Create new message
|
||||
sendSetDoMessage.uniqueStartByte = BPMSG_STARTBYTE;
|
||||
sendSetDoMessage.senderId = ((t_bp_admin *)handle)->deviceId;
|
||||
sendSetDoMessage.targetId = deviceId;
|
||||
sendSetDoMessage.packetNr = 0; // packetNr filled at transmitting time
|
||||
sendSetDoMessage.status = 0; // Clear status (filled by ProtocolThread)
|
||||
sendSetDoMessage.messageId = BPMSG_MSGID_SETDIGITALOUTVALUE;
|
||||
sendSetDoMessage.payloadSize = 2;
|
||||
sendSetDoMessage.payload = payload;
|
||||
|
||||
// Fill Payload
|
||||
payload[0] = bitNr;
|
||||
payload[1] = value;
|
||||
|
||||
// Calculate CRC
|
||||
bpmsgEncodeMessage(&sendSetDoMessage);
|
||||
|
||||
bpthreadAddMessage(((t_bp_admin *)handle)->bpthreadHandle, &sendSetDoMessage);
|
||||
}
|
||||
|
||||
/** \brief Sends message to set all digital out ports at once on another bus device
|
||||
*
|
||||
* \param handle The handle for the BusProtocol (received with bpInit())
|
||||
* \param deviceId The ID of the other bus device
|
||||
* \param bits All bitsNumber of the digital output pin
|
||||
*/
|
||||
void bpSendSetAllDigitalOut( int handle, UINT8 deviceId, UINT8 bits)
|
||||
{
|
||||
t_bpmsg_message sendSetDoMessage;
|
||||
UINT8 *payload = (UINT8 *)Memmod_Alloc( bpMessagePool );
|
||||
if (payload == 0) return;
|
||||
|
||||
BP_DEBUG_OUT('d'); BP_DEBUG_OUT('>');
|
||||
|
||||
// Create new message
|
||||
sendSetDoMessage.uniqueStartByte = BPMSG_STARTBYTE;
|
||||
sendSetDoMessage.senderId = ((t_bp_admin *)handle)->deviceId;
|
||||
sendSetDoMessage.targetId = deviceId;
|
||||
sendSetDoMessage.packetNr = 0; // packetNr filled at transmitting time
|
||||
sendSetDoMessage.status = 0; // Clear status (filled by ProtocolThread)
|
||||
sendSetDoMessage.messageId = BPMSG_MSGID_SETALLDIGITALOUT;
|
||||
sendSetDoMessage.payloadSize = 1;
|
||||
sendSetDoMessage.payload = payload;
|
||||
|
||||
// Fill Payload
|
||||
payload[0] = bits;
|
||||
|
||||
// Calculate CRC
|
||||
bpmsgEncodeMessage(&sendSetDoMessage);
|
||||
|
||||
bpthreadAddMessage(((t_bp_admin *)handle)->bpthreadHandle, &sendSetDoMessage);
|
||||
}
|
||||
|
||||
/** \brief Sends message to set all outputs (analogue & digital) on another bus device
|
||||
*
|
||||
* \param handle The handle for the BusProtocol (received with bpInit())
|
||||
* \param deviceId Identity of targeted bus device
|
||||
* \param bits All bitsNumber of the digital output pin
|
||||
* \param davValue pointer to array with 4 DAC value, i.e. DAC-value position 0 for Channel 0 etc... (voltage: 0-10000mV, ampere: 0-20000uA)
|
||||
*/
|
||||
void bpSendSetAllOutput( int handle, UINT8 deviceId, UINT8 bits, UINT16 *dacValue )
|
||||
{
|
||||
t_bpmsg_message sendSetAllOutpuntMessage;
|
||||
UINT8 *payload = (UINT8 *) Memmod_Alloc( bpMessagePool );
|
||||
if (payload == 0) return;
|
||||
|
||||
BP_DEBUG_OUT('a'); BP_DEBUG_OUT('o'); BP_DEBUG_OUT('>');
|
||||
|
||||
// Create new message
|
||||
sendSetAllOutpuntMessage.uniqueStartByte = BPMSG_STARTBYTE;
|
||||
sendSetAllOutpuntMessage.senderId = ((t_bp_admin *)handle)->deviceId;
|
||||
sendSetAllOutpuntMessage.targetId = deviceId;
|
||||
sendSetAllOutpuntMessage.packetNr = 0; // packetNr filled at transmitting time
|
||||
sendSetAllOutpuntMessage.status = 0; // Clear status (filled by ProtocolThread)
|
||||
sendSetAllOutpuntMessage.messageId = BPMSG_MSGID_SETALLDOUTPUT;
|
||||
sendSetAllOutpuntMessage.payloadSize = (4 * 2) + 1;
|
||||
sendSetAllOutpuntMessage.payload = payload;
|
||||
|
||||
// Fill Payload
|
||||
payload[0] = bits;
|
||||
bpmsgAdd16bit( &payload[1], dacValue[0]);
|
||||
bpmsgAdd16bit( &payload[3], dacValue[1]);
|
||||
bpmsgAdd16bit( &payload[5], dacValue[2]);
|
||||
bpmsgAdd16bit( &payload[7], dacValue[3]);
|
||||
|
||||
// Calculate CRC
|
||||
bpmsgEncodeMessage(&sendSetAllOutpuntMessage);
|
||||
|
||||
bpthreadAddMessage(((t_bp_admin *)handle)->bpthreadHandle, &sendSetAllOutpuntMessage);
|
||||
}
|
||||
|
||||
|
||||
/** \brief Sends message to call an Remote Procedure Call on an other bus device
|
||||
*
|
||||
* Request to execute a procedure on another device
|
||||
*
|
||||
* \param handle The handle for the BusProtocol (received with bpInit())
|
||||
* \param deviceId Identity of targeted bus device
|
||||
* \param functionId Identity of the RPC-function
|
||||
* \param nrOfParams Number of parameters for the RPC-function
|
||||
* \param params Pointer to an array of 32-bit integers
|
||||
*/
|
||||
void bpSendCallRpc( int handle, UINT8 deviceId, UINT8 functionId, UINT8 nrOfParams, INT32 *params )
|
||||
{
|
||||
t_bpmsg_message sendCallRpcMessage;
|
||||
UINT8 *payload;
|
||||
UINT8 payloadSize;
|
||||
UINT8 payloadIndex = 0;
|
||||
UINT8 index;
|
||||
|
||||
BP_DEBUG_OUT('c'); BP_DEBUG_OUT('>');
|
||||
|
||||
// Determine payload size
|
||||
payloadSize = 3 * BPMSG_UINT8_SIZE;
|
||||
payloadSize += nrOfParams * BPMSG_UINT32_SIZE;
|
||||
|
||||
payload = (UINT8 *)Memmod_Alloc( bpMessagePool );
|
||||
if (payload == 0) return;
|
||||
|
||||
// Create new message
|
||||
sendCallRpcMessage.uniqueStartByte = BPMSG_STARTBYTE;
|
||||
sendCallRpcMessage.senderId = ((t_bp_admin *)handle)->deviceId;
|
||||
sendCallRpcMessage.targetId = deviceId;
|
||||
sendCallRpcMessage.packetNr = 0; // packetNr filled at transmitting time
|
||||
sendCallRpcMessage.status = 0; // Clear status (filled by ProtocolThread)
|
||||
sendCallRpcMessage.messageId = BPMSG_MSGID_CALLRPC;
|
||||
sendCallRpcMessage.payloadSize = payloadSize;
|
||||
sendCallRpcMessage.payload = payload;
|
||||
|
||||
// Fill Payload
|
||||
payload[payloadIndex] = ((t_bp_admin *)handle)->rpcRequestNr;
|
||||
((t_bp_admin *)handle)->rpcRequestNr++;
|
||||
payloadIndex += BPMSG_UINT8_SIZE;
|
||||
|
||||
payload[payloadIndex] = functionId;
|
||||
payloadIndex += BPMSG_UINT8_SIZE;
|
||||
|
||||
payload[payloadIndex] = nrOfParams;
|
||||
payloadIndex += BPMSG_UINT8_SIZE;
|
||||
|
||||
for (index = 0; index < nrOfParams; index++)
|
||||
{
|
||||
bpmsgAdd32bit( payload + payloadIndex, (UINT32)params[index]);
|
||||
payloadIndex += BPMSG_UINT32_SIZE;
|
||||
}
|
||||
|
||||
|
||||
// Calculate CRC
|
||||
bpmsgEncodeMessage(&sendCallRpcMessage);
|
||||
|
||||
bpthreadAddMessage(((t_bp_admin *)handle)->bpthreadHandle, &sendCallRpcMessage);
|
||||
}
|
||||
|
||||
/** \brief Sends message to give result on issued RPC-function
|
||||
*
|
||||
* \param handle The handle for the BusProtocol (received with bpInit())
|
||||
* \param nrOfResults Number of results to be send
|
||||
* \param results Pointer to array with results.
|
||||
*/
|
||||
void bpSendRpcResult( int handle, UINT8 deviceId, UINT8 functionId, UINT8 requestNr, UINT8 nrOfResults, INT32 *results )
|
||||
{
|
||||
t_bpmsg_message sendCallRpcResultMessage;
|
||||
UINT8 *payload;
|
||||
UINT8 payloadSize;
|
||||
UINT8 payloadIndex = 0;
|
||||
UINT8 index;
|
||||
|
||||
BP_DEBUG_OUT('r'); BP_DEBUG_OUT('>');
|
||||
|
||||
// Determine payload size
|
||||
payloadSize = 3 * BPMSG_UINT8_SIZE;
|
||||
payloadSize += nrOfResults * BPMSG_UINT32_SIZE;
|
||||
|
||||
payload = (UINT8 *)Memmod_Alloc( bpMessagePool );
|
||||
if (payload == 0) return;
|
||||
|
||||
// Create new message
|
||||
sendCallRpcResultMessage.uniqueStartByte = BPMSG_STARTBYTE;
|
||||
sendCallRpcResultMessage.senderId = ((t_bp_admin *)handle)->deviceId;
|
||||
sendCallRpcResultMessage.targetId = deviceId;
|
||||
sendCallRpcResultMessage.packetNr = 0; // packetNr filled at transmitting time
|
||||
sendCallRpcResultMessage.status = 0; // Clear status (filled by ProtocolThread)
|
||||
sendCallRpcResultMessage.messageId = BPMSG_MSGID_GIVERPCRESULTS;
|
||||
sendCallRpcResultMessage.payloadSize = payloadSize;
|
||||
sendCallRpcResultMessage.payload = payload;
|
||||
|
||||
// Fill Payload
|
||||
payload[payloadIndex] = requestNr;
|
||||
payloadIndex += BPMSG_UINT8_SIZE;
|
||||
|
||||
payload[payloadIndex] = functionId;
|
||||
payloadIndex += BPMSG_UINT8_SIZE;
|
||||
|
||||
payload[payloadIndex] = nrOfResults;
|
||||
payloadIndex += BPMSG_UINT8_SIZE;
|
||||
|
||||
for (index = 0; index < nrOfResults; index++)
|
||||
{
|
||||
bpmsgAdd32bit( &payload[payloadIndex], (UINT32)results[index]);
|
||||
payloadIndex += BPMSG_UINT32_SIZE;
|
||||
}
|
||||
|
||||
// Calculate CRC
|
||||
bpmsgEncodeMessage(&sendCallRpcResultMessage);
|
||||
|
||||
bpthreadAddMessage(((t_bp_admin *)handle)->bpthreadHandle, &sendCallRpcResultMessage);
|
||||
}
|
||||
|
||||
|
||||
/** \brief Attachs a callback, which is called when it is the device its turn to send data on the bus
|
||||
*
|
||||
* \param handle The handle for the BusProtocol (received with bpInit())
|
||||
* \param onMyTurnCallback pointer to the callback function
|
||||
*/
|
||||
void bpAttachOnMyTurn( int handle, t_bp_myturn_callback onMyTurnCallback )
|
||||
{
|
||||
t_bp_admin *bpAdmin = (t_bp_admin *)handle;
|
||||
|
||||
bpthreadAttachMyTurn( bpAdmin->bpthreadHandle, onMyTurnCallback);
|
||||
}
|
||||
|
||||
/** \brief Detaches the above callback
|
||||
*
|
||||
* \param handle The handle for the BusProtocol (received with bpInit())
|
||||
* \param onMyTurnCallback pointer to the callback function
|
||||
*/
|
||||
void bpDetachOnMyTurn( int handle, t_bp_myturn_callback onMyTurnCallback )
|
||||
{
|
||||
t_bp_admin *bpAdmin = (t_bp_admin *)handle;
|
||||
|
||||
bpthreadDetachMyTurn( bpAdmin->bpthreadHandle, onMyTurnCallback);
|
||||
}
|
||||
|
||||
/** \brief Attachs a RPC-function, which can be called by another bus device
|
||||
*
|
||||
* \param handle The handle for the BusProtocol (received with bpInit())
|
||||
* \param functionId The identity of the RPC-function
|
||||
* \param functionPointer Pointer to actual RPC-function
|
||||
* \param nrOfParams Number of parameters, required by RPC
|
||||
*/
|
||||
void bpAttachRpc( int handle, UINT8 functionId, char * functionName, t_rpc_remote_procedure_call functionPointer, UINT8 nrOfParams )
|
||||
{
|
||||
t_bp_admin *bpAdmin = (t_bp_admin *)handle;
|
||||
|
||||
rpcAdd( bpAdmin->rpcHandle, functionId, functionName, functionPointer, nrOfParams);
|
||||
}
|
||||
|
||||
/** \brief Detaches the above RPC-function
|
||||
*
|
||||
* \post RPC-function is not supported anymore
|
||||
* \param handle The handle for the BusProtocol (received with bpInit())
|
||||
* \param functionId Identity of the detached RPC-function
|
||||
*/
|
||||
void bpDetachRpc( int handle, UINT8 functionId )
|
||||
{
|
||||
t_bp_admin *bpAdmin = (t_bp_admin *)handle;
|
||||
|
||||
rpcRemove( bpAdmin->rpcHandle, functionId );
|
||||
}
|
||||
|
||||
/** \brief Attachs a "RPC result"-function, which is a result of a requeste RPC-call on another bus device
|
||||
*
|
||||
* \param handle The handle for the BusProtocol (returned by bpInit())
|
||||
* \param functionId The functionId on which the result should be catched
|
||||
* \param functionPointer The funtion which must be called when a RPC-result is received.
|
||||
*/
|
||||
void bpAttachRpcResult( int handle, UINT8 functionId, t_bp_rpcresult_callback functionPointer, UINT8 nrOfResults )
|
||||
{
|
||||
t_bp_admin *bpAdmin = (t_bp_admin *)handle;
|
||||
|
||||
rpcrAdd( bpAdmin->rpcrHandle, functionId, functionPointer, nrOfResults);
|
||||
}
|
||||
|
||||
/** \brief Detaches the above "RPC result"-function
|
||||
*
|
||||
* \param handle The handle for the BusProtocol (returned by bpInit())
|
||||
* \param functionId The functionId on which the result should be catched
|
||||
*/
|
||||
void bpDetachRpcResult( int handle, UINT8 functionId )
|
||||
{
|
||||
t_bp_admin *bpAdmin = (t_bp_admin *)handle;
|
||||
|
||||
rpcrRemove( bpAdmin->rpcrHandle, functionId );
|
||||
}
|
||||
|
||||
|
||||
t_rpc_entity *bpLookupRpcEntry( int handle, UINT8 functionId )
|
||||
{
|
||||
t_bp_admin *bpAdmin = (t_bp_admin *)handle;
|
||||
|
||||
return rpcLookupEntry( bpAdmin->rpcHandle, functionId );
|
||||
}
|
||||
|
||||
void WriteElectricStatusCallback( int handle, BOOLEAN isDigital, UINT8 device, UINT8 channel, UINT16 value )
|
||||
{
|
||||
if (isDigital)
|
||||
{
|
||||
bpSendSetDigitalOutValue( handle, device, channel, (BOOLEAN)value ) ;
|
||||
}
|
||||
else
|
||||
{
|
||||
bpSendSetDacValue( handle, device, channel, 0, value );
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user