add/update interface

components/ena/ena-exposure.c

@@ -27,6 +27,8 @@
 
 #include "ena-exposure.h"
 
+static ena_exposure_summary_t *current_summary;
+
 static ena_exposure_config_t DEFAULT_ENA_EXPOSURE_CONFIG = {
     // transmission_risk_values
     {
@@ -77,14 +79,13 @@ static ena_exposure_config_t DEFAULT_ENA_EXPOSURE_CONFIG = {
 static const char kFileHeader[] = "EK Export v1    ";
 static size_t kFileHeaderSize = sizeof(kFileHeader) - 1;
 
-extern uint8_t export_bin_start[] asm("_binary_export_bin_start"); // test data from Google or https://svc90.main.px.t-online.de/version/v1/diagnosis-keys/country/DE/date/2020-07-22
-extern uint8_t export_bin_end[] asm("_binary_export_bin_end");
-
-int ena_exposure_risk_score(ena_exposure_config_t *config, ena_exposure_parameter_t params)
+int ena_exposure_transmission_risk_score(ena_exposure_config_t *config, ena_exposure_parameter_t params)
 {
-    int score = 1;
-    score *= config->transmission_risk_values[params.report_type];
+    return config->transmission_risk_values[params.report_type];
+}
 
+int ena_exposure_duration_risk_score(ena_exposure_config_t *config, ena_exposure_parameter_t params)
+{
     // calc duration level
     int duration_level = MINUTES_0;
     if (params.duration > 0)
@@ -118,8 +119,12 @@ int ena_exposure_risk_score(ena_exposure_config_t *config, ena_exposure_paramete
             duration_level = MINUTES_LONGER;
         }
     }
-    score *= config->duration_risk_values[duration_level];
 
+    return config->duration_risk_values[duration_level];
+}
+
+int ena_exposure_days_risk_score(ena_exposure_config_t *config, ena_exposure_parameter_t params)
+{
     // calc days level
     int days_level = DAYS_14;
 
@@ -152,8 +157,11 @@ int ena_exposure_risk_score(ena_exposure_config_t *config, ena_exposure_paramete
         days_level = DAYS_13;
     }
 
-    score *= config->days_risk_values[days_level];
+    return config->days_risk_values[days_level];
+}
 
+int ena_exposure_attenuation_risk_score(ena_exposure_config_t *config, ena_exposure_parameter_t params)
+{
     // calc attenuation level
     int attenuation_level = ATTENUATION_73;
 
@@ -186,7 +194,19 @@ int ena_exposure_risk_score(ena_exposure_config_t *config, ena_exposure_paramete
         attenuation_level = ATTENUATION_63;
     }
 
-    score *= config->attenuation_risk_values[attenuation_level];
+    return config->attenuation_risk_values[attenuation_level];
+}
+
+int ena_exposure_risk_score(ena_exposure_config_t *config, ena_exposure_parameter_t params)
+{
+    int score = 1;
+    score *= ena_exposure_transmission_risk_score(config, params);
+
+    score *= ena_exposure_duration_risk_score(config, params);
+
+    score *= ena_exposure_days_risk_score(config, params);
+
+    score *= ena_exposure_attenuation_risk_score(config, params);
 
     if (score > 255)
     {
@@ -196,22 +216,25 @@ int ena_exposure_risk_score(ena_exposure_config_t *config, ena_exposure_paramete
     return score;
 }
 
-void ena_exposure_summary(ena_exposure_config_t *config, ena_exposure_summary_t *summary)
+void ena_exposure_summary(ena_exposure_config_t *config)
 {
-    // XXX TEST key export (should be called on other location though)
-    ESP_ERROR_CHECK_WITHOUT_ABORT(ena_exposure_check_export(export_bin_start, (export_bin_end - export_bin_start)));
-
     uint32_t count = ena_storage_exposure_information_count();
     uint32_t current_time = (uint32_t)time(NULL);
 
-    summary->days_since_last_exposure = INT_MAX;
-    summary->max_risk_score = 0;
-    summary->risk_score_sum = 0;
-    summary->num_exposures = count;
+    if (current_summary == NULL)
+    {
+        current_summary = malloc(sizeof(ena_exposure_summary_t));
+    }
+
+    current_summary->last_update = ena_storage_read_last_exposure_date();
+    current_summary->days_since_last_exposure = INT_MAX;
+    current_summary->max_risk_score = 0;
+    current_summary->risk_score_sum = 0;
+    current_summary->num_exposures = count;
 
     if (count == 0)
     {
-        summary->days_since_last_exposure = -1;
+        current_summary->days_since_last_exposure = -1;
     }
 
     ena_exposure_information_t exposure_info;
@@ -220,21 +243,31 @@ void ena_exposure_summary(ena_exposure_config_t *config, ena_exposure_summary_t
     {
         ena_storage_get_exposure_information(i, &exposure_info);
         params.days = (current_time - exposure_info.day) / (60 * 60 * 24); // difference in days
-        if (params.days < summary->days_since_last_exposure)
+        if (params.days < current_summary->days_since_last_exposure)
         {
-            summary->days_since_last_exposure = params.days;
+            current_summary->days_since_last_exposure = params.days;
         }
         params.duration = exposure_info.duration_minutes;
         params.attenuation = exposure_info.typical_attenuation;
         int score = ena_exposure_risk_score(config, params);
-        if (score > summary->max_risk_score)
+        if (score > current_summary->max_risk_score)
         {
-            summary->max_risk_score = score;
+            current_summary->max_risk_score = score;
         }
-        summary->risk_score_sum += score;
+        current_summary->risk_score_sum += score;
     }
 }
 
+ena_exposure_summary_t *ena_exposure_current_summary(void)
+{
+    if (current_summary == NULL)
+    {
+        ena_exposure_summary(ena_exposure_default_config());
+    }
+
+    return current_summary;
+}
+
 ena_exposure_config_t *ena_exposure_default_config(void)
 {
     return &DEFAULT_ENA_EXPOSURE_CONFIG;

components/ena/ena-storage.c

@@ -22,7 +22,8 @@
 
 #define BLOCK_SIZE (4096)
 
-const int ENA_STORAGE_TEK_COUNT_ADDRESS = (ENA_STORAGE_START_ADDRESS); // starting address for TEK COUNT
+const int ENA_STORAGE_LAST_EXPOSURE_DATE_ADDRESS = (ENA_STORAGE_START_ADDRESS);
+const int ENA_STORAGE_TEK_COUNT_ADDRESS = (ENA_STORAGE_LAST_EXPOSURE_DATE_ADDRESS + sizeof(uint32_t));
 const int ENA_STORAGE_TEK_START_ADDRESS = (ENA_STORAGE_TEK_COUNT_ADDRESS + sizeof(uint32_t));
 const int ENA_STORAGE_EXPOSURE_INFORMATION_COUNT_ADDRESS = (ENA_STORAGE_TEK_START_ADDRESS + sizeof(ena_tek_t) * ENA_STORAGE_TEK_MAX);
 const int ENA_STORAGE_EXPOSURE_INFORMATION_START_ADDRESS = (ENA_STORAGE_EXPOSURE_INFORMATION_COUNT_ADDRESS + sizeof(uint32_t));
@@ -144,6 +145,18 @@ void ena_storage_shift_delete(size_t address, size_t end_address, size_t size)
     }
 }
 
+uint32_t ena_storage_read_last_exposure_date(void)
+{
+    uint32_t timestamp = 0;
+    ena_storage_read(ENA_STORAGE_LAST_EXPOSURE_DATE_ADDRESS, &timestamp, sizeof(uint32_t));
+    return timestamp;
+}
+
+void ena_storage_write_last_exposure_date(uint32_t timestamp)
+{
+    ena_storage_write(ENA_STORAGE_LAST_EXPOSURE_DATE_ADDRESS, &timestamp, sizeof(uint32_t));
+}
+
 uint32_t ena_storage_read_last_tek(ena_tek_t *tek)
 {
     uint32_t tek_count = 0;
@@ -298,6 +311,7 @@ void ena_storage_erase(void)
     ESP_LOGI(ENA_STORAGE_LOG, "erased partition %s!", ENA_STORAGE_PARTITION_NAME);
 
     uint32_t count = 0;
+    ena_storage_write(ENA_STORAGE_LAST_EXPOSURE_DATE_ADDRESS, &count, sizeof(uint32_t));
     ena_storage_write(ENA_STORAGE_TEK_COUNT_ADDRESS, &count, sizeof(uint32_t));
     ena_storage_write(ENA_STORAGE_EXPOSURE_INFORMATION_COUNT_ADDRESS, &count, sizeof(uint32_t));
     ena_storage_write(ENA_STORAGE_TEMP_BEACONS_COUNT_ADDRESS, &count, sizeof(uint32_t));

components/ena/ena.c

@@ -91,6 +91,11 @@ void ena_start(void)
     ena_storage_erase();
 #endif
 
+    if (ena_storage_read_last_exposure_date() == 0xFFFFFFFF)
+    {
+        ena_storage_erase();
+    }
+
     // init NVS for BLE
     esp_err_t ret;
     ret = nvs_flash_init();

components/ena/include/ena-exposure.h

@@ -21,7 +21,7 @@
 #define _ena_EXPOSURE_H_
 
 #include <stdio.h>
-
+#include "esp_err.h"
 #include "ena-crypto.h"
 
 #define ENA_EXPOSURE_LOG "ESP-ENA-exposure" // TAG for Logging
@@ -135,6 +135,7 @@ typedef struct __attribute__((__packed__))
  */
 typedef struct __attribute__((__packed__))
 {
+    uint32_t last_update;         // timestamp of last update of exposure data
     int days_since_last_exposure; // Number of days since the most recent exposure.
     int num_exposures;            // Number of all exposure information
     int max_risk_score;           // max. risk score of all exposure information
@@ -142,10 +143,52 @@ typedef struct __attribute__((__packed__))
 } ena_exposure_summary_t;
 
 /**
- * @brief calculate risk score
+ * @brief calculate transmission risk score
  * 
  * @param[in] config the exposure configuration used for calculating score
  * @param[in] params the exposure parameter to calculate with
+ * 
+ * @return
+ */
+int ena_exposure_transmission_risk_score(ena_exposure_config_t *config, ena_exposure_parameter_t params);
+
+/**
+ * @brief calculate duration risk score
+ * 
+ * @param[in] config the exposure configuration used for calculating score
+ * @param[in] params the exposure parameter to calculate with
+ * 
+ * @return
+ */
+int ena_exposure_duration_risk_score(ena_exposure_config_t *config, ena_exposure_parameter_t params);
+
+/**
+ * @brief calculate days risk score
+ * 
+ * @param[in] config the exposure configuration used for calculating score
+ * @param[in] params the exposure parameter to calculate with
+ * 
+ * @return
+ */
+int ena_exposure_days_risk_score(ena_exposure_config_t *config, ena_exposure_parameter_t params);
+
+/**
+ * @brief calculate attenuation risk score
+ * 
+ * @param[in] config the exposure configuration used for calculating score
+ * @param[in] params the exposure parameter to calculate with
+ * 
+ * @return
+ */
+int ena_exposure_attenuation_risk_score(ena_exposure_config_t *config, ena_exposure_parameter_t params);
+
+/**
+ * @brief calculate overall risk score
+ * 
+ * @param[in] config the exposure configuration used for calculating score
+ * @param[in] params the exposure parameter to calculate with
+ * 
+ * @return
  */
 int ena_exposure_risk_score(ena_exposure_config_t *config, ena_exposure_parameter_t params);
 
@@ -153,12 +196,22 @@ int ena_exposure_risk_score(ena_exposure_config_t *config, ena_exposure_paramete
  * @brief returns the current exposure summary
  * 
  * @param[in] config the exposure configuration used for calculating scores
- * @param[out] summary pointer to exposure summary to write to
  */
-void ena_exposure_summary(ena_exposure_config_t *config, ena_exposure_summary_t *summary);
+void ena_exposure_summary(ena_exposure_config_t *config);
+
+/**
+ * @brief return the current exposure summary
+ * 
+ * @return
+ *          ena_exposure_summary_t pointer to the current exposure summary
+ */
+ena_exposure_summary_t *ena_exposure_current_summary(void);
 
 /**
  * @brief return a default exposure configuration
+ * 
+ * @return
+ *      ena_exposure_config_t   default exposure configuration
  */
 ena_exposure_config_t *ena_exposure_default_config(void);
 

components/ena/include/ena-storage.h

@@ -22,11 +22,11 @@
 
 #include "ena-crypto.h"
 
-#define ENA_STORAGE_LOG "ESP-ENA-storage"                                    // TAG for Logging
-#define ENA_STORAGE_PARTITION_NAME (CONFIG_ENA_STORAGE_PARTITION_NAME)       // name of partition to use for storing
-#define ENA_STORAGE_START_ADDRESS (CONFIG_ENA_STORAGE_START_ADDRESS)         // start address of storage
-#define ENA_STORAGE_TEK_MAX (CONFIG_ENA_STORAGE_TEK_MAX)                     // Period of storing TEKs                                                                            // length of a stored beacon -> RPI keysize + AEM size + 4 Bytes for ENIN + 4 Bytes for RSSI
-#define ENA_STORAGE_TEMP_BEACONS_MAX (CONFIG_ENA_STORAGE_TEMP_BEACONS_MAX)   // Maximum number of temporary stored beacons                                                    // length of a stored beacon -> RPI keysize + AEM size + 4 Bytes for ENIN + 4 Bytes for RSSI
+#define ENA_STORAGE_LOG "ESP-ENA-storage"                                                  // TAG for Logging
+#define ENA_STORAGE_PARTITION_NAME (CONFIG_ENA_STORAGE_PARTITION_NAME)                     // name of partition to use for storing
+#define ENA_STORAGE_START_ADDRESS (CONFIG_ENA_STORAGE_START_ADDRESS)                       // start address of storage
+#define ENA_STORAGE_TEK_MAX (CONFIG_ENA_STORAGE_TEK_MAX)                                   // Period of storing TEKs                                                                            // length of a stored beacon -> RPI keysize + AEM size + 4 Bytes for ENIN + 4 Bytes for RSSI
+#define ENA_STORAGE_TEMP_BEACONS_MAX (CONFIG_ENA_STORAGE_TEMP_BEACONS_MAX)                 // Maximum number of temporary stored beacons                                                    // length of a stored beacon -> RPI keysize + AEM size + 4 Bytes for ENIN + 4 Bytes for RSSI
 #define ENA_STORAGE_EXPOSURE_INFORMATION_MAX (CONFIG_ENA_STORAGE_EXPOSURE_INFORMATION_MAX) // Maximum number of stored exposure information
 
 /**
@@ -59,7 +59,7 @@ typedef struct __attribute__((__packed__))
     uint32_t day;            // Day of the exposure, using UTC, encapsulated as the time of the beginning of that day.
     int typical_attenuation; // Aggregation of the attenuations of all of a given diagnosis key's beacons received during the scan, in dB.
     int min_attenuation;     // Minimum attenuation of all of a given diagnosis key's beacons received during the scan, in dB.
-    int duration_minutes;     //The duration of the exposure in minutes.
+    int duration_minutes;    //The duration of the exposure in minutes.
     int report_type;         // Type of diagnosis associated with a key.
 } ena_exposure_information_t;
 
@@ -90,6 +90,21 @@ void ena_storage_write(size_t address, void *data, size_t size);
  */
 void ena_storage_shift_delete(size_t address, size_t end_address, size_t size);
 
+/**
+ * @brief       get timestamp of most recent exposure data
+ * 
+ * @return 
+ *              unix timestamp
+ */
+uint32_t ena_storage_read_last_exposure_date(void);
+
+/**
+ * @brief       set timestamp of most recent exposure data
+ * 
+ * @param[in] timestamp unix timestamp
+ */
+void ena_storage_write_last_exposure_date(uint32_t timestamp);
+
 /**
  * @brief       get last stored TEK
  * 
@@ -218,7 +233,6 @@ void ena_storage_erase(void);
  */
 void ena_storage_erase_tek(void);
 
-
 /**
  * @brief       erase all stored exposure information
  * 
@@ -248,7 +262,6 @@ void ena_storage_erase_beacon(void);
  */
 void ena_storage_dump_teks(void);
 
-
 /**
  * @brief       dump all stored exposure information to serial output
  *