src/main/io/displayport_crsf.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 <string.h>
  23
  24 #include "platform.h"
  25
  26 #if defined(USE_CRSF_CMS_TELEMETRY)
  27
  28 #include "cms/cms.h"
  29 #include "common/maths.h"
  30 #include "common/printf.h"
  31 #include "common/time.h"
  32 #include "drivers/display.h"
  33 #include "drivers/time.h"
  34 #include "io/displayport_crsf.h"
  35
  36 #define CRSF_DISPLAY_PORT_OPEN_DELAY_MS     400
  37 #define CRSF_DISPLAY_PORT_CLEAR_DELAY_MS    45
  38
  39 static crsfDisplayPortScreen_t crsfScreen;
  40 static timeMs_t delayTransportUntilMs = 0;
  41
  42 displayPort_t crsfDisplayPort;
  43
  44 static int crsfGrab(displayPort_t *displayPort)
  45 {
  46     return displayPort->grabCount = 1;
  47 }
  48
  49 static int crsfClearScreen(displayPort_t *displayPort)
  50 {
  51     UNUSED(displayPort);
  52     memset(crsfScreen.buffer, ' ', sizeof(crsfScreen.buffer));
  53     memset(crsfScreen.pendingTransport, 0, sizeof(crsfScreen.pendingTransport));
  54     crsfScreen.reset = true;
  55     delayTransportUntilMs = millis() + CRSF_DISPLAY_PORT_CLEAR_DELAY_MS;
  56     return 0;
  57 }
  58
  59 static int crsfRelease(displayPort_t *displayPort)
  60 {
  61     displayPort->grabCount = 0;
  62     return crsfClearScreen(displayPort);
  63 }
  64
  65 static int crsfDrawScreen(displayPort_t *displayPort)
  66 {
  67     UNUSED(displayPort);
  68     return 0;
  69 }
  70
  71 static int crsfScreenSize(const displayPort_t *displayPort)
  72 {
  73     return displayPort->rows * displayPort->cols;
  74 }
  75
  76
  77 static int crsfWriteString(displayPort_t *displayPort, uint8_t col, uint8_t row, const char *s)
  78 {
  79     UNUSED(displayPort);
  80     if (row >= crsfScreen.rows || col >= crsfScreen.cols) {
  81         return 0;
  82     }
  83     const size_t truncLen = MIN((int)strlen(s), crsfScreen.cols-col);  // truncate at colCount
  84     char *rowStart = &crsfScreen.buffer[row * crsfScreen.cols + col];
  85     crsfScreen.pendingTransport[row] = memcmp(rowStart, s, truncLen);
  86     if (crsfScreen.pendingTransport[row]) {
  87         memcpy(rowStart, s, truncLen);
  88     }
  89     return 0;
  90 }
  91
  92 static int crsfWriteChar(displayPort_t *displayPort, uint8_t col, uint8_t row, uint8_t c)
  93 {
  94     char s[1];
  95     tfp_sprintf(s, "%c", c);
  96     return crsfWriteString(displayPort, col, row, s);
  97 }
  98
  99 static bool crsfIsTransferInProgress(const displayPort_t *displayPort)
 100 {
 101     UNUSED(displayPort);
 102     return false;
 103 }
 104
 105 static bool crsfIsSynced(const displayPort_t *displayPort)
 106 {
 107     UNUSED(displayPort);
 108     return true;
 109 }
 110
 111 static int crsfHeartbeat(displayPort_t *displayPort)
 112 {
 113     UNUSED(displayPort);
 114     return 0;
 115 }
 116
 117 static void crsfResync(displayPort_t *displayPort)
 118 {
 119     displayPort->rows = crsfScreen.rows;
 120     displayPort->cols = crsfScreen.cols;
 121 }
 122
 123 static uint32_t crsfTxBytesFree(const displayPort_t *displayPort)
 124 {
 125     UNUSED(displayPort);
 126     return UINT32_MAX;
 127 }
 128
 129 static const displayPortVTable_t crsfDisplayPortVTable = {
 130     .grab = crsfGrab,
 131     .release = crsfRelease,
 132     .clearScreen = crsfClearScreen,
 133     .drawScreen = crsfDrawScreen,
 134     .screenSize = crsfScreenSize,
 135     .writeString = crsfWriteString,
 136     .writeChar = crsfWriteChar,
 137     .isTransferInProgress = crsfIsTransferInProgress,
 138     .heartbeat = crsfHeartbeat,
 139     .resync = crsfResync,
 140     .isSynced = crsfIsSynced,
 141     .txBytesFree = crsfTxBytesFree
 142 };
 143
 144 crsfDisplayPortScreen_t *crsfDisplayPortScreen(void)
 145 {
 146     return &crsfScreen;
 147 }
 148
 149 void crsfDisplayPortMenuOpen(void)
 150 {
 151     if (cmsInMenu) {
 152         return;
 153     }
 154     if (cmsDisplayPortSelect(&crsfDisplayPort)) {
 155         cmsMenuOpen();
 156         delayTransportUntilMs = millis() + CRSF_DISPLAY_PORT_OPEN_DELAY_MS;
 157     }
 158 }
 159
 160 void crsfDisplayPortMenuExit(void)
 161 {
 162     if (!cmsInMenu) {
 163         return;
 164     }
 165     uint8_t exitMenu = CMS_EXIT;
 166     cmsMenuExit(&crsfDisplayPort, &exitMenu);
 167 }
 168
 169 void crsfDisplayPortSetDimensions(uint8_t rows, uint8_t cols)
 170 {
 171     crsfScreen.rows = MIN(rows, CRSF_DISPLAY_PORT_ROWS_MAX);
 172     crsfScreen.cols = MIN(cols, CRSF_DISPLAY_PORT_COLS_MAX);
 173     crsfResync(&crsfDisplayPort);
 174 }
 175
 176 void crsfDisplayPortRefresh(void)
 177 {
 178     if (!cmsInMenu) {
 179         crsfDisplayPortMenuOpen();
 180         return;
 181     }
 182     memset(crsfScreen.pendingTransport, 1, crsfScreen.rows);
 183     crsfScreen.reset = true;
 184     delayTransportUntilMs = millis() + CRSF_DISPLAY_PORT_CLEAR_DELAY_MS;
 185 }
 186
 187 int crsfDisplayPortNextRow(void)
 188 {
 189     const timeMs_t currentTimeMs = millis();
 190     if (currentTimeMs < delayTransportUntilMs) {
 191         return -1;
 192     }
 193     for(unsigned int i=0; i<CRSF_DISPLAY_PORT_ROWS_MAX; i++) {
 194         if (crsfScreen.pendingTransport[i]) {
 195             return i;
 196         }
 197     }
 198     return -1;
 199 }
 200
 201 displayPort_t *displayPortCrsfInit()
 202 {
 203     crsfDisplayPortSetDimensions(CRSF_DISPLAY_PORT_ROWS_MAX, CRSF_DISPLAY_PORT_COLS_MAX);
 204     displayInit(&crsfDisplayPort, &crsfDisplayPortVTable);
 205     return &crsfDisplayPort;
 206 }
 207
 208 #endif