Revert "PortalControl: Implement (un)lock retry, if the door sensor state does not change."

Commit included ATMegaCard changes not meant for production.

This reverts commit a30c7068.

ATMegaCard/ISO7816-card.c

@@ -3,16 +3,6 @@
 #include <util/delay.h>
 #include <string.h>
 
-#define BAUD (F_CPU/372)
-#define USART_NAME UART
-#define PARITY EVEN
-#define STOPBITS 2
-#include "../common/serial.h"
-#define UART_recv_init UART_switch_mode_receive
-#define UART_transmit_init UART_switch_mode_transmit
-#define UART_receive_char_timeout UART_read_char_timeout
-#define UART_ERR_TIMEOUT ERR_TIMEOUT
-
 //ATMega Card
 //ATR: 3B8F014156522049534F3738313620302E31B9
 //Query: 00C101FE3E00000267016400C101FE3E00000267016400C101FE3E000002670164
@@ -42,9 +32,20 @@ uint16_t ISO7816_receive_buffer(uint8_t* buffer, uint8_t length);
 uint8_t  ISO7816_transmit_buffer(uint8_t* buffer, uint8_t length);
 uint8_t  ISO7816_transmit_t1_header(ISO7816_T1_Header* t1_header);
 
+void ISO7816_init(void){
+	UART_init();
+}
+/*
+void ISO7816_sendATR(void){
+	UART_transmit_init();
+	for (uint8_t i = 0; i < sizeof(atr); i++){
+		UART_transmit_char(atr[i]);
+	}
+	UART_recv_init();
+}*/
+
 void ISO7816_sendATR(void){
 	uint8_t checksum = 0;
-	UART_init();
 	UART_transmit_init();
 	UART_transmit_char(atr.initial_char);
 	checksum ^= atr.t0; UART_transmit_char(atr.t0);

ATMegaCard/ISO7816-card.h

 #pragma once
 
+#include "software_serial.h"
 #include "../common/ISO7816-common.h"
 
 #define ISO7816_APDU_READ_TIMEOUT 3000 //300ms

ATMegaCard/Makefile

@@ -31,7 +31,7 @@
 
 # MCU name
 
-MCU = atmega16
+MCU = atmega163
 
 
 
@@ -41,13 +41,6 @@ ifeq ($(MCU), atmega163)
 	HEX_FILE_NAME = MEGA163
 endif
 
-#Fuse settings for ATmega16
-ifeq ($(MCU), atmega16)
-	#4Mhz internal, BOD, Quick Startup
-	FUSE_BITS = -u -U lfuse:w:0x83:m -U hfuse:w:0xd1:m
-	HEX_FILE_NAME = MEGA16
-endif
-
 # Output format. (can be srec, ihex, binary)
 FORMAT = ihex
 

ATMegaCard/common.h

-//#define F_CPU 3579500
-#define F_CPU 4000000
\ No newline at end of file
+#define F_CPU 3579500
\ No newline at end of file

ATMegaCard/main.c

 #include "common.h"
 #include <avr/io.h>
 #include <util/delay.h>
-#include <avr/interrupt.h>
 #include <string.h>
 #include "rng.h"
 
@@ -22,6 +21,8 @@ uint16_t main_handle_adpu(ISO7816_APDU_Header* header,
 uint8_t current_application = 0xFF;
 
 int main(void){
+	//DDRB = (1 << 5) | (1 << 7);
+// 	ISO7816_init();
 	ISO7816_set_apdu_handler(main_handle_adpu);
 	ISO7816_sendATR();
 	sei();

ATMegaCard/rng.c

@@ -3,10 +3,6 @@
 
 #define ADC_RNG_CHANNEL 0
 
-#ifndef ADCSR
-	#define ADCSR ADCSRA
-#endif
-
 uint16_t seed;
 
 uint8_t rnd_adc_read(void);

ATMegaCard/software_serial.c

@@ -11,23 +11,21 @@
 #endif
 
 
-void SoftUART_recv_init(void);
-	
 /**
  * Initializes the Software UART
  */
-void SoftUART_init(void){
+void UART_init(void){
 	#ifdef UART_USE_AS_STDOUT
 		stdout = &UART_stdout; //assign serial output stream as stdout.
 	#endif
 	
-	SoftUART_recv_init();
+	UART_recv_init();
 }
 
 /**
  * Switches the UART to transmit mode
  */
-void SoftUART_transmit_init(void){
+void UART_transmit_init(void){
 	cli(); //interrupts disable (messes up send timings otherwise)
 	SWSERIAL_PORT |= (1 << SWSERIAL_LINE); //data line to high level (otherwise we might trigger a start bit)
 	SWSERIAL_PORT_DR |= (1 << SWSERIAL_LINE); //output
@@ -37,9 +35,9 @@ void SoftUART_transmit_init(void){
  * Sends a 0-terminated string
  * Note: The caller must to switch to transmit mode before calling this
  */
-void SoftUART_transmit_buffer_sz(char* buffer){
+void UART_transmit_buffer_sz(char* buffer){
 	while (buffer[0] != 0){
-		SoftUART_transmit_char(buffer[0]);
+		UART_transmit_char(buffer[0]);
 		buffer++;
 	}
 }
@@ -48,13 +46,13 @@ void SoftUART_transmit_buffer_sz(char* buffer){
  * Sends a byte coverted to hex digits
  * Note: The caller must to switch to transmit mode before calling this
  */
-void SoftUART_transmit_byte_hex(unsigned char b){
+void UART_transmit_byte_hex(unsigned char b){
 
 	unsigned char n;
 	n = '0' + (b >> 4 & 0xF);
-	SoftUART_transmit_char((n > '9') ? n + 7 : n);
+	UART_transmit_char((n > '9') ? n + 7 : n);
 	n = '0' + (b & 0xF);
-	SoftUART_transmit_char((n > '9') ? n + 7 : n);
+	UART_transmit_char((n > '9') ? n + 7 : n);
 }
 
 
@@ -62,7 +60,7 @@ void SoftUART_transmit_byte_hex(unsigned char b){
  * Writes a single character to the data line, bit-by-bit
  * Note: The caller must to switch to transmit mode before calling this
  */
-void SoftUART_transmit_char(unsigned char x){
+void UART_transmit_char(unsigned char x){
 
 	_delay_us(BIT_LENGTH); //guard time beween bytes
 	
@@ -113,7 +111,7 @@ volatile uint8_t recv_valid = 0;    //Did we receive 1 for the stop bits and val
 /**
  * Switch UART into receive mode
  */
-void SoftUART_recv_init(void){
+void UART_recv_init(void){
 	SWSERIAL_PORT_DR &= ~(1 << SWSERIAL_LINE); //set Serial pin to input
 	SWSERIAL_PORT |= (1 << SWSERIAL_LINE); //pullup
 	
@@ -122,15 +120,15 @@ void SoftUART_recv_init(void){
 	TIFR = (1 << ICF1); //clear old interrupt flag.
 	TIMSK = 1 << TICIE1; //enable ICP interrupt, disable timer compare interrupt
 	TCCR1B =  (1 << CS10)   //Timer prescaler = 1
-#ifdef CTC1
+// #ifdef CTC1
 			| (1 << CTC1)   //Clear timer on compare match (important for exact timing, don't do it in software)
-#else
-			| (1 << WGM12)
-#endif
+// #else
+// 			| (1 << WGM12)
+// #endif
 			| (1 << ICNC1) //Capture interrupt noise canceler enable (filters out very short spikes  < 4 clks)
-#ifdef ICES1
-			| (1 << ICES1)
-#endif
+// #ifdef ICES1
+// 			| (1 << ICES1)
+// #endif
 			;
 	
 	OCR1A  = 372; //Default smartcard conversion factor 3571200Hz/372(clks/bit) = 9600bit/s
@@ -141,30 +139,30 @@ void SoftUART_recv_init(void){
 /**
  * Is a byte available to be processed?
  */
-inline uint8_t SoftUART_data_available(void){
+inline uint8_t UART_data_available(void){
 	return recv_avail != 0;
 }
 /**
  * Reads the last byte that was received.
  * Resets the availability flag.
  */
-uint8_t SoftUART_read_char(void){
+uint8_t UART_read_char(void){
 	recv_avail = 0;
 	return recv_buffer2;
 }
 
-uint16_t SoftUART_receive_char_timeout(uint16_t timeout){
+uint16_t UART_receive_char_timeout(uint16_t timeout){
 	while ((timeout > 0) && (recv_avail == 0)) {_delay_us(100); timeout--;}
 	if (recv_avail == 0) return UART_ERR_TIMEOUT;
 	
-	return SoftUART_read_char();
+	return UART_read_char();
 }
 
 /**
  * Enables the timer (interrupt) that samples the data line to receive the bits.
  * Disables the Capture (ICP) interrupt that triggered on the start bit.
  */
-void SoftUART_start_read(void){
+void UART_start_read(void){
 	recv_bits = 0;
 	
 	#if SWSERIAL_PARITY == EVEN
@@ -185,7 +183,7 @@ void SoftUART_start_read(void){
  */
 ISR(TIMER1_CAPT_vect){
 	PORTB |= (1 << 5); //Debug
-	SoftUART_start_read();
+	UART_start_read();
 	PORTB &= ~(1 << 5); //Debug
 }
 
@@ -217,7 +215,7 @@ ISR(TIMER1_COMPA_vect){
 			recv_avail = 1;
 		}
 		recv_bits = 0;
-		SoftUART_recv_init();
+		UART_recv_init();
 	}
 	PORTB &= ~(1 << 7); //Debug
 }

ATMegaCard/software_serial.h

@@ -41,18 +41,18 @@
 
 #define INST_LENGTH(count) ((1000000*count)/F_CPU)  //(µSec) Duration of count CPU Instructions
 
-void SoftUART_transmit_char(unsigned char data);
+void UART_transmit_char(unsigned char data);
 
-void SoftUARTtransmit_buffer_sz(char* buffer);
-void SoftUARTtransmit_byte_hex(unsigned char b);
+void UART_transmit_buffer_sz(char* buffer);
+void UART_transmit_byte_hex(unsigned char b);
 
-void SoftUARTinit(void);
+void UART_init(void);
 
-void SoftUARTtransmit_init(void);
-void SoftUARTrecv_init(void);
+void UART_transmit_init(void);
+void UART_recv_init(void);
 
-void SoftUARTtransmit_char(unsigned char x);
+void UART_transmit_char(unsigned char x);
 
-uint8_t SoftUARTdata_available(void);
-uint8_t SoftUARTread_char(void);
-uint16_t SoftUARTreceive_char_timeout(uint16_t timeout);
\ No newline at end of file
+uint8_t UART_data_available(void);
+uint8_t UART_read_char(void);
+uint16_t UART_receive_char_timeout(uint16_t timeout);
\ No newline at end of file

Control/cardreader_interface.c

@@ -32,7 +32,8 @@
  *    Card -> Host:   other ISO7816 status code (-> abort)
 **/
 
-void cardreader_process_message(void);
+
+void unlock(void);
 uint8_t check_card_status(uint8_t* msg_buffer, uint8_t length, uint8_t expected_body_length);
 void cardreader_select_auth_applet(void);
 uint8_t cardreader_select_auth_applet_result(uint8_t* msg_buffer, uint8_t length);
@@ -58,11 +59,11 @@ uint8_t cardreader_sys_get_card_status(void);
 static uint8_t cardreader_power_state = CARDREADER_POWER_STATE_OFF;
 static volatile uint8_t cardreader_startup_event = 0;
 
-#define AUTH_STATE_NONE 1                   //System idle
-#define AUTH_STATE_CARD_INSERTED 2          //Card has been inserted into th reader, auth will be started.
-#define AUTH_STATE_SELECTING_AUTH_APPLET 3  //APDU to select the portal auth application has been sent.
-#define AUTH_STATE_AUTH_REQUESTED_SENT 4    //Authorisation challange has been sent.
-#define AUTH_STATE_AUTH_VERYFIED 5          //Authorisation key has been verified, new key has been sent.
+#define AUTH_STATE_NONE 1
+#define AUTH_STATE_CARD_INSERTED 2
+#define AUTH_STATE_SELECTING_AUTH_APPLET 3
+#define AUTH_STATE_AUTH_REQUESTED_SENT 4
+#define AUTH_STATE_AUTH_VERYFIED 5
 
 volatile uint8_t auth_state = AUTH_STATE_NONE;
 volatile uint16_t state_timeout;
@@ -144,10 +145,8 @@ void cardreader_process(void){
 		return;
 	}
 	
-	if (transport_data_available()) cardreader_process_message();
-}
-
-void cardreader_process_message(void){
+	if (!transport_data_available()) return;
+	
 	uint8_t msg_buffer[100];
 	
 	uint16_t ret = transport_receive_message(msg_buffer, 100, 400);
@@ -338,13 +337,11 @@ uint8_t cardreader_update_key_result(uint8_t* msg_buffer, uint8_t length){
 // 	cardreader_display_show_result(1);
 	
 	cardreader_display_clear();
-// 	if (
-	toggle_lock_unlock(cardreader_display_write_sz_P);
-// 		){
+	if (toggle_lock_unlock(cardreader_display_write_sz_P)){
 // 		cardreader_display_write_sz_P(PSTR("Auth Successful"));
-// 		cardreader_display_move(0,1);
-// 		cardreader_display_write_sz_P(PSTR("Remove Card"));
-// 	}
+		cardreader_display_move(0,1);
+		cardreader_display_write_sz_P(PSTR("Remove Card"));
+	}
 	
 	keystore_update_salt();
 	
@@ -451,6 +448,7 @@ void cardreader_display_show_result(uint8_t success){
 	}
 }
 
+
 void cardreader_display_set_backlight(uint8_t on){
 	cardreader_display_message_t msg = {CARDREADER_MSG_TYPE_DISPALY};
 	msg.command = CARDREADER_DISPLAY_MSG_SET_BACKLIGHT;
@@ -459,18 +457,4 @@ void cardreader_display_set_backlight(uint8_t on){
 	
 	uint8_t success;
 	transport_receive_message(&success, 1, 3000);
-}
-
-void cardreader_display_show_door_retry(void){
-	cardreader_display_move(10,0);
-	cardreader_display_write_sz_P(PSTR("Retry"));
-}
-
-void cardreader_display_show_door_result(uint8_t success){
-	cardreader_display_move(0,1);
-	if (success) {
-		cardreader_display_write_sz_P(PSTR("OK, remove card "));
-	} else {
-		cardreader_display_write_sz_P(PSTR("Mechanical Fail!"));
-	}
 }
\ No newline at end of file

Control/cardreader_interface.h

@@ -23,7 +23,4 @@ void cardreader_process(void);
 void cardreader_tick(void);
 
 uint8_t cardreader_init_card_key(KEY key);
-uint8_t cardreader_clear_card_key(void);
-
-void cardreader_display_show_door_retry(void);
-void cardreader_display_show_door_result(uint8_t success);
\ No newline at end of file
+uint8_t cardreader_clear_card_key(void);
\ No newline at end of file

Control/door.c

 #include "door.h"
 #include "log.h"
-#include "cardreader_interface.h" //for (un)lock messages
 
 uint8_t door_read_pin_status(void);
 uint8_t door_update_status(uint8_t sensor_status);
@@ -21,21 +20,17 @@ const char* const status_names[] PROGMEM = {status_unlocked,
                                             status_unlocking,
                                             status_locking};
 
-uint8_t door_status;
+volatile uint8_t door_status;
 
-uint8_t sensor_candidate_status;
-uint8_t sensor_stability;
+volatile uint8_t sensor_candidate_status;
+volatile uint8_t sensor_stability;
 #define DOOR_PIN_NEEDED_STABILITY 4
 
-#define DOOR_COMMAND_PULSE_TIME 45 //450ms
-uint8_t door_command_pulse_time = 0;
-
-#define DOOR_COMMAND_WAIT_TIMEOUT 900 //9s
-uint16_t door_command_wait_timeout = 0;
-
-uint8_t door_command_retry_count = 0;
-#define DOOR_COMMAND_MAX_RETRY 1
+#define DOOR_COMMAND_PULSE_TIME 35 //350ms
+volatile uint8_t door_command_pulse_time = 0;
 
+#define DOOR_COMMAND_WAIT_TIMEOUT 1000 //10s
+volatile uint16_t door_command_wait_timeout = 0;
 
 void door_init(void){
 	DOOR_PORT &= ~(COMMAND_UNLOCK_PIN | COMMAND_LOCK_PIN); //commnd pins off
@@ -57,9 +52,7 @@ void door_init(void){
 void door_tick(void){
 	if (door_command_pulse_time != 0) {
 		door_command_pulse_time--;
-		if (door_command_pulse_time == 0) {
-			DOOR_PORT &= (uint8_t)~(COMMAND_LOCK_PIN|COMMAND_UNLOCK_PIN);
-		}
+		if (door_command_pulse_time == 0) DOOR_PORT &= (uint8_t)~(COMMAND_LOCK_PIN|COMMAND_UNLOCK_PIN);
 	}
 	
 	if (   ((door_status & DOOR_STATUS_UNLOCKING) && !(door_status & DOOR_STATUS_UNLOCKED))
@@ -67,30 +60,12 @@ void door_tick(void){
 		door_command_wait_timeout--;
 		if (door_command_wait_timeout == 0){
 			
+			printf_P(PSTR("Error: Door command timeout\n"));
 			log_append(LOG_EVENT_DOOR_COMMAND_TIMEOUT, 0);
 			
-			printf_P(PSTR("Error: Door command timeout!"));
+			//TODO: Retry (and turn keymatic power on if currently off)
 			
-			if (door_command_retry_count < DOOR_COMMAND_MAX_RETRY){
-				printf_P(PSTR(" Retry...\n"));
-				cardreader_display_show_door_retry();
-				uint8_t retry = door_command_retry_count;
-				
-				//TODO: turn keymatic power on if currently off?
-				if (door_status & DOOR_STATUS_UNLOCKING) unlock();
-				if (door_status & DOOR_STATUS_LOCKING  ) lock();
-				//lock/unlock resets the counter, restore it.
-				door_command_retry_count = retry + 1;
-				
-			} else {
-				
-				log_append(LOG_EVENT_DOOR_COMMAND_RETRY_FAIL, 0);
-				
-				printf_P(" Giving Up :((\n");
-				cardreader_display_show_door_result(0);
-				
-				door_status &= (uint8_t)~(DOOR_STATUS_UNLOCKING | DOOR_STATUS_LOCKING); //clear activity flags
-			}
+			door_status &= (uint8_t)~(DOOR_STATUS_UNLOCKING | DOOR_STATUS_LOCKING); //clear activity flags
 		}
 	}
 	
@@ -120,15 +95,8 @@ uint8_t door_read_pin_status(void){
 uint8_t door_update_status(uint8_t sensor_status){
 	uint8_t new_door_status = (sensor_status & DOOR_STATUS_HW_MASK) | (door_status & DOOR_STATUS_SW_MASK);
 
-	if ((new_door_status & DOOR_STATUS_LOCKED) && (door_status & DOOR_STATUS_LOCKING)){
-		new_door_status &= (uint8_t)~DOOR_STATUS_LOCKING;
-		cardreader_display_show_door_result(1);
-	}
-		
-	if ((new_door_status & DOOR_STATUS_UNLOCKED) && (door_status & DOOR_STATUS_UNLOCKING)){
-		new_door_status &= (uint8_t)~DOOR_STATUS_UNLOCKING;
-		cardreader_display_show_door_result(1);
-	}
+	if (new_door_status & DOOR_STATUS_LOCKED)   new_door_status &= (uint8_t)~DOOR_STATUS_LOCKING;
+	if (new_door_status & DOOR_STATUS_UNLOCKED) new_door_status &= (uint8_t)~DOOR_STATUS_UNLOCKING;
 	
 	if (is_alarm_status(new_door_status)) new_door_status |= DOOR_STATUS_ALARM;
 	
@@ -146,7 +114,7 @@ uint8_t is_alarm_status(uint8_t door_status){
 	
 	//NOTE: This condition is supposed to trigger, if the door is slammed open.
 	//      We can't use the LOCKED sensor, because the connection between lock bolt and frame will be interrupted by this.
-	//      This connection is what the sensor actually detects. TODO: Can we improve this?
+	//      This connection is what the sensor actually detects. TODO: Can we improove this?
 	//      The UNLOCKED sensor, however will be uneffected, leaving the lock sensors in an
 	//      undefined (neither locked nor unlocked) state. We trigger an alarm if this occurs when the door is open.
 	//      Unfortunately the UNLOCKED has shown failures in the past, possibly causing a false alarm.
@@ -168,7 +136,6 @@ uint8_t door_get_status(void){
 void unlock(void){
 	door_command_pulse_time = DOOR_COMMAND_PULSE_TIME;
 	door_command_wait_timeout = DOOR_COMMAND_WAIT_TIMEOUT;
-	door_command_retry_count = 0;
 	
 	door_status = (door_status & (uint8_t)~DOOR_STATUS_LOCKING) | DOOR_STATUS_UNLOCKING;
 	DOOR_PORT   = (DOOR_PORT   & (uint8_t)~COMMAND_LOCK_PIN)    | COMMAND_UNLOCK_PIN;
@@ -177,9 +144,6 @@ void unlock(void){
 void lock(void){
 	door_command_pulse_time = DOOR_COMMAND_PULSE_TIME;
 	door_command_wait_timeout = DOOR_COMMAND_WAIT_TIMEOUT;
-	door_command_retry_count = 0;
-	
-// 	printf_P(PSTR("."));
 	
 	door_status = (door_status & (uint8_t)~DOOR_STATUS_UNLOCKING) | DOOR_STATUS_LOCKING;
 	DOOR_PORT   = (DOOR_PORT   & (uint8_t)~COMMAND_UNLOCK_PIN)    | COMMAND_LOCK_PIN;
@@ -194,47 +158,34 @@ uint8_t toggle_lock_unlock( void (*msg_target)(const char*) ){
 }
 
 uint8_t unlock_checked( void (*msg_target)(const char*) ){
-	uint8_t ok = 0;
-	const char* msg;
-	
 	if (door_status & DOOR_STATUS_UNLOCKED){
-		msg = PSTR("Already unlocked\n");
+		msg_target(PSTR("Already unlocked\n"));
 	} else if (door_status & DOOR_STATUS_LOCKING){
-		msg = PSTR("Can't unlock while locking\n");
+		msg_target(PSTR("Can't unlock while locking\n"));
 	} else {
 		unlock();
-		msg = PSTR("Unlocking...\n");
-		ok = 1;
+		msg_target(PSTR("Unlocking...\n"));
+		return 1;
 	}
-	
-	printf_P(msg);
-	if (msg_target) msg_target(msg);
-	
-	return ok;
+	return 0;
 }
 
 
 uint8_t lock_checked( void (*msg_target)(const char*) ){
-	uint8_t ok = 0;
-	const char* msg;
 	if (is_alarm_status(door_status)){
-		msg = PSTR("Can't lock in alarm state\n");
+		msg_target(PSTR("Can't lock in alarm state\n"));
 	} else if (door_status & DOOR_STATUS_UNLOCKING) {
-		msg = PSTR("Can't lock while unlocking\n");
+		msg_target(PSTR("Can't lock while unlocking\n"));
 	} else if (door_status & DOOR_STATUS_OPEN){
-		msg = PSTR("Can't lock while door open\n");
+		msg_target(PSTR("Can't lock while door open\n"));
 	} else if (door_status & DOOR_STATUS_LOCKED){
-		msg = PSTR("Already locked\n");
+		msg_target(PSTR("Already locked\n"));
 	} else {
 		lock();
-		msg = PSTR("Locking...\n");
-		ok = 1;
+		msg_target(PSTR("Locking...\n"));
+		return 1;
 	}
-	
-	printf_P(msg);
-	if (msg_target) msg_target(msg);
-	
-	return ok;
+	return 0;
 }
 
 uint8_t door_clear_alarm(void){

Control/log.c

@@ -5,17 +5,16 @@
 #include "door.h"
 #include "power_monitor.h"
 
-const char log_event_startup[]                 PROGMEM = "== System Started ==";
-const char log_event_alarm_raised[]            PROGMEM = "Alarm Raised";
-const char log_event_alarm_changed[]           PROGMEM = "State change during Alarm";
-const char log_event_alarm_login[]             PROGMEM = "Login during Alarm";
-const char log_event_alarm_disabled[]          PROGMEM = "Alarm disabled";
-const char log_event_ac_fail[]                 PROGMEM = "AC Power Fail";
-const char log_event_ac_return[]               PROGMEM = "AC Power Restored";
-const char log_event_main_battery_low[]        PROGMEM = "Main Battery Low";
-const char log_event_keymatic_battery_low[]    PROGMEM = "Keymatic Battery Low";
-const char log_event_door_command_timeout[]    PROGMEM = "Door command Timeout";
-const char log_event_door_command_retry_fail[] PROGMEM = "Door command retry failed";
+const char log_event_startup[]              PROGMEM = "== System Started ==";
+const char log_event_alarm_raised[]         PROGMEM = "Alarm Raised";
+const char log_event_alarm_changed[]        PROGMEM = "State change during Alarm";
+const char log_event_alarm_login[]          PROGMEM = "Login during Alarm";
+const char log_event_alarm_disabled[]       PROGMEM = "Alarm disabled";
+const char log_event_ac_fail[]              PROGMEM = "AC Power Fail";
+const char log_event_ac_return[]            PROGMEM = "AC Power Restored";
+const char log_event_main_battery_low[]     PROGMEM = "Main Battery Low";
+const char log_event_keymatic_battery_low[] PROGMEM = "Keymatic Battery Low";
+const char log_event_door_command_timeout[] PROGMEM = "Door command Timeout";
 
 const char* const event_names[] PROGMEM = {log_event_startup,
                                log_event_alarm_raised,
@@ -26,8 +25,7 @@ const char* const event_names[] PROGMEM = {log_event_startup,
                                log_event_ac_return,
                                log_event_main_battery_low,
                                log_event_keymatic_battery_low,
-                               log_event_door_command_timeout,
-                               log_event_door_command_retry_fail};
+                               log_event_door_command_timeout};
 
 uint8_t log_get_first_entry_index(void){
 	uint8_t l = eeprom_read_byte(LOG_START_POINTER_LOCATION);

Control/log.h

@@ -20,17 +20,16 @@ struct log_entry_t{
 #define LOG_START_POINTER_LOCATION ((void*)(EEPROM_SIZE-1))
 #define LOG_END_POINTER_LOCATION   ((void*)(EEPROM_SIZE-2))
 
-#define LOG_EVENT_STARTUP                 0x00
-#define LOG_EVENT_ALARM_RAISED            0x01
-#define LOG_EVENT_ALARM_CHANGED           0x02
-#define LOG_EVENT_ALARM_LOGIN             0x03
-#define LOG_EVENT_ALARM_DISABLED          0x04
-#define LOG_EVENT_AC_FAIL                 0x05
-#define LOG_EVENT_AC_RETURN               0x06
-#define LOG_EVENT_MAIN_BATTERY_LOW        0x07
-#define LOG_EVENT_KEYMATIC_BATTERY_LOW    0x08
-#define LOG_EVENT_DOOR_COMMAND_TIMEOUT    0x09
-#define LOG_EVENT_DOOR_COMMAND_RETRY_FAIL 0x0A
+#define LOG_EVENT_STARTUP              0x00
+#define LOG_EVENT_ALARM_RAISED         0x01
+#define LOG_EVENT_ALARM_CHANGED        0x02
+#define LOG_EVENT_ALARM_LOGIN          0x03
+#define LOG_EVENT_ALARM_DISABLED       0x04
+#define LOG_EVENT_AC_FAIL              0x05
+#define LOG_EVENT_AC_RETURN            0x06
+#define LOG_EVENT_MAIN_BATTERY_LOW     0x07
+#define LOG_EVENT_KEYMATIC_BATTERY_LOW 0x08
+#define LOG_EVENT_DOOR_COMMAND_TIMEOUT 0x09
 
 #define LOG_EVENT_NONE                 0xFF
 

Control/shell/shell.c

@@ -302,14 +302,14 @@ void cmd_lock(readline_parsed_cmd_t* cmd){
 	if ((cmd->num_args > 0) && (strcmp(cmd->args[0], "-f") == 0)){
 		lock();
 	} else {
-		lock_checked(0);
+		lock_checked(print_P);
 	}
 }
 void cmd_unlock(readline_parsed_cmd_t* cmd){
 	if ((cmd->num_args > 0) && (strcmp(cmd->args[0], "-f") == 0)){
 		unlock();
 	} else {
-		unlock_checked(0);
+		unlock_checked(print_P);
 	}
 }
 

common/serial.h

@@ -154,15 +154,18 @@ void FUNC_switch_baudrate(uint32_t baud){
 }
 
 void FUNC_switch_mode_receive(void){
-	while ( !( UCSRA & (1 << TXC)) ) {;} //Wait for transmit complete
+	//Wait for empty transmit buffer
+	while ( !( UCSRA & (1 << UDRE)) ) {;}
 	UCSRB &= ~(1<<TXEN);
+	_delay_ms(1);
 	UCSRB |=  (1<<RXEN);
-	while (UCSRA & (1 << RXC)){UDR;} //trash receive buffer
+	while (UCSRA & (1 << RXC)){ //trash receive buffer
+		UDR;
+	}
 }
 void FUNC_switch_mode_transmit(void){
 	UCSRB |=  (1<<TXEN);
 	UCSRB &= ~(1<<RXEN);
-	while (UCSRA & (1 << RXC)){UDR;} //trash receive buffer
 }