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 displayWrite(displayPort_t *instance, uint8_t x, uint8_t y, uint8_t attr, const char *s)
  84 {
  85     instance->posX = x + strlen(s);
  86     instance->posY = y;
  87     return instance->vTable->writeString(instance, x, y, attr, s);
  88 }
  89
  90 int displayWriteChar(displayPort_t *instance, uint8_t x, uint8_t y, uint8_t attr, uint8_t c)
  91 {
  92     instance->posX = x + 1;
  93     instance->posY = y;
  94     return instance->vTable->writeChar(instance, x, y, attr, c);
  95 }
  96
  97 bool displayIsTransferInProgress(const displayPort_t *instance)
  98 {
  99     return instance->vTable->isTransferInProgress(instance);
 100 }
 101
 102 bool displayIsSynced(const displayPort_t *instance)
 103 {
 104     return instance->vTable->isSynced(instance);
 105 }
 106
 107 bool displayHeartbeat(displayPort_t *instance)
 108 {
 109     return instance->vTable->heartbeat(instance);
 110 }
 111
 112 void displayRedraw(displayPort_t *instance)
 113 {
 114     instance->vTable->redraw(instance);
 115 }
 116
 117 uint16_t displayTxBytesFree(const displayPort_t *instance)
 118 {
 119     return instance->vTable->txBytesFree(instance);
 120 }
 121
 122 bool displayLayerSupported(displayPort_t *instance, displayPortLayer_e layer)
 123 {
 124     if (layer == DISPLAYPORT_LAYER_FOREGROUND) {
 125         // Every device must support the foreground (default) layer
 126         return true;
 127     } else if (layer < DISPLAYPORT_LAYER_COUNT && instance->vTable->layerSupported) {
 128         return instance->vTable->layerSupported(instance, layer);
 129     }
 130     return false;
 131 }
 132
 133 bool displayLayerSelect(displayPort_t *instance, displayPortLayer_e layer)
 134 {
 135     if (instance->vTable->layerSelect) {
 136         return instance->vTable->layerSelect(instance, layer);
 137     }
 138     return false;
 139 }
 140
 141 bool displayLayerCopy(displayPort_t *instance, displayPortLayer_e destLayer, displayPortLayer_e sourceLayer)
 142 {
 143     if (instance->vTable->layerCopy && sourceLayer != destLayer) {
 144         return instance->vTable->layerCopy(instance, destLayer, sourceLayer);
 145     }
 146     return false;
 147 }
 148
 149 bool displayWriteFontCharacter(displayPort_t *instance, uint16_t addr, const osdCharacter_t *chr)
 150 {
 151     if (instance->vTable->writeFontCharacter) {
 152         return instance->vTable->writeFontCharacter(instance, addr, chr);
 153     }
 154     return false;
 155 }
 156
 157 void displaySetBackgroundType(displayPort_t *instance, displayPortBackground_e backgroundType)
 158 {
 159     if (instance->vTable->setBackgroundType) {
 160         instance->vTable->setBackgroundType(instance, backgroundType);
 161     }
 162 }
 163
 164 bool displayCheckReady(displayPort_t *instance, bool rescan)
 165 {
 166     if (instance->vTable->checkReady) {
 167         return instance->vTable->checkReady(instance, rescan);
 168     }
 169     // Drivers that don't provide a checkReady method are
 170     // assumed to be immediately ready (either by actually
 171     // begin ready very quickly or by blocking)
 172     return true;
 173 }
 174
 175 void displayBeginTransaction(displayPort_t *instance, displayTransactionOption_e opts)
 176 {
 177     if (instance->vTable->beginTransaction) {
 178         instance->vTable->beginTransaction(instance, opts);
 179     }
 180 }
 181
 182 void displayCommitTransaction(displayPort_t *instance)
 183 {
 184     if (instance->vTable->commitTransaction) {
 185         instance->vTable->commitTransaction(instance);
 186     }
 187 }
 188
 189 bool displayGetCanvas(displayCanvas_t *canvas, const displayPort_t *instance)
 190 {
 191 #if defined(USE_CANVAS)
 192     if (canvas && instance->vTable->getCanvas && instance->vTable->getCanvas(canvas, instance)) {
 193         canvas->gridElementWidth = canvas->width / instance->cols;
 194         canvas->gridElementHeight = canvas->height / instance->rows;
 195         return true;
 196     }
 197 #else
 198     UNUSED(canvas);
 199     UNUSED(instance);
 200 #endif
 201     return false;
 202 }
 203
 204 bool displaySupportsOsdSymbols(displayPort_t *instance)
 205 {
 206     // Assume device types that support OSD display will support the OSD symbols (since the OSD logic will use them)
 207     if ((instance->deviceType == DISPLAYPORT_DEVICE_TYPE_MAX7456)
 208         || (instance->deviceType == DISPLAYPORT_DEVICE_TYPE_MSP)
 209         || (instance->deviceType == DISPLAYPORT_DEVICE_TYPE_FRSKYOSD)) {
 210         return true;
 211     } else {
 212         return false;
 213     }
 214 }
 215
 216 void displayInit(displayPort_t *instance, const displayPortVTable_t *vTable, displayPortDeviceType_e deviceType)
 217 {
 218     instance->vTable = vTable;
 219     instance->useFullscreen = false;
 220     instance->grabCount = 0;
 221     instance->deviceType = deviceType;
 222
 223     displayBeginTransaction(instance, DISPLAY_TRANSACTION_OPT_NONE);
 224     displayClearScreen(instance, DISPLAY_CLEAR_WAIT);
 225     displayCommitTransaction(instance);
 226 }