void canix_SFP_HMS_handler(const canix_frame *frame)
{
canix_frame answer;
answer.src = canix_selfaddr();
answer.dst = frame->src;
answer.proto = HCAN_PROTO_SFP;
answer.data[0] = HCAN_SRV_HMS;
switch (frame->data[1])
{
case HCAN_HMS_PING_REQUEST :
answer.data[1] = HCAN_HMS_PING_REPLAY;
answer.size = 2;
canix_frame_send(&answer);
break;
case HCAN_HMS_DEVICE_STATE_REQUEST :
answer.data[1] = HCAN_HMS_DEVICE_STATE_REPLAY;
answer.data[2] = HCAN_HMS_DEV_STATE_APPLICATION;
answer.size = 3;
canix_frame_send(&answer);
break;
case HCAN_HMS_DEVICE_RESET :
canix_reset();
break;
case HCAN_HMS_DEVICE_TYPE_REQUEST :
answer.data[1] = HCAN_HMS_DEVICE_TYPE_REPLAY;
#if defined (__AVR_ATmega8__)
answer.data[2] = 0;
#elif defined (__AVR_ATmega32__)
answer.data[2] = 1;
#elif defined (__AVR_ATmega644__)
answer.data[2] = 2;
#endif
answer.data[3] = eeprom_read_byte((uint8_t *)EEPR_BOARD_TYPE);
answer.size = 4;
canix_frame_send(&answer);
break;
case HCAN_HMS_INTERNAL_EEPROM_WRITE :
{
// only write to eeprom, if the value changed !
uint8_t read =
eeprom_read_byte((uint8_t *)(frame->data[2] |
(frame->data[3] << 8)));
if (read != frame->data[4])
eeprom_write_byte((uint8_t *)(frame->data[2] |
(frame->data[3] << 8)), frame->data[4]);
answer.data[1] = HCAN_HMS_INTERNAL_EEPROM_WRITE_ACK;
answer.size = 2;
canix_frame_send(&answer);
}
break;
case HCAN_HMS_INTERNAL_EEPROM_READ_REQUEST :
answer.data[1] = HCAN_HMS_INTERNAL_EEPROM_READ_REPLAY;
answer.data[2] = eeprom_read_byte((uint8_t *)(frame->data[2] |
(frame->data[3] << 8)));
answer.size = 3;
canix_frame_send(&answer);
break;
case HCAN_HMS_INTERNAL_EEPROM_READ_BULK_REQUEST :
{
uint16_t address;
address = frame->data[2] | (frame->data[3] << 8);
answer.data[1] = HCAN_HMS_INTERNAL_EEPROM_READ_BULK_REPLAY;
answer.data[2] = eeprom_read_byte((uint8_t*) (address + 0));
answer.data[3] = eeprom_read_byte((uint8_t*) (address + 1));
answer.data[4] = eeprom_read_byte((uint8_t*) (address + 2));
answer.data[5] = eeprom_read_byte((uint8_t*) (address + 3));
answer.data[6] = eeprom_read_byte((uint8_t*) (address + 4));
answer.data[7] = eeprom_read_byte((uint8_t*) (address + 5));
answer.size = 8;
canix_frame_send(&answer);
}
break;
case HCAN_HMS_UPTIME_QUERY :
answer.size = 6;
answer.data[1] = HCAN_HMS_UPTIME_REPLAY;
answer.data[2] = canix_rtc_clock.uptime_sec >> 24;
answer.data[3] = canix_rtc_clock.uptime_sec >> 16;
answer.data[4] = canix_rtc_clock.uptime_sec >> 8;
answer.data[5] = canix_rtc_clock.uptime_sec;
canix_frame_send(&answer);
break;
case HCAN_HMS_SYSLOG_LEVEL_SET :
#ifdef CANIX_SYSLOG
canix_set_syslog_level(frame->data[2]);
eeprom_write_byte((uint8_t *)EEPR_DEBUG_LEVEL, frame->data[2]);
#endif
break;
case HCAN_HMS_BUILD_VERSION_QUERY :
answer.data[1] = HCAN_HMS_BUILD_VERSION_REPLAY;
answer.data[2] =
#include <buildver>
>> 8;
answer.data[3] =
#include <buildver>
;
answer.size = 4;
canix_frame_send(&answer);
break;
case HCAN_HMS_CAN_EC_QUERY :
{
uint16_t ec = can_error_counters();
answer.data[1] = HCAN_HMS_CAN_EC_REPLAY;
answer.data[2] = ec >> 8;
answer.data[3] = ec;
answer.size = 4;
canix_frame_send(&answer);
}
break;
case HCAN_HMS_RX_RECEIVED_QUERY :
{
answer.data[1] = HCAN_HMS_RX_RECEIVED_REPLAY;
answer.data[2] = canix_rx_received >> 24;
answer.data[3] = canix_rx_received >> 16;
answer.data[4] = canix_rx_received >> 8;
answer.data[5] = canix_rx_received;
answer.size = 6;
canix_frame_send(&answer);
}
break;
case HCAN_HMS_RX_LOST_QUERY :
{
answer.data[1] = HCAN_HMS_RX_LOST_REPLAY;
answer.data[2] = canix_rx_lost >> 24;
answer.data[3] = canix_rx_lost >> 16;
answer.data[4] = canix_rx_lost >> 8;
answer.data[5] = canix_rx_lost;
answer.size = 6;
canix_frame_send(&answer);
}
break;
case HCAN_HMS_TX_SENT_QUERY :
{
answer.data[1] = HCAN_HMS_TX_SENT_REPLAY;
answer.data[2] = canix_tx_sent >> 24;
answer.data[3] = canix_tx_sent >> 16;
answer.data[4] = canix_tx_sent >> 8;
answer.data[5] = canix_tx_sent;
answer.size = 6;
canix_frame_send(&answer);
}
break;
case HCAN_HMS_TX_DROPPED_QUERY :
{
answer.data[1] = HCAN_HMS_TX_DROPPED_REPLAY;
answer.data[2] = canix_tx_dropped >> 24;
answer.data[3] = canix_tx_dropped >> 16;
answer.data[4] = canix_tx_dropped >> 8;
answer.data[5] = canix_tx_dropped;
answer.size = 6;
canix_frame_send(&answer);
}
break;
case HCAN_HMS_RX_TX_STATS_RESET :
{
canix_rx_received = 0;
canix_rx_lost = 0;
canix_tx_sent = 0;
canix_tx_dropped = 0;
}
break;
}
}
uint8_t canix_init(void)
{
uint8_t i;
uint8_t res;
// RTC init
canix_rtc_init();
// init callbacks
for (i = 0; i < MAX_FRAME_CALLBACKS; i++)
frame_callback_entry[i].callback = (canix_frame_callback) 0;
for (i = 0; i < MAX_IDLE_CALLBACKS; i++)
idle_callback[i] = (canix_idle_callback) 0;
for (i = 0; i < MAX_RTC_CALLBACKS; i++)
rtc_callback[i] = (canix_rtc_callback) 0;
#ifdef CANIX_LED_SETUP1
canix_led_init_ports();
#endif
#ifdef CANIX_LED_SETUP2
canix_led_init_ports();
#endif
// Eingangsbuffer leeren
for (i = 0; i < CANIX_QUEUE_SIZE; i++)
canix_rx_queue[i].used = 0;
spi_init();
res = can_open_interface();
#ifdef CANIX_HMS
// HMS Stuff
canix_reg_frame_callback(canix_SFP_HMS_handler, canix_selfaddr(),
HCAN_PROTO_SFP, HCAN_SRV_HMS);
canix_reg_frame_callback(canix_SFP_HMS_handler, HCAN_MULTICAST_INFO,
HCAN_PROTO_SFP, HCAN_SRV_HMS);
#endif
#ifdef CANIX_RTS
// RTS Stuff (Real Time Service, just passive receiving)
canix_reg_frame_callback(canix_SFP_RTS_handler, HCAN_MULTICAST_INFO,
HCAN_PROTO_SFP, HCAN_SRV_RTS);
canix_reg_frame_callback(canix_SFP_RTS_handler, canix_selfaddr(),
HCAN_PROTO_SFP, HCAN_SRV_RTS);
#endif
#ifdef CANIX_SYSLOG
// enable syslog debug messages
canix_set_syslog_level(eeprom_read_byte((uint8_t *)EEPR_DEBUG_LEVEL));
#endif
sei();
#ifdef CANIX_EDS
eds_init();
canix_reg_frame_callback(eds_can_callback, canix_selfaddr(),
HCAN_PROTO_SFP, HCAN_SRV_EDS);
#endif
return res;
}
