smartwatch/narf52
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Compare commits

base: smartwatch:ba83d9cdea7bacd605dda71f8fdeac0853364613
Branches Tags
smartwatch:master
..
compare: smartwatch:a2852bd8233c869cb64c5da0a81c3cdfd07e99b9
Branches Tags
smartwatch:master

No commits in common. "ba83d9cdea7bacd605dda71f8fdeac0853364613" and "a2852bd8233c869cb64c5da0a81c3cdfd07e99b9" have entirely different histories.
ba83d9cdea ... a2852bd823

22 changed files with 150 additions and 534 deletions
Show Stats Expand all files Collapse all files

3
.vscode/tasks.json vendored
View File

@ -2,9 +2,10 @@
"version": "2.0.0",
"options": {
"env": {
"APPLICATION": "blinky",
// "APPLICATION": "blinky",
// "APPLICATION": "spi",
// "APPLICATION": "st7789_lcd",
"APPLICATION": "sys_tick",
},
},
"presentation": {

1
Makefile
View File

@ -33,7 +33,6 @@ CC_SRCS = $(wildcard $(SRC_DIR)/*.cc)
CC_SRCS += $(wildcard $(SRC_DIR)/platform/$(CORE)/*.cc)
CC_SRCS += $(wildcard $(SRC_DIR)/platform/$(PLATFORM)/*.cc)
CC_SRCS += $(wildcard $(SRC_DIR)/application/$(APPLICATION)/*.cc)
CC_SRCS += $(wildcard $(SRC_DIR)/virtual_timer/*.cc)
CC_OBJS = $(patsubst $(SRC_DIR)%,$(OBJ_DIR)%,$(patsubst %.cc,%.cc.o,$(CC_SRCS)))
OBJS = $(A_OBJS) $(C_OBJS) $(CC_OBJS)

19
interfaces/HwTimerInterface.h
View File

@ -1,19 +0,0 @@
#ifndef __INTERFACES_HWTIMERINTERFACE_H__
#define __INTERFACES_HWTIMERINTERFACE_H__
#include <cstdint>
namespace pinetime::interfaces
{
class HwTimerInterface
{
public:
virtual void enable_timer() = 0;
virtual void disable_timer() = 0;
virtual uint64_t tick() = 0;
};
}
#endif

19
interfaces/VirtualTimerInterface.h
View File

@ -1,19 +0,0 @@
#ifndef __INTERFACES_VIRTUALTIMERINTERFACE_H__
#define __INTERFACES_VIRTUALTIMERINTERFACE_H__
#include <cstdint>
namespace pinetime::interfaces
{
class VirtualTimerInterface
{
public:
virtual void timer_notification(uint64_t) = 0;
virtual void timer_enable() = 0;
virtual void timer_disable() = 0;
};
}
#endif

56
src/Pool.h
View File

@ -1,56 +0,0 @@
#ifndef __POOL_H__
#define __POOL_H__
#include <cstddef>
#include <cstdint>
#include "platform/cm4/InterruptLock.h"
namespace pinetime
{
template <typename T, std::size_t sizeT>
class Pool
{
union Item
{
uint8_t item[sizeof(T)];
Item * next;
};
Item items[sizeT];
uint8_t map[sizeT];
public:
Pool()
{
for(unsigned int i = 0; i < sizeT; i++) {
map[i] = 0;
}
}
void *alloc()
{
pinetime::platform::cm4::InterruptLock lock;
void * res = nullptr;
for(unsigned int i = 0; i < sizeT; i++) {
if(map[i] == 0) {
map[i] = 0xff;
res = static_cast<void *>(items + i);
break;
}
}
return res;
}
void free(T * ptr)
{
pinetime::platform::cm4::InterruptLock lock;
// ptr is not assumed to be aligned, since the integer based aritmetic provides always the correct index and omits the ramainder.
std::size_t index = (reinterpret_cast<std::uintptr_t>(ptr) - reinterpret_cast<std::uintptr_t>(items)) / sizeof(Item);
map[index] = 0;
}
};
}
#endif

19
src/application/blinky/main.cc
View File

@ -1,19 +1,15 @@
#include <array>
#include "virtual_timer/VirtualTimerDistributor.h"
#include "delay.h"
#include "platform/cm4/InterruptHandler.h"
#include "platform/cm4/InterruptGuardian.h"
#include "platform/cm4/SystemTick.h"
#include "platform/nrf52/gpio.h"
#include "platform/nrf52/InterruptHandler.h"
#include "platform/nrf52/InterruptGuardian.h"
#include "delay.h"
using namespace pinetime::platform;
using namespace pinetime::virtual_timer;
enum {
PIN_NUMBER_LED_1 = 17,
@ -22,30 +18,23 @@ enum {
PIN_NUMBER_LED_4 = 20
};
// LEDs
nrf52::Gpio led_1(PIN_NUMBER_LED_1);
nrf52::Gpio led_2(PIN_NUMBER_LED_2);
nrf52::Gpio led_3(PIN_NUMBER_LED_3);
nrf52::Gpio led_4(PIN_NUMBER_LED_4);
std::array<nrf52::Gpio *, 4> leds = {&led_1, &led_2, &led_3, &led_4};
// IRQs
nrf52::InterruptGuardian nrf52::InterruptGuardian::instance;
cm4::InterruptGuardian cm4::InterruptGuardian::instance;
// Timer
cm4::SystemTick system_tick;
VirtualTimerDistributor virtual_timer_distributor(system_tick.instance());
pinetime::Delay delay;
nrf52::InterruptGuardian nrf52::InterruptGuardian::instance;
int main(void)
{
cm4::InterruptGuardian::enable_interrupts();
while(true) {
for(auto it = std::begin(leds); it != std::end(leds); ++it) {
nrf52::Gpio * tmp = *it;
tmp->toggle();
delay.delay(200);
delay_ms(500);
}
}
return 0;

8
src/application/spi/main.cc
View File

@ -1,4 +1,6 @@
#include "delay.h"
#include "platform/cm4/InterruptHandler.h"
#include "platform/cm4/InterruptGuardian.h"
@ -9,19 +11,19 @@
using namespace pinetime::platform;
uint8_t buf[] = "Test";
const uint8_t buf[] = "Test";
nrf52::Gpio led_1(17);
nrf52::Gpio lcd_chip_select(25);
nrf52::Spi spi_0(0, 2, 3, 4, lcd_chip_select);
cm4::InterruptGuardian cm4::InterruptGuardian::instance;
nrf52::InterruptGuardian nrf52::InterruptGuardian::instance;
int main(void)
{
cm4::InterruptGuardian::enable_interrupts();
nrf52::Spi spi_0(0, 2, 3, 4, lcd_chip_select);
while(1) {
delay_ms(200);
spi_0.send(buf, sizeof(buf));
led_1.toggle();
}

4
src/application/st7789_lcd/main.cc
View File

@ -1,3 +1,5 @@
#include "delay.h"
#include "platform/cm4/InterruptHandler.h"
#include "platform/cm4/InterruptGuardian.h"
@ -24,10 +26,10 @@ nrf52::InterruptGuardian nrf52::InterruptGuardian::instance;
int main(void)
{
cm4::InterruptGuardian::enable_interrupts();
lcd.init();
lcd.clear(0);
while(true) {
delay_ms(200);
led_1.toggle();
}
}

49
src/application/sys_tick/main.cc Normal file
View File

@ -0,0 +1,49 @@
#include <array>
#include "platform/cm4/InterruptHandler.h"
#include "platform/cm4/InterruptGuardian.h"
#include "platform/cm4/SystemTick.h"
#include "platform/nrf52/gpio.h"
#include "platform/nrf52/InterruptHandler.h"
#include "platform/nrf52/InterruptGuardian.h"
using namespace pinetime::platform;
enum {
PIN_NUMBER_LED_1 = 17,
PIN_NUMBER_LED_2 = 18,
PIN_NUMBER_LED_3 = 19,
PIN_NUMBER_LED_4 = 20
};
nrf52::Gpio led_1(PIN_NUMBER_LED_1);
nrf52::Gpio led_2(PIN_NUMBER_LED_2);
nrf52::Gpio led_3(PIN_NUMBER_LED_3);
nrf52::Gpio led_4(PIN_NUMBER_LED_4);
std::array<nrf52::Gpio *, 4> leds = {&led_1, &led_2, &led_3, &led_4};
nrf52::InterruptGuardian nrf52::InterruptGuardian::instance;
cm4::InterruptGuardian cm4::InterruptGuardian::instance;
int main(void)
{
cm4::SystemTick ticker;
ticker.enable();
uint32_t last_tick = 0;
cm4::InterruptGuardian::enable_interrupts();
while(true) {
for(auto it = std::begin(leds); it != std::end(leds); ++it) {
volatile uint32_t tick = ticker.tick() / 1000;
if(tick != last_tick) {
nrf52::Gpio * tmp = *it;
tmp->toggle();
last_tick = tick;
}
}
}
return 0;
}

27
src/delay.cc
View File

@ -1,27 +0,0 @@
#include "delay.h"
using namespace pinetime;
using namespace pinetime::virtual_timer;
Delay::Delay()
: VirtualTimer(0)
, pause(false)
{
}
void Delay::delay(uint64_t time_ms)
{
this->pause = true;
this->timer_set_period_ms(time_ms);
this->timer_enable();
while(this->pause) {
// FIXME: Low power
asm volatile("nop");
}
this->timer_disable();
}
void Delay::notification()
{
this->pause = false;
}

25
src/delay.h
View File

@ -1,25 +0,0 @@
#ifndef __DELAY_H__
#define __DELAY_H__
#include "virtual_timer/VirtualTimer.h"
namespace pinetime
{
class Delay
: public pinetime::virtual_timer::VirtualTimer
{
public:
Delay();
void delay(uint64_t);
void notification();
private:
bool pause;
};
}
#endif

9
src/platform/cm4/SystemTick.cc
View File

@ -2,13 +2,11 @@ extern "C" {
#include "nrf52.h"
}
#include "virtual_timer/VirtualTimerDistributor.h"
#include "platform/cm4/InterruptHandler.h"
#include "platform/cm4/InterruptGuardian.h"
#include "platform/cm4/SystemTick.h"
using namespace pinetime::platform::cm4;
using namespace pinetime::virtual_timer;
SystemTick::SystemTick()
: InterruptHandler(InterruptGuardian::Cm4IrqN::SYS_TICK_IRQ)
@ -19,20 +17,19 @@ SystemTick::SystemTick()
void SystemTick::handle()
{
this->sys_tick++;
VirtualTimerDistributor::instance().notify(this->sys_tick);
}
void SystemTick::enable_timer()
void SystemTick::enable()
{
SysTick_Config(SystemCoreClock / 1000);
}
void SystemTick::disable_timer()
void SystemTick::disable()
{
SysTick->CTRL = 0;
}
uint64_t SystemTick::tick()
uint32_t SystemTick::tick()
{
return this->sys_tick;
}

27
src/platform/cm4/SystemTick.h
View File

@ -1,34 +1,21 @@
#ifndef __PLATFORM_CM4_SYSTEMTICK_H__
#define __PLATFORM_CM4_SYSTEMTICK_H__
#include "HwTimerInterface.h"
#include "platform/cm4/InterruptHandler.h"
namespace pinetime::platform::cm4
{
class SystemTick;
}
extern pinetime::platform::cm4::SystemTick system_tick;
namespace pinetime::platform::cm4 {
namespace pinetime::platform::cm4
{
class SystemTick
: public pinetime::platform::cm4::InterruptHandler
, public pinetime::interfaces::HwTimerInterface
class SystemTick : public pinetime::platform::cm4::InterruptHandler
{
public:
SystemTick();
static inline SystemTick & instance() { return system_tick; }
void enable_timer() override;
void disable_timer() override;
uint64_t tick() override;
void handle() override;
void handle();
void enable();
void disable();
uint32_t tick();
private:
uint64_t sys_tick;
uint32_t sys_tick;
};
}

74
src/platform/nrf52/InterruptGuardian.h
View File

@ -15,43 +15,43 @@ public:
InterruptGuardian();
enum Nrf52IrqN {
POWER_CLOCK_IRQ, //!< 0 POWER_CLOCK
RADIO_IRQ, //!< 1 RADIO
UARTE0_UART0_IRQ, //!< 2 UARTE0_UART0
SPIM0_SPIS0_TWIM0_TWIS0_SPI0_TWI0_IRQ, //!< 3 SPIM0_SPIS0_TWIM0_TWIS0_SPI0_TWI0
SPIM1_SPIS1_TWIM1_TWIS1_SPI1_TWI1_IRQ, //!< 4 SPIM1_SPIS1_TWIM1_TWIS1_SPI1_TWI1
NFCT_IRQ, //!< 5 NFCT
GPIOTE_IRQ, //!< 6 GPIOTE
SAADC_IRQ, //!< 7 SAADC
TIMER0_IRQ, //!< 8 TIMER0
TIMER1_IRQ, //!< 9 TIMER1
TIMER2_IRQ, //!< 10 TIMER2
RTC0_IRQ, //!< 11 RTC0
TEMP_IRQ, //!< 12 TEMP
RNG_IRQ, //!< 13 RNG
ECB_IRQ, //!< 14 ECB
CCM_AAR_IRQ, //!< 15 CCM_AAR
WDT_IRQ, //!< 16 WDT
RTC1_IRQ, //!< 17 RTC1
QDEC_IRQ, //!< 18 QDEC
COMP_LPCOMP_IRQ, //!< 19 COMP_LPCOMP
SWI0_EGU0_IRQ, //!< 20 SWI0_EGU0
SWI1_EGU1_IRQ, //!< 21 SWI1_EGU1
SWI2_EGU2_IRQ, //!< 22 SWI2_EGU2
SWI3_EGU3_IRQ, //!< 23 SWI3_EGU3
SWI4_EGU4_IRQ, //!< 24 SWI4_EGU4
SWI5_EGU5_IRQ, //!< 25 SWI5_EGU5
TIMER3_IRQ, //!< 26 TIMER3
TIMER4_IRQ, //!< 27 TIMER4
PWM0_IRQ, //!< 28 PWM0
PDM_IRQ, //!< 29 PDM
MWU_IRQ, //!< 32 MWU
PWM1_IRQ, //!< 33 PWM1
PWM2_IRQ, //!< 34 PWM2
SPIM2_SPIS2_SPI2_IRQ, //!< 35 SPIM2_SPIS2_SPI2
RTC2_IRQ, //!< 36 RTC2
I2S_IRQ, //!< 37 I2S
FPU_IRQ //!< 38 FPU
POWER_CLOCK_IRQn, //!< 0 POWER_CLOCK
RADIO_IRQn, //!< 1 RADIO
UARTE0_UART0_IRQn, //!< 2 UARTE0_UART0
SPIM0_SPIS0_TWIM0_TWIS0_SPI0_TWI0_IRQn, //!< 3 SPIM0_SPIS0_TWIM0_TWIS0_SPI0_TWI0
SPIM1_SPIS1_TWIM1_TWIS1_SPI1_TWI1_IRQn, //!< 4 SPIM1_SPIS1_TWIM1_TWIS1_SPI1_TWI1
NFCT_IRQn, //!< 5 NFCT
GPIOTE_IRQn, //!< 6 GPIOTE
SAADC_IRQn, //!< 7 SAADC
TIMER0_IRQn, //!< 8 TIMER0
TIMER1_IRQn, //!< 9 TIMER1
TIMER2_IRQn, //!< 10 TIMER2
RTC0_IRQn, //!< 11 RTC0
TEMP_IRQn, //!< 12 TEMP
RNG_IRQn, //!< 13 RNG
ECB_IRQn, //!< 14 ECB
CCM_AAR_IRQn, //!< 15 CCM_AAR
WDT_IRQn, //!< 16 WDT
RTC1_IRQn, //!< 17 RTC1
QDEC_IRQn, //!< 18 QDEC
COMP_LPCOMP_IRQn, //!< 19 COMP_LPCOMP
SWI0_EGU0_IRQn, //!< 20 SWI0_EGU0
SWI1_EGU1_IRQn, //!< 21 SWI1_EGU1
SWI2_EGU2_IRQn, //!< 22 SWI2_EGU2
SWI3_EGU3_IRQn, //!< 23 SWI3_EGU3
SWI4_EGU4_IRQn, //!< 24 SWI4_EGU4
SWI5_EGU5_IRQn, //!< 25 SWI5_EGU5
TIMER3_IRQn, //!< 26 TIMER3
TIMER4_IRQn, //!< 27 TIMER4
PWM0_IRQn, //!< 28 PWM0
PDM_IRQn, //!< 29 PDM
MWU_IRQn, //!< 32 MWU
PWM1_IRQn, //!< 33 PWM1
PWM2_IRQn, //!< 34 PWM2
SPIM2_SPIS2_SPI2_IRQn, //!< 35 SPIM2_SPIS2_SPI2
RTC2_IRQn, //!< 36 RTC2
I2S_IRQn, //!< 37 I2S
FPU_IRQn //!< 38 FPU
};
private:

10
src/platform/nrf52/low_level_interrupt.cc
View File

@ -44,13 +44,3 @@ extern "C" {
}
using namespace pinetime::platform::nrf52;
void SPIM0_SPIS0_TWIM0_TWIS0_SPI0_TWI0_IRQHandler(void)
{
uint32_t irq_nr = InterruptGuardian::Nrf52IrqN::SPIM0_SPIS0_TWIM0_TWIS0_SPI0_TWI0_IRQ;
InterruptHandler *h = InterruptGuardian::instance.nrf52_vector[irq_nr];
assert(h != nullptr);
h->handle();
}

122
src/platform/nrf52/spi.cc
View File

@ -1,130 +1,70 @@
#include <assert.h>
#include "platform/nrf52/InterruptHandler.h"
#include "platform/nrf52/InterruptGuardian.h"
#include "platform/nrf52/spi.h"
extern "C" {
#include "nrf52.h"
#include "nrf52_bitfields.h"
NRF_GPIO_Type *const GPIO_REGS = reinterpret_cast<NRF_GPIO_Type *>(NRF_P0_BASE);
NRF_SPIM_Type *SPIM_REGS = reinterpret_cast<NRF_SPIM_Type *>(NRF_SPIM0_BASE);
NRF_SPI_Type *SPI_REGS = reinterpret_cast<NRF_SPI_Type *>(NRF_SPI0_BASE);
}
using namespace pinetime::platform::nrf52;
Spi::Spi(uint32_t instance, uint32_t sck, uint32_t mosi, uint32_t miso, pinetime::interfaces::GpioInterface & cs)
: InterruptHandler(InterruptGuardian::Nrf52IrqN::SPIM0_SPIS0_TWIM0_TWIS0_SPI0_TWI0_IRQ)
, chip_select(cs)
, xfer_active(false)
: chip_select(cs)
{
assert(instance < 3);
// sck pin
GPIO_REGS->OUTCLR = 1UL << sck;
GPIO_REGS->PIN_CNF[mosi] = GPIO_PIN_CNF_DIR_Output << GPIO_PIN_CNF_DIR_Pos
| GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos
| GPIO_PIN_CNF_PULL_Disabled << GPIO_PIN_CNF_PULL_Pos
| GPIO_PIN_CNF_DRIVE_S0S1 << GPIO_PIN_CNF_DRIVE_Pos
| GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos;
// mosi pin
GPIO_REGS->OUTCLR = 1UL << mosi;
GPIO_REGS->PIN_CNF[mosi] = GPIO_PIN_CNF_DIR_Output << GPIO_PIN_CNF_DIR_Pos
| GPIO_PIN_CNF_INPUT_Disconnect << GPIO_PIN_CNF_INPUT_Pos
| GPIO_PIN_CNF_PULL_Disabled << GPIO_PIN_CNF_PULL_Pos
| GPIO_PIN_CNF_DRIVE_S0S1 << GPIO_PIN_CNF_DRIVE_Pos
| GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos;
// miso pin
GPIO_REGS->PIN_CNF[miso] = GPIO_PIN_CNF_DIR_Input << GPIO_PIN_CNF_DIR_Pos
| GPIO_PIN_CNF_INPUT_Connect << GPIO_PIN_CNF_INPUT_Pos
| GPIO_PIN_CNF_PULL_Pulldown << GPIO_PIN_CNF_PULL_Pos
| GPIO_PIN_CNF_DRIVE_S0S1 << GPIO_PIN_CNF_DRIVE_Pos
| GPIO_PIN_CNF_SENSE_Disabled << GPIO_PIN_CNF_SENSE_Pos;
// ss already configured by gpio driver
IRQn_Type irq = SPIM0_SPIS0_TWIM0_TWIS0_SPI0_TWI0_IRQn;
if(instance == 2) {
SPIM_REGS = reinterpret_cast<NRF_SPIM_Type *>(NRF_SPIM2_BASE);
irq = SPIM2_SPIS2_SPI2_IRQn;
if(instance == 0) {
SPI_REGS = reinterpret_cast<NRF_SPI_Type *>(NRF_SPI0_BASE);
} else if(instance == 1) {
SPIM_REGS = reinterpret_cast<NRF_SPIM_Type *>(NRF_SPIM1_BASE);
irq = SPIM1_SPIS1_TWIM1_TWIS1_SPI1_TWI1_IRQn;
SPI_REGS = reinterpret_cast<NRF_SPI_Type *>(NRF_SPI1_BASE);
} else {
SPIM_REGS = reinterpret_cast<NRF_SPIM_Type *>(NRF_SPIM0_BASE);
irq = SPIM0_SPIS0_TWIM0_TWIS0_SPI0_TWI0_IRQn;
SPI_REGS = reinterpret_cast<NRF_SPI_Type *>(NRF_SPI2_BASE);
}
this->chip_select.set();
SPIM_REGS->ENABLE = 0;
SPIM_REGS->PSEL.SCK = sck;
SPIM_REGS->PSEL.MOSI = mosi;
SPIM_REGS->PSEL.MISO = miso;
SPIM_REGS->FREQUENCY = SPI_FREQUENCY_FREQUENCY_M8;
SPI_REGS->ENABLE = 0;
SPI_REGS->PSEL.SCK = sck;
SPI_REGS->PSEL.MOSI = mosi;
SPI_REGS->PSEL.MISO = miso;
SPI_REGS->FREQUENCY = SPI_FREQUENCY_FREQUENCY_M8;
SPIM_REGS->CONFIG = (0x03 << 1); //Sample on trailing edge of clock, shift serial data on leading edge, SCK polarity Active low
SPIM_REGS->EVENTS_ENDRX = 0;
SPIM_REGS->EVENTS_ENDTX = 0;
SPIM_REGS->EVENTS_END = 0;
SPIM_REGS->INTENSET = (1 << 1) // Stopped
| (1 << 6) // End
| (1 << 19); // Started
SPIM_REGS->ENABLE = (SPIM_ENABLE_ENABLE_Enabled << SPIM_ENABLE_ENABLE_Pos);
NVIC_SetPriority(irq, 2);
NVIC_EnableIRQ(irq);
SPI_REGS->CONFIG = (0x03 << 1); //Sample on trailing edge of clock, shift serial data on leading edge, SCK polarity Active low
SPI_REGS->EVENTS_READY = 0;
SPI_REGS->ENABLE = (SPI_ENABLE_ENABLE_Enabled << SPI_ENABLE_ENABLE_Pos);
}
Spi::~Spi()
{
SPIM_REGS->ENABLE = 0;
SPI_REGS->ENABLE = 0;
}
void Spi::send(const uint8_t * buffer, uint32_t len)
{
this->chip_select.clear();
this->xfer_active = true;
SPIM_REGS->TXD.PTR = reinterpret_cast<uint32_t>(buffer);
SPIM_REGS->TXD.MAXCNT = len;
SPIM_REGS->TXD.LIST = 0;
SPIM_REGS->RXD.PTR = 0;
SPIM_REGS->RXD.MAXCNT = 0;
SPIM_REGS->RXD.LIST = 0;
SPIM_REGS->EVENTS_END = 0;
SPIM_REGS->TASKS_START = 1;
// FIXME: LOW POWER???
while(this->xfer_active);
for(unsigned int i = 0; i < len; i++) {
this->transfer(buffer[i]);
}
this->chip_select.set();
}
void Spi::recv(uint8_t * buffer, uint32_t len)
{
// FIXME: not implemented yet
this->chip_select.clear();
for(unsigned int i = 0; i < len; i++) {
buffer[i] = this->transfer(buffer[i]);
}
this->chip_select.set();
}
void Spi::handle()
uint32_t Spi::transfer(uint32_t data)
{
if((SPIM_REGS->INTENSET & (1 << 6)) && (SPIM_REGS->EVENTS_END == 1)) {
SPIM_REGS->EVENTS_END = 0;
this->xfer_active = false;
}
if((SPIM_REGS->INTENSET & (1 << 19)) && (SPIM_REGS->EVENTS_STARTED == 1)) {
SPIM_REGS->EVENTS_STARTED = 0;
}
if((SPIM_REGS->INTENSET & (1 << 1)) && (SPIM_REGS->EVENTS_STOPPED == 1)) {
SPIM_REGS->EVENTS_STOPPED = 0;
this->xfer_active = false;
}
}
volatile uint32_t ret;
SPI_REGS->EVENTS_READY = 0;
SPI_REGS->TXD = data;
while(SPI_REGS->EVENTS_READY == 0) {;}
ret = SPI_REGS->RXD;
return ret;
}

9
src/platform/nrf52/spi.h
View File

@ -4,13 +4,9 @@
#include "gpio_interface.h"
#include "spi_interface.h"
#include "platform/nrf52/InterruptHandler.h"
namespace pinetime::platform::nrf52 {
class Spi
: public pinetime::platform::nrf52::InterruptHandler
, public pinetime::interfaces::SpiInterface
class Spi : public pinetime::interfaces::SpiInterface
{
public:
Spi(uint32_t instance, uint32_t sck, uint32_t mosi, uint32_t miso, pinetime::interfaces::GpioInterface & cs);
@ -21,10 +17,7 @@ public:
private:
uint32_t transfer(uint32_t);
void handle() override;
pinetime::interfaces::GpioInterface & chip_select;
volatile bool xfer_active;
};
}

21
src/st7789.cc
View File

@ -1,4 +1,3 @@
#include <array>
#include <cstdint>
#include "st7789.h"
@ -116,21 +115,17 @@ void St7789::send_data(uint8_t data)
void St7789::clear(uint16_t Color)
{
unsigned int odd = 0;
std::array<uint8_t, 240> line;
for(auto it = line.begin(); it != line.end(); ++it) {
if(odd % 2 == 0) {
*it = static_cast<uint8_t>((Color >> 8) & 0xff);
} else {
*it = static_cast<uint8_t>(Color & 0xff);
}
odd++;
}
unsigned int i,j;
set_windows(0, 0, 240, 240);
this->data_command.set();
for(unsigned int i = 0; i < 240 * 2; i++) {
this->spi.send(line.data(), line.size());
for(i = 0; i < 240; i++) {
for(j = 0; j < 240; j++){
uint8_t c = (Color >> 8) & 0xff;
this->spi.send(&c, 1);
c = Color & 0xff;
this->spi.send(&c, 1);
}
}
}

38
src/virtual_timer/VirtualTimer.cc
View File

@ -1,38 +0,0 @@
#include "virtual_timer/VirtualTimerDistributor.h"
#include "virtual_timer/VirtualTimer.h"
using namespace pinetime::virtual_timer;
VirtualTimer::VirtualTimer(uint64_t period_ms)
: period(period_ms)
{
}
void VirtualTimer::timer_enable()
{
VirtualTimerDistributor & distri = VirtualTimerDistributor::instance();
this->start_time = distri.tick();
distri.register_timer(this);
}
void VirtualTimer::timer_disable()
{
VirtualTimerDistributor::instance().unregister_timer(this);
}
void VirtualTimer::timer_notification(uint64_t tick_ms)
{
if((tick_ms - this->start_time) >= (this->period)) {
this->notification();
}
}
void VirtualTimer::timer_set_period_ms(uint64_t period_ms)
{
this->period = period_ms;
}
// void VirtualTimer::notify()
// {
// asm volatile("nop");
// }

30
src/virtual_timer/VirtualTimer.h
View File

@ -1,30 +0,0 @@
#ifndef __VIRTUAL_TIMER_VIRTUALTIMER_H__
#define __VIRTUAL_TIMER_VIRTUALTIMER_H__
#include "VirtualTimerInterface.h"
namespace pinetime::virtual_timer
{
class VirtualTimer
: public pinetime::interfaces::VirtualTimerInterface
{
public:
VirtualTimer(uint64_t);
void timer_enable() override;
void timer_disable() override;
void timer_notification(uint64_t) override;
void timer_set_period_ms(uint64_t);
virtual void notification() = 0;
private:
uint64_t period;
uint64_t start_time;
};
}
#endif

73
src/virtual_timer/VirtualTimerDistributor.cc
View File

@ -1,73 +0,0 @@
#include "virtual_timer/VirtualTimer.h"
#include "virtual_timer/VirtualTimerDistributor.h"
using namespace pinetime::virtual_timer;
using namespace pinetime::interfaces;
VirtualTimerDistributor::VirtualTimerDistributor(pinetime::interfaces::HwTimerInterface & timer)
: hw_timer(timer)
, num_registered_timers(0)
{
for(auto it = this->virtual_timer_list.begin(); it != this->virtual_timer_list.end(); ++it) {
*it = nullptr;
}
}
void VirtualTimerDistributor::register_timer(VirtualTimerInterface *timer)
{
volatile bool enable = false;
if(num_registered_timers == MAX_TIMERS) {
// FIXME: Error notification
return;
}
if(num_registered_timers == 0) {
// Timer list is empty - so - hw timer isn't running
enable = true;
} else {
// Check if timer already registered
for(auto it = this->virtual_timer_list.begin(); it != this->virtual_timer_list.end(); ++it) {
if(*it == timer) {
return;
}
}
}
for(auto it = this->virtual_timer_list.begin(); it != this->virtual_timer_list.end(); ++it) {
if(*it == nullptr) {
*it = timer;
num_registered_timers++;
break;
}
}
if(enable) {
hw_timer.enable_timer();
}
}
void VirtualTimerDistributor::unregister_timer(VirtualTimerInterface *timer)
{
for(auto it = this->virtual_timer_list.begin(); it != this->virtual_timer_list.end(); ++it) {
if(*it == timer) {
*it = nullptr;
num_registered_timers--;
break;
}
}
if(num_registered_timers == 0) {
hw_timer.disable_timer();
}
}
void VirtualTimerDistributor::notify(uint64_t time_ms)
{
for(auto it = this->virtual_timer_list.begin(); it != this->virtual_timer_list.end(); ++it) {
if(*it != nullptr) {
VirtualTimerInterface *vt = *it;
vt->timer_notification(time_ms);
}
}
}
uint64_t VirtualTimerDistributor::tick()
{
return hw_timer.tick();
}

41
src/virtual_timer/VirtualTimerDistributor.h
View File

@ -1,41 +0,0 @@
#ifndef __VIRTUAL_TIMER_VIRTUALTIMERDISTRIBUTOR_H__
#define __VIRTUAL_TIMER_VIRTUALTIMERDISTRIBUTOR_H__
#include <array>
#include "HwTimerInterface.h"
#include "VirtualTimerInterface.h"
namespace pinetime::virtual_timer
{
class VirtualTimerDistributor;
}
extern pinetime::virtual_timer::VirtualTimerDistributor virtual_timer_distributor;
namespace pinetime::virtual_timer
{
class VirtualTimerDistributor
{
public:
VirtualTimerDistributor(pinetime::interfaces::HwTimerInterface &);
static inline VirtualTimerDistributor& instance() { return virtual_timer_distributor; }
void register_timer(pinetime::interfaces::VirtualTimerInterface *);
void unregister_timer(pinetime::interfaces::VirtualTimerInterface *);
void notify(uint64_t);
uint64_t tick();
private:
static const uint32_t MAX_TIMERS = 8;
std::array<pinetime::interfaces::VirtualTimerInterface *, MAX_TIMERS> virtual_timer_list;
pinetime::interfaces::HwTimerInterface & hw_timer;
uint32_t num_registered_timers;
};
}
#endif