// process message "brightness"
void process_brightness(MessageTypeEnum messagetype)
{
// "Set" or "SetGet" -> modify dimmer state and abort any running animation
if ((messagetype == MESSAGETYPE_SET) || (messagetype == MESSAGETYPE_SETGET))
{
start_brightness = end_brightness = msg_dimmer_brightness_get_brightness();
UART_PUTF("Requested Brightness: %u%%;", start_brightness);
animation_length = 0;
animation_mode = 0;
animation_position = 0;
setPWMDutyCyclePercent(start_brightness);
/* TODO: Write to EEPROM (?)
// write back switch state to EEPROM
switch_state[i] = req_state;
switch_timeout[i] = req_timeout;
eeprom_write_word((uint16_t*)EEPROM_POS_SWITCH_STATE + i * 2, u16);
*/
}
// remember some values before the packet buffer is destroyed
uint32_t acksenderid = pkg_header_get_senderid();
uint32_t ackpacketcounter = pkg_header_get_packetcounter();
inc_packetcounter();
// "Set" -> send "Ack"
if (messagetype == MESSAGETYPE_SET)
{
pkg_header_init_dimmer_brightness_ack();
UART_PUTS("Sending Ack\r\n");
}
// "Get" or "SetGet" -> send "AckStatus"
else
{
pkg_header_init_dimmer_brightness_ackstatus();
// set message data
msg_dimmer_brightness_set_brightness(start_brightness);
UART_PUTS("Sending AckStatus\r\n");
}
// set common fields
pkg_header_set_senderid(device_id);
pkg_header_set_packetcounter(packetcounter);
pkg_headerext_common_set_acksenderid(acksenderid);
pkg_headerext_common_set_ackpacketcounter(ackpacketcounter);
pkg_headerext_common_set_error(false); // FIXME: Move code for the Ack to a function and also return an Ack when errors occur before!
pkg_header_calc_crc32();
rfm12_send_bufx();
}
// Show info about the received packets.
// This is only for debugging and only few messages are supported. The definition
// of all packets must be known at the PC program that's processing the data.
void decode_data(uint8_t len)
{
uint32_t u32, messagegroupid, messageid;
uint16_t u16;
pkg_header_adjust_offset();
uint16_t senderid = pkg_header_get_senderid();
uint32_t packetcounter = pkg_header_get_packetcounter();
MessageTypeEnum messagetype = pkg_header_get_messagetype();
UART_PUTF("Packet Data: SenderID=%u;", senderid);
UART_PUTF("PacketCounter=%lu;", packetcounter);
UART_PUTF("MessageType=%u;", messagetype);
// show ReceiverID for all requests
if ((messagetype == MESSAGETYPE_GET) || (messagetype == MESSAGETYPE_SET) || (messagetype == MESSAGETYPE_SETGET))
{
uint16_t receiverid = pkg_headerext_common_get_receiverid();
UART_PUTF("ReceiverID=%u;", receiverid);
}
uint16_t acksenderid = 65000;
uint32_t ackpacketcounter = 0;
// show AckSenderID, AckPacketCounter and Error for "Ack" and "AckStatus"
if ((messagetype == MESSAGETYPE_ACK) || (messagetype == MESSAGETYPE_ACKSTATUS))
{
acksenderid = pkg_headerext_common_get_acksenderid();
ackpacketcounter = pkg_headerext_common_get_ackpacketcounter();
uint8_t error = pkg_headerext_common_get_error();
UART_PUTF("AckSenderID=%u;", acksenderid);
UART_PUTF("AckPacketCounter=%lu;", ackpacketcounter);
UART_PUTF("Error=%u;", error);
}
// show MessageGroupID and MessageID for all MessageTypes except "Ack"
if (messagetype != MESSAGETYPE_ACK)
{
messagegroupid = pkg_headerext_common_get_messagegroupid();
messageid = pkg_headerext_common_get_messageid();
UART_PUTF("MessageGroupID=%u;", messagegroupid);
UART_PUTF("MessageID=%u;", messageid);
}
// show raw message data for all MessageTypes with data (= all except "Get" and "Ack")
if ((messagetype != MESSAGETYPE_GET) && (messagetype != MESSAGETYPE_ACK))
{
uint8_t i;
uint8_t start = __HEADEROFFSETBITS / 8;
uint8_t shift = __HEADEROFFSETBITS % 8;
uint16_t count = (((uint16_t)len * 8) - __HEADEROFFSETBITS + 7) / 8;
//UART_PUTF4("\r\n\r\nLEN=%u, START=%u, SHIFT=%u, COUNT=%u\r\n\r\n", len, start, shift, count);
UART_PUTS("MessageData=");
for (i = start; i < start + count; i++)
{
UART_PUTF("%02x", array_read_UIntValue8(i, shift, 8, 0, 255, bufx));
}
UART_PUTS(";");
// additionally decode the message data for a small number of messages
switch (messagegroupid)
{
case MESSAGEGROUP_GENERIC:
switch (messageid)
{
case MESSAGEID_GENERIC_VERSION:
UART_PUTF("Major=%u;", msg_generic_version_get_major());
UART_PUTF("Minor=%u;", msg_generic_version_get_minor());
UART_PUTF("Patch=%u;", msg_generic_version_get_patch());
UART_PUTF("Hash=%08lx;", msg_generic_version_get_hash());
break;
case MESSAGEID_GENERIC_BATTERYSTATUS:
UART_PUTF("Percentage=%u;", msg_generic_batterystatus_get_percentage());
break;
/*DateTime Status:
UART_PUTS("Command Name=DateTime Status;");
UART_PUTF3("Date=%u-%02u-%02u;", bufx[6] + 2000, bufx[7], bufx[8]);
UART_PUTF3("Time=%02u:%02u:%02u", bufx[9], bufx[10], bufx[11]);*/
default:
break;
}
break;
case MESSAGEGROUP_WEATHER:
switch (messageid)
{
case MESSAGEID_WEATHER_TEMPERATURE:
UART_PUTS("Temperature=");
print_signed(msg_weather_temperature_get_temperature());
UART_PUTS(";");
break;
case MESSAGEID_WEATHER_HUMIDITYTEMPERATURE:
u16 = msg_weather_humiditytemperature_get_humidity();
UART_PUTF2("Humidity=%u.%u;Temperature=", u16 / 10, u16 % 10);
print_signed(msg_weather_humiditytemperature_get_temperature());
UART_PUTS(";");
break;
case MESSAGEID_WEATHER_BAROMETRICPRESSURETEMPERATURE:
u32 = msg_weather_barometricpressuretemperature_get_barometricpressure();
UART_PUTF("Pressure=%ld;Temperature=", u32);
print_signed(msg_weather_barometricpressuretemperature_get_temperature());
UART_PUTS(";");
break;
default:
break;
}
break;
case MESSAGEGROUP_POWERSWITCH:
switch (messageid)
{
case MESSAGEID_POWERSWITCH_SWITCHSTATE:
UART_PUTF("On=%u;", msg_powerswitch_switchstate_get_on());
UART_PUTF("TimeoutSec=%u;", msg_powerswitch_switchstate_get_timeoutsec());
break;
default:
break;
}
break;
default:
break;
}
}
UART_PUTS("\r\n");
// Detect and process Acknowledges to base station, whose requests have to be removed from the request queue
if ((messagetype == MESSAGETYPE_ACK) || (messagetype == MESSAGETYPE_ACKSTATUS))
{
if (acksenderid == device_id) // request sent from base station
{
remove_request(senderid, device_id, ackpacketcounter);
}
}
}
void process_packet(uint8_t len)
{
pkg_header_adjust_offset();
UART_PUTS("Received: ");
print_bytearray(bufx, len);
// check SenderID
uint32_t senderID = pkg_header_get_senderid();
UART_PUTF("SenderID:%u;", senderID);
if (senderID != 0)
{
UART_PUTS("\r\nERR: Illegal SenderID.\r\n");
return;
}
// check PacketCounter
// TODO: Reject if packet counter lower than remembered!!
uint32_t packcnt = pkg_header_get_packetcounter();
UART_PUTF("PacketCounter:%lu;", packcnt);
if (0) // packcnt <= station_packetcounter ??
{
UART_PUTF("\r\nERR: Received PacketCounter < %lu.\r\n", station_packetcounter);
return;
}
// write received counter
station_packetcounter = packcnt;
e2p_dimmer_set_basestationpacketcounter(station_packetcounter);
// check MessageType
MessageTypeEnum messagetype = pkg_header_get_messagetype();
UART_PUTF("MessageType:%u;", messagetype);
if ((messagetype != MESSAGETYPE_GET) && (messagetype != MESSAGETYPE_SET) && (messagetype != MESSAGETYPE_SETGET))
{
UART_PUTS("\r\nERR: Unsupported MessageType.\r\n");
return;
}
// check device id
uint8_t rcv_id = pkg_headerext_common_get_receiverid();
UART_PUTF("ReceiverID:%u;", rcv_id);
if (rcv_id != device_id)
{
UART_PUTS("\r\nWRN: DeviceID does not match.\r\n");
return;
}
// check MessageGroup + MessageID
uint32_t messagegroupid = pkg_headerext_common_get_messagegroupid();
uint32_t messageid = pkg_headerext_common_get_messageid();
UART_PUTF("MessageGroupID:%u;", messagegroupid);
if (messagegroupid != MESSAGEGROUP_DIMMER)
{
UART_PUTS("\r\nERR: Unsupported MessageGroupID.\r\n");
return;
}
UART_PUTF("MessageID:%u;", messageid);
switch (messageid)
{
case MESSAGEID_DIMMER_BRIGHTNESS:
process_brightness(messagetype);
break;
case MESSAGEID_DIMMER_ANIMATION:
process_animation(messagetype);
break;
default:
UART_PUTS("\r\nERR: Unsupported MessageID.\r\n");
break;
}
}
