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); }