G4-Scope¶

#include <jee.h>
using namespace jeeh;

const Pin led ("C6","P");

int main () {
    while (true) {
        led.toggle();
        msWait(500);
    }
}

#include <jee.h>
#include <jee/hal.h>
using namespace jeeh;
#include "defs.hpp"

int main () {
    initBoard();

    while (true) { led.toggle(); msWait(500); }
}

#include <jee.h>
#include <jee/hal.h>
using namespace jeeh;
#include "defs.hpp"

int main () {
    initBoard();

    Pin::config("A4:A");
    dac::init(); // currently hard-coded for DAC1, output pin A4
    adc::init(); // currently hard-coded for ADC1
    msWait(2); // TODO needs > 1 ms settling time, but why?

    // this code needs a jumper between DAC out (A4) and ADC in (A0)

    const uint16_t steps [] = {
        0, 1000, 2000, 3000, 4000, 4095, 4000, 3000, 2000, 1000, 0,
    };

    for (auto e : steps) {
        dac::set(e);
        msWait(1);

        logf("%4d => %4d %4d %4d", e,
            adc::read(1), adc::read(1), adc::read(1)); // A0 is ADC1 channel 1
    }

    while (true) { led.toggle(); msWait(500); }
}

#include <jee.h>
#include <jee/hal.h>
using namespace jeeh;
#include "defs.hpp"

int main () {
    initBoard();
    cordic::init();

    for (auto i = 0; i <= 16; ++i) {
        auto v = cordic::sine(i << 12);
        logf("%6d %*c", v, v/1024+32, '+');
    }

    while (true) { led.toggle(); msWait(500); }
}

#include <jee.h>
#include <jee/hal.h>
using namespace jeeh;
#include "defs.hpp"

int main () {
    initBoard();
    cordic::init();

    Pin::config("A4:A");
    dac::init(); // currently hard-coded for DAC1, output pin A4
    adc::init(); // currently hard-coded for ADC1
    ADC1[0x14](0,3) = 7; // max ADC sample time, to let weak DAC output settle
    msWait(2); // TODO needs > 1 ms settling time, but why?

    // this code needs a jumper between DAC out (A4) and ADC in (A0)

    // use range 0x0100..0x0F00 to stay out of the 12-bit DAC's extremes
    uint16_t sine [20];
    cordic::sineFill(sine, 0x0700, 0x0800);

    for (auto e : sine) {
        dac::set(e);
        msWait(1);

        adc::read(1);          // A0 is ADC1 channel 1
        auto v = adc::read(1); // use 2nd reading, it's more accurate
        logf("%4d %4d %*c", e, v, v/64, '+');
    }

    while (true) { led.toggle(); msWait(500); }
}

#include <jee.h>
#include <jee/hal.h>
using namespace jeeh;
#include "defs.hpp"
#include "common.h"

int main () {
    initBoard();

    // system clock = 170 MHz, timer clock = 10 KHz, trigger = 1 Hz, pwm = 10%
    initTimer3(17'000, 10'000, 10);
    led.mode("2"); // alt mode 2: TIM3 CH1

    while (true) {}
}

void initTimer3 (uint16_t div, uint16_t cnt, uint8_t pct =50) {
    enum { CR1=0x00, CCMR1=0x18, CCER=0x20, PSC=0x28, ARR=0x2C, CCR1=0x34 };

    RCC(ena::TIM3,1) = 1;
    TIM3[CCMR1](0,8) = 0x68; // OC1PE, OC1MR: PWM mode 1
    TIM3[CCER](0) = 1;       // CC1E

    TIM3[PSC] = div - 1;
    TIM3[ARR] = cnt - 1;
    TIM3[CCR1] = (cnt*pct) / 100; // duty cycle 1..100%

    TIM3[CR1](0) = 1; // CEN
}

#include <jee.h>
#include <jee/hal.h>
using namespace jeeh;
#include "defs.hpp"
#include "common.h"

struct Config {
    uint32_t base =0;
    uint32_t dmaBase =0;
    uint8_t dmaIdx =0, dmaC =0, dmaT =0;
};

template< const Config& C >
struct DmaFeed {
    static constexpr IoReg<C.dmaBase>                       DMA {};
    static constexpr IoReg<C.dmaBase+dma::CHAN_STEP*C.dmaC> DCH {};

    void init (const uint16_t* vec, int num, uint16_t reg, uint8_t trg) {
        (void) vec, (void) num, (void) reg, (void) trg;
        RCC(ena::DMA1+C.dmaIdx,1) = 1;
        RCC(ena::DMAMUX,1) = 1;

        constexpr auto CHMAP = 6; // G431
        DMAMUX[4*(CHMAP*C.dmaIdx+C.dmaC)] = C.dmaT;

        // channel configuration
        DCH[dma::CCR] = 0b0101'1011'0010; // MSIZE PSIZE MINC CIRC DIR TCIE

        DCH[dma::CPAR] = C.base + reg;
        DCH[dma::CMAR] = (uintptr_t) vec;
        DCH[dma::CNDTR] = num;
        DCH[dma::CCR](0) = 1; // EN
    }

    void deinit () {
        DCH[dma::CCR] = 0;
        RCC(ena::DMAMUX,1) = 0;
        RCC(ena::DMA1+C.dmaIdx,1) = 0;
    }
};

constexpr Config DAC_CONF = {
    DAC1.ADDR, DMA1.ADDR, 1-1, 2-1, 61,
};

DmaFeed<DAC_CONF> feeder;

int main () {
    initBoard();
    cordic::init();

    Pin::config("A4:A");
    dac::init(); // currently hard-coded for DAC1, output pin A4
    adc::init(); // currently hard-coded for ADC1
    ADC1[0x14](0,3) = 7; // max ADC sample time, to let weak DAC output settle
    msWait(2); // TODO needs > 1 ms settling time, but why?

    // this code needs a jumper between DAC out (A4) and ADC in (A0)

    // use range 0x0100..0x0F00 to stay out of the 12-bit DAC's extremes
    uint16_t sine [4096];
    cordic::sineFill(sine, 0x0700, 0x0800);

    // system clock = 170 MHz, timer clock = 10 KHz, trigger = 2 KHz
    initTimer3(17'000, 5);

    // set up a continuous 16-bit stream from sine[] to DAC1
    feeder.init(sine, 4096, 0x08, 61); // trigger on TIM3 CH1

    for (auto i = 0; i < 20; ++i) {
        adc::read(1);          // A0 is ADC1 channel 1
        auto v = adc::read(1); // use 2nd reading, it's more accurate
        logf("%4d %*c", v, v/64, '+');
logf("%d", +feeder.DCH[dma::CNDTR]);
//logf("%d", +TIM3[0x24]);

        msWait(100);
    }

    while (true) { led.toggle(); msWait(500); }
}

// Lines with "CG" control the code-generated parts of this file.

//CG1 board leds
#define LED  "C6"

const Pin led (LED,"P");

//CG3 board pins
#define PINS_BKL "B10"
#define PINS_RST "B11"
#define PINS_DC "B14"

//CG[ board spi
#define SPI_NAME SPI2
constexpr spi::Config SPI_CONF {
    "B15:H5,B14,B13,B12:HP", SPI2.ADDR, ena::SPI2, 170,
};
//CG]

spi::Poll<SPI_CONF> spiBus; // st7789 lcd

rtt::Desc rttDesc;

void jeeh::logWriter (const void* ptr, size_t len) {
    rttDesc.tx.write((const char*) ptr, len);
}

void initBoard () {
    fastClock();
    rttDesc.tx.flags = 2; // set RTT output to blocking mode
    cycles::init();

    logf("\n%s: %s @ %d MHz (%s)",
            PIOENV, SVDNAME, SystemCoreClock / 1'000'000, VERSION);
}

#include <jee.h>
#include <jee/hal.h>
#include <jee/dev/st7796.h>
using namespace jeeh;
#include "defs.hpp"
#include "common.h"

using Screen = dev::ST7796<LcdSpi,170,320,35>; // 1.9" LCD module
util::TwoDee<Screen> gfx;

int main () {
    initBoard();
    initGrid(gfx);

    // draw a a box of maximum size, and a line from origin to the middle
    // to verify proper setup and orientation: (0,0) should be bottom left

    gfx.fg = GREEN; gfx.box({0, 0, Screen::width-1, Screen::height-1});
    gfx.fg = RED;   gfx.line({0,0}, {Screen::width/2, Screen::height/2});

    while (true) { led.toggle(); msWait(500); }
}

template< typename T >
void initGrid (T& g) {
    g.init();
    g.clear();

    g.fg = GREY;
    for (auto i = 1; i < GC; ++i)
        g.hLine({TB, TB+i*PW}, GH);
    for (auto i = 1; i < GR; ++i)
        g.vLine({TB+i*PH, TL}, GW);

    g.fg = WHITE; g.box({TB, TL, GH+1, GW+1});
}