src/main/drivers/display.c

   1 /*
   2  * This file is part of Cleanflight and Betaflight.
   3  *
   4  * Cleanflight and Betaflight are free software. You can redistribute
   5  * this software and/or modify this software under the terms of the
   6  * GNU General Public License as published by the Free Software
   7  * Foundation, either version 3 of the License, or (at your option)
   8  * any later version.
   9  *
  10  * Cleanflight and Betaflight are distributed in the hope that they
  11  * will be useful, but WITHOUT ANY WARRANTY; without even the implied
  12  * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  13  * See the GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this software.
  17  *
  18  * If not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <stdbool.h>
  22 #include <stdint.h>
  23 #include <string.h>
  24
  25 #include "platform.h"
  26
  27 #include "common/utils.h"
  28
  29 #include "drivers/display_canvas.h"
  30 #include "drivers/osd.h"
  31
  32 #include "display.h"
  33
  34 void displayClearScreen(displayPort_t *instance, displayClearOption_e options)
  35 {
  36     instance->vTable->clearScreen(instance, options);
  37     instance->cleared = true;
  38     instance->cursorRow = -1;
  39 }
  40
  41 // Return true if screen still being transferred
  42 bool displayDrawScreen(displayPort_t *instance)
  43 {
  44     return instance->vTable->drawScreen(instance);
  45 }
  46
  47 int displayScreenSize(const displayPort_t *instance)
  48 {
  49     return instance->vTable->screenSize(instance);
  50 }
  51
  52 void displayGrab(displayPort_t *instance)
  53 {
  54     instance->vTable->grab(instance);
  55     instance->vTable->clearScreen(instance, DISPLAY_CLEAR_WAIT);
  56     ++instance->grabCount;
  57 }
  58
  59 void displayRelease(displayPort_t *instance)
  60 {
  61     instance->vTable->release(instance);
  62     --instance->grabCount;
  63 }
  64
  65 void displayReleaseAll(displayPort_t *instance)
  66 {
  67     instance->vTable->release(instance);
  68     instance->grabCount = 0;
  69 }
  70
  71 bool displayIsGrabbed(const displayPort_t *instance)
  72 {
  73     // can be called before initialised
  74     return (instance && instance->grabCount > 0);
  75 }
  76
  77 void displaySetXY(displayPort_t *instance, uint8_t x, uint8_t y)
  78 {
  79     instance->posX = x;
  80     instance->posY = y;
  81 }
  82
  83 int displaySys(displayPort_t *instance, uint8_t x, uint8_t y, displayPortSystemElement_e systemElement)
  84 {
  85     if (instance->vTable->writeSys) {
  86         return instance->vTable->writeSys(instance, x, y, systemElement);
  87     }
  88
  89     return 0;
  90 }
  91
  92 int displayWrite(displayPort_t *instance, uint8_t x, uint8_t y, uint8_t attr, const char *text)
  93 {
  94     instance->posX = x + strlen(text);
  95     instance->posY = y;
  96     return instance->vTable->writeString(instance, x, y, attr, text);
  97 }
  98
  99 int displayWriteChar(displayPort_t *instance, uint8_t x, uint8_t y, uint8_t attr, uint8_t c)
 100 {
 101     instance->posX = x + 1;
 102     instance->posY = y;
 103     return instance->vTable->writeChar(instance, x, y, attr, c);
 104 }
 105
 106 bool displayIsTransferInProgress(const displayPort_t *instance)
 107 {
 108     return instance->vTable->isTransferInProgress(instance);
 109 }
 110
 111 bool displayIsSynced(const displayPort_t *instance)
 112 {
 113     return instance->vTable->isSynced(instance);
 114 }
 115
 116 bool displayHeartbeat(displayPort_t *instance)
 117 {
 118     return instance->vTable->heartbeat(instance);
 119 }
 120
 121 void displayRedraw(displayPort_t *instance)
 122 {
 123     instance->vTable->redraw(instance);
 124 }
 125
 126 uint16_t displayTxBytesFree(const displayPort_t *instance)
 127 {
 128     return instance->vTable->txBytesFree(instance);
 129 }
 130
 131 bool displayLayerSupported(displayPort_t *instance, displayPortLayer_e layer)
 132 {
 133     if (layer == DISPLAYPORT_LAYER_FOREGROUND) {
 134         // Every device must support the foreground (default) layer
 135         return true;
 136     } else if (layer < DISPLAYPORT_LAYER_COUNT && instance->vTable->layerSupported) {
 137         return instance->vTable->layerSupported(instance, layer);
 138     }
 139     return false;
 140 }
 141
 142 bool displayLayerSelect(displayPort_t *instance, displayPortLayer_e layer)
 143 {
 144     if (instance->vTable->layerSelect) {
 145         return instance->vTable->layerSelect(instance, layer);
 146     }
 147     return false;
 148 }
 149
 150 bool displayLayerCopy(displayPort_t *instance, displayPortLayer_e destLayer, displayPortLayer_e sourceLayer)
 151 {
 152     if (instance->vTable->layerCopy && sourceLayer != destLayer) {
 153         return instance->vTable->layerCopy(instance, destLayer, sourceLayer);
 154     }
 155     return false;
 156 }
 157
 158 bool displayWriteFontCharacter(displayPort_t *instance, uint16_t addr, const osdCharacter_t *chr)
 159 {
 160     if (instance->vTable->writeFontCharacter) {
 161         return instance->vTable->writeFontCharacter(instance, addr, chr);
 162     }
 163     return false;
 164 }
 165
 166 void displaySetBackgroundType(displayPort_t *instance, displayPortBackground_e backgroundType)
 167 {
 168     if (instance->vTable->setBackgroundType) {
 169         instance->vTable->setBackgroundType(instance, backgroundType);
 170     }
 171 }
 172
 173 bool displayCheckReady(displayPort_t *instance, bool rescan)
 174 {
 175     if (instance->vTable->checkReady) {
 176         return instance->vTable->checkReady(instance, rescan);
 177     }
 178     // Drivers that don't provide a checkReady method are
 179     // assumed to be immediately ready (either by actually
 180     // begin ready very quickly or by blocking)
 181     return true;
 182 }
 183
 184 void displayBeginTransaction(displayPort_t *instance, displayTransactionOption_e opts)
 185 {
 186     if (instance->vTable->beginTransaction) {
 187         instance->vTable->beginTransaction(instance, opts);
 188     }
 189 }
 190
 191 void displayCommitTransaction(displayPort_t *instance)
 192 {
 193     if (instance->vTable->commitTransaction) {
 194         instance->vTable->commitTransaction(instance);
 195     }
 196 }
 197
 198 bool displayGetCanvas(displayCanvas_t *canvas, const displayPort_t *instance)
 199 {
 200 #if defined(USE_CANVAS)
 201     if (canvas && instance->vTable->getCanvas && instance->vTable->getCanvas(canvas, instance)) {
 202         canvas->gridElementWidth = canvas->width / instance->cols;
 203         canvas->gridElementHeight = canvas->height / instance->rows;
 204         return true;
 205     }
 206 #else
 207     UNUSED(canvas);
 208     UNUSED(instance);
 209 #endif
 210     return false;
 211 }
 212
 213 bool displaySupportsOsdSymbols(displayPort_t *instance)
 214 {
 215     // Assume device types that support OSD display will support the OSD symbols (since the OSD logic will use them)
 216     if ((instance->deviceType == DISPLAYPORT_DEVICE_TYPE_MAX7456)
 217         || (instance->deviceType == DISPLAYPORT_DEVICE_TYPE_MSP)
 218         || (instance->deviceType == DISPLAYPORT_DEVICE_TYPE_FRSKYOSD)) {
 219         return true;
 220     } else {
 221         return false;
 222     }
 223 }
 224
 225 void displayInit(displayPort_t *instance, const displayPortVTable_t *vTable, displayPortDeviceType_e deviceType)
 226 {
 227     instance->vTable = vTable;
 228     instance->useFullscreen = false;
 229     instance->grabCount = 0;
 230     instance->deviceType = deviceType;
 231
 232     displayBeginTransaction(instance, DISPLAY_TRANSACTION_OPT_NONE);
 233     displayClearScreen(instance, DISPLAY_CLEAR_WAIT);
 234     displayCommitTransaction(instance);
 235 }