You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
368 lines
10 KiB
368 lines
10 KiB
#include "dwin_screen.hpp"
|
|
|
|
#include <string.h>
|
|
|
|
#include <map>
|
|
namespace iflytop {
|
|
namespace dwin {
|
|
DwinScreen g_dwinScreen;
|
|
}
|
|
} // namespace iflytop
|
|
|
|
using namespace iflytop;
|
|
using namespace iflytop::dwin;
|
|
using namespace std;
|
|
|
|
#define TAG "dwin"
|
|
|
|
DwinScreen& DwinScreen::ins() { return g_dwinScreen; }
|
|
|
|
static void dumphex(uint8_t* data, size_t len) {
|
|
printf("(%d)", len);
|
|
for (size_t i = 0; i < len; i++) {
|
|
printf("%02X ", data[i]);
|
|
}
|
|
printf("\n");
|
|
}
|
|
void DwinScreen::init(UART_HandleTypeDef* huart, map<string, DwinRamManager*>& rammanager) {
|
|
m_huart = huart;
|
|
// m_dwcfg = dwcfg;
|
|
m_rammanager_map = rammanager;
|
|
ZUART::cfg_t cfg;
|
|
cfg.huart = m_huart;
|
|
cfg.name = "DwinScreenUart";
|
|
cfg.rxbuffersize = RX_CACHE_SIZE;
|
|
cfg.rxovertime_ms = 2;
|
|
m_uarthandler.initialize(&cfg);
|
|
|
|
m_uarthandler.startRxIt();
|
|
|
|
m_uarthandler.setrxcb([this](uint8_t* data, size_t len) {
|
|
// irq
|
|
if (txcontext.receipt_ready_flag) {
|
|
return;
|
|
}
|
|
// dumphex(data, len);
|
|
memcpy(txcontext.receiptcache, data, len);
|
|
txcontext.receiptlen = len;
|
|
txcontext.receipt_ready_flag = true;
|
|
});
|
|
// m_rammanager.init(dwcfg.freeRawStartAddr, dwcfg.freeRawEndAddr);
|
|
// m_textDisplayerManager.init(dwcfg.textDisplayerStartAddr, dwcfg.textDisplayerEndAddr);
|
|
// m_varIconManager.init(dwcfg.varIconStartAddr, dwcfg.varIconEndAddr);
|
|
dumpram();
|
|
}
|
|
|
|
void DwinScreen::dumpram() {
|
|
for (auto& each : m_rammanager_map) {
|
|
ZLOGI(TAG, "%-20s:(%d/%d)", each.first.c_str(), each.second->totalsize() - each.second->remainsize(), each.second->totalsize());
|
|
}
|
|
}
|
|
|
|
uint16_t DwinScreen::alloc_free_ram(uint16_t size) {
|
|
auto item = m_rammanager_map.find(FREE_RAM_MAP);
|
|
ZASSERT(item != m_rammanager_map.end());
|
|
return item->second->alloc(size);
|
|
}
|
|
uint16_t DwinScreen::alloc_one_text_displayer() {
|
|
auto item = m_rammanager_map.find(LEVEL1_TEXT);
|
|
ZASSERT(item != m_rammanager_map.end());
|
|
return item->second->alloc();
|
|
}
|
|
uint16_t DwinScreen::alloc_one_var_icon() {
|
|
auto item = m_rammanager_map.find(LEVEL1_ICON);
|
|
ZASSERT(item != m_rammanager_map.end());
|
|
return item->second->alloc();
|
|
}
|
|
uint16_t DwinScreen::alloc_from(const char* whichrammanager, uint16_t size) {
|
|
auto item = m_rammanager_map.find(whichrammanager);
|
|
if (item == m_rammanager_map.end()) {
|
|
ZLOGE(TAG, "alloc_from %s failed, not found", whichrammanager);
|
|
ZASSERT(false);
|
|
}
|
|
return item->second->alloc(size);
|
|
}
|
|
|
|
void DwinScreen::clearrxcache() {
|
|
// CriticalContext cc;
|
|
txcontext.receipt_ready_flag = false;
|
|
txcontext.receiptlen = 0;
|
|
}
|
|
void DwinScreen::sendcmd(uint8_t* cmd, size_t len) {
|
|
// printf("sendcmd:");
|
|
// for (size_t i = 0; i < len; i++) {
|
|
// ZLOGE(TAG,"%02X ", cmd[i]);
|
|
// }
|
|
// printf("\n");
|
|
m_uarthandler.tx(cmd, len);
|
|
// m_com.send((char*)cmd, len);
|
|
}
|
|
|
|
bool DwinScreen::sendcmdblock(int overtime) {
|
|
clearrxcache();
|
|
sendcmd(txcontext.txcache, txcontext.txlen);
|
|
for (int i = 0; i < overtime; i++) {
|
|
if (txcontext.receipt_ready_flag) {
|
|
return true;
|
|
} else {
|
|
// zos_delay(1);
|
|
// HAL_Delay(1);
|
|
osDelay(1);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool DwinScreen::write_varspace(uint16_t regaddr, uint8_t* data, uint8_t len, int overtime) {
|
|
/**
|
|
* @brief
|
|
*
|
|
* 2byte 1byte cmd add val
|
|
* 5AA5 datalen 0x82 2 xbyte
|
|
*
|
|
*/
|
|
txcontext.txcache[0] = 0x5A;
|
|
txcontext.txcache[1] = 0xA5;
|
|
txcontext.txcache[2] = 0; // data len
|
|
txcontext.txcache[3] = 0x82;
|
|
txcontext.txcache[4] = regaddr >> 8;
|
|
txcontext.txcache[5] = regaddr & 0xFF;
|
|
|
|
memcpy(&txcontext.txcache[6], data, len);
|
|
txcontext.txcache[2] = len + 1 + 2; //
|
|
|
|
txcontext.txlen = 6 + len;
|
|
|
|
if (!sendcmdblock(overtime)) {
|
|
ZLOGE(TAG, "write_varspace failed");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
bool DwinScreen::read_varspace(uint16_t regaddr, uint8_t* data, uint8_t len, int overtime) {
|
|
/**
|
|
* @brief
|
|
*
|
|
* 2byte 1byte cmd add val
|
|
* 5AA5 datalen 0x82 2 xbyte
|
|
*
|
|
*/
|
|
txcontext.txcache[0] = 0x5A;
|
|
txcontext.txcache[1] = 0xA5;
|
|
txcontext.txcache[2] = 0; // data len
|
|
txcontext.txcache[3] = 0x83;
|
|
txcontext.txcache[4] = regaddr >> 8;
|
|
txcontext.txcache[5] = regaddr & 0xFF;
|
|
txcontext.txcache[6] = len / 2; // word len
|
|
|
|
txcontext.txcache[2] = 4; //
|
|
txcontext.txlen = 7;
|
|
|
|
if (!sendcmdblock(overtime)) {
|
|
ZLOGE(TAG, "read_varspace failed");
|
|
return false;
|
|
}
|
|
|
|
// ZLOGI(TAG, "read_varspace success %d", txcontext.receiptlen);
|
|
memcpy(data, &txcontext.receiptcache[7], len);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DwinScreen::write_reg16(uint16_t regaddr, uint16_t data, int overtime) { //
|
|
uint8_t data8[2];
|
|
data8[0] = data >> 8;
|
|
data8[1] = data & 0xFF;
|
|
|
|
return write_reg(regaddr, data8, 2, overtime);
|
|
}
|
|
|
|
bool DwinScreen::read_reg16(uint16_t regaddr, uint16_t& data, int overtime) {
|
|
uint8_t data8[2];
|
|
bool suc = read_reg(regaddr, data8, 2, overtime);
|
|
if (!suc) return false;
|
|
|
|
data = data8[0] << 8 | data8[1];
|
|
return true;
|
|
}
|
|
|
|
bool DwinScreen::write_varspace16(uint16_t regaddr, uint16_t data, int overtime) { //
|
|
uint8_t data8[2];
|
|
data8[0] = data >> 8;
|
|
data8[1] = data & 0xFF;
|
|
|
|
return write_varspace(regaddr, data8, 2, overtime);
|
|
}
|
|
|
|
bool DwinScreen::write_varspace16_muti(uint16_t regaddr, uint16_t* data, size_t n16, int overtime) {
|
|
for (size_t i = 0; i < n16; i++) {
|
|
m_tx_pre_processcache[i * 2] = data[i] >> 8;
|
|
m_tx_pre_processcache[i * 2 + 1] = data[i] & 0xFF;
|
|
}
|
|
return write_varspace(regaddr, m_tx_pre_processcache, n16 * 2, overtime);
|
|
}
|
|
|
|
bool DwinScreen::read_varspace16_muti(uint16_t regaddr, uint16_t* data, size_t n16, int overtime) {
|
|
// TODO: CHECK BUFSIZE
|
|
memset(m_rd_pre_processcache, 0, sizeof(m_rd_pre_processcache));
|
|
bool suc = read_varspace(regaddr, m_rd_pre_processcache, n16 * 2, overtime);
|
|
if (!suc) return false;
|
|
|
|
for (size_t i = 0; i < n16; i++) {
|
|
data[i] = m_rd_pre_processcache[i * 2] << 8 | m_rd_pre_processcache[i * 2 + 1];
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool DwinScreen::read_varspace8_muti(uint16_t regaddr, uint8_t* data, size_t n8, int overtime) {
|
|
// TODO: CHECK BUFSIZE
|
|
memset(m_rd_pre_processcache, 0, sizeof(m_rd_pre_processcache));
|
|
bool suc = read_varspace(regaddr, m_rd_pre_processcache, n8, overtime);
|
|
memcpy(data, m_rd_pre_processcache, n8);
|
|
if (!suc) return false;
|
|
return true;
|
|
}
|
|
|
|
bool DwinScreen::read_varspace16(uint16_t regaddr, uint16_t& data, int overtime) {
|
|
uint8_t data8[2];
|
|
bool suc = read_varspace(regaddr, data8, 2, overtime);
|
|
if (!suc) return false;
|
|
|
|
data = data8[0] << 8 | data8[1];
|
|
return true;
|
|
}
|
|
|
|
bool DwinScreen::write_varspace8(uint16_t regaddr, uint16_t subadd, uint16_t data, int overtime) {
|
|
uint16_t val = 0;
|
|
bool suc = read_varspace16(regaddr, val, overtime);
|
|
if (!suc) return false;
|
|
|
|
if (subadd == 0) {
|
|
// H
|
|
val = val & 0x00FF;
|
|
val = val | ((data << 8) & 0xff00);
|
|
} else {
|
|
// L
|
|
val = val & 0xFF00;
|
|
val = val | (data & 0xff);
|
|
}
|
|
|
|
suc = write_varspace16(regaddr, val, overtime);
|
|
if (!suc) return false;
|
|
return true;
|
|
}
|
|
bool DwinScreen::read_varspace8(uint16_t regaddr, uint16_t subadd, uint16_t& data, int overtime) {
|
|
uint16_t val = 0;
|
|
bool suc = read_varspace16(regaddr, val, overtime);
|
|
if (!suc) return false;
|
|
|
|
if (subadd == 0) {
|
|
// H
|
|
data = val >> 8;
|
|
} else {
|
|
// L
|
|
data = val & 0xff;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool DwinScreen::write_reg(uint16_t regaddr, uint8_t* data, size_t len, int overtime) {
|
|
/**
|
|
* @brief
|
|
*
|
|
* 2byte 1byte cmd add val
|
|
* 5AA5 datalen 0x82 2 xbyte
|
|
*
|
|
*/
|
|
txcontext.txcache[0] = 0x5A;
|
|
txcontext.txcache[1] = 0xA5;
|
|
txcontext.txcache[2] = 0; // data len
|
|
txcontext.txcache[3] = 0x80;
|
|
txcontext.txcache[4] = regaddr >> 8;
|
|
txcontext.txcache[5] = regaddr & 0xFF;
|
|
|
|
memcpy(&txcontext.txcache[6], data, len);
|
|
txcontext.txcache[2] = len + 1 + 2; //
|
|
|
|
txcontext.txlen = 6 + len;
|
|
|
|
if (!sendcmdblock(overtime)) {
|
|
ZLOGE(TAG, "write_reg failed");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
bool DwinScreen::read_reg(uint16_t regaddr, uint8_t* data, size_t len, int overtime) {
|
|
/**
|
|
* @brief
|
|
*
|
|
* 2byte 1byte cmd add val
|
|
* 5AA5 datalen 0x82 2 xbyte
|
|
*
|
|
*/
|
|
txcontext.txcache[0] = 0x5A;
|
|
txcontext.txcache[1] = 0xA5;
|
|
txcontext.txcache[2] = 0; // data len
|
|
txcontext.txcache[3] = 0x81;
|
|
txcontext.txcache[4] = regaddr >> 8;
|
|
txcontext.txcache[5] = regaddr & 0xFF;
|
|
txcontext.txcache[6] = len / 2; // word len
|
|
|
|
txcontext.txcache[2] = 4; //
|
|
txcontext.txlen = 7;
|
|
|
|
if (!sendcmdblock(overtime)) {
|
|
ZLOGE(TAG, "read_varspace failed");
|
|
return false;
|
|
}
|
|
memcpy(data, &txcontext.receiptcache[7], len);
|
|
return true;
|
|
}
|
|
|
|
bool DwinScreen::set_page(uint16_t pageid) {
|
|
uint16_t data[2] = {0x5A01, pageid};
|
|
return write_varspace16_muti(0x84, data, 2, 10);
|
|
}
|
|
uint16_t DwinScreen::get_page() {
|
|
uint16_t page = 0;
|
|
read_varspace16(0x14, page, 100);
|
|
return page;
|
|
}
|
|
bool DwinScreen::ping() {
|
|
uint16_t page = 0;
|
|
bool suc = read_varspace16(0x14, page, 100);
|
|
return suc;
|
|
}
|
|
|
|
bool DwinScreen::set_brightness(uint16_t brightness) {
|
|
// 5A A5 04 82 0082 0A
|
|
uint8_t data[3] = {0, 0x82, (uint8_t)brightness};
|
|
return write_varspace(0x82, data, 3, 10);
|
|
}
|
|
bool DwinScreen::set_rtc(uint16_t year, uint16_t month, uint16_t day, uint16_t hour, uint16_t minute, uint16_t second) {
|
|
year = year - 2000;
|
|
|
|
uint16_t year_month = year << 8 | month;
|
|
uint16_t day_hour = day << 8 | hour;
|
|
uint16_t min_second = minute << 8 | second;
|
|
uint16_t data[4] = {0x5AA5, year_month, day_hour, min_second};
|
|
return write_varspace16_muti(0x9C, data, 4, 10);
|
|
}
|
|
|
|
bool DwinScreen::get_rtc(Date* date) {
|
|
uint8_t data[8] = {0};
|
|
bool suc = read_varspace8_muti(0x10, data, 8, 10);
|
|
// dumphex(data, 8);
|
|
if (!suc) return false;
|
|
|
|
date->year = (data[0] & 0xff) + 2000;
|
|
date->month = data[1];
|
|
date->day = data[2];
|
|
date->weekdaynum = data[3];
|
|
date->hour = data[4];
|
|
date->minute = data[5];
|
|
date->second = data[6];
|
|
// printf("year:%d month:%d day:%d weekdaynum:%d hour:%d minute:%d second:%d\n", //
|
|
// date->year, date->month, date->day, date->weekdaynum, date->hour, date->minute, date->second);
|
|
return suc;
|
|
}
|