1369 lines
45 KiB
C
1369 lines
45 KiB
C
#include <avr/eeprom.h>
|
|
#include <avr/io.h>
|
|
#include <avr/interrupt.h>
|
|
#include <util/delay.h>
|
|
#include <util/twi.h>
|
|
#include <assert.h>
|
|
#include <stdbool.h>
|
|
|
|
#define SPI_PORT PORTB
|
|
#define SPI_DDR DDRB
|
|
#define SPI_SCK PB5
|
|
#define SPI_MOSI PB3
|
|
#define SPI_SS PB2
|
|
|
|
#define LCD_CD PB0
|
|
#define LCD_RST PB1
|
|
|
|
#define ENC_A (PINB & (1 << PB6))
|
|
#define ENC_B (PINB & (1 << PB7))
|
|
|
|
#define TWI_PORT PORTC
|
|
#define TWI_SDA PC4
|
|
#define TWI_SCL PC5
|
|
|
|
#define SI5351_ADDRESS 0x60
|
|
|
|
#define SI5351_REGISTER_3_OUTPUT_ENABLE_CONTROL 3
|
|
// ...
|
|
#define SI5351_REGISTER_26_MSNA 26
|
|
#define SI5351_REGISTER_34_MSNB 34
|
|
// ...
|
|
#define SI5351_REGISTER_177_PLL_RESET 177
|
|
|
|
#define SYM_ENTRY(SYM) { SYM, sizeof(SYM) / 2 }
|
|
|
|
static uint8_t EEMEM eeprom_contrast = 8;
|
|
static uint8_t EEMEM eeprom_backlight = 1;
|
|
|
|
static const __flash uint8_t sacred_chao[] = { 0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0xE0, 0xF0, 0xF0, 0xF8, 0xFC, 0xFC, 0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFE, 0xFE, 0xFC, 0xFC, 0xF8, 0xF0, 0xF0, 0xE0, 0xC0, 0x80, 0x00, 0x00, 0x00, 0x00,
|
|
0x80, 0xF0, 0xFC, 0xFE, 0xFF, 0xFF, 0x7F, 0x3F, 0x1F, 0x3F, 0x3F, 0x7F, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x1F, 0x0F, 0x0F, 0x07, 0x07, 0x07, 0x03, 0xC3, 0xE3, 0x73, 0x37, 0x17, 0x07, 0x0F, 0x1E, 0x3C, 0xF0, 0x80,
|
|
0xFF, 0xFF, 0xFF, 0xE7, 0xC3, 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x00, 0x00, 0xFC, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFC, 0x30, 0x00, 0x00, 0xFF,
|
|
0x01, 0x0F, 0x3F, 0x4F, 0x9F, 0x3F, 0x3E, 0x3C, 0x7C, 0x7C, 0x7C, 0x7C, 0x3E, 0x3E, 0x3E, 0x1F, 0x1F, 0x0F, 0x07, 0x01, 0x00, 0x00, 0x00, 0x01, 0x03, 0x07, 0x07, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x07, 0x07, 0x03, 0x81, 0x40, 0x30, 0x0E, 0x01,
|
|
0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x04, 0x08, 0x08, 0x10, 0x20, 0x20, 0x40, 0x40, 0x40, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x40, 0x40, 0x40, 0x20, 0x20, 0x10, 0x08, 0x08, 0x04, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00 };
|
|
|
|
static const __flash uint8_t onders_org[] = { 0xE0, 0x60, 0xE0, 0x00, 0x00, 0xE0, 0x60, 0xE0, 0x00, 0x00, 0xE0, 0x60, 0xF8, 0x00, 0x00, 0xE0, 0xA0, 0xE0, 0x00, 0x00, 0xE0, 0x20, 0x60, 0x00, 0x00, 0xE0, 0xA0, 0xA0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x60, 0xE0, 0x00, 0x00, 0xE0, 0x20, 0x60, 0x00, 0x00, 0xE0, 0x60, 0xE0,
|
|
0x03, 0x02, 0x03, 0x00, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x03, 0x02, 0x03, 0x00, 0x00, 0x03, 0x02, 0x02, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x02, 0x03, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x0B, 0x0A, 0x0F};
|
|
|
|
static const __flash uint8_t sym_0[] = { 0xF8, 0xFC, 0x0C, 0xFC, 0xF8,
|
|
0x1F, 0x3F, 0x30, 0x3F, 0x1F };
|
|
static const __flash uint8_t sym_1[] = { 0x30, 0x30, 0xFC, 0xFC, 0x00,
|
|
0x30, 0x30, 0x3F, 0x3F, 0x30 };
|
|
static const __flash uint8_t sym_2[] = { 0x18, 0x1C, 0x8C, 0xFC, 0xF8,
|
|
0x38, 0x3E, 0x3F, 0x33, 0x30 };
|
|
static const __flash uint8_t sym_3[] = { 0x18, 0x9C, 0x8C, 0xFC, 0x78,
|
|
0x18, 0x39, 0x31, 0x3F, 0x1E };
|
|
static const __flash uint8_t sym_4[] = { 0x80, 0xE0, 0x78, 0xFC, 0xFC,
|
|
0x07, 0x07, 0x06, 0x3F, 0x3F };
|
|
static const __flash uint8_t sym_5[] = { 0xFC, 0xFC, 0x8C, 0x8C, 0x0C,
|
|
0x1C, 0x3D, 0x31, 0x3F, 0x1F };
|
|
static const __flash uint8_t sym_6[] = { 0xF8, 0xFC, 0x8C, 0xBC, 0x38,
|
|
0x1F, 0x3F, 0x31, 0x3F, 0x1F };
|
|
static const __flash uint8_t sym_7[] = { 0x0C, 0x0C, 0xEC, 0xFC, 0x1C,
|
|
0x00, 0x3E, 0x3F, 0x01, 0x00 };
|
|
static const __flash uint8_t sym_8[] = { 0x78, 0xFC, 0x8C, 0xFC, 0x78,
|
|
0x1E, 0x3F, 0x31, 0x3F, 0x1E };
|
|
static const __flash uint8_t sym_9[] = { 0xF8, 0xFC, 0x8C, 0xFC, 0xF8,
|
|
0x1C, 0x3D, 0x31, 0x3F, 0x1F };
|
|
|
|
static const __flash uint8_t sym_colon[] = { 0x30, 0x30,
|
|
0x0C, 0x0C };
|
|
|
|
static const __flash uint8_t sym_a[] = { 0xC0, 0xF0, 0x3C, 0x3C, 0xF0, 0xC0,
|
|
0x3F, 0x3F, 0x06, 0x06, 0x3F, 0x3F };
|
|
static const __flash uint8_t sym_b[] = { 0xFC, 0xFC, 0x8C, 0x8C, 0xFC, 0x78,
|
|
0x3F, 0x3F, 0x31, 0x31, 0x3F, 0x1E };
|
|
static const __flash uint8_t sym_c[] = { 0xF8, 0xFC, 0x0C, 0x1C, 0x18,
|
|
0x1F, 0x3F, 0x30, 0x38, 0x18 };
|
|
static const __flash uint8_t sym_d[] = { 0xFC, 0xFC, 0x0C, 0x1C, 0xF8, 0xF0,
|
|
0x3F, 0x3F, 0x30, 0x38, 0x1F, 0x0F };
|
|
static const __flash uint8_t sym_e[] = { 0xFC, 0xFC, 0x8C, 0x8C, 0x0C,
|
|
0x3F, 0x3F, 0x31, 0x31, 0x30 };
|
|
static const __flash uint8_t sym_g[] = { 0xF8, 0xFC, 0x0C, 0x0C, 0x3C, 0x38,
|
|
0x1F, 0x3F, 0x30, 0x33, 0x3F, 0x1F };
|
|
static const __flash uint8_t sym_h[] = { 0xFC, 0xFC, 0x80, 0x80, 0xFC, 0xFC,
|
|
0x3F, 0x3F, 0x01, 0x01, 0x3F, 0x3F };
|
|
static const __flash uint8_t sym_i[] = { 0x0C, 0xFC, 0xFC, 0x0C,
|
|
0x30, 0x3F, 0x3F, 0x30 };
|
|
static const __flash uint8_t sym_k[] = { 0xFC, 0xFC, 0xC0, 0xF0, 0x7C, 0x1C,
|
|
0x3F, 0x3F, 0x03, 0x0F, 0x3E, 0x38 };
|
|
static const __flash uint8_t sym_l[] = { 0xFC, 0xFC, 0x00, 0x00, 0x00,
|
|
0x3F, 0x3F, 0x30, 0x30, 0x30 };
|
|
static const __flash uint8_t sym_m[] = { 0xFC, 0xFC, 0x38, 0x70, 0xE0, 0x70, 0x38, 0xFC, 0xFC,
|
|
0x3F, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0x3F };
|
|
static const __flash uint8_t sym_n[] = { 0xFC, 0xFC, 0xF0, 0xC0, 0x00, 0xFC, 0xFC,
|
|
0x3F, 0x3F, 0x00, 0x03, 0x0F, 0x3F, 0x3F };
|
|
static const __flash uint8_t sym_o[] = { 0xF8, 0xFC, 0x0C, 0x0C, 0xFC, 0xF8,
|
|
0x1F, 0x3F, 0x30, 0x30, 0x3F, 0x1F };
|
|
static const __flash uint8_t sym_p[] = { 0xFC, 0xFC, 0x8C, 0x8C, 0xFC, 0xF8,
|
|
0x3F, 0x3F, 0x01, 0x01, 0x01, 0x00 };
|
|
static const __flash uint8_t sym_r[] = { 0xFC, 0xFC, 0x8C, 0x8C, 0xFC, 0xF8,
|
|
0x3F, 0x3F, 0x01, 0x03, 0x3F, 0x3E };
|
|
static const __flash uint8_t sym_s[] = { 0xF8, 0xFC, 0x8C, 0x8C, 0x9C, 0x18,
|
|
0x18, 0x39, 0x31, 0x31, 0x3F, 0x1F };
|
|
static const __flash uint8_t sym_t[] = { 0x0C, 0x0C, 0xFC, 0xFC, 0x0C, 0x0C,
|
|
0x00, 0x00, 0x3F, 0x3F, 0x00, 0x00 };
|
|
static const __flash uint8_t sym_u[] = { 0xFC, 0xFC, 0x00, 0x00, 0xFC, 0xFC,
|
|
0x1F, 0x3F, 0x30, 0x30, 0x3F, 0x1F };
|
|
|
|
static const __flash uint8_t sym_underscore[] = { 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x20, 0x20, 0x20, 0x20, 0x20 };
|
|
|
|
static const __flash uint8_t sym_invalid[] = { 0x80, 0xE0, 0x98, 0xCC, 0x4C, 0x18, 0xE0, 0x80,
|
|
0x01, 0x07, 0x1F, 0x24, 0x25, 0x1F, 0x07, 0x01};
|
|
|
|
struct symbol {
|
|
const __flash uint8_t* data;
|
|
const uint8_t length;
|
|
};
|
|
|
|
static const struct symbol symbol_table[] = { SYM_ENTRY(sym_0),
|
|
SYM_ENTRY(sym_1),
|
|
SYM_ENTRY(sym_2),
|
|
SYM_ENTRY(sym_3),
|
|
SYM_ENTRY(sym_4),
|
|
SYM_ENTRY(sym_5),
|
|
SYM_ENTRY(sym_6),
|
|
SYM_ENTRY(sym_7),
|
|
SYM_ENTRY(sym_8),
|
|
SYM_ENTRY(sym_9),
|
|
SYM_ENTRY(sym_colon),
|
|
SYM_ENTRY(sym_invalid),
|
|
SYM_ENTRY(sym_invalid),
|
|
SYM_ENTRY(sym_invalid),
|
|
SYM_ENTRY(sym_invalid),
|
|
SYM_ENTRY(sym_invalid),
|
|
SYM_ENTRY(sym_invalid),
|
|
SYM_ENTRY(sym_a),
|
|
SYM_ENTRY(sym_b),
|
|
SYM_ENTRY(sym_c),
|
|
SYM_ENTRY(sym_d),
|
|
SYM_ENTRY(sym_e),
|
|
SYM_ENTRY(sym_invalid),
|
|
SYM_ENTRY(sym_g),
|
|
SYM_ENTRY(sym_h),
|
|
SYM_ENTRY(sym_i),
|
|
SYM_ENTRY(sym_invalid),
|
|
SYM_ENTRY(sym_k),
|
|
SYM_ENTRY(sym_l),
|
|
SYM_ENTRY(sym_m),
|
|
SYM_ENTRY(sym_n),
|
|
SYM_ENTRY(sym_o),
|
|
SYM_ENTRY(sym_p),
|
|
SYM_ENTRY(sym_invalid),
|
|
SYM_ENTRY(sym_r),
|
|
SYM_ENTRY(sym_s),
|
|
SYM_ENTRY(sym_t),
|
|
SYM_ENTRY(sym_u),
|
|
SYM_ENTRY(sym_invalid),
|
|
SYM_ENTRY(sym_invalid),
|
|
SYM_ENTRY(sym_invalid),
|
|
SYM_ENTRY(sym_invalid),
|
|
SYM_ENTRY(sym_invalid),
|
|
SYM_ENTRY(sym_invalid),
|
|
SYM_ENTRY(sym_invalid),
|
|
SYM_ENTRY(sym_invalid),
|
|
SYM_ENTRY(sym_invalid),
|
|
SYM_ENTRY(sym_underscore),
|
|
};
|
|
|
|
enum input { cw, ccw, click, hold };
|
|
|
|
static volatile enum state { home, ch1, ch2, ch3, plla, pllb, setup } current_state = home;
|
|
static volatile enum state home_state = ch1;
|
|
static volatile enum setup_state { contrast, backlight, back, change_contrast, change_backlight } setup_state = contrast;
|
|
static volatile enum pll_state { integer, numerator, denominator, pll_back, change_integer, change_numerator, change_denominator } pll_state = integer;
|
|
|
|
static volatile uint8_t enc = 0;
|
|
static volatile uint8_t select_offset = 0;
|
|
static volatile uint8_t digit_select = 0;
|
|
static volatile uint8_t max_digits = 0;
|
|
static volatile bool digit_selected = false;
|
|
|
|
static volatile uint8_t value_contrast;
|
|
static volatile uint8_t value_backlight;
|
|
|
|
struct pll_config {
|
|
uint8_t reg;
|
|
uint32_t integer;
|
|
uint32_t numerator;
|
|
uint32_t denominator;
|
|
};
|
|
|
|
static volatile struct pll_config plla_config = { SI5351_REGISTER_26_MSNA, 0, 0, 0 };
|
|
static volatile struct pll_config pllb_config = { SI5351_REGISTER_34_MSNB, 0, 0, 0 };
|
|
|
|
static const uint8_t m_si5351_regs_15to92_149to170[100][2] = {
|
|
// Init
|
|
{3, 0xFF},
|
|
{16, 0x4F}, /* CLK0 Control: 8mA drive, Multisynth 0 as CLK0 source, Clock
|
|
not inverted, Source = PLLA, Multisynth 0 in integer mode,
|
|
clock powered up */
|
|
{17, 0x4F}, /* CLK1 Control: 8mA drive, Multisynth 1 as CLK1 source, Clock
|
|
not inverted, Source = PLLA, Multisynth 1 in integer mode,
|
|
clock powered up */
|
|
{18, 0x6F}, /* CLK2 Control: 8mA drive, Multisynth 2 as CLK2 source, Clock
|
|
not inverted, Source = PLLB, Multisynth 2 in integer mode,
|
|
clock powered up */
|
|
{19, 0x80}, /* CLK3 Control: Not used ... clock powered down */
|
|
{20, 0x80}, /* CLK4 Control: Not used ... clock powered down */
|
|
{21, 0x80}, /* CLK5 Control: Not used ... clock powered down */
|
|
{22, 0x80}, /* CLK6 Control: Not used ... clock powered down */
|
|
{23, 0x80}, /* CLK7 Control: Not used ... clock powered down */
|
|
{24, 0x00}, /* Clock disable state 0..3 (low when disabled) */
|
|
{25, 0x00}, /* Clock disable state 4..7 (low when disabled) */
|
|
// PLL_A Setup (720MHz)
|
|
// P1: 0x00C66 = 3174
|
|
// P2: 0x00002 = 2
|
|
// P3: 0x00005 = 5
|
|
{26, 0x00}, // D7 - D0: MSNA_P3 [15:8]
|
|
{27, 0x05}, // D7 - D0: MSNA_P3 [7:0]
|
|
{28, 0x00}, // D1 - D0: MSNA_P1 [17:16]
|
|
{29, 0x0C}, // D7 - D0: MSNA_P1 [15:8]
|
|
{30, 0x66}, // D7 - D0: MSNA_P1 [7:0]
|
|
{31, 0x00}, // D7 - D4: MSNA_P3 [19:16], D3 - D0: MSNA_P2 [19:16]
|
|
{32, 0x00}, // D7 - D0: MSNA_P2 [15:8]
|
|
{33, 0x02}, // D7 - D0: MSNA_P2 [7:0]
|
|
// PLL_B Setup (705MHz)
|
|
{34, 0x02},
|
|
{35, 0x71},
|
|
{36, 0x00},
|
|
{37, 0x0C},
|
|
{38, 0x1A},
|
|
{39, 0x00},
|
|
{40, 0x00},
|
|
{41, 0x86},
|
|
// Multisynth0 Setup (120MHz)
|
|
{42, 0x00},
|
|
{43, 0x01},
|
|
{44, 0x00},
|
|
{45, 0x01},
|
|
{46, 0x00},
|
|
{47, 0x00},
|
|
{48, 0x00},
|
|
{49, 0x00},
|
|
// Multisynth1 Setup (12MHz)
|
|
{50, 0x00},
|
|
{51, 0x01},
|
|
{52, 0x00},
|
|
{53, 0x1C},
|
|
{54, 0x00},
|
|
{55, 0x00},
|
|
{56, 0x00},
|
|
{57, 0x00},
|
|
// Multisynth2 Setup (13.56MHz)
|
|
{58, 0x00},
|
|
{59, 0x01},
|
|
{60, 0x00},
|
|
{61, 0x18},
|
|
{62, 0x00},
|
|
{63, 0x00},
|
|
{64, 0x00},
|
|
{65, 0x00}};
|
|
|
|
static const uint8_t m_si5351_regs_custom[51][2] = {
|
|
// Init
|
|
{3, 0xFF},
|
|
{16, 0x4F}, /* CLK0 Control: 8mA drive, Multisynth 0 as CLK0 source, Clock
|
|
not inverted, Source = PLLA, Multisynth 0 in integer mode,
|
|
clock powered up */
|
|
{17, 0x4F}, /* CLK1 Control: 8mA drive, Multisynth 1 as CLK1 source, Clock
|
|
not inverted, Source = PLLA, Multisynth 1 in integer mode,
|
|
clock powered up */
|
|
{18, 0x6F}, /* CLK2 Control: 8mA drive, Multisynth 2 as CLK2 source, Clock
|
|
not inverted, Source = PLLB, Multisynth 2 in integer mode,
|
|
clock powered up */
|
|
{19, 0x80}, /* CLK3 Control: Not used ... clock powered down */
|
|
{20, 0x80}, /* CLK4 Control: Not used ... clock powered down */
|
|
{21, 0x80}, /* CLK5 Control: Not used ... clock powered down */
|
|
{22, 0x80}, /* CLK6 Control: Not used ... clock powered down */
|
|
{23, 0x80}, /* CLK7 Control: Not used ... clock powered down */
|
|
{24, 0x00}, /* Clock disable state 0..3 (low when disabled) */
|
|
{25, 0x00}, /* Clock disable state 4..7 (low when disabled) */
|
|
// PLL_A Setup (900MHz) (36 + 0/1)
|
|
// P1: 4096 => 0x01000
|
|
// P2: 0 => 0x00000
|
|
// P3: 1 => 0x00001
|
|
{26, 0x00}, // D7 - D0: MSNA_P3 [15:8]
|
|
{27, 0x01}, // D7 - D0: MSNA_P3 [7:0]
|
|
{28, 0x00}, // D1 - D0: MSNA_P1 [17:16]
|
|
{29, 0x10}, // D7 - D0: MSNA_P1 [15:8]
|
|
{30, 0x00}, // D7 - D0: MSNA_P1 [7:0]
|
|
{31, 0x00}, // D7 - D4: MSNA_P3 [19:16], D3 - D0: MSNA_P2 [19:16]
|
|
{32, 0x00}, // D7 - D0: MSNA_P2 [15:8]
|
|
{33, 0x00}, // D7 - D0: MSNA_P2 [7:0]
|
|
// PLL_B Setup (375MHz) (15 + 0/1)
|
|
/* // P1: 1408 => 0x00580 */
|
|
/* // P2: 0 => 0x00000 */
|
|
/* // P3: 1 => 0x00001 */
|
|
{34, 0x00}, // D7 - D0: MSNB_P3 [15:8] */
|
|
{35, 0x01}, // D7 - D0: MSNB_P3 [7:0] */
|
|
{36, 0x00}, // D1 - D0: MSNB_P1 [17:16] */
|
|
{37, 0x05}, // D7 - D0: MSNB_P1 [15:8] */
|
|
{38, 0x80}, // D7 - D0: MSNB_P1 [7:0] */
|
|
{39, 0x00}, // D7 - D4: MSNB_P3 [19:16], D3 - D0: MSNA_P2 [19:16] */
|
|
{40, 0x00}, // D7 - D0: MSNB_P2 [15:8] */
|
|
{41, 0x00}, // D7 - D0: MSNB_P2 [7:0] */
|
|
// Multisynth0 Setup (120MHz)
|
|
// P1: 1
|
|
// P2: 0
|
|
// P3: 1
|
|
{42, 0x00}, // D7 - D0: MS0_P3 [15:8]
|
|
{43, 0x01}, // D7 - D0: MS0_P3 [7:0]
|
|
{44, 0x00}, // D6 - D4: R0_DIV [2:0], D3 - D2: MS0_DIVBY4 [1:0], D1 -D0: MS0_P1 [17:16]
|
|
{45, 0x01}, // D7 - D0: MS0_P1 [15:8]
|
|
{46, 0x01}, // D7 - D0: MS0_P1 [7:0]
|
|
{47, 0x00}, // D7 - D4: MS0_P3 [19:16], D3 - D0: MS0_P2 [19:16]
|
|
{48, 0x00}, // D7 - D0: MS0_P2 [15:8]
|
|
{49, 0x00}, // D7 - D0: MS0_P2 [7:0]
|
|
// Multisynth1 Setup (12MHz)
|
|
{50, 0x00},
|
|
{51, 0x01},
|
|
{52, 0x00},
|
|
{53, 0x1C},
|
|
{54, 0x00},
|
|
{55, 0x00},
|
|
{56, 0x00},
|
|
{57, 0x00},
|
|
// Multisynth2 Setup (13.56MHz)
|
|
{58, 0x00},
|
|
{59, 0x01},
|
|
{60, 0x00},
|
|
{61, 0x18},
|
|
{62, 0x00},
|
|
{63, 0x00},
|
|
{64, 0x00},
|
|
{65, 0x00}};
|
|
|
|
static uint32_t ten_pow(const uint8_t exponent) {
|
|
uint32_t result = 1;
|
|
|
|
for (uint8_t i = 0; i < exponent; i++)
|
|
result *= 10;
|
|
|
|
return result;
|
|
}
|
|
|
|
static void spi_init(void) {
|
|
SPI_DDR |= (1 << SPI_SCK) | (1 << SPI_MOSI) | (1 << SPI_SS);
|
|
SPI_PORT |= (1 << SPI_SS);
|
|
SPCR = (1 << SPE) | (1 << MSTR);
|
|
SPSR = (1 << SPI2X);
|
|
}
|
|
|
|
static uint8_t spi_byte(const uint8_t data) {
|
|
SPDR = data;
|
|
while(!(SPSR & (1 << SPIF)));
|
|
return SPDR;
|
|
}
|
|
|
|
static void lcd_write(const uint8_t data) {
|
|
SPI_PORT &= ~(1 << SPI_SS);
|
|
spi_byte(data);
|
|
SPI_PORT |= (1 << SPI_SS);
|
|
}
|
|
|
|
static void lcd_init(void) {
|
|
// TODO: Optimize waiting times
|
|
SPI_DDR |= (1 << LCD_CD) | (1 << LCD_RST);
|
|
_delay_ms(1);
|
|
SPI_PORT |= (1 << LCD_RST);
|
|
_delay_ms(5);
|
|
|
|
lcd_write(0x40); // (6) Set Scroll Line: Display start line 0
|
|
lcd_write(0xA1); // (13) Set SEG direction: SEG reverse
|
|
lcd_write(0xC0); // (14) Set COM direction: Normal COM0 - COM63
|
|
lcd_write(0xA6); // (11) Set Inverse Display: Display inverse off
|
|
lcd_write(0xA2); // (17) Set LCD Bias Ratio: Set Bias 1/9 (Duty 1/65)
|
|
lcd_write(0x2F); // (5) Set Power Control: Booster, Regulator and Follower on
|
|
lcd_write(0x27); // (8) Set VLCD Resistor Ratio: Set Contrast
|
|
lcd_write(0x81); // (9) Set Electronic Volume: Set Contrast
|
|
lcd_write(value_contrast); // (9) Set Electronic Volume: Set Contrast
|
|
lcd_write(0xAF); // (12) Set Display Enable: Display on
|
|
}
|
|
|
|
static void lcd_update_contrast(void) {
|
|
SPI_PORT &= ~(1 << LCD_CD);
|
|
lcd_write(0x81); // (9) Set Electronic Volume: Set Contrast
|
|
lcd_write(value_contrast); // (9) Set Electronic Volume: Set Contrast
|
|
SPI_PORT |= (1 << LCD_CD);
|
|
}
|
|
|
|
static void lcd_update_backlight(void) {
|
|
switch (value_backlight) {
|
|
case 0:
|
|
DDRD &= (0 << PD5);
|
|
break;
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
case 5:
|
|
TCCR0B = 0x0C; // Prescaler = 256;
|
|
DDRD |= (1 << PD5);
|
|
OCR0B = value_backlight - 1;
|
|
break;
|
|
default:
|
|
TCCR0B = 0x0B; // Prescaler = 64;
|
|
DDRD |= (1 << PD5);
|
|
OCR0B = value_backlight - 4;
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void lcd_move_cursor(const uint8_t column, const uint8_t row) {
|
|
assert(row < 16);
|
|
|
|
SPI_PORT &= ~(1 << LCD_CD);
|
|
lcd_write(0x00 + (0x0F & column));
|
|
lcd_write(0x10 + (column >> 4));
|
|
lcd_write(0xB0 + row);
|
|
SPI_PORT |= (1 << LCD_CD);
|
|
}
|
|
|
|
static void lcd_fill(const uint8_t data) {
|
|
for (uint8_t i = 0; i < 8; i++) {
|
|
lcd_move_cursor(0, i);
|
|
|
|
for (uint8_t j = 0; j < 102; j++)
|
|
lcd_write(data);
|
|
}
|
|
}
|
|
|
|
static void lcd_write_kerning(const uint8_t length,
|
|
const bool invert) {
|
|
for (uint8_t i = 0; i < length; i++)
|
|
if (invert)
|
|
lcd_write(0xFF);
|
|
else
|
|
lcd_write(0x00);
|
|
}
|
|
|
|
static void lcd_write_symbol_page(const struct symbol* symbol,
|
|
const uint8_t page,
|
|
const bool invert) {
|
|
for (uint8_t i = 0; i < symbol->length; i++)
|
|
if (invert)
|
|
lcd_write(~symbol->data[page * symbol->length + i]);
|
|
else
|
|
lcd_write(symbol->data[page * symbol->length + i]);
|
|
}
|
|
|
|
static void lcd_write_digit_page(const uint8_t digit,
|
|
const uint8_t page,
|
|
const bool invert) {
|
|
lcd_write_symbol_page(&symbol_table[digit], page, invert);
|
|
}
|
|
|
|
static void lcd_write_character_page(const char character,
|
|
const uint8_t page,
|
|
const bool invert) {
|
|
lcd_write_symbol_page(&symbol_table[character - 48], page, invert);
|
|
}
|
|
|
|
static void lcd_write_string_page(const char* string,
|
|
const uint8_t kerning,
|
|
const uint8_t page,
|
|
const bool invert) {
|
|
for (uint8_t i = 0; string[i] != 0; i++) {
|
|
lcd_write_kerning(kerning, invert);
|
|
lcd_write_character_page(string[i], page, invert);
|
|
}
|
|
}
|
|
|
|
static void lcd_write_integer_page(const uint32_t integer,
|
|
const uint8_t digits,
|
|
const uint8_t page,
|
|
const bool invert) {
|
|
if (digits != 0 || integer != 0) {
|
|
uint8_t input_digits = 0;
|
|
uint32_t comperator = 1;
|
|
|
|
// Get digits
|
|
for (; comperator <= integer; comperator *= 10, input_digits++);
|
|
|
|
// Print leading zeroes
|
|
for (int8_t i = digits - input_digits; i > 0; i--) {
|
|
lcd_write_kerning(2, invert);
|
|
lcd_write_digit_page(0, page, invert);
|
|
}
|
|
|
|
// Print number itself
|
|
for (; comperator >= 10; comperator /= 10) {
|
|
lcd_write_kerning(2, invert);
|
|
lcd_write_digit_page((integer % comperator) / (comperator / 10),
|
|
page, invert);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void lcd_write_selected_integer_page(const uint32_t integer,
|
|
const uint8_t digits,
|
|
const uint8_t page,
|
|
const bool invert) {
|
|
max_digits = digits;
|
|
|
|
if (digits != 0 || integer != 0) {
|
|
uint8_t input_digits = 0;
|
|
uint32_t comperator = 1;
|
|
|
|
// Get digits
|
|
for (; comperator <= integer; comperator *= 10, input_digits++);
|
|
lcd_write_kerning(1, invert);
|
|
|
|
// Print leading zeroes
|
|
for (int8_t i = digits - input_digits; i > 0; i--) {
|
|
if (input_digits + i - 1 != digit_select) {
|
|
lcd_write_kerning(1, invert);
|
|
lcd_write_digit_page(0, page, invert);
|
|
lcd_write_kerning(1, invert);
|
|
} else {
|
|
lcd_write_kerning(1, !invert);
|
|
lcd_write_digit_page(0, page, !invert);
|
|
lcd_write_kerning(1, !invert);
|
|
}
|
|
}
|
|
|
|
// Print number itself
|
|
for (; comperator >= 10; comperator /= 10, input_digits--) {
|
|
if (input_digits - 1 != digit_select) {
|
|
lcd_write_kerning(1, invert);
|
|
lcd_write_digit_page((integer % comperator) / (comperator / 10),
|
|
page, invert);
|
|
lcd_write_kerning(1, invert);
|
|
} else {
|
|
lcd_write_kerning(1, !invert);
|
|
|
|
lcd_write_digit_page((integer % comperator) / (comperator / 10),
|
|
page, !invert);
|
|
lcd_write_kerning(1, !invert);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void twi_error(bool inverted) {
|
|
if (inverted)
|
|
lcd_fill(0xFF);
|
|
else
|
|
lcd_fill(0x00);
|
|
|
|
for (uint8_t i = 0; i < 2; i++) {
|
|
lcd_move_cursor(0, i);
|
|
lcd_write_string_page("TW_STATUS:\0", 2, i, inverted);
|
|
lcd_write_kerning(2, inverted);
|
|
lcd_write_integer_page(TW_STATUS, 3, i, inverted);
|
|
}
|
|
|
|
for (uint8_t i = 0; i < 2; i++) {
|
|
lcd_move_cursor(0, i + 2);
|
|
lcd_write_string_page("TW_DATA:\0", 2, i, inverted);
|
|
lcd_write_kerning(16, inverted);
|
|
lcd_write_integer_page(TWDR, 3, i, inverted);
|
|
}
|
|
|
|
for (;;);
|
|
}
|
|
|
|
static void twi_start(void) {
|
|
TWCR = (1 << TWINT) | (1 << TWSTA) | (1 << TWEN); // Start transmission
|
|
while (!(TWCR & (1 << TWINT))); // Wait until start is transmitted
|
|
|
|
if (TW_STATUS != TW_START) // Check status
|
|
twi_error(true);
|
|
}
|
|
|
|
static uint8_t twi_transmit(const uint8_t data) {
|
|
TWDR = data;
|
|
TWCR = (1 << TWINT) | (1 << TWEN); // Transmit data
|
|
while (!(TWCR & (1 << TWINT))); // Wait until data is transmitted
|
|
|
|
return TW_STATUS;
|
|
}
|
|
|
|
static uint8_t twi_receive(void) {
|
|
TWCR = (1 << TWINT) | (1 << TWEN); // Receive data
|
|
while (!(TWCR & (1 << TWINT))); // Wait until data is received
|
|
|
|
return TW_STATUS;
|
|
}
|
|
|
|
static void twi_stop(void) {
|
|
TWCR = (1 << TWINT) | (1 << TWSTO) | (1 << TWEN);
|
|
}
|
|
|
|
static uint8_t twi_read_register(const uint8_t address,
|
|
const uint8_t reg) {
|
|
twi_start();
|
|
|
|
if (twi_transmit(address << 1) != TW_MT_SLA_ACK)
|
|
twi_error(true);
|
|
|
|
if (twi_transmit(reg) != TW_MT_DATA_ACK)
|
|
twi_error(true);
|
|
|
|
twi_stop();
|
|
|
|
_delay_us(2);
|
|
|
|
twi_start();
|
|
|
|
if (twi_transmit((address << 1) + 1) != TW_MR_SLA_ACK)
|
|
twi_error(true);
|
|
|
|
if (twi_receive() != TW_MR_DATA_NACK)
|
|
twi_error(true);
|
|
|
|
twi_stop();
|
|
|
|
return TWDR;
|
|
}
|
|
|
|
static void twi_write_register(const uint8_t address,
|
|
const uint8_t reg,
|
|
const uint8_t data) {
|
|
twi_start();
|
|
|
|
if (twi_transmit(address << 1) != TW_MT_SLA_ACK)
|
|
twi_error(true);
|
|
|
|
if (twi_transmit(reg) != TW_MT_DATA_ACK)
|
|
twi_error(true);
|
|
|
|
if (twi_transmit(data) != TW_MT_DATA_ACK)
|
|
twi_error(true);
|
|
|
|
twi_stop();
|
|
}
|
|
|
|
static void draw_splash(void) {
|
|
lcd_fill(0x00);
|
|
|
|
for (uint8_t i = 0; i < 5; i++) {
|
|
lcd_move_cursor(31, 1 + i);
|
|
|
|
for (uint8_t j = 0; j < 40; j++)
|
|
lcd_write(sacred_chao[i * 40 + j]);
|
|
}
|
|
|
|
for (uint8_t i = 0; i < 2; i++) {
|
|
lcd_move_cursor(26, 6 + i);
|
|
|
|
for (uint8_t j = 0; j < 48; j++)
|
|
lcd_write(onders_org[i * 48 + j]);
|
|
}
|
|
}
|
|
|
|
static void draw_home(void) {
|
|
lcd_fill(0x00);
|
|
|
|
bool ch1_selected = false;
|
|
bool ch2_selected = false;
|
|
bool ch3_selected = false;
|
|
bool plla_selected = false;
|
|
bool pllb_selected = false;
|
|
bool setup_selected = false;
|
|
|
|
switch (home_state) {
|
|
case ch1:
|
|
ch1_selected = true;
|
|
break;
|
|
case ch2:
|
|
ch2_selected = true;
|
|
break;
|
|
case ch3:
|
|
ch3_selected = true;
|
|
break;
|
|
case plla:
|
|
plla_selected = true;
|
|
break;
|
|
case pllb:
|
|
pllb_selected = true;
|
|
break;
|
|
default: // setup
|
|
setup_selected = true;
|
|
break;
|
|
}
|
|
|
|
for (uint8_t i = 0; i < 2; i++) {
|
|
lcd_move_cursor(0, i);
|
|
lcd_write_string_page("CH1\0", 2, i, ch1_selected);
|
|
lcd_write_kerning(2, ch1_selected);
|
|
|
|
lcd_move_cursor(0, 2 + i);
|
|
lcd_write_string_page("CH2\0", 2, i, ch2_selected);
|
|
lcd_write_kerning(2, ch2_selected);
|
|
|
|
lcd_move_cursor(0, 4 + i);
|
|
lcd_write_string_page("CH3\0", 2, i, ch3_selected);
|
|
lcd_write_kerning(2, ch3_selected);
|
|
|
|
lcd_move_cursor(0, 6 + i);
|
|
lcd_write_kerning(1, plla_selected);
|
|
lcd_write_string_page("PLL\0", 1, i, plla_selected);
|
|
|
|
lcd_write_string_page("A\0", 1, i, plla_selected);
|
|
lcd_write_kerning(2, plla_selected);
|
|
|
|
lcd_write_kerning(1, false);
|
|
|
|
lcd_write_kerning(1, pllb_selected);
|
|
lcd_write_string_page("PLL\0", 1, i, pllb_selected);
|
|
|
|
lcd_write_string_page("B\0", 1, i, pllb_selected);
|
|
lcd_write_kerning(2, pllb_selected);
|
|
|
|
lcd_move_cursor(61, 6 + i);
|
|
lcd_write_string_page("SETUP\0", 2, i, setup_selected);
|
|
lcd_write_kerning(2, setup_selected);
|
|
}
|
|
}
|
|
|
|
static void draw_pll(void) {
|
|
lcd_fill(0x00);
|
|
|
|
volatile struct pll_config* pll_config = &plla_config;
|
|
|
|
switch (current_state) {
|
|
case plla:
|
|
pll_config = &plla_config;
|
|
break;
|
|
case pllb:
|
|
pll_config = &pllb_config;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
bool integer_selected = false;
|
|
bool numerator_selected = false;
|
|
bool denominator_selected = false;
|
|
bool back_selected = false;
|
|
bool change_integer_selected = false;
|
|
bool change_numerator_selected = false;
|
|
bool change_denominator_selected = false;
|
|
|
|
switch (pll_state) {
|
|
case integer:
|
|
integer_selected = true;
|
|
break;
|
|
case numerator:
|
|
numerator_selected = true;
|
|
break;
|
|
case denominator:
|
|
denominator_selected = true;
|
|
break;
|
|
case pll_back:
|
|
back_selected = true;
|
|
break;
|
|
case change_integer:
|
|
change_integer_selected = true;
|
|
break;
|
|
case change_numerator:
|
|
change_numerator_selected = true;
|
|
break;
|
|
case change_denominator:
|
|
change_denominator_selected = true;
|
|
break;
|
|
}
|
|
|
|
for (uint8_t i = 0; i < 2; i++) {
|
|
lcd_move_cursor(0, i);
|
|
lcd_write_kerning(33, true);
|
|
lcd_write_string_page("PLL\0", 2, i, true);
|
|
lcd_write_kerning(4, true);
|
|
switch (current_state) {
|
|
case plla:
|
|
lcd_write_string_page("A\0", 2, i, true);
|
|
break;
|
|
case pllb:
|
|
lcd_write_string_page("B\0", 2, i, true);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
lcd_write_kerning(35, true);
|
|
}
|
|
|
|
if (select_offset == 0)
|
|
for (uint8_t i = 0; i < 2; i++) {
|
|
lcd_move_cursor(0, 2 + i);
|
|
lcd_write_kerning(1, integer_selected);
|
|
lcd_write_string_page("INTEGER:\0", 1, i, integer_selected);
|
|
lcd_write_kerning(2, integer_selected);
|
|
lcd_write_kerning(7, false);
|
|
if (change_integer_selected)
|
|
lcd_write_selected_integer_page(pll_config->integer, 6,
|
|
i, false);
|
|
else
|
|
lcd_write_integer_page(pll_config->integer, 6, i, false);
|
|
lcd_write_kerning(2, false);
|
|
}
|
|
|
|
for (uint8_t i = 0; i < 2; i++) {
|
|
lcd_move_cursor(0, 4 + i - select_offset * 2);
|
|
lcd_write_kerning(1, numerator_selected);
|
|
lcd_write_string_page("NUM:\0", 1, i, numerator_selected);
|
|
lcd_write_kerning(2, numerator_selected);
|
|
lcd_write_kerning(21, false);
|
|
if (change_numerator_selected)
|
|
lcd_write_selected_integer_page(pll_config->numerator, 7,
|
|
i, false);
|
|
else
|
|
lcd_write_integer_page(pll_config->numerator, 7, i, false);
|
|
lcd_write_kerning(2, false);
|
|
}
|
|
|
|
for (uint8_t i = 0; i < 2; i++) {
|
|
lcd_move_cursor(0, 6 + i - select_offset * 2);
|
|
lcd_write_kerning(1, denominator_selected);
|
|
lcd_write_string_page("DENOM:\0", 1, i, denominator_selected);
|
|
lcd_write_kerning(2, denominator_selected);
|
|
lcd_write_kerning(8, false);
|
|
if (change_denominator_selected)
|
|
lcd_write_selected_integer_page(pll_config->denominator, 7,
|
|
i, false);
|
|
else
|
|
lcd_write_integer_page(pll_config->denominator, 7, i, false);
|
|
lcd_write_kerning(2, false);
|
|
}
|
|
|
|
if (select_offset == 1)
|
|
for (uint8_t i = 0; i < 2; i++) {
|
|
lcd_move_cursor(33, 6 + i);
|
|
lcd_write_string_page("BACK\0", 2, i, back_selected);
|
|
lcd_write_kerning(2, back_selected);
|
|
}
|
|
}
|
|
|
|
static void draw_setup(void) {
|
|
lcd_fill(0x00);
|
|
|
|
bool contrast_selected = false;
|
|
bool backlight_selected = false;
|
|
bool back_selected = false;
|
|
bool change_contrast_selected = false;
|
|
bool change_backlight_selected = false;
|
|
|
|
switch (setup_state) {
|
|
case contrast:
|
|
contrast_selected = true;
|
|
break;
|
|
case backlight:
|
|
backlight_selected = true;
|
|
break;
|
|
case back:
|
|
back_selected = true;
|
|
break;
|
|
case change_contrast:
|
|
change_contrast_selected = true;
|
|
break;
|
|
case change_backlight:
|
|
change_backlight_selected = true;
|
|
break;
|
|
}
|
|
|
|
for (uint8_t i = 0; i < 2; i++) {
|
|
lcd_move_cursor(0, i);
|
|
lcd_write_kerning(30, true);
|
|
lcd_write_string_page("SETUP\0", 2, i, true);
|
|
lcd_write_kerning(33, true);
|
|
}
|
|
|
|
for (uint8_t i = 0; i < 2; i++) {
|
|
lcd_move_cursor(0, 2 + i);
|
|
lcd_write_string_page("CONTRAST:\0", 2, i, contrast_selected);
|
|
lcd_write_kerning(2, contrast_selected);
|
|
lcd_write_kerning(16, false);
|
|
lcd_write_integer_page(value_contrast, 2, i,
|
|
change_contrast_selected);
|
|
lcd_write_kerning(2, change_contrast_selected);
|
|
}
|
|
|
|
for (uint8_t i = 0; i < 2; i++) {
|
|
lcd_move_cursor(0, 4 + i);
|
|
lcd_write_string_page("BACKLIGHT:\0", 2, i, backlight_selected);
|
|
lcd_write_kerning(2, backlight_selected);
|
|
lcd_write_kerning(5, false);
|
|
lcd_write_integer_page(value_backlight, 3, i,
|
|
change_backlight_selected);
|
|
lcd_write_kerning(2, change_backlight_selected);
|
|
}
|
|
|
|
for (uint8_t i = 0; i < 2; i++) {
|
|
lcd_move_cursor(33, 6 + i);
|
|
lcd_write_string_page("BACK\0", 2, i, back_selected);
|
|
lcd_write_kerning(2, back_selected);
|
|
}
|
|
}
|
|
|
|
static void change_state(const enum state new_state) {
|
|
switch (new_state) {
|
|
case home:
|
|
current_state = home;
|
|
draw_home();
|
|
break;
|
|
case ch1:
|
|
break;
|
|
case ch2:
|
|
break;
|
|
case ch3:
|
|
break;
|
|
case plla:
|
|
select_offset = 0;
|
|
pll_state = integer;
|
|
current_state = plla;
|
|
draw_pll();
|
|
break;
|
|
case pllb:
|
|
select_offset = 0;
|
|
pll_state = integer;
|
|
current_state = pllb;
|
|
draw_pll();
|
|
break;
|
|
case setup:
|
|
setup_state = contrast;
|
|
current_state = setup;
|
|
draw_setup();
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void update_home(const enum input event) {
|
|
switch (event) {
|
|
case cw:
|
|
home_state++;
|
|
if (home_state > setup)
|
|
home_state = ch1;
|
|
draw_home();
|
|
break;
|
|
case ccw:
|
|
home_state--;
|
|
if (home_state > setup)
|
|
home_state = setup;
|
|
draw_home();
|
|
break;
|
|
case click:
|
|
change_state(home_state);
|
|
break;
|
|
case hold:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void update_pll(const enum input event) {
|
|
volatile struct pll_config* pll_config = &plla_config;
|
|
|
|
switch (current_state) {
|
|
case plla:
|
|
pll_config = &plla_config;
|
|
break;
|
|
case pllb:
|
|
pll_config = &pllb_config;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
switch (event) {
|
|
case cw:
|
|
switch (pll_state) {
|
|
case integer:
|
|
case numerator:
|
|
case denominator:
|
|
case pll_back:
|
|
pll_state++;
|
|
if (pll_state > denominator)
|
|
select_offset = 1;
|
|
if (pll_state > pll_back) {
|
|
select_offset = 0;
|
|
pll_state = integer;
|
|
}
|
|
break;
|
|
case change_integer:
|
|
if (digit_selected)
|
|
pll_config->integer += ten_pow(digit_select);
|
|
else
|
|
if (--digit_select > max_digits)
|
|
digit_select = max_digits - 1;
|
|
break;
|
|
case change_numerator:
|
|
if (digit_selected)
|
|
pll_config->numerator += ten_pow(digit_select);
|
|
else
|
|
if (--digit_select > max_digits)
|
|
digit_select = max_digits - 1;
|
|
break;
|
|
case change_denominator:
|
|
if (digit_selected)
|
|
pll_config->denominator += ten_pow(digit_select);
|
|
else
|
|
if (--digit_select > max_digits)
|
|
digit_select = max_digits - 1;
|
|
break;
|
|
}
|
|
draw_pll();
|
|
break;
|
|
case ccw:
|
|
switch (pll_state) {
|
|
case integer:
|
|
case numerator:
|
|
case denominator:
|
|
case pll_back:
|
|
pll_state--;
|
|
if (pll_state < numerator)
|
|
select_offset = 0;
|
|
if (pll_state > pll_back) {
|
|
select_offset = 1;
|
|
pll_state = pll_back;
|
|
}
|
|
break;
|
|
case change_integer:
|
|
// TODO: Fix going back to zero
|
|
if (digit_selected)
|
|
pll_config->integer -= ten_pow(digit_select);
|
|
else
|
|
if (++digit_select >= max_digits)
|
|
digit_select = 0;
|
|
break;
|
|
case change_numerator:
|
|
// TODO: Fix going back to zero
|
|
if (digit_selected)
|
|
pll_config->numerator -= ten_pow(digit_select);
|
|
else
|
|
if (++digit_select >= max_digits)
|
|
digit_select = 0;
|
|
break;
|
|
case change_denominator:
|
|
// TODO: Fix going back to zero
|
|
if (digit_selected)
|
|
pll_config->denominator -= ten_pow(digit_select);
|
|
else
|
|
if (++digit_select >= max_digits)
|
|
digit_select = 0;
|
|
break;
|
|
}
|
|
draw_pll();
|
|
break;
|
|
case click:
|
|
switch (pll_state) {
|
|
case integer:
|
|
pll_state = change_integer;
|
|
draw_pll();
|
|
break;
|
|
case numerator:
|
|
pll_state = change_numerator;
|
|
draw_pll();
|
|
break;
|
|
case denominator:
|
|
pll_state = change_denominator;
|
|
draw_pll();
|
|
break;
|
|
case pll_back:
|
|
change_state(home);
|
|
break;
|
|
case change_integer:
|
|
if (digit_selected) {
|
|
// TODO: Save/write new value
|
|
digit_selected = false;
|
|
digit_select = 0;
|
|
} else
|
|
digit_selected = true;
|
|
break;
|
|
case change_numerator:
|
|
if (digit_selected) {
|
|
// TODO: Save/write new value
|
|
digit_selected = false;
|
|
digit_select = 0;
|
|
} else
|
|
digit_selected = true;
|
|
break;
|
|
case change_denominator:
|
|
if (digit_selected) {
|
|
// TODO: Save/write new value
|
|
digit_selected = false;
|
|
digit_select = 0;
|
|
} else
|
|
digit_selected = true;
|
|
break;
|
|
}
|
|
break;
|
|
case hold:
|
|
switch (pll_state) {
|
|
case integer:
|
|
case numerator:
|
|
case denominator:
|
|
case pll_back:
|
|
change_state(home);
|
|
break;
|
|
case change_integer:
|
|
digit_selected = false;
|
|
pll_state = integer;
|
|
draw_pll();
|
|
break;
|
|
case change_numerator:
|
|
digit_selected = false;
|
|
pll_state = integer;
|
|
draw_pll();
|
|
break;
|
|
case change_denominator:
|
|
digit_selected = false;
|
|
pll_state = integer;
|
|
draw_pll();
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void update_setup(const enum input event) {
|
|
switch (event) {
|
|
case cw:
|
|
switch (setup_state) {
|
|
case contrast:
|
|
case backlight:
|
|
case back:
|
|
setup_state++;
|
|
if (setup_state > back)
|
|
setup_state = contrast;
|
|
break;
|
|
case change_contrast:
|
|
if (value_contrast < 63) {
|
|
value_contrast++;
|
|
lcd_update_contrast();
|
|
}
|
|
break;
|
|
case change_backlight:
|
|
if (value_backlight < 100) {
|
|
value_backlight++;
|
|
lcd_update_backlight();
|
|
}
|
|
break;
|
|
}
|
|
draw_setup();
|
|
break;
|
|
case ccw:
|
|
switch (setup_state) {
|
|
case contrast:
|
|
case backlight:
|
|
case back:
|
|
setup_state--;
|
|
if (setup_state > back)
|
|
setup_state = back;
|
|
break;
|
|
case change_contrast:
|
|
if (value_contrast > 0) {
|
|
value_contrast--;
|
|
lcd_update_contrast();
|
|
}
|
|
break;
|
|
case change_backlight:
|
|
if (value_backlight > 0) {
|
|
value_backlight--;
|
|
lcd_update_backlight();
|
|
}
|
|
break;
|
|
}
|
|
draw_setup();
|
|
break;
|
|
case click:
|
|
switch (setup_state) {
|
|
case contrast:
|
|
setup_state = change_contrast;
|
|
draw_setup();
|
|
break;
|
|
case backlight:
|
|
setup_state = change_backlight;
|
|
draw_setup();
|
|
break;
|
|
case back:
|
|
change_state(home);
|
|
break;
|
|
case change_contrast:
|
|
eeprom_update_byte(&eeprom_contrast, value_contrast);
|
|
setup_state = contrast;
|
|
draw_setup();
|
|
break;
|
|
case change_backlight:
|
|
eeprom_update_byte(&eeprom_backlight, value_backlight);
|
|
setup_state = backlight;
|
|
draw_setup();
|
|
break;
|
|
}
|
|
break;
|
|
case hold:
|
|
switch (setup_state) {
|
|
case contrast:
|
|
case backlight:
|
|
case back:
|
|
change_state(home);
|
|
break;
|
|
case change_contrast:
|
|
setup_state = contrast;
|
|
value_contrast = eeprom_read_byte(&eeprom_contrast);
|
|
lcd_update_contrast();
|
|
draw_setup();
|
|
break;
|
|
case change_backlight:
|
|
setup_state = backlight;
|
|
value_backlight = eeprom_read_byte(&eeprom_backlight);
|
|
lcd_update_backlight();
|
|
draw_setup();
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void update_state(const enum input event) {
|
|
switch (current_state) {
|
|
case home:
|
|
update_home(event);
|
|
break;
|
|
case ch1:
|
|
break;
|
|
case ch2:
|
|
break;
|
|
case ch3:
|
|
break;
|
|
case plla:
|
|
update_pll(event);
|
|
break;
|
|
case pllb:
|
|
update_pll(event);
|
|
break;
|
|
case setup:
|
|
update_setup(event);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Encoder rotation interrupt
|
|
ISR(PCINT0_vect) {
|
|
cli();
|
|
|
|
// Dechatter
|
|
_delay_ms(3);
|
|
|
|
switch (enc) {
|
|
case 0:
|
|
if (ENC_A && !ENC_B)
|
|
enc = 1;
|
|
else if (!ENC_A && ENC_B)
|
|
enc = 3;
|
|
break;
|
|
case 1:
|
|
if (ENC_A && ENC_B) {
|
|
enc = 2;
|
|
update_state(cw);
|
|
} else if (!ENC_A && !ENC_B) {
|
|
enc = 0;
|
|
update_state(ccw);
|
|
}
|
|
break;
|
|
case 2:
|
|
if (!ENC_A && ENC_B)
|
|
enc = 3;
|
|
else if (ENC_A && !ENC_B)
|
|
enc = 1;
|
|
break;
|
|
case 3:
|
|
if (!ENC_A && !ENC_B) {
|
|
enc = 0;
|
|
update_state(cw);
|
|
} else if (ENC_A && ENC_B) {
|
|
enc = 2;
|
|
update_state(ccw);
|
|
}
|
|
break;
|
|
}
|
|
|
|
sei();
|
|
}
|
|
|
|
// Encoder button interrupt
|
|
ISR(PCINT1_vect) {
|
|
cli();
|
|
|
|
// Debounce
|
|
_delay_ms(2);
|
|
|
|
if (PINC & (1 << PC0)) { // Release
|
|
if (TCCR1B & (1 << CS10)) // If release before hold
|
|
update_state(click); // Switch to selected state
|
|
|
|
TCCR1B &= (0 << CS11) & (0 << CS10); // Disable Timer/Counter1
|
|
} else { // Press
|
|
TCNT1 = 0;
|
|
if (!(TCCR1B & (1 << CS10)))
|
|
TCCR1B |= (1 << CS11) | (1 << CS10); // Enable Timer/Counter1
|
|
}
|
|
|
|
sei();
|
|
}
|
|
|
|
// Timer/Counter1 compare match A for back event
|
|
ISR(TIMER1_COMPA_vect) {
|
|
cli();
|
|
|
|
TCCR1B &= (0 << CS11) & (0 << CS10); // Disable Timer/Counter1
|
|
update_state(hold);
|
|
|
|
sei();
|
|
}
|
|
|
|
int main(void) {
|
|
// Load contrast and backlight values from EEPROM
|
|
value_contrast = eeprom_read_byte(&eeprom_contrast);
|
|
value_backlight = eeprom_read_byte(&eeprom_backlight);
|
|
|
|
// Init backlight
|
|
TCCR0A |= (1 << WGM01) | (1 << WGM00) | (1 << COM0B1);
|
|
OCR0A = 255;
|
|
lcd_update_backlight();
|
|
|
|
// SPI and LCD init
|
|
spi_init();
|
|
lcd_init();
|
|
|
|
// Encoder setup
|
|
PORTB |= (1 << PB6) | (1 << PB7);
|
|
PCICR |= (1 << PCIE0);
|
|
PCMSK0 |= (1 << PCINT6) | (1 << PCINT7);
|
|
|
|
// Encoder switch setup
|
|
PORTC |= (1 << PC0);
|
|
PCICR |= (1 << PCIE1);
|
|
PCMSK1 |= (1 << PCINT8);
|
|
|
|
// Timer/Counter1 setup to recognize held button
|
|
OCR1A = 65535;
|
|
TIMSK1 |= (1 << OCIE1A); // Enable match compare A
|
|
|
|
// Show splash screen
|
|
draw_splash();
|
|
_delay_ms(2000);
|
|
|
|
// Load the menu
|
|
change_state(current_state);
|
|
|
|
// Set TWI bit rate to 200kHz
|
|
TWBR = 12;
|
|
|
|
(void) &twi_read_register;
|
|
(void) &twi_write_register;
|
|
|
|
for (uint16_t i = 0; i < sizeof(m_si5351_regs_custom) / 2; i++)
|
|
twi_write_register(SI5351_ADDRESS, m_si5351_regs_custom[i][0],
|
|
m_si5351_regs_custom[i][1]);
|
|
|
|
twi_write_register(SI5351_ADDRESS, SI5351_REGISTER_177_PLL_RESET, 0xAC);
|
|
twi_write_register(SI5351_ADDRESS, SI5351_REGISTER_3_OUTPUT_ENABLE_CONTROL, 0x00);
|
|
|
|
// Enable interrupts
|
|
sei();
|
|
|
|
// Run...
|
|
for (;;);
|
|
}
|