touchCalibrationStorage.cpp

Go to the documentation of this file.

 
#include <stdio.h>
#include <string.h>
#include "main.h"
#include "touchCalibrationStorage.hpp"
 
namespace {
 
const uint32_t BLOCK_BYTES = CFG_EEPROM_TOUCHSCREEN_CALIBRATED + 1;
 
const uint32_t HEADER_BYTES = 12;
 
const uint32_t HEADER_MAGIC = 0x314C4143;
 
const uint16_t HEADER_VERSION = 1;
 
uint32_t crc32(const uint8_t *data, uint32_t length) {
    uint32_t crc = 0xFFFFFFFFu;
    for (uint32_t i = 0; i < length; i++) {
        crc ^= data[i];
        for (int bit = 0; bit < 8; bit++) {
            crc = (crc & 1u) ? ((crc >> 1) ^ 0xEDB88320u) : (crc >> 1);
        }
    }
    return ~crc;
}
 
bool storageRead(void *ctx, uint32_t address, uint8_t *data, uint32_t length) {
    MB85RS64V *fram = static_cast<MB85RS64V *>(ctx);
    if (fram == nullptr || address >= MB85RS64V::SIZE_BYTES) {
        return false;
    }
    return fram->read(static_cast<uint16_t>(address), data, length);
}
 
bool storageWrite(void *ctx, uint32_t address, const uint8_t *data, uint32_t length) {
    MB85RS64V *fram = static_cast<MB85RS64V *>(ctx);
    if (fram == nullptr || address >= MB85RS64V::SIZE_BYTES ||
            !fram->write(static_cast<uint16_t>(address), data, length)) {
        printf("Calibration storage write failed (address 0x%04lX, %lu bytes)\r\n", (unsigned long) address,
                (unsigned long) length);
        Error_Handler();
        return false;
    }
    return true;
}
 
}   // namespace
 
void touchCalibrationAttachStorage(Adafruit_RA8875 *display, MB85RS64V *fram) {
    if (display == nullptr || fram == nullptr) {
        printf("touchCalibrationAttachStorage: display or FRAM object is missing\r\n");
        Error_Handler();
        return;
    }
    display->setCalibrationStorage(storageRead, storageWrite, fram, MB85RS64V::SIZE_BYTES);
}
 
bool touchCalibrationLoad(Adafruit_RA8875 *display, MB85RS64V *fram, tsMatrix_t *matrix) {
    if (display == nullptr || fram == nullptr || matrix == nullptr) {
        printf("touchCalibrationLoad: missing argument\r\n");
        Error_Handler();
        return false;
    }
 
    uint8_t header[HEADER_BYTES];
    if (!fram->read(TOUCH_CAL_HEADER_ADDRESS, header, HEADER_BYTES)) {
        printf("Stored calibration: header could not be read\r\n");
        Error_Handler();
        return false;
    }
 
    const uint32_t magic = (uint32_t) header[0] | ((uint32_t) header[1] << 8) | ((uint32_t) header[2] << 16) |
            ((uint32_t) header[3] << 24);
    const uint16_t version = (uint16_t) (header[4] | (header[5] << 8));
    const uint16_t length = (uint16_t) (header[6] | (header[7] << 8));
    const uint32_t storedCrc = (uint32_t) header[8] | ((uint32_t) header[9] << 8) | ((uint32_t) header[10] << 16) |
            ((uint32_t) header[11] << 24);
 
    if (magic != HEADER_MAGIC) {
        printf("Stored calibration: none (no marker in the FRAM)\r\n");
        return false;
    }
    if (version != HEADER_VERSION || length != BLOCK_BYTES) {
        printf("Stored calibration: unknown format (version %u, length %u)\r\n", (unsigned) version,
                (unsigned) length);
        return false;
    }
 
    uint8_t block[BLOCK_BYTES];
    if (!fram->read(TOUCH_CAL_ADDRESS, block, BLOCK_BYTES)) {
        printf("Stored calibration: matrix block could not be read\r\n");
        Error_Handler();
        return false;
    }
    if (crc32(block, BLOCK_BYTES) != storedCrc) {
        printf("Stored calibration: checksum does not match, data is damaged\r\n");
        return false;
    }
 
    if (!display->readCalibration(TOUCH_CAL_ADDRESS, matrix)) {
        printf("Stored calibration: the library does not report it as calibrated\r\n");
        return false;
    }
    if (matrix->Divider == 0) {
        printf("Stored calibration: matrix divider is zero, not usable\r\n");
        return false;
    }
    return true;
}
 
bool touchCalibrationSave(Adafruit_RA8875 *display, MB85RS64V *fram, tsMatrix_t *matrix) {
    if (display == nullptr || fram == nullptr || matrix == nullptr) {
        printf("touchCalibrationSave: missing argument\r\n");
        Error_Handler();
        return false;
    }
 
    // Matrix first: the library writes the seven values and then its flag byte
    display->writeCalibration(TOUCH_CAL_ADDRESS, matrix);
 
    uint8_t block[BLOCK_BYTES];
    if (!fram->read(TOUCH_CAL_ADDRESS, block, BLOCK_BYTES)) {
        printf("Calibration save: matrix block could not be read back\r\n");
        Error_Handler();
        return false;
    }
    const uint32_t crc = crc32(block, BLOCK_BYTES);
 
    // Header last: it is what marks the stored matrix as valid
    uint8_t header[HEADER_BYTES];
    header[0] = (uint8_t) (HEADER_MAGIC & 0xFF);
    header[1] = (uint8_t) ((HEADER_MAGIC >> 8) & 0xFF);
    header[2] = (uint8_t) ((HEADER_MAGIC >> 16) & 0xFF);
    header[3] = (uint8_t) ((HEADER_MAGIC >> 24) & 0xFF);
    header[4] = (uint8_t) (HEADER_VERSION & 0xFF);
    header[5] = (uint8_t) (HEADER_VERSION >> 8);
    header[6] = (uint8_t) (BLOCK_BYTES & 0xFF);
    header[7] = (uint8_t) (BLOCK_BYTES >> 8);
    header[8] = (uint8_t) (crc & 0xFF);
    header[9] = (uint8_t) ((crc >> 8) & 0xFF);
    header[10] = (uint8_t) ((crc >> 16) & 0xFF);
    header[11] = (uint8_t) ((crc >> 24) & 0xFF);
    if (!fram->write(TOUCH_CAL_HEADER_ADDRESS, header, HEADER_BYTES)) {
        printf("Calibration save: header could not be written\r\n");
        Error_Handler();
        return false;
    }
 
    // Prove it: load it back and compare with what was saved
    tsMatrix_t check;
    if (!touchCalibrationLoad(display, fram, &check)) {
        return false;
    }
    return memcmp(&check, matrix, sizeof(tsMatrix_t)) == 0;
}