Merge pull request #19 from JF002/spi-dma

Spi dma
This commit is contained in:
JF002 2020-01-26 15:44:26 +01:00 committed by GitHub
commit 7c03810f46
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
13 changed files with 360 additions and 135 deletions

View file

@ -1,5 +1,5 @@
cmake_minimum_required(VERSION 3.10) cmake_minimum_required(VERSION 3.10)
project(pinetime VERSION 0.2.0 LANGUAGES C CXX ASM) project(pinetime VERSION 0.2.1 LANGUAGES C CXX ASM)
set(NRF_TARGET "nrf52") set(NRF_TARGET "nrf52")

View file

@ -1,4 +1,6 @@
#include <libraries/svc/nrf_svci.h> #include <libraries/svc/nrf_svci.h>
#include <FreeRTOS.h>
#include <task.h>
#include "Gfx.h" #include "Gfx.h"
#include "../../drivers/St7789.h" #include "../../drivers/St7789.h"
using namespace Pinetime::Components; using namespace Pinetime::Components;
@ -7,15 +9,38 @@ Gfx::Gfx(Pinetime::Drivers::St7789 &lcd) : lcd{lcd} {
} }
void Gfx::Init() { void Gfx::Init() {
lcd.Init();
} }
void Gfx::ClearScreen() { void Gfx::ClearScreen() {
lcd.FillRectangle(0, 0, width, height, 0x0000); SetBackgroundColor(0x0000);
state.remainingIterations = 240 + 1;
state.currentIteration = 0;
state.busy = true;
state.action = Action::FillRectangle;
state.taskToNotify = xTaskGetCurrentTaskHandle();
lcd.BeginDrawBuffer(0, 0, width, height);
lcd.NextDrawBuffer(reinterpret_cast<const uint8_t *>(buffer), width * 2);
WaitTransfertFinished();
} }
void Gfx::FillRectangle(uint8_t x, uint8_t y, uint8_t width, uint8_t height, uint16_t color) { void Gfx::FillRectangle(uint8_t x, uint8_t y, uint8_t w, uint8_t h, uint16_t color) {
lcd.FillRectangle(x, y, width, height, color); SetBackgroundColor(color);
state.remainingIterations = 240 + 1;
state.currentIteration = 0;
state.busy = true;
state.action = Action::FillRectangle;
state.color = color;
state.taskToNotify = xTaskGetCurrentTaskHandle();
lcd.BeginDrawBuffer(x, y, w, h);
lcd.NextDrawBuffer(reinterpret_cast<const uint8_t *>(buffer), width * 2);
WaitTransfertFinished();
} }
void Gfx::DrawString(uint8_t x, uint8_t y, uint16_t color, const char *text, const FONT_INFO *p_font, bool wrap) { void Gfx::DrawString(uint8_t x, uint8_t y, uint16_t color, const char *text, const FONT_INFO *p_font, bool wrap) {
@ -56,31 +81,38 @@ void Gfx::DrawString(uint8_t x, uint8_t y, uint16_t color, const char *text, con
void Gfx::DrawChar(const FONT_INFO *font, uint8_t c, uint8_t *x, uint8_t y, uint16_t color) { void Gfx::DrawChar(const FONT_INFO *font, uint8_t c, uint8_t *x, uint8_t y, uint16_t color) {
uint8_t char_idx = c - font->startChar; uint8_t char_idx = c - font->startChar;
uint16_t bytes_in_line = CEIL_DIV(font->charInfo[char_idx].widthBits, 8); uint16_t bytes_in_line = CEIL_DIV(font->charInfo[char_idx].widthBits, 8);
uint16_t bg = 0x0000;
if (c == ' ') { if (c == ' ') {
*x += font->height / 2; *x += font->height / 2;
return; return;
} }
// TODO For now, LCD and SPI driver start a new transfer (cs pin + set address windows + write byte) FOR EACH PIXEL! // Build first line
// This could be improved by setting CS pin, DC pin and address window ONLY ONCE for the whole character for (uint16_t j = 0; j < bytes_in_line; j++) {
for (uint8_t k = 0; k < 8; k++) {
lcd.BeginDrawBuffer(*x, y, bytes_in_line*8, font->height); if ((1 << (7 - k)) & font->data[font->charInfo[char_idx].offset + j]) {
uint16_t bg = 0x0000; buffer[(j*8)+k] = color;
for (uint16_t i = 0; i < font->height; i++) { }
for (uint16_t j = 0; j < bytes_in_line; j++) { else {
for (uint8_t k = 0; k < 8; k++) { buffer[(j*8)+k] = bg;
if ((1 << (7 - k)) &
font->data[font->charInfo[char_idx].offset + i * bytes_in_line + j]) {
lcd.NextDrawBuffer(reinterpret_cast<uint8_t *>(&color), 2);
}
else {
lcd.NextDrawBuffer(reinterpret_cast<uint8_t *>(&bg), 2);
}
} }
} }
} }
lcd.EndDrawBuffer();
state.remainingIterations = font->height + 0;
state.currentIteration = 0;
state.busy = true;
state.action = Action::DrawChar;
state.font = const_cast<FONT_INFO *>(font);
state.character = c;
state.color = color;
state.taskToNotify = xTaskGetCurrentTaskHandle();
lcd.BeginDrawBuffer(*x, y, bytes_in_line*8, font->height);
lcd.NextDrawBuffer(reinterpret_cast<const uint8_t *>(&buffer), bytes_in_line*8*2);
WaitTransfertFinished();
*x += font->charInfo[char_idx].widthBits + font->spacePixels; *x += font->charInfo[char_idx].widthBits + font->spacePixels;
} }
@ -96,4 +128,59 @@ void Gfx::Wakeup() {
lcd.Wakeup(); lcd.Wakeup();
} }
void Gfx::SetBackgroundColor(uint16_t color) {
for(int i = 0; i < width; i++) {
buffer[i] = color;
}
}
bool Gfx::GetNextBuffer(uint8_t **data, size_t &size) {
if(!state.busy) return false;
state.remainingIterations--;
if (state.remainingIterations == 0) {
state.busy = false;
NotifyEndOfTransfert(state.taskToNotify);
return false;
}
if(state.action == Action::FillRectangle) {
*data = reinterpret_cast<uint8_t *>(buffer);
size = width * 2;
} else if(state.action == Action::DrawChar) {
uint16_t bg = 0x0000;
uint8_t char_idx = state.character - state.font->startChar;
uint16_t bytes_in_line = CEIL_DIV(state.font->charInfo[char_idx].widthBits, 8);
for (uint16_t j = 0; j < bytes_in_line; j++) {
for (uint8_t k = 0; k < 8; k++) {
if ((1 << (7 - k)) & state.font->data[state.font->charInfo[char_idx].offset + ((state.currentIteration+1) * bytes_in_line) + j]) {
buffer[(j*8)+k] = state.color;
}
else {
buffer[(j*8)+k] = bg;
}
}
}
*data = reinterpret_cast<uint8_t *>(buffer);
size = bytes_in_line*8*2;
}
state.currentIteration++;
return true;
}
void Gfx::NotifyEndOfTransfert(TaskHandle_t task) {
if(task != nullptr) {
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
vTaskNotifyGiveFromISR(task, &xHigherPriorityTaskWoken);
portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}
}
void Gfx::WaitTransfertFinished() const {
ulTaskNotifyTake(pdTRUE, 500);
}

View file

@ -1,6 +1,9 @@
#pragma once #pragma once
#include <cstdint> #include <cstdint>
#include <nrf_font.h> #include <nrf_font.h>
#include <drivers/BufferProvider.h>
#include <FreeRTOS.h>
#include <task.h>
namespace Pinetime { namespace Pinetime {
@ -8,7 +11,7 @@ namespace Pinetime {
class St7789; class St7789;
} }
namespace Components { namespace Components {
class Gfx { class Gfx : public Pinetime::Drivers::BufferProvider {
public: public:
explicit Gfx(Drivers::St7789& lcd); explicit Gfx(Drivers::St7789& lcd);
void Init(); void Init();
@ -19,12 +22,34 @@ namespace Pinetime {
void Sleep(); void Sleep();
void Wakeup(); void Wakeup();
bool GetNextBuffer(uint8_t **buffer, size_t &size) override;
private: private:
static constexpr uint8_t width = 240;
static constexpr uint8_t height = 240;
enum class Action { None, FillRectangle, DrawChar};
struct State {
State() : busy{false}, action{Action::None}, remainingIterations{0}, currentIteration{0} {}
volatile bool busy;
volatile Action action;
volatile uint16_t remainingIterations;
volatile uint16_t currentIteration;
volatile FONT_INFO *font;
volatile uint16_t color;
volatile uint8_t character;
volatile TaskHandle_t taskToNotify = nullptr;
};
volatile State state;
uint16_t buffer[width]; // 1 line buffer
Drivers::St7789& lcd; Drivers::St7789& lcd;
const uint8_t width = 240;
const uint8_t height = 240;
void pixel_draw(uint8_t x, uint8_t y, uint16_t color); void pixel_draw(uint8_t x, uint8_t y, uint16_t color);
void SetBackgroundColor(uint16_t color);
void WaitTransfertFinished() const;
void NotifyEndOfTransfert(TaskHandle_t task);
}; };
} }
} }

View file

@ -14,25 +14,19 @@
using namespace Pinetime::Applications; using namespace Pinetime::Applications;
DisplayApp::DisplayApp(Controllers::Battery &batteryController, DisplayApp::DisplayApp(Pinetime::Drivers::St7789& lcd,
Pinetime::Components::Gfx& gfx,
Pinetime::Drivers::Cst816S& touchPanel,
Controllers::Battery &batteryController,
Controllers::Ble &bleController, Controllers::Ble &bleController,
Controllers::DateTime &dateTimeController) : Controllers::DateTime &dateTimeController) :
spi{Drivers::SpiMaster::SpiModule::SPI0, { lcd{lcd},
Drivers::SpiMaster::BitOrder::Msb_Lsb, gfx{gfx},
Drivers::SpiMaster::Modes::Mode3, touchPanel{touchPanel},
Drivers::SpiMaster::Frequencies::Freq8Mhz,
pinSpiSck,
pinSpiMosi,
pinSpiMiso,
pinSpiCsn
}},
lcd{new Drivers::St7789(spi, pinLcdDataCommand)},
gfx{new Components::Gfx(*lcd.get()) },
batteryController{batteryController}, batteryController{batteryController},
bleController{bleController}, bleController{bleController},
dateTimeController{dateTimeController}, dateTimeController{dateTimeController},
clockScreen{*(gfx.get())}/*, clockScreen{gfx} {
messageScreen{*(gfx.get())}*/ {
msgQueue = xQueueCreate(queueSize, itemSize); msgQueue = xQueueCreate(queueSize, itemSize);
currentScreen = &clockScreen; currentScreen = &clockScreen;
} }
@ -59,12 +53,12 @@ void DisplayApp::InitHw() {
nrf_gpio_pin_clear(pinLcdBacklight2); nrf_gpio_pin_clear(pinLcdBacklight2);
nrf_gpio_pin_clear(pinLcdBacklight3); nrf_gpio_pin_clear(pinLcdBacklight3);
spi.Init();
gfx->Init();
currentScreen->Refresh(true); currentScreen->Refresh(true);
touchPanel.Init();
} }
uint32_t acc = 0;
uint32_t count = 0;
bool toggle = true;
void DisplayApp::Refresh() { void DisplayApp::Refresh() {
TickType_t queueTimeout; TickType_t queueTimeout;
switch (state) { switch (state) {
@ -87,16 +81,16 @@ void DisplayApp::Refresh() {
nrf_gpio_pin_set(pinLcdBacklight2); nrf_gpio_pin_set(pinLcdBacklight2);
vTaskDelay(100); vTaskDelay(100);
nrf_gpio_pin_set(pinLcdBacklight1); nrf_gpio_pin_set(pinLcdBacklight1);
lcd->DisplayOff(); lcd.DisplayOff();
lcd->Sleep(); lcd.Sleep();
touchPanel.Sleep(); touchPanel.Sleep();
state = States::Idle; state = States::Idle;
break; break;
case Messages::GoToRunning: case Messages::GoToRunning:
lcd->Wakeup(); lcd.Wakeup();
touchPanel.Wakeup(); touchPanel.Wakeup();
lcd->DisplayOn(); lcd.DisplayOn();
nrf_gpio_pin_clear(pinLcdBacklight3); nrf_gpio_pin_clear(pinLcdBacklight3);
nrf_gpio_pin_clear(pinLcdBacklight2); nrf_gpio_pin_clear(pinLcdBacklight2);
nrf_gpio_pin_clear(pinLcdBacklight1); nrf_gpio_pin_clear(pinLcdBacklight1);
@ -124,16 +118,8 @@ void DisplayApp::RunningState() {
if(currentScreen != nullptr) { if(currentScreen != nullptr) {
currentScreen->Refresh(false); currentScreen->Refresh(false);
} }
// if(screenState) {
// currentScreen = &clockScreen;
// } else {
// currentScreen = &messageScreen;
// }
// screenState = !screenState;
} }
void DisplayApp::IdleState() { void DisplayApp::IdleState() {
} }
@ -153,7 +139,7 @@ void DisplayApp::OnTouchEvent() {
auto info = touchPanel.GetTouchInfo(); auto info = touchPanel.GetTouchInfo();
if(info.isTouch) { if(info.isTouch) {
lcd->FillRectangle(info.x-10, info.y-10, 20,20, pointColor); gfx.FillRectangle(info.x-10, info.y-10, 20,20, pointColor);
pointColor+=10; pointColor+=10;
} }
} }

View file

@ -23,7 +23,10 @@ namespace Pinetime {
public: public:
enum class States {Idle, Running}; enum class States {Idle, Running};
enum class Messages : uint8_t {GoToSleep, GoToRunning, UpdateDateTime, UpdateBleConnection, UpdateBatteryLevel, TouchEvent} ; enum class Messages : uint8_t {GoToSleep, GoToRunning, UpdateDateTime, UpdateBleConnection, UpdateBatteryLevel, TouchEvent} ;
DisplayApp(Controllers::Battery &batteryController, DisplayApp(Pinetime::Drivers::St7789& lcd,
Pinetime::Components::Gfx& gfx,
Pinetime::Drivers::Cst816S&,
Controllers::Battery &batteryController,
Controllers::Ble &bleController, Controllers::Ble &bleController,
Controllers::DateTime& dateTimeController); Controllers::DateTime& dateTimeController);
void Start(); void Start();
@ -33,9 +36,8 @@ namespace Pinetime {
TaskHandle_t taskHandle; TaskHandle_t taskHandle;
static void Process(void* instance); static void Process(void* instance);
void InitHw(); void InitHw();
Pinetime::Drivers::SpiMaster spi; Pinetime::Drivers::St7789& lcd;
std::unique_ptr<Drivers::St7789> lcd; Pinetime::Components::Gfx& gfx;
std::unique_ptr<Components::Gfx> gfx;
const FONT_INFO largeFont {lCD_70ptFontInfo.height, lCD_70ptFontInfo.startChar, lCD_70ptFontInfo.endChar, lCD_70ptFontInfo.spacePixels, lCD_70ptFontInfo.charInfo, lCD_70ptFontInfo.data}; const FONT_INFO largeFont {lCD_70ptFontInfo.height, lCD_70ptFontInfo.startChar, lCD_70ptFontInfo.endChar, lCD_70ptFontInfo.spacePixels, lCD_70ptFontInfo.charInfo, lCD_70ptFontInfo.data};
const FONT_INFO smallFont {lCD_14ptFontInfo.height, lCD_14ptFontInfo.startChar, lCD_14ptFontInfo.endChar, lCD_14ptFontInfo.spacePixels, lCD_14ptFontInfo.charInfo, lCD_14ptFontInfo.data}; const FONT_INFO smallFont {lCD_14ptFontInfo.height, lCD_14ptFontInfo.startChar, lCD_14ptFontInfo.endChar, lCD_14ptFontInfo.spacePixels, lCD_14ptFontInfo.charInfo, lCD_14ptFontInfo.data};
void Refresh(); void Refresh();
@ -52,18 +54,11 @@ namespace Pinetime {
Pinetime::Controllers::Ble &bleController; Pinetime::Controllers::Ble &bleController;
Pinetime::Controllers::DateTime& dateTimeController; Pinetime::Controllers::DateTime& dateTimeController;
Pinetime::Drivers::Cst816S touchPanel; Pinetime::Drivers::Cst816S& touchPanel;
void OnTouchEvent(); void OnTouchEvent();
Screens::Clock clockScreen; Screens::Clock clockScreen;
Screens::Screen* currentScreen = nullptr; Screens::Screen* currentScreen = nullptr;
// Screens::Message messageScreen;
// bool screenState = false;
static constexpr uint8_t pinSpiSck = 2;
static constexpr uint8_t pinSpiMosi = 3;
static constexpr uint8_t pinSpiMiso = 4;
static constexpr uint8_t pinSpiCsn = 25;
static constexpr uint8_t pinLcdDataCommand = 18;
static constexpr uint8_t pinLcdBacklight1 = 14; static constexpr uint8_t pinLcdBacklight1 = 14;
static constexpr uint8_t pinLcdBacklight2 = 22; static constexpr uint8_t pinLcdBacklight2 = 22;
static constexpr uint8_t pinLcdBacklight3 = 23; static constexpr uint8_t pinLcdBacklight3 = 23;

View file

@ -9,10 +9,10 @@ using namespace Pinetime::Applications::Screens;
void Clock::Refresh(bool fullRefresh) { void Clock::Refresh(bool fullRefresh) {
if(fullRefresh) { if(fullRefresh) {
gfx.FillRectangle(0,0,240,240,0x0000); gfx.FillRectangle(0,0,240,240,0x0000);
currentChar[0] = 0; currentChar[0] = 1;
currentChar[1] = 0; currentChar[1] = 2;
currentChar[2] = 0; currentChar[2] = 3;
currentChar[3] = 0; currentChar[3] = 4;
auto dummy = currentDateTime.Get(); auto dummy = currentDateTime.Get();
} }

View file

@ -9,6 +9,6 @@ using namespace Pinetime::Applications::Screens;
void Message::Refresh(bool fullRefresh) { void Message::Refresh(bool fullRefresh) {
if(fullRefresh) { if(fullRefresh) {
gfx.FillRectangle(0,0,240,240,0xffff); gfx.FillRectangle(0,0,240,240,0xffff);
gfx.DrawString(120, 10, 0x0000, "COUCOU", &smallFont, false); gfx.DrawString(120, 10, 0x5555, "COUCOU", &smallFont, false);
} }
} }

View file

@ -0,0 +1,11 @@
#pragma once
#include <cstddef>
namespace Pinetime {
namespace Drivers {
class BufferProvider {
public:
virtual bool GetNextBuffer(uint8_t** buffer, size_t& size) = 0;
};
}
}

View file

@ -1,23 +1,27 @@
#include <hal/nrf_gpio.h> #include <hal/nrf_gpio.h>
#include <hal/nrf_spim.h>
#include "SpiMaster.h" #include "SpiMaster.h"
#include <algorithm>
using namespace Pinetime::Drivers; using namespace Pinetime::Drivers;
SpiMaster::SpiMaster(const SpiMaster::SpiModule spi, const SpiMaster::Parameters &params) : SpiMaster::SpiMaster(const SpiMaster::SpiModule spi, const SpiMaster::Parameters &params) :
spi{spi}, params{params} { spi{spi}, params{params} {
} }
bool SpiMaster::Init() { bool SpiMaster::Init() {
/* Configure GPIO pins used for pselsck, pselmosi, pselmiso and pselss for SPI0 */ /* Configure GPIO pins used for pselsck, pselmosi, pselmiso and pselss for SPI0 */
nrf_gpio_pin_set(params.pinSCK);
nrf_gpio_cfg_output(params.pinSCK); nrf_gpio_cfg_output(params.pinSCK);
nrf_gpio_pin_clear(params.pinMOSI);
nrf_gpio_cfg_output(params.pinMOSI); nrf_gpio_cfg_output(params.pinMOSI);
nrf_gpio_cfg_input(params.pinMISO, NRF_GPIO_PIN_NOPULL); nrf_gpio_cfg_input(params.pinMISO, NRF_GPIO_PIN_NOPULL);
nrf_gpio_cfg_output(params.pinCSN); nrf_gpio_cfg_output(params.pinCSN);
pinCsn = params.pinCSN; pinCsn = params.pinCSN;
switch(spi) { switch(spi) {
case SpiModule::SPI0: spiBaseAddress = NRF_SPI0; break; case SpiModule::SPI0: spiBaseAddress = NRF_SPIM0; break;
case SpiModule::SPI1: spiBaseAddress = NRF_SPI1; break; case SpiModule::SPI1: spiBaseAddress = NRF_SPIM1; break;
default: return false; default: return false;
} }
@ -49,51 +53,130 @@ bool SpiMaster::Init() {
} }
spiBaseAddress->CONFIG = regConfig; spiBaseAddress->CONFIG = regConfig;
spiBaseAddress->EVENTS_READY = 0; spiBaseAddress->EVENTS_ENDRX = 0;
spiBaseAddress->ENABLE = (SPI_ENABLE_ENABLE_Enabled << SPI_ENABLE_ENABLE_Pos); spiBaseAddress->EVENTS_ENDTX = 0;
spiBaseAddress->EVENTS_END = 0;
spiBaseAddress->INTENSET = ((unsigned)1 << (unsigned)6);
spiBaseAddress->INTENSET = ((unsigned)1 << (unsigned)1);
spiBaseAddress->INTENSET = ((unsigned)1 << (unsigned)19);
spiBaseAddress->ENABLE = (SPIM_ENABLE_ENABLE_Enabled << SPIM_ENABLE_ENABLE_Pos);
NRFX_IRQ_PRIORITY_SET(SPIM0_SPIS0_TWIM0_TWIS0_SPI0_TWI0_IRQn,2);
NRFX_IRQ_ENABLE(SPIM0_SPIS0_TWIM0_TWIS0_SPI0_TWI0_IRQn);
return true; return true;
} }
bool SpiMaster::Write(const uint8_t *data, size_t size) {
volatile uint32_t dummyread;
void SpiMaster::SetupWorkaroundForFtpan58(NRF_SPIM_Type *spim, uint32_t ppi_channel, uint32_t gpiote_channel) {
// Create an event when SCK toggles.
NRF_GPIOTE->CONFIG[gpiote_channel] = (GPIOTE_CONFIG_MODE_Event << GPIOTE_CONFIG_MODE_Pos) |
(spim->PSEL.SCK << GPIOTE_CONFIG_PSEL_Pos) |
(GPIOTE_CONFIG_POLARITY_Toggle << GPIOTE_CONFIG_POLARITY_Pos);
// Stop the spim instance when SCK toggles.
NRF_PPI->CH[ppi_channel].EEP = (uint32_t) &NRF_GPIOTE->EVENTS_IN[gpiote_channel];
NRF_PPI->CH[ppi_channel].TEP = (uint32_t) &spim->TASKS_STOP;
NRF_PPI->CHENSET = 1U << ppi_channel;
// Disable IRQ
spim->INTENCLR = (1<<6);
spim->INTENCLR = (1<<1);
spim->INTENCLR = (1<<19);
}
void SpiMaster::DisableWorkaroundForFtpan58(NRF_SPIM_Type *spim, uint32_t ppi_channel, uint32_t gpiote_channel) {
NRF_GPIOTE->CONFIG[gpiote_channel] = 0;
NRF_PPI->CH[ppi_channel].EEP = 0;
NRF_PPI->CH[ppi_channel].TEP = 0;
NRF_PPI->CHENSET = ppi_channel;
spim->INTENSET = (1<<6);
spim->INTENSET = (1<<1);
spim->INTENSET = (1<<19);
}
void SpiMaster::OnEndEvent(BufferProvider& provider) {
if(!busy) return;
auto s = currentBufferSize;
if(s > 0) {
auto currentSize = std::min((size_t) 255, s);
PrepareTx(currentBufferAddr, currentSize);
currentBufferAddr += currentSize;
currentBufferSize -= currentSize;
spiBaseAddress->TASKS_START = 1;
} else {
uint8_t* buffer = nullptr;
size_t size = 0;
if(provider.GetNextBuffer(&buffer, size)) {
currentBufferAddr = (uint32_t) buffer;
currentBufferSize = size;
auto s = currentBufferSize;
auto currentSize = std::min((size_t)255, s);
PrepareTx(currentBufferAddr, currentSize);
currentBufferAddr += currentSize;
currentBufferSize -= currentSize;
spiBaseAddress->TASKS_START = 1;
} else {
busy = false;
nrf_gpio_pin_set(pinCsn);
}
}
}
void SpiMaster::OnStartedEvent(BufferProvider& provider) {
if(!busy) return;
}
void SpiMaster::PrepareTx(const volatile uint32_t bufferAddress, const volatile size_t size) {
spiBaseAddress->TXD.PTR = bufferAddress;
spiBaseAddress->TXD.MAXCNT = size;
spiBaseAddress->TXD.LIST = 0;
spiBaseAddress->RXD.PTR = 0;
spiBaseAddress->RXD.MAXCNT = 0;
spiBaseAddress->RXD.LIST = 0;
spiBaseAddress->EVENTS_END = 0;
}
bool SpiMaster::Write(const uint8_t *data, size_t size) {
if(data == nullptr) return false; if(data == nullptr) return false;
/* enable slave (slave select active low) */ while(busy) {
nrf_gpio_pin_clear(pinCsn); asm("nop");
spiBaseAddress->EVENTS_READY = 0;
spiBaseAddress->TXD = (uint32_t)*data++;
while(--size)
{
spiBaseAddress->TXD = (uint32_t)*data++;
/* Wait for the transaction complete or timeout (about 10ms - 20 ms) */
while (spiBaseAddress->EVENTS_READY == 0);
/* clear the event to be ready to receive next messages */
spiBaseAddress->EVENTS_READY = 0;
dummyread = spiBaseAddress->RXD;
} }
/* Wait for the transaction complete or timeout (about 10ms - 20 ms) */ if(size == 1) {
while (spiBaseAddress->EVENTS_READY == 0); SetupWorkaroundForFtpan58(spiBaseAddress, 0,0);
} else {
DisableWorkaroundForFtpan58(spiBaseAddress, 0, 0);
}
dummyread = spiBaseAddress->RXD; nrf_gpio_pin_clear(pinCsn);
/* disable slave (slave select active low) */ currentBufferAddr = (uint32_t)data;
nrf_gpio_pin_set(pinCsn); currentBufferSize = size;
busy = true;
auto currentSize = std::min((size_t)255, (size_t)currentBufferSize);
PrepareTx(currentBufferAddr, currentSize);
currentBufferSize -= currentSize;
currentBufferAddr += currentSize;
spiBaseAddress->TASKS_START = 1;
if(size == 1) {
while (spiBaseAddress->EVENTS_END == 0);
busy = false;
}
return true; return true;
} }
void SpiMaster::Sleep() { void SpiMaster::Sleep() {
while(NRF_SPI0->ENABLE != 0) { while(spiBaseAddress->ENABLE != 0) {
NRF_SPI0->ENABLE = (SPIM_ENABLE_ENABLE_Disabled << SPIM_ENABLE_ENABLE_Pos); spiBaseAddress->ENABLE = (SPIM_ENABLE_ENABLE_Disabled << SPIM_ENABLE_ENABLE_Pos);
} }
nrf_gpio_cfg_default(params.pinSCK); nrf_gpio_cfg_default(params.pinSCK);
nrf_gpio_cfg_default(params.pinMOSI); nrf_gpio_cfg_default(params.pinMOSI);
@ -104,3 +187,5 @@ void SpiMaster::Sleep() {
void SpiMaster::Wakeup() { void SpiMaster::Wakeup() {
Init(); Init();
} }

View file

@ -2,7 +2,9 @@
#include <cstdint> #include <cstdint>
#include <cstddef> #include <cstddef>
#include <array> #include <array>
#include <atomic>
#include "BufferProvider.h"
namespace Pinetime { namespace Pinetime {
namespace Drivers { namespace Drivers {
class SpiMaster { class SpiMaster {
@ -25,15 +27,26 @@ namespace Pinetime {
bool Init(); bool Init();
bool Write(const uint8_t* data, size_t size); bool Write(const uint8_t* data, size_t size);
void OnStartedEvent(BufferProvider& provider);
void OnEndEvent(BufferProvider& provider);
void Sleep(); void Sleep();
void Wakeup(); void Wakeup();
private: private:
NRF_SPI_Type * spiBaseAddress; void SetupWorkaroundForFtpan58(NRF_SPIM_Type *spim, uint32_t ppi_channel, uint32_t gpiote_channel);
void DisableWorkaroundForFtpan58(NRF_SPIM_Type *spim, uint32_t ppi_channel, uint32_t gpiote_channel);
void PrepareTx(const volatile uint32_t bufferAddress, const volatile size_t size);
NRF_SPIM_Type * spiBaseAddress;
uint8_t pinCsn; uint8_t pinCsn;
SpiMaster::SpiModule spi; SpiMaster::SpiModule spi;
SpiMaster::Parameters params; SpiMaster::Parameters params;
volatile bool busy = false;
volatile uint32_t currentBufferAddr = 0;
volatile size_t currentBufferSize = 0;
}; };
} }
} }

View file

@ -38,7 +38,7 @@ void St7789::WriteData(uint8_t data) {
void St7789::WriteSpi(const uint8_t* data, size_t size) { void St7789::WriteSpi(const uint8_t* data, size_t size) {
spi.Write(data, size); spi.Write(data, size);
} }
void St7789::SoftwareReset() { void St7789::SoftwareReset() {
@ -95,20 +95,6 @@ void St7789::DisplayOn() {
WriteCommand(static_cast<uint8_t>(Commands::DisplayOn)); WriteCommand(static_cast<uint8_t>(Commands::DisplayOn));
} }
void St7789::FillRectangle(uint16_t x, uint16_t y, uint16_t width, uint16_t height, uint16_t color) {
BeginDrawBuffer(x, y, width, height);
uint32_t c = color + (color << 16);
uint8_t w = width/2;
for(y=height+ST7789_ROW_OFFSET; y>ST7789_ROW_OFFSET; y--) {
for(x=w; x>0; x--) {
NextDrawBuffer(reinterpret_cast<const uint8_t *>(&c), 4);
}
}
EndDrawBuffer();
}
void St7789::SetAddrWindow(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1) { void St7789::SetAddrWindow(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1) {
WriteCommand(static_cast<uint8_t>(Commands::ColumnAddressSet)); WriteCommand(static_cast<uint8_t>(Commands::ColumnAddressSet));
WriteData(x0 >> 8); WriteData(x0 >> 8);
@ -156,11 +142,8 @@ void St7789::BeginDrawBuffer(uint16_t x, uint16_t y, uint16_t width, uint16_t he
nrf_gpio_pin_set(pinDataCommand); nrf_gpio_pin_set(pinDataCommand);
} }
void St7789::EndDrawBuffer() {
}
void St7789::NextDrawBuffer(const uint8_t *data, size_t size) { void St7789::NextDrawBuffer(const uint8_t *data, size_t size) {
spi.Write(data, size); WriteSpi(data, size);
} }
void St7789::HardwareReset() { void St7789::HardwareReset() {
@ -191,5 +174,3 @@ void St7789::Wakeup() {
NormalModeOn(); NormalModeOn();
DisplayOn(); DisplayOn();
} }

View file

@ -10,19 +10,15 @@ namespace Pinetime {
void Init(); void Init();
void Uninit(); void Uninit();
void DrawPixel(uint16_t x, uint16_t y, uint32_t color); void DrawPixel(uint16_t x, uint16_t y, uint32_t color);
void FillRectangle(uint16_t x, uint16_t y, uint16_t width, uint16_t height, uint16_t color);
void BeginDrawBuffer(uint16_t x, uint16_t y, uint16_t width, uint16_t height); void BeginDrawBuffer(uint16_t x, uint16_t y, uint16_t width, uint16_t height);
void NextDrawBuffer(const uint8_t* data, size_t size); void NextDrawBuffer(const uint8_t* data, size_t size);
void EndDrawBuffer();
void DisplayOn(); void DisplayOn();
void DisplayOff(); void DisplayOff();
void Sleep(); void Sleep();
void Wakeup(); void Wakeup();
private: private:
SpiMaster& spi; SpiMaster& spi;
uint8_t pinDataCommand; uint8_t pinDataCommand;
@ -36,10 +32,7 @@ namespace Pinetime {
void DisplayInversionOn(); void DisplayInversionOn();
void NormalModeOn(); void NormalModeOn();
void WriteToRam(); void WriteToRam();
void SetAddrWindow(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1); void SetAddrWindow(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1);
void WriteCommand(uint8_t cmd); void WriteCommand(uint8_t cmd);
void WriteSpi(const uint8_t* data, size_t size); void WriteSpi(const uint8_t* data, size_t size);
@ -63,7 +56,6 @@ namespace Pinetime {
static constexpr uint16_t Width = 240; static constexpr uint16_t Width = 240;
static constexpr uint16_t Height = 240; static constexpr uint16_t Height = 240;
void RowAddressSet(); void RowAddressSet();
}; };
} }
} }

View file

@ -15,6 +15,10 @@
#include "BLE/BleManager.h" #include "BLE/BleManager.h"
#include "Components/Battery/BatteryController.h" #include "Components/Battery/BatteryController.h"
#include "Components/Ble/BleController.h" #include "Components/Ble/BleController.h"
#include "../drivers/Cst816s.h"
#include <drivers/St7789.h>
#include <drivers/SpiMaster.h>
#include <Components/Gfx/Gfx.h>
#if NRF_LOG_ENABLED #if NRF_LOG_ENABLED
#include "Logging/NrfLogger.h" #include "Logging/NrfLogger.h"
@ -24,6 +28,18 @@ Pinetime::Logging::NrfLogger logger;
Pinetime::Logging::DummyLogger logger; Pinetime::Logging::DummyLogger logger;
#endif #endif
std::unique_ptr<Pinetime::Drivers::SpiMaster> spi;
std::unique_ptr<Pinetime::Drivers::St7789> lcd;
std::unique_ptr<Pinetime::Components::Gfx> gfx;
std::unique_ptr<Pinetime::Drivers::Cst816S> touchPanel;
static constexpr uint8_t pinSpiSck = 2;
static constexpr uint8_t pinSpiMosi = 3;
static constexpr uint8_t pinSpiMiso = 4;
static constexpr uint8_t pinSpiCsn = 25;
static constexpr uint8_t pinLcdDataCommand = 18;
std::unique_ptr<Pinetime::Applications::DisplayApp> displayApp; std::unique_ptr<Pinetime::Applications::DisplayApp> displayApp;
TaskHandle_t systemThread; TaskHandle_t systemThread;
bool isSleeping = false; bool isSleeping = false;
@ -85,9 +101,29 @@ void SystemTask(void *) {
APP_GPIOTE_INIT(2); APP_GPIOTE_INIT(2);
bool erase_bonds=false; bool erase_bonds=false;
nrf_sdh_freertos_init(ble_manager_start_advertising, &erase_bonds); nrf_sdh_freertos_init(ble_manager_start_advertising, &erase_bonds);
spi.reset(new Pinetime::Drivers::SpiMaster {Pinetime::Drivers::SpiMaster::SpiModule::SPI0, {
Pinetime::Drivers::SpiMaster::BitOrder::Msb_Lsb,
Pinetime::Drivers::SpiMaster::Modes::Mode3,
Pinetime::Drivers::SpiMaster::Frequencies::Freq8Mhz,
pinSpiSck,
pinSpiMosi,
pinSpiMiso,
pinSpiCsn
}});
lcd.reset(new Pinetime::Drivers::St7789(*spi, pinLcdDataCommand));
gfx.reset(new Pinetime::Components::Gfx(*lcd));
touchPanel.reset(new Pinetime::Drivers::Cst816S());
spi->Init();
lcd->Init();
touchPanel->Init();
batteryController.Init();
displayApp.reset(new Pinetime::Applications::DisplayApp(*lcd, *gfx, *touchPanel, batteryController, bleController, dateTimeController));
displayApp->Start(); displayApp->Start();
batteryController.Init();
batteryController.Update(); batteryController.Update();
displayApp->PushMessage(Pinetime::Applications::DisplayApp::Messages::UpdateBatteryLevel); displayApp->PushMessage(Pinetime::Applications::DisplayApp::Messages::UpdateBatteryLevel);
@ -158,8 +194,22 @@ void OnNewTime(current_time_char_t* currentTime) {
dayOfWeek, hour, minute, second, nrf_rtc_counter_get(portNRF_RTC_REG)); dayOfWeek, hour, minute, second, nrf_rtc_counter_get(portNRF_RTC_REG));
} }
void SPIM0_SPIS0_TWIM0_TWIS0_SPI0_TWI0_IRQHandler(void) {
if(((NRF_SPIM0->INTENSET & (1<<6)) != 0) && NRF_SPIM0->EVENTS_END == 1) {
NRF_SPIM0->EVENTS_END = 0;
spi->OnEndEvent(*gfx);
}
if(((NRF_SPIM0->INTENSET & (1<<19)) != 0) && NRF_SPIM0->EVENTS_STARTED == 1) {
NRF_SPIM0->EVENTS_STARTED = 0;
spi->OnStartedEvent(*gfx);
}
if(((NRF_SPIM0->INTENSET & (1<<1)) != 0) && NRF_SPIM0->EVENTS_STOPPED == 1) {
NRF_SPIM0->EVENTS_STOPPED = 0;
}
}
int main(void) { int main(void) {
displayApp.reset(new Pinetime::Applications::DisplayApp(batteryController, bleController, dateTimeController));
logger.Init(); logger.Init();
nrf_drv_clock_init(); nrf_drv_clock_init();