Touchscreen

Posted on Sun 11th, September 2016

• #1

allObjects

In many previous projects I used a 2.8" TFT 262K Color LCD display with resistive touchscreen. Since the display had no touchscreen controller, I implemented one on Espruino (Resistive Touchscreen directly (no touch controller)). Recently I wanted to use the display again, but for whatever reason it turned out to be dead not only like a possum, but really really dead. So I ordered some cheaper once of 2.2" size, since needed them just to verify code for the ILI9341 display controller.

The cheap 2.4" display showed though up with a XPT2046 touchscreen controller from XPTEK TECHNOLOGY CO., LTD, SHENZHEN. After consulting the data sheet it seems that the XPT2046 is functionally about equal to Burr-Brown's / TI's ADS7843 and thus Espruino's ADS7843 module works... at least, it returns coordinates... dodged that bullet... easily...

But from there on in went tricky to say the least... and unfortunately ended with the conclusion: module useless (from the point of usable values,.. and more), because the user's touch accuracy is about +- 2..3 pixels... but the module error is up to 32... just not useful for a touch UI.

Why?

Below code and and attached shot show. The code sets up the display and the touch screen, then draws calibration markers in all corners and the center and then logs values for calibration.

// TFT24TRCportraitCalibr.js
//
//  2.4" 240x320 262K Color TFT LCD ILI9341 on SPI1 with 
//  Resistive Touch Screen Controller XPT2046 on SPI2
//  using out of box ILI9341 and ADS7843 modules.
//
// Wiring:
//  2.4"
//  DSP                  PICO [<---USB
//   1   VCC      red     3   3.3            shared
//   2   GND      blk     1   GND            shared
//   3   CS       blu     7   B6   CS        LCD
//   4   RST      brn     9   A8   reset RST LCD
//   5   D/C      grn     8   B7   D/C       LCD
//   6   MOSI     ylw     6   B5   SPI1 MOSI LCD
//   7   SCK      wht     4   B3   SPI1 SCK  LCD
//   8   LED      org    18   A5   LED       LCD
//   9   MISO     grn     5   B4   SPI1 MISO LCD
//  10   T_CLK    wht    23   B13  SPI2 SCK  Touch
//  11   T_CS     ylw    22   B10  CS        Touch
//  12   T_MOSI   grn    25   B15  SPI2 MOSI Touch
//  13   T_MISO   blu    24   B14  SPI2 MISO Touch
//  14   T_IRQ    blk    21   B1   IRQ       Touch

var dW = 240, dH = 320, dsp, dMod = require("ILI9341"),
    tSPI=SPI2, tCs = B10, tIrq = B1, 
    touch, tMod = require("ADS7843");

// marker specs (lik dice face 5; top left to bottom right)
var mrks =
    [{i:1, label:"topLeft"    , x: 20, y: 20, xOff: 14, yOff:-6}
    ,{i:2, label:"topRight"   , x:220, y: 20, xOff:-66, yOff:-6}
    ,{i:3, label:"center"     , x:120, y:160, xOff:-29, yOff:14}
    ,{i:4, label:"bottomLeft" , x: 20, y:300, xOff: 14, yOff:-6}
    ,{i:5, label:"bottomRight", x:220, y:300, xOff:-74, yOff:-6}
    ];
var mSiz = 9; // half of marker size, (0.7 of font size)

// print marker at x/y of size s with x/y label
function mrkr(d,x,y,s,xOff,yOff) {
  dsp.setColor(1,1,1);
  dsp.drawRect(x-s,y-s,x+s,y+s);
  dsp.drawLine(x-s,y,x+s,y);
  dsp.drawLine(x,y-s,x,y+s);
  dsp.setFontVector(s / 0.7);
  dsp.drawString(x + " / " + y, x+xOff, y+yOff);
}

function average(arry) { // return avarage of array values
  return arry.reduce(
    function(p,c) { return p + c; },0) / arry.length; }

function logAverage(seq,xs,ys) { // log x / y average
  var x = Math.round(average(xs)), 
      y = Math.round(average(ys));
  console.log(
      seq + 1
    , mrks[seq].label
    , mrks[seq].x, mrks[seq].y
    , x ,"(" + (x - mrks[seq].x) + ")"
    , y ,"(" + (y - mrks[seq].y) + ")"
    );
}

function onInit() {
  A5.set();
  SPI1.setup({sck:B3, miso:B4, mosi:B5, baud: 1000000});
                   // spi, dc, cs, rst, callback
  dsp = dMod.connect(SPI1, B7, B6, A8, function() {
      dsp.clear();
      // print markers like dice face of 5
      mrks.forEach(function(m) {
        mrkr(dsp, m.x, m.y, mSiz, m.xOff, m.yOff); });
      // setup touchscreen with callback averaging
      // x and y sequence for calibration of 
      // touchscreen to lcd display.
      SPI2.setup({sck:B13, miso:B14, mosi:B15, baud: 2000000});
      var seq = 0, xs = [], ys = [], x, y;
      touch = tMod.connect(
            // spi, cs, irq, offsetx, offsety, w, h, callback // landscape
            SPI2, B10, B1,   -15,   6, dH, dW, function(yt, xt) {  // portrait
          if (yt !== undefined) {
            // collect x and y for averaging
            xs.push(dW - xt); ys.push(yt);
          } else {
            // log x and y avarages in console 
            logAverage(seq, xs, ys);
            xs = []; ys = []; seq   = (seq +1) % 5;
          }
      });
  });
}

onInit();

The issues are:

ILI9341 initializes in portrait with x=0..239 - 240 pixels wide - and y=0...319 - 320 pixels high - and 0 / 0 top left (see shot).
XPT2046 controller is wired portrait, but not in a twisted way... not just rotated by 90 degrees... It could be fixed with the some additional calculation: with or hight - coordinate touch value.
it is not good enough to have an x and y offset for the controller function to calculate the actual x and y for a given display size. The offset helps with the touch screen not aligning with the display, but it messes up the scaling: if the low value is ok, the high value is too much off and vice versa. This can be seen in the output generated by above code when touching the calibration points from top left to bottom right.

Because many touch screens are larger than the display because they show fixed, printed buttons in the overhang area. For touching in the overhang, proper calculation returns values beyond the screen coordinates.

Produced output (aligned and with headings added):

 1v86 Copyright 2016 G.Williams
>echo(0);
=undefined
        expected x / y   effective (deviation)
1 topLeft       20  20      21 (  1)  21 (  1)
2 topRight     220  20     201 (-19)  22 (  2)
3 center       120 160     110 (-10) 144 (-16)
4 bottomLeft    20 300      19 ( -1) 271 (-29)
5 bottomRight  220 300     203 (-17) 268 (-32)
>

Looking at x coordinate, the low value is about correct, but the deviation for higher values goes linearly up by about 10 per 120 pixels (half screen width). The 'balconies' or 'porches'
(screen vs display sizes and alignments) impact the calculation beyond what an offset can handle.

Same can be said for the y coordinate: after adjusting with an offset, the error is even worse.

Since the issues are hardware - wiring, size and alignment dependent, a module has to provide an option to pass a calculation function that takes minimum AND maximum touch values into account to scale properly with the display size. I'll take a stab at it and will publish in a next post.

2 Attachments

TFT24TRCportraitCalibr.js

• #2

allObjects

Here it is, the calibration, resulting in a new module and a calibration function:

// TFT24TRCportraitCalibr2.js
//
//  2.4" 240x320 262K Color TFT LCD ILI9341 on SPI1 with 
//  Resistive Touch Screen Controller XPT2046 on SPI2
//  using out of box ILI9341 and ADS7843 modules.
//
// Wiring:
//  2.4"
//  DSP                  PICO [<---USB
//   1   VCC      red     3   3.3            shared
//   2   GND      blk     1   GND            shared
//   3   CS       blu     7   B6   CS        LCD
//   4   RST      brn     9   A8   reset RST LCD
//   5   D/C      grn     8   B7   D/C       LCD
//   6   MOSI     ylw     6   B5   SPI1 MOSI LCD
//   7   SCK      wht     4   B3   SPI1 SCK  LCD
//   8   LED      org    18   A5   LED       LCD
//   9   MISO     grn     5   B4   SPI1 MISO LCD
//  10   T_CLK    wht    23   B13  SPI2 SCK  Touch
//  11   T_CS     ylw    22   B10  CS        Touch
//  12   T_MOSI   grn    25   B15  SPI2 MOSI Touch
//  13   T_MISO   blu    24   B14  SPI2 MISO Touch
//  14   T_IRQ    blk    21   B1   IRQ       Touch

var dW = 240, dH = 320, dsp, dMod = require("ILI9341"),
    tSPI=SPI2, tCs = B10, tIrq = B1, 
    touch, tMod = // require("ADS7843");
// future XPT2046 touchscreen controller
// default calculation is a pass thru
{ calc: function(x, y, d) { return [x,y,d]; } // default calculation
, connect: function(spi, cs, irq, callback, calc) {
    // overwrite default 'calculation': pass thru incl. raw values
    if (calc) { this.calc = calc; }
    // wake the controller up
    spi.send([0x90,0],cs);
    // look for a press
    var watchFunction = function() {
      var interval = setInterval(function () {
        if (!digitalRead(irq)) { // touch down
          var d = spi.send([0x90,0,0xD0,0,0], cs);
          callback.apply(undefined, this.calc(d[1]*256+d[2], d[3]*256+d[4], d));
        } else {
          callback();
          clearInterval(interval);
          interval = undefined;
          setWatch(watchFunction, irq, { repeat : false, edge: "falling" });
        }
      }.bind(this), 50);
    }.bind(this);
    setWatch(watchFunction, irq, { repeat : false, edge: "falling" });
    return this;
  }
};

// marker specs (lik dice face 5; top left to bottom right)
var mrks =
    [{i:1, label:"topLeft    ", x: 20, y: 20, xOff: 14, yOff:-6}
    ,{i:2, label:"topRight   ", x:220, y: 20, xOff:-66, yOff:-6}
    ,{i:3, label:"center     ", x:120, y:160, xOff:-29, yOff:14}
    ,{i:4, label:"bottomLeft ", x: 20, y:300, xOff: 14, yOff:-6}
    ,{i:5, label:"bottomRight", x:220, y:300, xOff:-74, yOff:-6}
    ];
var mSiz = 9; // half of marker size, (0.7 of font size)

// print marker at x/y of size s with x/y label
function mrkr(d,x,y,s,xOff,yOff) {
  dsp.setColor(1,1,1);
  dsp.drawRect(x-s,y-s,x+s,y+s);
  dsp.drawLine(x-s,y,x+s,y);
  dsp.drawLine(x,y-s,x,y+s);
  dsp.setFontVector(s / 0.7);
  dsp.drawString(x + " / " + y, x+xOff, y+yOff);
}

function average(arry) { // return avarage of array values
  return arry.reduce(
    function(p,c) { return p + c; },0) / arry.length; }

function fInt(i,l) { return ("        " + i).substr(-l); }

function logXY(m,xp,yp,l,d) {
  console.log(
      m.i
    , m.label
    , fInt(m.x,4), fInt(m.y,4)
    , fInt(m[xp],l), (d) ? "(" + fInt(m[xp] - m.x,4) + ")" : ""
    , fInt(m[yp],l), (d) ? "(" + fInt(m[yp] - m.y,4) + ")" : ""
    );
}

function handleAverage(seq,xs,ys) { // log x / y average
  var m = mrks[seq],
      x = Math.round(average(xs)), 
      y = Math.round(average(ys));
  m.xAvg = x; m.yAvg = y;
  logXY(m,"xAvg","yAvg",6);
  if (seq === 4) { // all in, calc calibration parms and calib with new calc function
    var xscs = [], // xscales = x deltas per pixel
        yscs = [], // yscales = y deltas per pixel
        xoss = [], // xoffsets 
        yoss = []; // yoffsets
    xscs.push((mrks[1].xAvg - mrks[0].xAvg) / (mrks[1].x - mrks[0].x)); // top x deltas
    xscs.push((mrks[2].xAvg - mrks[0].xAvg) / (mrks[2].x - mrks[0].x)); // top left - cent
    xscs.push((mrks[1].xAvg - mrks[2].xAvg) / (mrks[1].x - mrks[2].x)); // cent - top right
    xscs.push((mrks[4].xAvg - mrks[3].xAvg) / (mrks[4].x - mrks[3].x)); // bottom x deltas
    xscs.push((mrks[2].xAvg - mrks[3].xAvg) / (mrks[2].x - mrks[3].x)); // bot left - cent
    xscs.push((mrks[4].xAvg - mrks[2].xAvg) / (mrks[4].x - mrks[2].x)); // cent - top right
    console.log(xscs);
    yscs.push((mrks[3].yAvg - mrks[0].yAvg) / (mrks[3].y - mrks[0].y)); // left y deltas
    yscs.push((mrks[2].yAvg - mrks[0].yAvg) / (mrks[2].y - mrks[0].y)); // top left - cent
    yscs.push((mrks[3].yAvg - mrks[2].yAvg) / (mrks[3].y - mrks[2].y)); // cent - left bottom
    yscs.push((mrks[4].yAvg - mrks[1].yAvg) / (mrks[4].y - mrks[1].y)); // right y deltas
    yscs.push((mrks[2].yAvg - mrks[1].yAvg) / (mrks[2].y - mrks[1].y)); // top right - cent
    yscs.push((mrks[4].yAvg - mrks[2].yAvg) / (mrks[4].y - mrks[2].y)); // cent - bot right
    console.log(yscs);
    var xsc = average(xscs), 
        ysc = average(yscs);
    mrks.forEach(function(m) { 
        xoss.push(m.x - m.xAvg / xsc); 
        yoss.push(m.y - m.yAvg / ysc);
    });
    console.log(xoss);
    console.log(yoss);
    var xos = average(xoss), 
        yos = average(yoss);
    console.log("x / y scale", xsc, ysc);
    console.log("x / y offset", xos, yos);
    mrks.forEach(function(m){
      m.xc = Math.round((m.xAvg / xsc) + xos);
      m.yc = Math.round((m.yAvg / ysc) + yos);
      logXY(m,"xc","yc",4,true);
    });
    
    // calibrated calc function set in touch:
    // x / y scale   -121.5825         89.79285714285
    // x / y offset   258.33405300927 -18.53090446265
    touch.calc = function(yr, xr) { // xy raw
      return [Math.round(xr / xsc + xos) // / x scale per pixel + x offset
             ,Math.round(yr / ysc + yos) // / y scale per pixel + y offset
             ];
    };
    
    calibrated = true;
    console.log("---- calibrated, normal mode");
    console.log(" touch markers for validation.");
  }
}

var calibrated = false;

function onInit() {
  A5.set();
  SPI1.setup({sck:B3, miso:B4, mosi:B5, baud: 1000000});
                   // spi, dc, cs, rst, callback
  dsp = dMod.connect(SPI1, B7, B6, A8, function() {
      dsp.clear();
      // print markers like dice face of 5
      mrks.forEach(function(m) {
        mrkr(dsp, m.x, m.y, mSiz, m.xOff, m.yOff); });
      console.log("---- in calibration mode:");
      console.log(" touch markers from top left to bottom right.");
      // setup touchscreen with callback averaging
      // x and y sequence for calibration of 
      // touchscreen to lcd display.
      SPI2.setup({sck:B13, miso:B14, mosi:B15, baud: 2000000});
      var seq = 0, xs = [], ys = [], x, y;
      touch = tMod.connect(
          // spi, cs, irq, callback, calc // landscape
          SPI2, B10, B1, function(m1, m2, rd) {  // portrait
            var xt, yt;
            if (calibrated) { // calibrated mode
              xt = m1; yt = m2;
              if (xt !== undefined) {
                console.log(fInt(xt,4),fInt(yt,4));
              }
            } else { // calibration mode
              xt = m2; yt = m1;
              if (xt !== undefined) {
                // console.log(rd);
                // collect x and y for averaging
                xs.push(xt); ys.push(yt);
              } else {
                // log x and y avarages in console 
                handleAverage(seq, xs, ys);
                xs = []; ys = []; seq   = (seq +1) % 5;
              }
            }
      });
  });
}

onInit();

Related console output:

 1v86 Copyright 2016 G.Williams
>echo(0);
=undefined
---- in calibration mode:
 touch markers from top left to bottom right.
1 topLeft       20   20  29148    3490
2 topRight     220   20   4862    3495
3 center       120  160  17118   16160
4 bottomLeft    20  300  28996   28347
5 bottomRight  220  300   4706   28424
[ -121.43, -120.3, -122.56, -121.45, -118.78, -124.12 ]
[ 88.775, 90.5, 87.05, 89.03214285714, 90.46428571428, 87.6 ]
[ 260.01976284584, 260.03623188405, 260.95849802371, 258.76811594202, 258.75164690382 ]
[ -19.25601574739, -19.31225645763, -21.76997549511, -18.85108263367, -19.71718957136 ]
x / y scale -121.44 88.90357142857
x / y offset 259.70685111989 -19.78130398103
1 topLeft       20   20   20 (   0)   19 (  -1)
2 topRight     220   20  220 (   0)   20 (   0)
3 center       120  160  119 (  -1)  162 (   2)
4 bottomLeft    20  300   21 (   1)  299 (  -1)
5 bottomRight  220  300  221 (   1)  300 (   0)
---- calibrated, normal mode
 touch markers for validation.
  21  18
  23  17
  18  18
 222  19
 221  19
 223  20
 120 160
 121 160
 116 160
 121 159
  19 303
  20 303
  16 299
 220 304
 221 301
 221 299
 222 301
>

The calibration goes as follows:

30..53 provided a new module base on existing one that allows to set a customized calculation function
- 30 shows the default - pass through function - which accepts the raw coordinates and the read data. Read data is pass just in case...
- 41 shows the calculation invocation with the pre-calculation of the raw coordinates (same as known from existing modules: highByte * 256 + lowByte)
- 48 and 49 are noteworthy where context of module / touch singleton is bound in order to use this.calc(...) function in nested anonymous watch and interval functions.
- 176..187 raw values are collected while touching the calibration marks from top left to bottom right.
- 97 starts the actual calibration calculations...
- 98..117 calculates raw value per pixel based on known coordinates of the markers and measured values: scale value (raw value) / pixel = read value difference divided by pixel delta of the markers
- 118..128 calculates the offset for each axis.
- 126 and 127 show the calculated scale and offset values.
- 128..132 calculates the new values from the initially read values (1..5 console output) with given scaling and offset and shows them in the console for verification (117..121 console output)
- 134..141 sets the new calibrated calculation function in touch singleton
- 143 switches into regular mode for verification of the calc function (touching/tapping the markers again shows new calculated values as expected.

1 Attachment

TFT24TRCportraitCalibr2.js

• #3

allObjects

XPT2046.js module code:

/*

XPT2046 (pin/function compatible to ADS7843) 
Resistive Touch Screen Controller module

` ` `
var touch, touchModule = require("XPT2046");

function onInit() {
      // ...
      // setup touchscreen 
      SPI2.setup({sck:B13, miso:B14, mosi:B15, baud: 2000000});
      touch = tMod.connect(
          // spi, cs, irq, callback, calc // landscape
          SPI2, B10, B1, function(x, y, rd) {  // portrait
              if (x !== undefined) {
                console.log(x,y);
              }
      }, function(yr, xr, d) { // calc function - converts raw data to x / y coordinates;
        // scale and offset values calculated using markers and default calc function.
        // see http://forum.espruino.com/conversations/292641 - Touchscreen     
//      return [ Math.round(xr / xsc + xos) // / x scale per pixel + x offset
//             , Math.round(yr / ysc + yos) // / y scale per pixel + y offset
        return [ Math.round(xr / -121.44          + 259.70685111989) 
               , Math.round(yr /   88.90357142857 + -19.78130398103)
               ];
      });
      // ...
}
` ` `

 */

exports = // XPT2046 module
{ calc: function(x, y, d) { return [x,y,d]; } // default calculation
, connect: function(spi, cs, irq, callback, calc) {
    // overwrite default 'calculation': pass thru incl. raw values
    if (calc) { this.calc = calc; }
    // wake the controller up
    spi.send([0x90,0],cs);
    // look for a press
    var watchFunction = function() {
      var interval = setInterval(function () {
        if (!digitalRead(irq)) { // touch down
          var d = spi.send([0x90,0,0xD0,0,0], cs);
          callback.apply(undefined, this.calc(d[1]*256+d[2], d[3]*256+d[4], d));
        } else {
          callback();
          clearInterval(interval);
          interval = undefined;
          setWatch(watchFunction, irq, { repeat : false, edge: "falling" });
        }
      }.bind(this), 50);
    }.bind(this);
    setWatch(watchFunction, irq, { repeat : false, edge: "falling" });
    return this;
  }
};

Application using the (minified) module code from local Web IDE sandbox/modules folder. Note the touchscreen module .connect() that is supplied with the calculation function to converts the raw screen controller data into x and y for the screen.

// TFT24TRCportraitCalibr3.js - XPT2046 module test
//
//  2.4" 240x320 262K Color TFT LCD ILI9341 on SPI1 with 
//  Resistive Touch Screen Controller XPT2046 on SPI2
//  using out of box ILI9341 and ADS7843 modules.
//
// Wiring:
//  2.4"
//  DSP                  PICO [<---USB
//   1   VCC      red     3   3.3            shared
//   2   GND      blk     1   GND            shared
//   3   CS       blu     7   B6   CS        LCD
//   4   RST      brn     9   A8   reset RST LCD
//   5   D/C      grn     8   B7   D/C       LCD
//   6   MOSI     ylw     6   B5   SPI1 MOSI LCD
//   7   SCK      wht     4   B3   SPI1 SCK  LCD
//   8   LED      org    18   A5   LED       LCD
//   9   MISO     grn     5   B4   SPI1 MISO LCD
//  10   T_CLK    wht    23   B13  SPI2 SCK  Touch
//  11   T_CS     ylw    22   B10  CS        Touch
//  12   T_MOSI   grn    25   B15  SPI2 MOSI Touch
//  13   T_MISO   blu    24   B14  SPI2 MISO Touch
//  14   T_IRQ    blk    21   B1   IRQ       Touch

var dW = 240, dH = 320, dsp, dMod = require("ILI9341"),
    touch, tMod = require("XPT2046");

// marker specs (lik dice face 5; top left to bottom right)
var mrks =
    [{i:1, label:"topLeft    ", x: 20, y: 20, xOff: 14, yOff:-6}
    ,{i:2, label:"topRight   ", x:220, y: 20, xOff:-66, yOff:-6}
    ,{i:3, label:"center     ", x:120, y:160, xOff:-29, yOff:14}
    ,{i:4, label:"bottomLeft ", x: 20, y:300, xOff: 14, yOff:-6}
    ,{i:5, label:"bottomRight", x:220, y:300, xOff:-74, yOff:-6}
    ];
var mSiz = 9; // half of marker size, (0.7 of font size)

// print marker at x/y of size s with x/y label
function mrkr(d,x,y,s,xOff,yOff) {
  dsp.setColor(1,1,1);
  dsp.drawRect(x-s,y-s,x+s,y+s);
  dsp.drawLine(x-s,y,x+s,y);
  dsp.drawLine(x,y-s,x,y+s);
  dsp.setFontVector(s / 0.7);
  dsp.drawString(x + " / " + y, x+xOff, y+yOff);
}

function fInt(i,l) { return ("        " + i).substr(-l); }

function onInit() {
  A5.set();
  SPI1.setup({sck:B3, miso:B4, mosi:B5, baud: 1000000});
                   // spi, dc, cs, rst, callback
  dsp = dMod.connect(SPI1, B7, B6, A8, function() {
      dsp.clear();
      // print markers like dice face of 5
      mrks.forEach(function(m) {
        mrkr(dsp, m.x, m.y, mSiz, m.xOff, m.yOff); });
      // setup touchscreen 
      SPI2.setup({sck:B13, miso:B14, mosi:B15, baud: 2000000});
      touch = tMod.connect(
          // spi, cs, irq, callback, calc
          SPI2, B10, B1, function(x, y) {
            if (x !== undefined) {
              console.log(fInt(x,4),fInt(y,4));
            }
          }, function(yr, xr, d) {
            // calc function - converts raw data to x / y coordinates;
            // scale and offset values calculated using calibration 
            // markers and default calc function. For more details see
            // http://forum.espruino.com/conversations/292641 - Touchscreen
//          return [ Math.round(xr / xsc + xos) // / x scale per pixel + x offset
//                 , Math.round(yr / ysc + yos) // / y scale per pixel + y offset
            return [ Math.round(xr / -121.44          + 259.70685111989) 
                   , Math.round(yr /   88.90357142857 + -19.78130398103)
                   ];
      });
  });
}

onInit();

Related console output (tapping on markers on screen).

NOTE the last 4 lines which lay outside of the display, because the touch screen has a pretty sizable porch at the bottom.

 1v86 Copyright 2016 G.Williams
>echo(0);
=undefined
  21   18
  22   19
  22   18
 223   20
 222   19
 121  162
 118  160
 121  162
  18  303
  19  303
  17  301
 219  303
 219  300
 220  300
 220  302
 130  333
 127  324
 128  328
 126  324
>

Note: This module is used in Modular and extensible UI framework and ui elements conversation.

1 Attachment

TFT24TRCportraitCalibr3.js

Post a reply
- Bold
- Italics
- Link
- Image
- List
- Quote
- code
- Preview
Formatting Help

Don't worry about formatting, just type in the text and we'll take care of making sense of it. We will auto-convert links, and if you put asterisks around words we will make them bold.

Tips:

Create headers by underlining text with ==== or ----

To *italicise* text put one asterisk each side of the word

To **bold** text put two asterisks each side of the word

Embed images by entering:
![](https://www.google.co.uk/images/srpr/logo4w.png)
That's the hard one: exclamation, square brackets and then the URL to the image in brackets.

* Create lists by starting lines with asterisks

1. Create numbered lists by starting lines with a number and a dot

> Quote text by starting lines with >

Mention another user by @username

For syntax highlighting, surround the code block with three backticks:

```
Your code goes here
```
Just like Github, a blank line must precede a code block.

If you upload more than 5 files we will display all attachments as thumbnails.

For a full reference visit the Markdown syntax.

Touchscreen

About

Touchscreen

Actions

Touchscreen

Formatting Help

About

Touchscreen

Actions

Espruino