int MovingLightModel_GetLanguage(const RDMHeader *header,
UNUSED const uint8_t *param_data) {
uint8_t *ptr = g_rdm_buffer + sizeof(RDMHeader);
ptr += RDMUtil_StringCopy((char*) ptr, RDM_LANGUAGE_STRING_SIZE,
LANGUAGES[g_moving_light.language_index],
RDM_LANGUAGE_STRING_SIZE);
return RDMResponder_AddHeaderAndChecksum(header, ACK, ptr - g_rdm_buffer);
}
// PID Handlers
// ----------------------------------------------------------------------------
int MovingLightModel_GetLanguageCapabilities(const RDMHeader *header,
UNUSED const uint8_t *param_data) {
uint8_t *ptr = g_rdm_buffer + sizeof(RDMHeader);
unsigned int i = 0;
for (; i < NUMBER_OF_LANGUAGES; i++) {
ptr += RDMUtil_StringCopy((char*) ptr, RDM_LANGUAGE_STRING_SIZE,
LANGUAGES[i], RDM_LANGUAGE_STRING_SIZE);
}
return RDMResponder_AddHeaderAndChecksum(header, ACK, ptr - g_rdm_buffer);
}
int DimmerModel_GetStatusIdDescription(const RDMHeader *header,
UNUSED const uint8_t *param_data) {
const uint16_t status_id = ExtractUInt16(param_data);
if (status_id != STS_OLP_TESTING) {
return RDMResponder_BuildNack(header, NR_DATA_OUT_OF_RANGE);
}
uint8_t *ptr = g_rdm_buffer + sizeof(RDMHeader);
ptr += RDMUtil_StringCopy((char*) ptr, RDM_DEFAULT_STRING_SIZE,
STS_OLP_TESTING_DESCRIPTION,
RDM_DEFAULT_STRING_SIZE);
return RDMResponder_AddHeaderAndChecksum(header, ACK, ptr - g_rdm_buffer);
}
int DimmerModel_GetOutputResponseDescription(const RDMHeader *header,
UNUSED const uint8_t *param_data) {
const uint8_t setting = param_data[0];
if (setting == 0u || setting > NUMBER_OF_OUTPUT_RESPONSE_TIMES) {
return RDMResponder_BuildNack(header, NR_DATA_OUT_OF_RANGE);
}
uint8_t *ptr = g_rdm_buffer + sizeof(RDMHeader);
*ptr++ = setting;
ptr += RDMUtil_StringCopy((char*) ptr, RDM_DEFAULT_STRING_SIZE,
OUTPUT_RESPONSE_TIMES[setting - 1],
RDM_DEFAULT_STRING_SIZE);
return RDMResponder_AddHeaderAndChecksum(header, ACK, ptr - g_rdm_buffer);
}
int DimmerModel_GetCurveDescription(const RDMHeader *header,
UNUSED const uint8_t *param_data) {
const uint8_t curve = param_data[0];
if (curve == 0u || curve > NUMBER_OF_CURVES) {
return RDMResponder_BuildNack(header, NR_DATA_OUT_OF_RANGE);
}
uint8_t *ptr = g_rdm_buffer + sizeof(RDMHeader);
*ptr++ = curve;
ptr += RDMUtil_StringCopy((char*) ptr, RDM_DEFAULT_STRING_SIZE,
DIMMER_CURVES[curve - 1],
RDM_DEFAULT_STRING_SIZE);
return RDMResponder_AddHeaderAndChecksum(header, ACK, ptr - g_rdm_buffer);
}
int DimmerModel_GetLockStateDescription(const RDMHeader *header,
const uint8_t *param_data) {
const uint8_t lock_state = param_data[0];
if (lock_state == 0u || lock_state >= NUMBER_OF_LOCK_STATES) {
return RDMResponder_BuildNack(header, NR_DATA_OUT_OF_RANGE);
}
uint8_t *ptr = g_rdm_buffer + sizeof(RDMHeader);
*ptr++ = lock_state;
ptr += RDMUtil_StringCopy((char*) ptr, RDM_DEFAULT_STRING_SIZE,
LOCK_STATES[lock_state],
RDM_DEFAULT_STRING_SIZE);
return RDMResponder_AddHeaderAndChecksum(header, ACK, ptr - g_rdm_buffer);
}
int DimmerModel_GetSelfTestDescription(const RDMHeader *header,
UNUSED const uint8_t *param_data) {
const uint8_t self_test_id = param_data[0];
if (self_test_id == SELF_TEST_OFF || self_test_id > NUMBER_OF_SELF_TESTS) {
return RDMResponder_BuildNack(header, NR_DATA_OUT_OF_RANGE);
}
uint8_t *ptr = g_rdm_buffer + sizeof(RDMHeader);
*ptr++ = self_test_id;
ptr += RDMUtil_StringCopy((char*) ptr, RDM_DEFAULT_STRING_SIZE,
SELF_TESTS[self_test_id - 1].description,
RDM_DEFAULT_STRING_SIZE);
return RDMResponder_AddHeaderAndChecksum(header, ACK, ptr - g_rdm_buffer);
}
int DimmerModel_GetModulationFrequencyDescription(
const RDMHeader *header,
UNUSED const uint8_t *param_data) {
const uint8_t setting = param_data[0];
if (setting == 0u || setting > NUMBER_OF_MODULATION_FREQUENCIES) {
return RDMResponder_BuildNack(header, NR_DATA_OUT_OF_RANGE);
}
const ModulationFrequency *frequency = &MODULATION_FREQUENCY[setting - 1];
uint8_t *ptr = g_rdm_buffer + sizeof(RDMHeader);
*ptr++ = setting;
ptr = PushUInt32(ptr, frequency->frequency);
ptr += RDMUtil_StringCopy((char*) ptr, RDM_DEFAULT_STRING_SIZE,
frequency->description,
RDM_DEFAULT_STRING_SIZE);
return RDMResponder_AddHeaderAndChecksum(header, ACK, ptr - g_rdm_buffer);
}
TEST_F(RDMUtilTest, StringCopy) {
const unsigned int DEST_SIZE = 10;
char dest[DEST_SIZE];
const char short_string[] = "foobar";
// A non NULL terminated string, shorter than the dest.
memset(dest, 0xff, DEST_SIZE);
const char expected1[] = "foo\0\xff\xff\xff\xff\xff\xff";
EXPECT_EQ(3, RDMUtil_StringCopy(dest, DEST_SIZE, short_string, 3));
EXPECT_THAT(ArrayTuple(dest, DEST_SIZE), StringIs(expected1, DEST_SIZE));
// A NULL terminated string, shorter than the dest.
memset(dest, 0xff, DEST_SIZE);
const char expected2[] = "foobar\0\xff\xff\xff";
EXPECT_EQ(6, RDMUtil_StringCopy(dest, DEST_SIZE, short_string, 6));
EXPECT_THAT(ArrayTuple(dest, DEST_SIZE), StringIs(expected2, DEST_SIZE));
// A non-null terminated string, equal in size to DEST
memset(dest, 0xff, DEST_SIZE);
const char equal_string[] = "0123456789";
const char expected3[] = "0123456789";
EXPECT_EQ(DEST_SIZE, RDMUtil_StringCopy(dest, DEST_SIZE, equal_string,
strlen(equal_string)));
EXPECT_THAT(ArrayTuple(dest, DEST_SIZE), StringIs(expected3, DEST_SIZE));
// A null terminated string, equal in size to DEST
const char equal_with_null[] = "012345678";
memset(dest, 0xff, DEST_SIZE);
const char expected4[] = "012345678";
EXPECT_EQ(9, RDMUtil_StringCopy(dest, DEST_SIZE, equal_with_null,
arraysize(equal_with_null)));
EXPECT_THAT(ArrayTuple(dest, DEST_SIZE), StringIs(expected4, DEST_SIZE));
// A non-NULL terminated string, longer than dest
const char long_string[] = "this is a test";
memset(dest, 0xff, DEST_SIZE);
const char expected5[] = "this is a ";
EXPECT_EQ(DEST_SIZE,
RDMUtil_StringCopy(dest, DEST_SIZE, long_string,
strlen(long_string)));
EXPECT_THAT(ArrayTuple(dest, DEST_SIZE), StringIs(expected5, DEST_SIZE));
// A non-NULL terminated string, longer than dest
memset(dest, 0xff, DEST_SIZE);
EXPECT_EQ(DEST_SIZE,
RDMUtil_StringCopy(dest, DEST_SIZE, long_string,
arraysize(long_string)));
EXPECT_THAT(ArrayTuple(dest, DEST_SIZE), StringIs(expected5, DEST_SIZE));
}
