static void test_cmd52_read_write_single_byte(sdmmc_card_t* card)
{
esp_err_t err;
printf("Write bytes to slave's W0_REG using CMD52\n");
const size_t scratch_area_reg = SLCHOST_CONF_W0 - DR_REG_SLCHOST_BASE;
const uint8_t test_byte_1 = 0xa5;
const uint8_t test_byte_2 = 0xb6;
// used to check Read-After-Write
uint8_t test_byte_1_raw;
uint8_t test_byte_2_raw;
uint8_t val = 0;
err = sdmmc_io_write_byte(card, 1, scratch_area_reg, test_byte_1, &test_byte_1_raw);
TEST_ESP_OK(err);
TEST_ASSERT_EQUAL_UINT8(test_byte_1, test_byte_1_raw);
err = sdmmc_io_write_byte(card, 1, scratch_area_reg + 1, test_byte_2, &test_byte_2_raw);
TEST_ESP_OK(err);
TEST_ASSERT_EQUAL_UINT8(test_byte_2, test_byte_2_raw);
printf("Read back bytes using CMD52\n");
TEST_ESP_OK(sdmmc_io_read_byte(card, 1, scratch_area_reg, &val));
TEST_ASSERT_EQUAL_UINT8(test_byte_1, val);
TEST_ESP_OK(sdmmc_io_read_byte(card, 1, scratch_area_reg + 1, &val));
TEST_ASSERT_EQUAL_UINT8(test_byte_2, val);
}
void test_pixelArray_addPixel(void) {
pixelArray_initialize();
Pixel pixel = pixel_initialize(0,0,0);
pixelArray_addPixel(pixel);
TEST_ASSERT_EQUAL_UINT8(1, pixelArray_length());
pixelArray_addPixel(pixel);
TEST_ASSERT_EQUAL_UINT8(2, pixelArray_length());
}
/** \brief test function write single register
**
** this function test modbus master write single register
** with callback
**
**/
void test_ciaaModbus_masterCmd0x06WriteSingleRegister_01(void)
{
int32_t hModbusMaster;
uint8_t slaveIdRecv;
uint8_t pduRecv[256];
uint8_t pdu[256] =
{
0X06,
0x00,
0x01,
0X00,
0x03,
};
uint32_t sizeRecv;
/* open modbus master */
hModbusMaster = ciaaModbus_masterOpen();
/* request write single register */
ciaaModbus_masterCmd0x06WriteSingleRegister(
hModbusMaster,
0x0001,
0x0003,
SLAVE_ID,
modbusMaster_cbEndOfComm);
/* perform task modbus master */
ciaaModbus_masterTask(hModbusMaster);
/* receive pdu from master */
ciaaModbus_masterRecvMsg(
hModbusMaster,
&slaveIdRecv,
pduRecv,
&sizeRecv);
/* send message to master */
ciaaModbus_masterSendMsg(
hModbusMaster,
SLAVE_ID,
pdu,
5);
/* verify */
TEST_ASSERT_EQUAL_UINT8(SLAVE_ID, slaveIdRecv);
TEST_ASSERT_EQUAL_UINT8_ARRAY(pdu, pduRecv, 5);
TEST_ASSERT_EQUAL_UINT32(5, sizeRecv);
TEST_ASSERT_EQUAL_UINT8(SLAVE_ID, callBackData_slaveId);
TEST_ASSERT_EQUAL_UINT8(0x06, callBackData_numFunc);
TEST_ASSERT_EQUAL_UINT8(0x00, callBackData_exceptioncode);
}
void test_hal_gpib_put_data(void){
char data = 'x';
hal_gpib_put_data(data);
TEST_ASSERT_EQUAL_UINT8(~data, DIO_VAL);
TEST_ASSERT_EQUAL(0xFF, DIO_DIR);
TEST_ASSERT_EQUAL(0, PE_VAL);
TEST_ASSERT_EQUAL(1, TE_VAL);
}
TEST(checksum, calc_8bit)
{
uint8_t array[] = {
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x00
};
size_t len = sizeof(array) / sizeof(array[0]);
uint8_t expects = 0xF8; /* 0x7F8 */
TEST_ASSERT_EQUAL_UINT8( expects, checksum_calc_8bit(array, len) );
}
void test_WhenNullCharReturned_ThenZeroIsReturned(void)
{
INT8 result;
UINT8 data[10];
//TEST_IGNORE();
// Given
USBIF_GetChar_ExpectAndReturn(0);
// When
result = Ser_ReadLine(data, FALSE, 10);
// Then
TEST_ASSERT_EQUAL_UINT8(-1, result);
}
void test_WhenLineReturnReturned_ThenLineReturnReturned(void)
{
INT8 result;
UINT8 data[10];
//TEST_IGNORE();
// Given
USBIF_GetChar_ExpectAndReturn('\r');
// When
result = Ser_ReadLine(data, FALSE, 10);
// Then
TEST_ASSERT_EQUAL_UINT8(0, result);
TEST_ASSERT_EQUAL_STRING("", data);
}
TEST(fixed_memorypool, allocate)
{
uint8_t *p[BLOCK_COUNT];
size_t datasize, headersize;
int i, j;
s_handle = fixedmpool_create(s_pool, s_blocksize, s_blockcount);
TEST_ASSERT_NOT_NULL( s_handle );
datasize = fixedmpool_blockdata_size(s_handle);
headersize = s_blocksize - datasize;
for (i=0; i<(int)s_blockcount; i++) {
p[i] = fixedmpool_allocate(s_handle);
TEST_ASSERT_NOT_NULL( p[i] );
}
TEST_ASSERT_NULL( fixedmpool_allocate(s_handle) );
for (i=0; i<(int)s_blockcount; i++) {
for (j=i+1; j<(int)s_blockcount; j++) {
TEST_ASSERT_NOT_EQUAL( p[i], p[j] );
}
}
for (i=0; i<(int)s_blockcount; i++) {
uint8_t offset = (uint8_t)(i << 4);
for (j=0; j<(int)datasize; j++) {
p[i][j] = offset + (uint8_t)j;
}
}
for (i=0; i<(int)s_blockcount; i++) {
uint8_t offset = (uint8_t)(i << 4);
for (j=0; j<(int)datasize; j++) {
TEST_ASSERT_EQUAL_UINT8( offset + (uint8_t)j, s_pool[(s_blocksize*i) + (headersize+j)] );
}
}
}
void test_setOneByteIsCorrect(void)
{
setOneByte(address,1,43);
TEST_ASSERT_EQUAL_UINT8(43,getOneByte(address,1));
}
/** \brief test function write multiple coils
**
** this function test modbus master write multiple coils
** with callback
**
**/
void test_ciaaModbus_masterCmd0x0FWriteMultipleCoilss_01(void)
{
int32_t hModbusMaster;
uint8_t coilsValue[] =
{
0xCD,
0x01,
};
uint8_t slaveIdRecv;
uint8_t pduRecv[256];
uint8_t pduRecvExp[256] =
{
0x0F,
0x00,
0x13,
0x00,
0x0A,
0x02,
0xCD,
0x01,
};
uint8_t pduSend[256] =
{
0x0F,
0x00,
0x13,
0x00,
0x0A,
};
uint32_t sizeRecv;
uint32_t sizeRecvExp = 8;
/* open modbus master */
hModbusMaster = ciaaModbus_masterOpen();
/* request read holding register */
ciaaModbus_masterCmd0x0FWriteMultipleCoils(
hModbusMaster,
0X0013,
0X000A,
coilsValue,
SLAVE_ID,
modbusMaster_cbEndOfComm);
/* perform task modbus master */
ciaaModbus_masterTask(hModbusMaster);
/* receive pdu from master */
ciaaModbus_masterRecvMsg(
hModbusMaster,
&slaveIdRecv,
pduRecv,
&sizeRecv);
/* send message to master */
ciaaModbus_masterSendMsg(
hModbusMaster,
SLAVE_ID,
pduSend,
5);
/* verify */
TEST_ASSERT_EQUAL_UINT8(SLAVE_ID, slaveIdRecv);
TEST_ASSERT_EQUAL_UINT8_ARRAY(pduRecvExp, pduRecv, sizeRecvExp);
TEST_ASSERT_EQUAL_UINT32(sizeRecvExp, sizeRecv);
TEST_ASSERT_EQUAL_UINT8(SLAVE_ID, callBackData_slaveId);
TEST_ASSERT_EQUAL_UINT8(0x0F, callBackData_numFunc);
TEST_ASSERT_EQUAL_UINT8(0x00, callBackData_exceptioncode);
}
void test_setListIndex(void) {
msg.setListIndex(3);
TEST_ASSERT_EQUAL_UINT8(3, msg.getListIndex());
}
void test_getDataLength(void) {
TEST_ASSERT_EQUAL_UINT8(6, msg.getDataLength());
}
void test_constructors(void) {
msg = AddEncryptionIdToList(1, 0x12345678, 3);
TEST_ASSERT_EQUAL_UINT8(1, msg.getChannel());
TEST_ASSERT_EQUAL_UINT32(0x12345678, msg.getEncryptionId());
TEST_ASSERT_EQUAL_UINT8(3, msg.getListIndex());
}
void test_setChannel(void) {
msg.setChannel(3);
TEST_ASSERT_EQUAL_UINT8(3, msg.getChannel());
}
void test_pixelArray_length(void) {
pixelArray_initialize();
TEST_ASSERT_EQUAL_UINT8(0, pixelArray_length());
}
static void test_stream_to_dealer ()
{
int rc;
char my_endpoint[MAX_SOCKET_STRING];
// We'll be using this socket in raw mode
void *stream = test_context_socket (ZMQ_STREAM);
int zero = 0;
TEST_ASSERT_SUCCESS_ERRNO (
zmq_setsockopt (stream, ZMQ_LINGER, &zero, sizeof (zero)));
int enabled = 1;
TEST_ASSERT_SUCCESS_ERRNO (
zmq_setsockopt (stream, ZMQ_STREAM_NOTIFY, &enabled, sizeof (enabled)));
bind_loopback_ipv4 (stream, my_endpoint, sizeof my_endpoint);
// We'll be using this socket as the other peer
void *dealer = test_context_socket (ZMQ_DEALER);
TEST_ASSERT_SUCCESS_ERRNO (
zmq_setsockopt (dealer, ZMQ_LINGER, &zero, sizeof (zero)));
TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (dealer, my_endpoint));
// Send a message on the dealer socket
send_string_expect_success (dealer, "Hello", 0);
// Connecting sends a zero message
// First frame is routing id
zmq_msg_t routing_id;
TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_init (&routing_id));
TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&routing_id, stream, 0));
TEST_ASSERT_TRUE (zmq_msg_more (&routing_id));
// Verify the existence of Peer-Address metadata
char const *peer_address = zmq_msg_gets (&routing_id, "Peer-Address");
TEST_ASSERT_NOT_NULL (peer_address);
TEST_ASSERT_EQUAL_STRING ("127.0.0.1", peer_address);
// Second frame is zero
byte buffer[255];
TEST_ASSERT_EQUAL_INT (
0, TEST_ASSERT_SUCCESS_ERRNO (zmq_recv (stream, buffer, 255, 0)));
// Verify the existence of Peer-Address metadata
peer_address = zmq_msg_gets (&routing_id, "Peer-Address");
TEST_ASSERT_NOT_NULL (peer_address);
TEST_ASSERT_EQUAL_STRING ("127.0.0.1", peer_address);
// Real data follows
// First frame is routing id
TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&routing_id, stream, 0));
TEST_ASSERT_TRUE (zmq_msg_more (&routing_id));
// Verify the existence of Peer-Address metadata
peer_address = zmq_msg_gets (&routing_id, "Peer-Address");
TEST_ASSERT_NOT_NULL (peer_address);
TEST_ASSERT_EQUAL_STRING ("127.0.0.1", peer_address);
// Second frame is greeting signature
recv_array_expect_success (stream, greeting.signature, 0);
// Send our own protocol greeting
TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_send (&routing_id, stream, ZMQ_SNDMORE));
TEST_ASSERT_EQUAL_INT (
sizeof (greeting), TEST_ASSERT_SUCCESS_ERRNO (
zmq_send (stream, &greeting, sizeof (greeting), 0)));
// Now we expect the data from the DEALER socket
// We want the rest of greeting along with the Ready command
int bytes_read = 0;
while (bytes_read < 97) {
// First frame is the routing id of the connection (each time)
TEST_ASSERT_GREATER_THAN_INT (
0, TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&routing_id, stream, 0)));
TEST_ASSERT_TRUE (zmq_msg_more (&routing_id));
// Second frame contains the next chunk of data
TEST_ASSERT_SUCCESS_ERRNO (
rc = zmq_recv (stream, buffer + bytes_read, 255 - bytes_read, 0));
bytes_read += rc;
}
// First two bytes are major and minor version numbers.
TEST_ASSERT_EQUAL_INT (3, buffer[0]); // ZMTP/3.0
TEST_ASSERT_EQUAL_INT (0, buffer[1]);
// Mechanism is "NULL"
TEST_ASSERT_EQUAL_INT8_ARRAY (buffer + 2,
"NULL\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", 20);
TEST_ASSERT_EQUAL_INT8_ARRAY (buffer + 54, "\4\51\5READY", 8);
TEST_ASSERT_EQUAL_INT8_ARRAY (buffer + 62, "\13Socket-Type\0\0\0\6DEALER",
22);
TEST_ASSERT_EQUAL_INT8_ARRAY (buffer + 84, "\10Identity\0\0\0\0", 13);
// Announce we are ready
memcpy (buffer, "\4\51\5READY", 8);
memcpy (buffer + 8, "\13Socket-Type\0\0\0\6ROUTER", 22);
memcpy (buffer + 30, "\10Identity\0\0\0\0", 13);
// Send Ready command
TEST_ASSERT_GREATER_THAN_INT (0, TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_send (
&routing_id, stream, ZMQ_SNDMORE)));
TEST_ASSERT_EQUAL_INT (
43, TEST_ASSERT_SUCCESS_ERRNO (zmq_send (stream, buffer, 43, 0)));
// Now we expect the data from the DEALER socket
// First frame is, again, the routing id of the connection
TEST_ASSERT_GREATER_THAN_INT (
0, TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_recv (&routing_id, stream, 0)));
TEST_ASSERT_TRUE (zmq_msg_more (&routing_id));
// Third frame contains Hello message from DEALER
TEST_ASSERT_EQUAL_INT (7, TEST_ASSERT_SUCCESS_ERRNO (
zmq_recv (stream, buffer, sizeof buffer, 0)));
// Then we have a 5-byte message "Hello"
TEST_ASSERT_EQUAL_INT (0, buffer[0]); // Flags = 0
TEST_ASSERT_EQUAL_INT (5, buffer[1]); // Size = 5
TEST_ASSERT_EQUAL_INT8_ARRAY (buffer + 2, "Hello", 5);
// Send "World" back to DEALER
TEST_ASSERT_GREATER_THAN_INT (0, TEST_ASSERT_SUCCESS_ERRNO (zmq_msg_send (
&routing_id, stream, ZMQ_SNDMORE)));
byte world[] = {0, 5, 'W', 'o', 'r', 'l', 'd'};
TEST_ASSERT_EQUAL_INT (
sizeof (world),
TEST_ASSERT_SUCCESS_ERRNO (zmq_send (stream, world, sizeof (world), 0)));
// Expect response on DEALER socket
recv_string_expect_success (dealer, "World", 0);
// Test large messages over STREAM socket
#define size 64000
uint8_t msgout[size];
memset (msgout, 0xAB, size);
zmq_send (dealer, msgout, size, 0);
uint8_t msgin[9 + size];
memset (msgin, 0, 9 + size);
bytes_read = 0;
while (bytes_read < 9 + size) {
// Get routing id frame
TEST_ASSERT_GREATER_THAN_INT (
0, TEST_ASSERT_SUCCESS_ERRNO (zmq_recv (stream, buffer, 256, 0)));
// Get next chunk
TEST_ASSERT_GREATER_THAN_INT (
0,
TEST_ASSERT_SUCCESS_ERRNO (rc = zmq_recv (stream, msgin + bytes_read,
9 + size - bytes_read, 0)));
bytes_read += rc;
}
for (int byte_nbr = 0; byte_nbr < size; byte_nbr++) {
TEST_ASSERT_EQUAL_UINT8 (0xAB, msgin[9 + byte_nbr]);
}
test_context_socket_close (dealer);
test_context_socket_close (stream);
}
void test_pixelArray_nextByte(void) {
pixelArray_initialize();
pixelArray_addPixel(pixel_initialize(1,2,3));
pixelArray_addPixel(pixel_initialize(4,5,6));
TEST_ASSERT_EQUAL_UINT8(pixelArray_nextByte(), 1);
TEST_ASSERT_EQUAL_UINT8(pixelArray_nextByte(), 2);
TEST_ASSERT_EQUAL_UINT8(pixelArray_nextByte(), 3);
TEST_ASSERT_EQUAL_UINT8(pixelArray_nextByte(), 4);
TEST_ASSERT_EQUAL_UINT8(pixelArray_nextByte(), 5);
TEST_ASSERT_EQUAL_UINT8(pixelArray_nextByte(), 6);
TEST_ASSERT_EQUAL_UINT8(pixelArray_nextByte(), 1);
TEST_ASSERT_EQUAL_UINT8(pixelArray_nextByte(), 2);
TEST_ASSERT_EQUAL_UINT8(pixelArray_nextByte(), 3);
TEST_ASSERT_EQUAL_UINT8(pixelArray_nextByte(), 4);
TEST_ASSERT_EQUAL_UINT8(pixelArray_nextByte(), 5);
TEST_ASSERT_EQUAL_UINT8(pixelArray_nextByte(), 6);
}
/** \brief test function write multiple register
**
** this function test modbus master write multiple registers
** with callback
**
**/
void test_ciaaModbus_masterCmd0x10WriteMultipleRegisters_01(void)
{
int32_t hModbusMaster;
int16_t hrValue[CIAA_MODBUS_QUANTITY_OF_HOLD_REG] =
{
0x1234,
0x5678,
};
uint8_t slaveIdRecv;
uint8_t pduRecv[256];
uint8_t pduRecvExp[256] =
{
0X10,
(CIAA_MODBUS_STARTING_ADDRESS >> 8) & 0XFF,
(CIAA_MODBUS_STARTING_ADDRESS >> 0) & 0XFF,
(CIAA_MODBUS_QUANTITY_OF_HOLD_REG >> 8) & 0XFF,
(CIAA_MODBUS_QUANTITY_OF_HOLD_REG >> 0) & 0XFF,
CIAA_MODBUS_QUANTITY_OF_HOLD_REG * 2,
0x12,
0x34,
0x56,
0x78,
};
uint8_t pduSend[256] =
{
0X10,
(CIAA_MODBUS_STARTING_ADDRESS >> 8) & 0XFF,
(CIAA_MODBUS_STARTING_ADDRESS >> 0) & 0XFF,
(CIAA_MODBUS_QUANTITY_OF_HOLD_REG >> 8) & 0XFF,
(CIAA_MODBUS_QUANTITY_OF_HOLD_REG >> 0) & 0XFF,
};
uint32_t sizeRecv;
uint32_t sizeRecvExp = 10;
/* open modbus master */
hModbusMaster = ciaaModbus_masterOpen();
/* request read holding register */
ciaaModbus_masterCmd0x10WriteMultipleRegisters(
hModbusMaster,
CIAA_MODBUS_STARTING_ADDRESS,
CIAA_MODBUS_QUANTITY_OF_HOLD_REG,
hrValue,
SLAVE_ID,
modbusMaster_cbEndOfComm);
/* perform task modbus master */
ciaaModbus_masterTask(hModbusMaster);
/* receive pdu from master */
ciaaModbus_masterRecvMsg(
hModbusMaster,
&slaveIdRecv,
pduRecv,
&sizeRecv);
/* send message to master */
ciaaModbus_masterSendMsg(
hModbusMaster,
SLAVE_ID,
pduSend,
5);
/* verify */
TEST_ASSERT_EQUAL_UINT8(SLAVE_ID, slaveIdRecv);
TEST_ASSERT_EQUAL_UINT8_ARRAY(pduRecvExp, pduRecv, sizeRecvExp);
TEST_ASSERT_EQUAL_UINT32(sizeRecvExp, sizeRecv);
TEST_ASSERT_EQUAL_UINT16(0X1234, hrValue[0]);
TEST_ASSERT_EQUAL_UINT16(0X5678, hrValue[1]);
TEST_ASSERT_EQUAL_UINT8(SLAVE_ID, callBackData_slaveId);
TEST_ASSERT_EQUAL_UINT8(0x10, callBackData_numFunc);
TEST_ASSERT_EQUAL_UINT8(0x00, callBackData_exceptioncode);
}
/** \brief test function read write multiple register
**
** this function test modbus master read write multiple registers
** with callback
**
**/
void test_ciaaModbus_masterCmd0x17ReadWriteMultipleRegisters_01(void)
{
int32_t hModbusMaster;
int16_t hrValueR[128];
int16_t hrValueW[] =
{
0x1122,
0x3344,
0x5566,
};
uint8_t slaveIdRecv;
uint8_t pduRecv[256];
uint8_t pduRecvExp[256] =
{
0X17,
0X00,
0X03,
0X00,
0X06,
0X00,
0X0E,
0X00,
0X03,
0X06,
0X11,
0X22,
0X33,
0X44,
0X55,
0X66,
};
uint8_t pduSend[256] =
{
0X17,
0X0C,
0XFF,
0XEE,
0XDD,
0XCC,
0XBB,
0XAA,
0X99,
0X88,
0X77,
0X66,
0X55,
0X44,
};
uint32_t sizeRecv;
uint32_t sizeRecvExp = 16;
/* open modbus master */
hModbusMaster = ciaaModbus_masterOpen();
/* request read holding register */
ciaaModbus_masterCmd0x17ReadWriteMultipleRegisters(
hModbusMaster,
0X0003,
0X0006,
hrValueR,
0X000E,
0X0003,
hrValueW,
SLAVE_ID,
modbusMaster_cbEndOfComm);
/* perform task modbus master */
ciaaModbus_masterTask(hModbusMaster);
/* receive pdu from master */
ciaaModbus_masterRecvMsg(
hModbusMaster,
&slaveIdRecv,
pduRecv,
&sizeRecv);
/* send message to master */
ciaaModbus_masterSendMsg(
hModbusMaster,
SLAVE_ID,
pduSend,
14);
/* verify */
TEST_ASSERT_EQUAL_UINT8(SLAVE_ID, slaveIdRecv);
TEST_ASSERT_EQUAL_UINT8_ARRAY(pduRecvExp, pduRecv, sizeRecvExp);
TEST_ASSERT_EQUAL_UINT32(sizeRecvExp, sizeRecv);
TEST_ASSERT_EQUAL_UINT16(0XFFEE, hrValueR[0]);
TEST_ASSERT_EQUAL_UINT16(0XDDCC, hrValueR[1]);
TEST_ASSERT_EQUAL_UINT16(0XBBAA, hrValueR[2]);
TEST_ASSERT_EQUAL_UINT16(0X9988, hrValueR[3]);
TEST_ASSERT_EQUAL_UINT16(0X7766, hrValueR[4]);
TEST_ASSERT_EQUAL_UINT16(0X5544, hrValueR[5]);
TEST_ASSERT_EQUAL_UINT8(SLAVE_ID, callBackData_slaveId);
TEST_ASSERT_EQUAL_UINT8(0x17, callBackData_numFunc);
TEST_ASSERT_EQUAL_UINT8(0x00, callBackData_exceptioncode);
}
/** \brief test get Response timeout
**
** this function test get Response timeout
**
**/
void test_ciaaModbus_masterGetRespTimeout_01(void)
{
int32_t hModbusMaster;
uint32_t timeout;
/* open modbus master */
hModbusMaster = ciaaModbus_masterOpen();
timeout = ciaaModbus_masterGetRespTimeout(hModbusMaster);
/* default response timeout 300 ms */
TEST_ASSERT_EQUAL_UINT32(300,timeout);
}
void test_getOneByteIsCorrect(void)
{
i2c_setRegister(3,26);
TEST_ASSERT_EQUAL_UINT8(26,getOneByte(address,3));
}
/** \brief test function read discrete inputs
**
** this function test modbus master read discrete inputs
** with callback
**
**/
void test_ciaaModbus_masterCmd0x02ReadDiscreteInputs_01(void)
{
int32_t hModbusMaster;
uint8_t discreteInputsValue[256];
uint8_t slaveIdRecv;
uint8_t pduRecv[256];
uint8_t pduRecvExp[256] =
{
0X02,
0x12,
0x34,
0x00,
0x13,
};
uint8_t pduSend[256] =
{
0X02,
0x03,
0XCD,
0X6B,
0X05,
};
uint32_t sizeRecv;
uint32_t sizeRecvExp = 5;
/* open modbus master */
hModbusMaster = ciaaModbus_masterOpen();
/* request read holding register */
ciaaModbus_masterCmd0x02ReadDiscreteInputs(
hModbusMaster,
0X1234,
0X0013,
discreteInputsValue,
SLAVE_ID,
modbusMaster_cbEndOfComm);
/* perform task modbus master */
ciaaModbus_masterTask(hModbusMaster);
/* receive pdu from master */
ciaaModbus_masterRecvMsg(
hModbusMaster,
&slaveIdRecv,
pduRecv,
&sizeRecv);
/* send message to master */
ciaaModbus_masterSendMsg(
hModbusMaster,
SLAVE_ID,
pduSend,
5);
/* verify */
TEST_ASSERT_EQUAL_UINT8(SLAVE_ID, slaveIdRecv);
TEST_ASSERT_EQUAL_UINT8_ARRAY(pduRecvExp, pduRecv, 5);
TEST_ASSERT_EQUAL_UINT32(sizeRecvExp, sizeRecv);
TEST_ASSERT_EQUAL_UINT8(0XCD, discreteInputsValue[0]);
TEST_ASSERT_EQUAL_UINT16(0X6B, discreteInputsValue[1]);
TEST_ASSERT_EQUAL_UINT16(0X05, discreteInputsValue[2]);
TEST_ASSERT_EQUAL_UINT8(SLAVE_ID, callBackData_slaveId);
TEST_ASSERT_EQUAL_UINT8(0x02, callBackData_numFunc);
TEST_ASSERT_EQUAL_UINT8(0x00, callBackData_exceptioncode);
}
/** \brief test function read holding registers
**
** this function test modbus master read holding registers
** with callback
**
**/
void test_ciaaModbus_masterCmd0x03ReadHoldingRegisters_01(void)
{
int32_t hModbusMaster;
int16_t hrValue[CIAA_MODBUS_QUANTITY_OF_HOLD_REG];
uint8_t slaveIdRecv;
uint8_t pduRecv[256];
uint8_t pduRecvExp[256] =
{
0X03,
(CIAA_MODBUS_STARTING_ADDRESS >> 8) & 0XFF,
(CIAA_MODBUS_STARTING_ADDRESS >> 0) & 0XFF,
(CIAA_MODBUS_QUANTITY_OF_HOLD_REG >> 8) & 0XFF,
(CIAA_MODBUS_QUANTITY_OF_HOLD_REG >> 0) & 0XFF,
};
uint8_t pduSend[256] =
{
0X03,
CIAA_MODBUS_QUANTITY_OF_HOLD_REG * 2,
0XAA,
0X55,
0X11,
0X22,
};
uint32_t sizeRecv;
uint32_t sizeRecvExp = 5;
/* open modbus master */
hModbusMaster = ciaaModbus_masterOpen();
/* request read holding register */
ciaaModbus_masterCmd0x03ReadHoldingRegisters(
hModbusMaster,
CIAA_MODBUS_STARTING_ADDRESS,
CIAA_MODBUS_QUANTITY_OF_HOLD_REG,
hrValue,
SLAVE_ID,
modbusMaster_cbEndOfComm);
/* perform task modbus master */
ciaaModbus_masterTask(hModbusMaster);
/* receive pdu from master */
ciaaModbus_masterRecvMsg(
hModbusMaster,
&slaveIdRecv,
pduRecv,
&sizeRecv);
/* send message to master */
ciaaModbus_masterSendMsg(
hModbusMaster,
SLAVE_ID,
pduSend,
6);
/* verify */
TEST_ASSERT_EQUAL_UINT8(SLAVE_ID, slaveIdRecv);
TEST_ASSERT_EQUAL_UINT8_ARRAY(pduRecvExp, pduRecv, 5);
TEST_ASSERT_EQUAL_UINT32(sizeRecvExp, sizeRecv);
TEST_ASSERT_EQUAL_UINT16(0XAA55, hrValue[0]);
TEST_ASSERT_EQUAL_UINT16(0X1122, hrValue[1]);
TEST_ASSERT_EQUAL_UINT8(SLAVE_ID, callBackData_slaveId);
TEST_ASSERT_EQUAL_UINT8(0x03, callBackData_numFunc);
TEST_ASSERT_EQUAL_UINT8(0x00, callBackData_exceptioncode);
}
/** \brief test function read input registers
**
** this function test modbus master read input registers
** with callback
**
**/
void test_ciaaModbus_masterCmd0x04ReadInputRegisters_01(void)
{
int32_t hModbusMaster;
int16_t irValue[CIAA_MODBUS_QUANTITY_OF_INPUT_REG];
uint8_t slaveIdRecv;
uint8_t pduRecv[256];
uint8_t pduRecvExp[256] =
{
0X04,
(CIAA_MODBUS_STARTING_ADDRESS >> 8) & 0XFF,
(CIAA_MODBUS_STARTING_ADDRESS >> 0) & 0XFF,
(CIAA_MODBUS_QUANTITY_OF_INPUT_REG >> 8) & 0XFF,
(CIAA_MODBUS_QUANTITY_OF_INPUT_REG >> 0) & 0XFF,
};
uint8_t pduSend[256] =
{
0X04,
CIAA_MODBUS_QUANTITY_OF_INPUT_REG * 2,
0XAA,
0X55,
0X11,
0X22,
};
uint32_t sizeRecv;
uint32_t sizeRecvExp = 5;
/* open modbus master */
hModbusMaster = ciaaModbus_masterOpen();
/* request read holding register */
ciaaModbus_masterCmd0x04ReadInputRegisters(
hModbusMaster,
CIAA_MODBUS_STARTING_ADDRESS,
CIAA_MODBUS_QUANTITY_OF_INPUT_REG,
irValue,
SLAVE_ID,
modbusMaster_cbEndOfComm);
/* perform task modbus master */
ciaaModbus_masterTask(hModbusMaster);
/* receive pdu from master */
ciaaModbus_masterRecvMsg(
hModbusMaster,
&slaveIdRecv,
pduRecv,
&sizeRecv);
/* send message to master */
ciaaModbus_masterSendMsg(
hModbusMaster,
SLAVE_ID,
pduSend,
6);
/* verify */
TEST_ASSERT_EQUAL_UINT8(SLAVE_ID, slaveIdRecv);
TEST_ASSERT_EQUAL_UINT8_ARRAY(pduRecvExp, pduRecv, 5);
TEST_ASSERT_EQUAL_UINT32(sizeRecvExp, sizeRecv);
TEST_ASSERT_EQUAL_UINT16(0XAA55, irValue[0]);
TEST_ASSERT_EQUAL_UINT16(0X1122, irValue[1]);
TEST_ASSERT_EQUAL_UINT8(SLAVE_ID, callBackData_slaveId);
TEST_ASSERT_EQUAL_UINT8(0x04, callBackData_numFunc);
TEST_ASSERT_EQUAL_UINT8(0x00, callBackData_exceptioncode);
}
/** \brief test function write single coil
**
** this function test modbus master write single coil
** with callback
**
**/
void test_ciaaModbus_masterCmd0x05WriteSingleCoil_01(void)
{
int32_t hModbusMaster;
uint8_t slaveIdRecv;
uint8_t pduRecv[256];
uint8_t pdu[256] =
{
0X05,
0x00,
0xAC,
0XFF,
0x00,
};
uint32_t sizeRecv;
/* open modbus master */
hModbusMaster = ciaaModbus_masterOpen();
/* request read holding register */
ciaaModbus_masterCmd0x05WriteSingleCoil(
hModbusMaster,
0x00AC,
true,
SLAVE_ID,
modbusMaster_cbEndOfComm);
/* perform task modbus master */
ciaaModbus_masterTask(hModbusMaster);
/* receive pdu from master */
ciaaModbus_masterRecvMsg(
hModbusMaster,
&slaveIdRecv,
pduRecv,
&sizeRecv);
/* send message to master */
ciaaModbus_masterSendMsg(
hModbusMaster,
SLAVE_ID,
pdu,
5);
/* verify */
TEST_ASSERT_EQUAL_UINT8(SLAVE_ID, slaveIdRecv);
TEST_ASSERT_EQUAL_UINT8_ARRAY(pdu, pduRecv, 5);
TEST_ASSERT_EQUAL_UINT32(5, sizeRecv);
TEST_ASSERT_EQUAL_UINT8(SLAVE_ID, callBackData_slaveId);
TEST_ASSERT_EQUAL_UINT8(0x05, callBackData_numFunc);
TEST_ASSERT_EQUAL_UINT8(0x00, callBackData_exceptioncode);
}
