void chb_eeprom_write(uint16_t addr, uint8_t *buf, uint16_t size)
{
// Write the address one byte at a time
uint16_t a = 0;
while (a < size)
{
eepromWriteU8(addr + a, buf[a]);
a++;
}
}
int tsSetThreshhold(uint8_t value)
{
if ((value < 0) || (value > 254))
{
return -1;
}
// Update threshhold value
_tsThreshhold = value;
// Persist to EEPROM
eepromWriteU8(CFG_EEPROM_TOUCHSCREEN_THRESHHOLD, value);
return 0;
}
void cmd_i2ceeprom_write(uint8_t argc, char **argv)
{
uint16_t addr;
uint8_t val;
// Try to convert supplied address to an integer
int32_t addr32;
getNumber (argv[0], &addr32);
// Check for invalid values (getNumber may complain about this as well)
if (addr32 < 0 || eepromCheckAddress(addr32))
{
printf("Address out of range %s", CFG_PRINTF_NEWLINE);
return;
}
// Address seems to be OK
addr = (uint16_t)addr32;
// Make sure this isn't in the reserved system config space
if (addr <= CFG_EEPROM_RESERVED)
{
printf("ERROR: Reserved address (0x%04X-0x%04X)%s", 0, CFG_EEPROM_RESERVED, CFG_PRINTF_NEWLINE);
return;
}
// Try to convert supplied data to an integer
int32_t val32;
getNumber (argv[1], &val32);
// Check for invalid values (getNumber may complain about this as well)
if (val32 < 0 || val32 > 0xFF)
{
printf("Invalid Data: 0-255 or 0x00-0xFF required.%s", CFG_PRINTF_NEWLINE);
return;
}
// Data seems to be OK
val = (uint8_t)val32;
// Write data at supplied address
eepromWriteU8(addr, val);
// Write successful
printf("0x%02X written at 0x%04X%s", val, addr, CFG_PRINTF_NEWLINE);
}
int setCalibrationMatrix( tsPoint_t * displayPtr, tsPoint_t * screenPtr, tsMatrix_t * matrixPtr)
{
int retValue = 0;
matrixPtr->Divider = ((screenPtr[0].x - screenPtr[2].x) * (screenPtr[1].y - screenPtr[2].y)) -
((screenPtr[1].x - screenPtr[2].x) * (screenPtr[0].y - screenPtr[2].y)) ;
if( matrixPtr->Divider == 0 )
{
retValue = -1 ;
}
else
{
matrixPtr->An = ((displayPtr[0].x - displayPtr[2].x) * (screenPtr[1].y - screenPtr[2].y)) -
((displayPtr[1].x - displayPtr[2].x) * (screenPtr[0].y - screenPtr[2].y)) ;
matrixPtr->Bn = ((screenPtr[0].x - screenPtr[2].x) * (displayPtr[1].x - displayPtr[2].x)) -
((displayPtr[0].x - displayPtr[2].x) * (screenPtr[1].x - screenPtr[2].x)) ;
matrixPtr->Cn = (screenPtr[2].x * displayPtr[1].x - screenPtr[1].x * displayPtr[2].x) * screenPtr[0].y +
(screenPtr[0].x * displayPtr[2].x - screenPtr[2].x * displayPtr[0].x) * screenPtr[1].y +
(screenPtr[1].x * displayPtr[0].x - screenPtr[0].x * displayPtr[1].x) * screenPtr[2].y ;
matrixPtr->Dn = ((displayPtr[0].y - displayPtr[2].y) * (screenPtr[1].y - screenPtr[2].y)) -
((displayPtr[1].y - displayPtr[2].y) * (screenPtr[0].y - screenPtr[2].y)) ;
matrixPtr->En = ((screenPtr[0].x - screenPtr[2].x) * (displayPtr[1].y - displayPtr[2].y)) -
((displayPtr[0].y - displayPtr[2].y) * (screenPtr[1].x - screenPtr[2].x)) ;
matrixPtr->Fn = (screenPtr[2].x * displayPtr[1].y - screenPtr[1].x * displayPtr[2].y) * screenPtr[0].y +
(screenPtr[0].x * displayPtr[2].y - screenPtr[2].x * displayPtr[0].y) * screenPtr[1].y +
(screenPtr[1].x * displayPtr[0].y - screenPtr[0].x * displayPtr[1].y) * screenPtr[2].y ;
// Persist data to EEPROM
eepromWriteS32(CFG_EEPROM_TOUCHSCREEN_CAL_AN, matrixPtr->An);
eepromWriteS32(CFG_EEPROM_TOUCHSCREEN_CAL_BN, matrixPtr->Bn);
eepromWriteS32(CFG_EEPROM_TOUCHSCREEN_CAL_CN, matrixPtr->Cn);
eepromWriteS32(CFG_EEPROM_TOUCHSCREEN_CAL_DN, matrixPtr->Dn);
eepromWriteS32(CFG_EEPROM_TOUCHSCREEN_CAL_EN, matrixPtr->En);
eepromWriteS32(CFG_EEPROM_TOUCHSCREEN_CAL_FN, matrixPtr->Fn);
eepromWriteS32(CFG_EEPROM_TOUCHSCREEN_CAL_DIVIDER, matrixPtr->Divider);
eepromWriteU8(CFG_EEPROM_TOUCHSCREEN_CALIBRATED, 1);
}
return( retValue ) ;
}
void tsCalibrate(void)
{
lcdOrientation_t orientation;
uint16_t right2, top2, left2, bottom2;
bool passed = false;
// Determine screen orientation before starting calibration
orientation = lcdGetOrientation();
/* -------------- Welcome Screen --------------- */
tsRenderCalibrationScreen(lcdGetWidth() / 2, lcdGetHeight() / 2, 5);
// Delay to avoid multiple touch events
systickDelay(250);
/* -------------- CALIBRATE TOP-LEFT --------------- */
passed = false;
while (!passed)
{
// Read X/Y depending on screen orientation
tsRenderCalibrationScreen(3, 3, 5);
_calibration.offsetLeft = orientation == LCD_ORIENTATION_LANDSCAPE ? tsReadY() : tsReadX();
_calibration.offsetTop = orientation == LCD_ORIENTATION_LANDSCAPE ? tsReadX() : tsReadY();
// Make sure values are in range
if (_calibration.offsetLeft < TS_CALIBRATION_OUTOFRANGE && _calibration.offsetTop < TS_CALIBRATION_OUTOFRANGE)
passed = true;
}
// Delay to avoid multiple touch events
systickDelay(250);
/* -------------- CALIBRATE BOTTOM-RIGHT --------------- */
passed = false;
while (!passed)
{
tsRenderCalibrationScreen(lcdGetWidth() - 4, lcdGetHeight() - 4, 5);
// Read X/Y depending on screen orientation
_calibration.offsetRight = orientation == LCD_ORIENTATION_LANDSCAPE ? TS_ADC_LIMIT - tsReadY() : TS_ADC_LIMIT - tsReadX();
_calibration.offsetBottom = orientation == LCD_ORIENTATION_LANDSCAPE ? TS_ADC_LIMIT - tsReadX() : TS_ADC_LIMIT - tsReadY();
// Redo test if value is out of range
if (_calibration.offsetRight < TS_CALIBRATION_OUTOFRANGE && _calibration.offsetBottom < TS_CALIBRATION_OUTOFRANGE)
passed = true;
}
// Delay to avoid multiple touch events
systickDelay(250);
/* -------------- CALIBRATE TOP-RIGHT --------------- */
passed = false;
while (!passed)
{
tsRenderCalibrationScreen(lcdGetWidth() - 4, 3, 5);
if (orientation == LCD_ORIENTATION_LANDSCAPE)
{
right2 = TS_ADC_LIMIT - tsReadY();
top2 = tsReadX();
}
else
{
right2 = tsReadX();
top2 = TS_ADC_LIMIT - tsReadY();
}
// Redo test if value is out of range
if (right2 < TS_CALIBRATION_OUTOFRANGE && top2 < TS_CALIBRATION_OUTOFRANGE)
passed = true;
}
// Average readings
_calibration.offsetRight = (_calibration.offsetRight + right2) / 2;
_calibration.offsetTop = (_calibration.offsetTop + top2) / 2;
// Delay to avoid multiple touch events
systickDelay(250);
/* -------------- CALIBRATE BOTTOM-LEFT --------------- */
passed = false;
while (!passed)
{
tsRenderCalibrationScreen(3, lcdGetHeight() - 4, 5);
if (orientation == LCD_ORIENTATION_LANDSCAPE)
{
left2 = tsReadY();
bottom2 = TS_ADC_LIMIT - tsReadX();
}
else
{
left2 = TS_ADC_LIMIT - tsReadX();
bottom2 = tsReadY();
}
// Redo test if value is out of range
if (left2 < TS_CALIBRATION_OUTOFRANGE && bottom2 < TS_CALIBRATION_OUTOFRANGE)
passed = true;
}
// Average readings
_calibration.offsetLeft = (_calibration.offsetLeft + left2) / 2;
_calibration.offsetBottom = (_calibration.offsetBottom + bottom2) / 2;
// Delay to avoid multiple touch events
systickDelay(250);
_calibration.divisorX = ((TS_ADC_LIMIT - (_calibration.offsetLeft + _calibration.offsetRight)) * 100) / lcdGetWidth();
_calibration.divisorY = ((TS_ADC_LIMIT - (_calibration.offsetTop + _calibration.offsetBottom)) * 100) / lcdGetHeight();
/* -------------- Persist Data --------------- */
// Persist data to EEPROM
eepromWriteU16(CFG_EEPROM_TOUCHSCREEN_OFFSET_LEFT, _calibration.offsetLeft);
eepromWriteU16(CFG_EEPROM_TOUCHSCREEN_OFFSET_RIGHT, _calibration.offsetRight);
eepromWriteU16(CFG_EEPROM_TOUCHSCREEN_OFFSET_TOP, _calibration.offsetTop);
eepromWriteU16(CFG_EEPROM_TOUCHSCREEN_OFFSET_BOT, _calibration.offsetBottom);
eepromWriteU16(CFG_EEPROM_TOUCHSCREEN_OFFSET_DIVX, _calibration.divisorX);
eepromWriteU16(CFG_EEPROM_TOUCHSCREEN_OFFSET_DIVY, _calibration.divisorY);
eepromWriteU8(CFG_EEPROM_TOUCHSCREEN_CALIBRATED, 1);
// Clear the screen
drawFill(COLOR_BLACK);
}
