ttrftech/NanoVNA
1
0
Fork 0
mirror of https://github.com/ttrftech/NanoVNA.git synced 2025-12-06 03:31:59 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #113 from DiSlord/master

Browse source 
Change font size, more compact and faster code for LCD
This commit is contained in:
TT 2020-01-26 22:29:44 +09:00 committed by GitHub
parent 066027f5b5 4a0ba6741e
commit 836ed2a7fb
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
9 changed files with 4217 additions and 4282 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3439
Font5x7.c
View file

File diff suppressed because it is too large Load diff

2
halconf.h
View file

@ -132,7 +132,7 @@
* @brief Enables the SERIAL subsystem. * @brief Enables the SERIAL subsystem.
*/ */
#if !defined(HAL_USE_SERIAL) || defined(__DOXYGEN__) #if !defined(HAL_USE_SERIAL) || defined(__DOXYGEN__)
#define HAL_USE_SERIAL TRUE #define HAL_USE_SERIAL FALSE
#endif #endif
/** /**

752
ili9341.c
View file

@ -21,6 +21,119 @@
#include "hal.h" #include "hal.h"
#include "nanovna.h" #include "nanovna.h"
uint16_t spi_buffer[1024];
// Default foreground & background colors
uint16_t foreground_color=DEFAULT_FG_COLOR;
uint16_t background_color=DEFAULT_BG_COLOR;
// Display width and height definition
#define ILI9341_WIDTH 320
#define ILI9341_HEIGHT 240
// Display commands list
#define ILI9341_NOP 0x00
#define ILI9341_SOFTWARE_RESET 0x01
#define ILI9341_READ_IDENTIFICATION 0x04
#define ILI9341_READ_STATUS 0x09
#define ILI9341_READ_POWER_MODE 0x0A
#define ILI9341_READ_MADCTL 0x0B
#define ILI9341_READ_PIXEL_FORMAT 0x0C
#define ILI9341_READ_IMAGE_FORMAT 0x0D
#define ILI9341_READ_SIGNAL_MODE 0x0E
#define ILI9341_READ_SELF_DIAGNOSTIC 0x0F
#define ILI9341_SLEEP_IN 0x10
#define ILI9341_SLEEP_OUT 0x11
#define ILI9341_PARTIAL_MODE_ON 0x12
#define ILI9341_NORMAL_DISPLAY_MODE_ON 0x13
#define ILI9341_INVERSION_OFF 0x20
#define ILI9341_INVERSION_ON 0x21
#define ILI9341_GAMMA_SET 0x26
#define ILI9341_DISPLAY_OFF 0x28
#define ILI9341_DISPLAY_ON 0x29
#define ILI9341_COLUMN_ADDRESS_SET 0x2A
#define ILI9341_PAGE_ADDRESS_SET 0x2B
#define ILI9341_MEMORY_WRITE 0x2C
#define ILI9341_COLOR_SET 0x2D
#define ILI9341_MEMORY_READ 0x2E
#define ILI9341_PARTIAL_AREA 0x30
#define ILI9341_VERTICAL_SCROLLING_DEF 0x33
#define ILI9341_TEARING_LINE_OFF 0x34
#define ILI9341_TEARING_LINE_ON 0x35
#define ILI9341_MEMORY_ACCESS_CONTROL 0x36
#define ILI9341_VERTICAL_SCROLLING 0x37
#define ILI9341_IDLE_MODE_OFF 0x38
#define ILI9341_IDLE_MODE_ON 0x39
#define ILI9341_PIXEL_FORMAT_SET 0x3A
#define ILI9341_WRITE_MEMORY_CONTINUE 0x3C
#define ILI9341_READ_MEMORY_CONTINUE 0x3E
#define ILI9341_SET_TEAR_SCANLINE 0x44
#define ILI9341_GET_SCANLINE 0x45
#define ILI9341_WRITE_BRIGHTNESS 0x51
#define ILI9341_READ_BRIGHTNESS 0x52
#define ILI9341_WRITE_CTRL_DISPLAY 0x53
#define ILI9341_READ_CTRL_DISPLAY 0x54
#define ILI9341_WRITE_CA_BRIGHTNESS 0x55
#define ILI9341_READ_CA_BRIGHTNESS 0x56
#define ILI9341_WRITE_CA_MIN_BRIGHTNESS 0x5E
#define ILI9341_READ_CA_MIN_BRIGHTNESS 0x5F
#define ILI9341_READ_ID1 0xDA
#define ILI9341_READ_ID2 0xDB
#define ILI9341_READ_ID3 0xDC
#define ILI9341_RGB_INTERFACE_CONTROL 0xB0
#define ILI9341_FRAME_RATE_CONTROL_1 0xB1
#define ILI9341_FRAME_RATE_CONTROL_2 0xB2
#define ILI9341_FRAME_RATE_CONTROL_3 0xB3
#define ILI9341_DISPLAY_INVERSION_CONTROL 0xB4
#define ILI9341_BLANKING_PORCH_CONTROL 0xB5
#define ILI9341_DISPLAY_FUNCTION_CONTROL 0xB6
#define ILI9341_ENTRY_MODE_SET 0xB7
#define ILI9341_BACKLIGHT_CONTROL_1 0xB8
#define ILI9341_BACKLIGHT_CONTROL_2 0xB9
#define ILI9341_BACKLIGHT_CONTROL_3 0xBA
#define ILI9341_BACKLIGHT_CONTROL_4 0xBB
#define ILI9341_BACKLIGHT_CONTROL_5 0xBC
#define ILI9341_BACKLIGHT_CONTROL_7 0xBE
#define ILI9341_BACKLIGHT_CONTROL_8 0xBF
#define ILI9341_POWER_CONTROL_1 0xC0
#define ILI9341_POWER_CONTROL_2 0xC1
#define ILI9341_VCOM_CONTROL_1 0xC5
#define ILI9341_VCOM_CONTROL_2 0xC7
#define ILI9341_POWERA 0xCB
#define ILI9341_POWERB 0xCF
#define ILI9341_NV_MEMORY_WRITE 0xD0
#define ILI9341_NV_PROTECTION_KEY 0xD1
#define ILI9341_NV_STATUS_READ 0xD2
#define ILI9341_READ_ID4 0xD3
#define ILI9341_POSITIVE_GAMMA_CORRECTION 0xE0
#define ILI9341_NEGATIVE_GAMMA_CORRECTION 0xE1
#define ILI9341_DIGITAL_GAMMA_CONTROL_1 0xE2
#define ILI9341_DIGITAL_GAMMA_CONTROL_2 0xE3
#define ILI9341_DTCA 0xE8
#define ILI9341_DTCB 0xEA
#define ILI9341_POWER_SEQ 0xED
#define ILI9341_3GAMMA_EN 0xF2
#define ILI9341_INTERFACE_CONTROL 0xF6
#define ILI9341_PUMP_RATIO_CONTROL 0xF7
//
// ILI9341_MEMORY_ACCESS_CONTROL registers
//
#define ILI9341_MADCTL_MY 0x80
#define ILI9341_MADCTL_MX 0x40
#define ILI9341_MADCTL_MV 0x20
#define ILI9341_MADCTL_ML 0x10
#define ILI9341_MADCTL_BGR 0x08
#define ILI9341_MADCTL_MH 0x04
#define ILI9341_MADCTL_RGB 0x00
#define DISPLAY_ROTATION_270 (ILI9341_MADCTL_MX | ILI9341_MADCTL_BGR)
#define DISPLAY_ROTATION_90 (ILI9341_MADCTL_MY | ILI9341_MADCTL_BGR)
#define DISPLAY_ROTATION_0 (ILI9341_MADCTL_MV | ILI9341_MADCTL_BGR)
#define DISPLAY_ROTATION_180 (ILI9341_MADCTL_MX | ILI9341_MADCTL_MY | ILI9341_MADCTL_MV | ILI9341_MADCTL_BGR)
//
// Pin macros
//
#define RESET_ASSERT palClearPad(GPIOA, 15) #define RESET_ASSERT palClearPad(GPIOA, 15)
#define RESET_NEGATE palSetPad(GPIOA, 15) #define RESET_NEGATE palSetPad(GPIOA, 15)
#define CS_LOW palClearPad(GPIOB, 6) #define CS_LOW palClearPad(GPIOB, 6)
@ -28,380 +141,435 @@
#define DC_CMD palClearPad(GPIOB, 7) #define DC_CMD palClearPad(GPIOB, 7)
#define DC_DATA palSetPad(GPIOB, 7) #define DC_DATA palSetPad(GPIOB, 7)
uint16_t spi_buffer[1024]; //*****************************************************************************
//********************************** SPI bus **********************************
//*****************************************************************************
// STM32 SPI transfer mode:
// in 8 bit mode:
// if you write *(uint8_t*)(&SPI1->DR) = (uint8_t) data, then data send as << data
// if you write *(uint16_t*)(&SPI1->DR) =(uint16_t) data, then data send as << dataLoByte, after send dataHiByte
// in 16 bit mode
// if you write *(uint16_t*)(&SPI1->DR) =(uint16_t) data, then data send as << data
void // SPI init in 8 bit mode
ssp_wait(void) #define SPI_CR2_8BIT 0x0700
{ #define SPI_CR2_16BIT 0x0F00
while (SPI1->SR & SPI_SR_BSY)
;
}
void // SPI bus activity macros
ssp_wait_slot(void)
{
while ((SPI1->SR & 0x1800) == 0x1800)
;
}
void // The RXNE flag is set depending on the FRXTH bit value in the SPIx_CR2 register:
ssp_senddata(uint8_t x) // • If FRXTH is set, RXNE goes high and stays high until the RXFIFO level is greater or equal to 1/4 (8-bit).
{ #define SPI_RX_IS_NOT_EMPTY (SPI1->SR&SPI_SR_RXNE)
*(uint8_t*)(&SPI1->DR) = x; #define SPI_RX_IS_EMPTY (((SPI1->SR&SPI_SR_RXNE) == 0))
while (SPI1->SR & SPI_SR_BSY)
;
}
uint8_t // The TXE flag is set when transmission TXFIFO has enough space to store data to send.
ssp_sendrecvdata(uint8_t x) // 0: Tx buffer not empty, bit is cleared automatically when the TXFIFO level becomes greater than 1/2
{ // 1: Tx buffer empty, flag goes high and stays high until the TXFIFO level is lower or equal to 1/2 of the FIFO depth
while (!(SPI1->SR & SPI_SR_TXE)); #define SPI_TX_IS_NOT_EMPTY (((SPI1->SR&(SPI_SR_TXE)) == 0))
// clear OVR #define SPI_TX_IS_EMPTY (SPI1->SR&SPI_SR_TXE)
while (SPI1->SR & SPI_SR_RXNE) (void)SPI1->DR;
*(uint8_t*)(&SPI1->DR) = x; // When BSY is set, it indicates that a data transfer is in progress on the SPI (the SPI bus is busy).
while (!(SPI1->SR & SPI_SR_RXNE)); #define SPI_IS_BUSY (SPI1->SR & SPI_SR_BSY)
return SPI1->DR;
}
void // SPI send data macros
ssp_senddata16(uint16_t x) #define SPI_WRITE_8BIT(data) *(__IO uint8_t*)(&SPI1->DR) = (uint8_t) data
{ #define SPI_WRITE_16BIT(data) SPI1->DR = data
ssp_wait_slot();
SPI1->DR = x;
//while (SPI1->SR & SPI_SR_BSY)
// ;
}
void // SPI read data macros
ssp_databit8(void) #define SPI_READ_DATA SPI1->DR
{
SPI1->CR2 = (SPI1->CR2 & 0xf0ff) | 0x0700;
//LPC_SSP1->CR0 = (LPC_SSP1->CR0 & 0xf0) | SSP_DATABIT_8;
}
void #ifdef __USE_DISPLAY_DMA__
ssp_databit16(void) static const stm32_dma_stream_t *dmatx = STM32_DMA_STREAM(STM32_SPI_SPI1_TX_DMA_STREAM);
{ static uint32_t txdmamode = STM32_DMA_CR_CHSEL(SPI1_TX_DMA_CHANNEL) // Select SPI1 Tx DMA
SPI1->CR2 = (SPI1->CR2 & 0xf0ff) | 0x0f00; | STM32_DMA_CR_PL(STM32_SPI_SPI1_DMA_PRIORITY) // Set priority
//LPC_SSP1->CR0 = (LPC_SSP1->CR0 & 0xf0) | SSP_DATABIT_16; | STM32_DMA_CR_DIR_M2P // Memory to Spi
} | STM32_DMA_CR_DMEIE //
| STM32_DMA_CR_TEIE;
const stm32_dma_stream_t *dmatx;
uint32_t txdmamode;
static void spi_lld_serve_tx_interrupt(SPIDriver *spip, uint32_t flags) { static void spi_lld_serve_tx_interrupt(SPIDriver *spip, uint32_t flags) {
(void)spip; (void)spip;
(void)flags; (void)flags;
} }
void static const stm32_dma_stream_t *dmarx = STM32_DMA_STREAM(STM32_SPI_SPI1_RX_DMA_STREAM);
spi_init(void) static uint32_t rxdmamode = STM32_DMA_CR_CHSEL(SPI1_RX_DMA_CHANNEL)
{ | STM32_DMA_CR_PL(STM32_SPI_SPI1_DMA_PRIORITY)
rccEnableSPI1(FALSE); | STM32_DMA_CR_DIR_P2M
| STM32_DMA_CR_TCIE
| STM32_DMA_CR_DMEIE
| STM32_DMA_CR_TEIE;
dmatx = STM32_DMA_STREAM(STM32_SPI_SPI1_TX_DMA_STREAM); static void spi_lld_serve_rx_interrupt(SPIDriver *spip, uint32_t flags) {
txdmamode = STM32_DMA_CR_CHSEL(SPI1_TX_DMA_CHANNEL) | (void)spip;
STM32_DMA_CR_PL(STM32_SPI_SPI1_DMA_PRIORITY) | (void)flags;
STM32_DMA_CR_DIR_M2P |
STM32_DMA_CR_DMEIE |
STM32_DMA_CR_TEIE |
STM32_DMA_CR_PSIZE_HWORD |
STM32_DMA_CR_MSIZE_HWORD;
dmaStreamAllocate(dmatx,
STM32_SPI_SPI1_IRQ_PRIORITY,
(stm32_dmaisr_t)spi_lld_serve_tx_interrupt,
NULL);
dmaStreamSetPeripheral(dmatx, &SPI1->DR);
SPI1->CR1 = 0;
SPI1->CR1 = SPI_CR1_MSTR | SPI_CR1_SSM | SPI_CR1_SSI;// | SPI_CR1_BR_1;
SPI1->CR2 = 0x0700 | SPI_CR2_TXDMAEN | SPI_CR2_FRXTH;
SPI1->CR1 |= SPI_CR1_SPE;
} }
void static void dmaStreamFlush(uint32_t len){
send_command(uint8_t cmd, int len, const uint8_t *data) while (len){
// DMA data transfer limited by 65535
uint16_t tx_size = len > 65535 ? 65535 : len;
dmaStreamSetTransactionSize(dmatx, tx_size);
dmaStreamEnable(dmatx);
len -= tx_size;
dmaWaitCompletion(dmatx);
}
}
#endif
static void spi_init(void)
{
rccEnableSPI1(FALSE);
SPI1->CR1 = 0;
SPI1->CR1 = SPI_CR1_MSTR // SPI is MASTER
| SPI_CR1_SSM // Software slave management (The external NSS pin is free for other application uses)
| SPI_CR1_SSI; // Internal slave select (This bit has an effect only when the SSM bit is set. Allow use NSS pin as I/O)
// | SPI_CR1_BR_1; // Baud rate control
SPI1->CR2 = SPI_CR2_8BIT // SPI data size, set to 8 bit
| SPI_CR2_FRXTH; // SPI_SR_RXNE generated every 8 bit data
// | SPI_CR2_SSOE; //
#ifdef __USE_DISPLAY_DMA__
// Tx DMA init
dmaStreamAllocate(dmatx, STM32_SPI_SPI1_IRQ_PRIORITY, (stm32_dmaisr_t)spi_lld_serve_tx_interrupt, NULL);
dmaStreamSetPeripheral(dmatx, &SPI1->DR);
// Rx DMA init
dmaStreamAllocate(dmarx, STM32_SPI_SPI1_IRQ_PRIORITY, (stm32_dmaisr_t)spi_lld_serve_rx_interrupt, NULL);
dmaStreamSetPeripheral(dmarx, &SPI1->DR);
// Enable DMA on SPI
SPI1->CR2|= SPI_CR2_TXDMAEN // Tx DMA enable
| SPI_CR2_RXDMAEN; // Rx DMA enable
#endif
SPI1->CR1|= SPI_CR1_SPE; //SPI enable
}
// Disable inline for this function
static void __attribute__ ((noinline)) send_command(uint8_t cmd, uint8_t len, const uint8_t *data)
{ {
CS_LOW; CS_LOW;
// while (SPI_TX_IS_NOT_EMPTY);
DC_CMD; DC_CMD;
ssp_databit8(); SPI_WRITE_8BIT(cmd);
ssp_senddata(cmd); // Need wait transfer complete and set data bit
while (SPI_IS_BUSY);
// Send command data (if need)
DC_DATA; DC_DATA;
while (len-- > 0) { while (len-- > 0) {
ssp_senddata(*data++); while (SPI_TX_IS_NOT_EMPTY);
SPI_WRITE_8BIT(*data++);
} }
//CS_HIGH; //CS_HIGH;
} }
void static const uint8_t ili9341_init_seq[] = {
send_command16(uint8_t cmd, int data)
{
CS_LOW;
DC_CMD;
ssp_databit8();
ssp_senddata(cmd);
DC_DATA;
ssp_databit16();
ssp_senddata16(data);
CS_HIGH;
}
const uint8_t ili9341_init_seq[] = {
// cmd, len, data..., // cmd, len, data...,
// SW reset
ILI9341_SOFTWARE_RESET, 0,
// display off
ILI9341_DISPLAY_OFF, 0,
// Power control B // Power control B
0xCF, 3, 0x00, 0x83, 0x30, ILI9341_POWERB, 3, 0x00, 0x83, 0x30,
// Power on sequence control // Power on sequence control
0xED, 4, 0x64, 0x03, 0x12, 0x81, ILI9341_POWER_SEQ, 4, 0x64, 0x03, 0x12, 0x81,
//0xED, 4, 0x55, 0x01, 0x23, 0x01, //ILI9341_POWER_SEQ, 4, 0x55, 0x01, 0x23, 0x01,
// Driver timing control A // Driver timing control A
0xE8, 3, 0x85, 0x01, 0x79, ILI9341_DTCA, 3, 0x85, 0x01, 0x79,
//0xE8, 3, 0x84, 0x11, 0x7a, //ILI9341_DTCA, 3, 0x84, 0x11, 0x7a,
// Power control A // Power control A
0xCB, 5, 0x39, 0x2C, 0x00, 0x34, 0x02, ILI9341_POWERA, 5, 0x39, 0x2C, 0x00, 0x34, 0x02,
// Pump ratio control // Pump ratio control
0xF7, 1, 0x20, ILI9341_PUMP_RATIO_CONTROL, 1, 0x20,
// Driver timing control B // Driver timing control B
0xEA, 2, 0x00, 0x00, ILI9341_DTCB, 2, 0x00, 0x00,
// POWER_CONTROL_1 // POWER_CONTROL_1
0xC0, 1, 0x26, ILI9341_POWER_CONTROL_1, 1, 0x26,
// POWER_CONTROL_2 // POWER_CONTROL_2
0xC1, 1, 0x11, ILI9341_POWER_CONTROL_2, 1, 0x11,
// VCOM_CONTROL_1 // VCOM_CONTROL_1
0xC5, 2, 0x35, 0x3E, ILI9341_VCOM_CONTROL_1, 2, 0x35, 0x3E,
// VCOM_CONTROL_2 // VCOM_CONTROL_2
0xC7, 1, 0xBE, ILI9341_VCOM_CONTROL_2, 1, 0xBE,
// MEMORY_ACCESS_CONTROL // MEMORY_ACCESS_CONTROL
//0x36, 1, 0x48, // portlait //ILI9341_MEMORY_ACCESS_CONTROL, 1, 0x48, // portlait
0x36, 1, 0x28, // landscape ILI9341_MEMORY_ACCESS_CONTROL, 1, DISPLAY_ROTATION_0, // landscape
// COLMOD_PIXEL_FORMAT_SET : 16 bit pixel // COLMOD_PIXEL_FORMAT_SET : 16 bit pixel
0x3A, 1, 0x55, ILI9341_PIXEL_FORMAT_SET, 1, 0x55,
// Frame Rate // Frame Rate
0xB1, 2, 0x00, 0x1B, ILI9341_FRAME_RATE_CONTROL_1, 2, 0x00, 0x1B,
// Gamma Function Disable // Gamma Function Disable
0xF2, 1, 0x08, ILI9341_3GAMMA_EN, 1, 0x08,
// gamma set for curve 01/2/04/08 // gamma set for curve 01/2/04/08
0x26, 1, 0x01, ILI9341_GAMMA_SET, 1, 0x01,
// positive gamma correction // positive gamma correction
0xE0, 15, 0x1F, 0x1A, 0x18, 0x0A, 0x0F, 0x06, 0x45, 0x87, 0x32, 0x0A, 0x07, 0x02, 0x07, 0x05, 0x00, // ILI9341_POSITIVE_GAMMA_CORRECTION, 15, 0x1F, 0x1A, 0x18, 0x0A, 0x0F, 0x06, 0x45, 0x87, 0x32, 0x0A, 0x07, 0x02, 0x07, 0x05, 0x00,
// negativ gamma correction // negativ gamma correction
0xE1, 15, 0x00, 0x25, 0x27, 0x05, 0x10, 0x09, 0x3A, 0x78, 0x4D, 0x05, 0x18, 0x0D, 0x38, 0x3A, 0x1F, // ILI9341_NEGATIVE_GAMMA_CORRECTION, 15, 0x00, 0x25, 0x27, 0x05, 0x10, 0x09, 0x3A, 0x78, 0x4D, 0x05, 0x18, 0x0D, 0x38, 0x3A, 0x1F,
// Column Address Set // Column Address Set
0x2A, 4, 0x00, 0x00, 0x01, 0x3f, // width 320 // ILI9341_COLUMN_ADDRESS_SET, 4, 0x00, 0x00, 0x01, 0x3f, // width 320
// Page Address Set // Page Address Set
0x2B, 4, 0x00, 0x00, 0x00, 0xef, // height 240 // ILI9341_PAGE_ADDRESS_SET, 4, 0x00, 0x00, 0x00, 0xef, // height 240
// entry mode // entry mode
0xB7, 1, 0x06, ILI9341_ENTRY_MODE_SET, 1, 0x06,
// display function control // display function control
0xB6, 4, 0x0A, 0x82, 0x27, 0x00, ILI9341_DISPLAY_FUNCTION_CONTROL, 4, 0x0A, 0x82, 0x27, 0x00,
// Interface Control (set WEMODE=0)
ILI9341_INTERFACE_CONTROL, 3, 0x00, 0x00, 0x00,
// control display // control display
//0x53, 1, 0x0c, //ILI9341_WRITE_CTRL_DISPLAY, 1, 0x0c,
// diaplay brightness // diaplay brightness
//0x51, 1, 0xff, //ILI9341_WRITE_BRIGHTNESS, 1, 0xff,
// sleep out // sleep out
0x11, 0, ILI9341_SLEEP_OUT, 0,
// display on
ILI9341_DISPLAY_ON, 0,
0 // sentinel 0 // sentinel
}; };
void void ili9341_init(void)
ili9341_init(void)
{ {
spi_init(); spi_init();
DC_DATA; DC_DATA;
RESET_ASSERT; RESET_ASSERT;
chThdSleepMilliseconds(10); chThdSleepMilliseconds(10);
RESET_NEGATE; RESET_NEGATE;
send_command(0x01, 0, NULL); // SW reset
chThdSleepMilliseconds(5);
send_command(0x28, 0, NULL); // display off
const uint8_t *p; const uint8_t *p;
for (p = ili9341_init_seq; *p; ) { for (p = ili9341_init_seq; *p; ) {
send_command(p[0], p[1], &p[2]); send_command(p[0], p[1], &p[2]);
p += 2 + p[1]; p += 2 + p[1];
chThdSleepMilliseconds(5); chThdSleepMilliseconds(5);
} }
chThdSleepMilliseconds(100);
send_command(0x29, 0, NULL); // display on
} }
void ili9341_pixel(int x, int y, int color) #ifndef __USE_DISPLAY_DMA__
{
uint8_t xx[4] = { x >> 8, x, (x+1) >> 8, (x+1) };
uint8_t yy[4] = { y >> 8, y, (y+1) >> 8, (y+1) };
uint8_t cc[2] = { color >> 8, color };
send_command(0x2A, 4, xx);
send_command(0x2B, 4, yy);
send_command(0x2C, 2, cc);
//send_command16(0x2C, color);
}
void ili9341_fill(int x, int y, int w, int h, int color) void ili9341_fill(int x, int y, int w, int h, int color)
{ {
uint8_t xx[4] = { x >> 8, x, (x+w-1) >> 8, (x+w-1) }; uint8_t xx[4] = { x >> 8, x, (x+w-1) >> 8, (x+w-1) };
uint8_t yy[4] = { y >> 8, y, (y+h-1) >> 8, (y+h-1) }; uint8_t yy[4] = { y >> 8, y, (y+h-1) >> 8, (y+h-1) };
int len = w * h;
send_command(0x2A, 4, xx); send_command(ILI9341_COLUMN_ADDRESS_SET, 4, xx);
send_command(0x2B, 4, yy); send_command(ILI9341_PAGE_ADDRESS_SET, 4, yy);
send_command(0x2C, 0, NULL); send_command(ILI9341_MEMORY_WRITE, 0, NULL);
while (len-- > 0) int32_t len = w * h;
ssp_senddata16(color); while (len-- > 0){
while (SPI_TX_IS_NOT_EMPTY);
SPI_WRITE_16BIT(color);
}
} }
#if 0
void ili9341_bulk(int x, int y, int w, int h) void ili9341_bulk(int x, int y, int w, int h)
{ {
uint8_t xx[4] = { x >> 8, x, (x+w-1) >> 8, (x+w-1) }; uint8_t xx[4] = { x >> 8, x, (x+w-1) >> 8, (x+w-1) };
uint8_t yy[4] = { y >> 8, y, (y+h-1) >> 8, (y+h-1) }; uint8_t yy[4] = { y >> 8, y, (y+h-1) >> 8, (y+h-1) };
uint16_t *buf = spi_buffer; uint16_t *buf = spi_buffer;
int len = w * h;
send_command(0x2A, 4, xx); send_command(ILI9341_COLUMN_ADDRESS_SET, 4, xx);
send_command(0x2B, 4, yy); send_command(ILI9341_PAGE_ADDRESS_SET, 4, yy);
send_command(0x2C, 0, NULL); send_command(ILI9341_MEMORY_WRITE, 0, NULL);
while (len-- > 0) int32_t len = w * h;
ssp_senddata16(*buf++); while (len-- > 0){
while (SPI_TX_IS_NOT_EMPTY);
SPI_WRITE_16BIT(*buf++);
}
}
static uint8_t ssp_sendrecvdata()
{
// Start RX clock (by sending data)
SPI_WRITE_8BIT(0);
while(SPI_RX_IS_EMPTY && SPI_IS_BUSY)
;
return SPI_READ_DATA;
}
void ili9341_read_memory(int x, int y, int w, int h, int len, uint16_t *out)
{
uint8_t xx[4] = { x >> 8, x, (x+w-1) >> 8, (x+w-1) };
uint8_t yy[4] = { y >> 8, y, (y+h-1) >> 8, (y+h-1) };
send_command(ILI9341_COLUMN_ADDRESS_SET, 4, xx);
send_command(ILI9341_PAGE_ADDRESS_SET, 4, yy);
send_command(ILI9341_MEMORY_READ, 0, NULL);
// Skip data from rx buffer
while (SPI_RX_IS_NOT_EMPTY)
(void) SPI_READ_DATA;
// require 8bit dummy clock
ssp_sendrecvdata();
while (len-- > 0) {
// read data is always 18bit
uint8_t r = ssp_sendrecvdata();
uint8_t g = ssp_sendrecvdata();
uint8_t b = ssp_sendrecvdata();
*out++ = RGB565(r,g,b);
}
CS_HIGH;
} }
#else #else
//
// Use DMA for send data
//
// Fill region by some color
void ili9341_fill(int x, int y, int w, int h, int color)
{
uint8_t xx[4] = { x >> 8, x, (x+w-1) >> 8, (x+w-1) };
uint8_t yy[4] = { y >> 8, y, (y+h-1) >> 8, (y+h-1) };
send_command(ILI9341_COLUMN_ADDRESS_SET, 4, xx);
send_command(ILI9341_PAGE_ADDRESS_SET, 4, yy);
send_command(ILI9341_MEMORY_WRITE, 0, NULL);
dmaStreamSetMemory0(dmatx, &color);
dmaStreamSetMode(dmatx, txdmamode | STM32_DMA_CR_PSIZE_HWORD | STM32_DMA_CR_MSIZE_HWORD);
dmaStreamFlush(w * h);
}
// Copy spi_buffer to region
void ili9341_bulk(int x, int y, int w, int h) void ili9341_bulk(int x, int y, int w, int h)
{ {
uint8_t xx[4] = { x >> 8, x, (x+w-1) >> 8, (x+w-1) }; uint8_t xx[4] = { x >> 8, x, (x+w-1) >> 8, (x+w-1) };
uint8_t yy[4] = { y >> 8, y, (y+h-1) >> 8, (y+h-1) }; uint8_t yy[4] = { y >> 8, y, (y+h-1) >> 8, (y+h-1) };
int len = w * h; send_command(ILI9341_COLUMN_ADDRESS_SET, 4, xx);
send_command(ILI9341_PAGE_ADDRESS_SET, 4, yy);
send_command(0x2A, 4, xx); send_command(ILI9341_MEMORY_WRITE, 0, NULL);
send_command(0x2B, 4, yy);
send_command(0x2C, 0, NULL);
// Init Tx DMA mem->spi, set size, mode (spi and mem data size is 16 bit)
dmaStreamSetMemory0(dmatx, spi_buffer); dmaStreamSetMemory0(dmatx, spi_buffer);
dmaStreamSetTransactionSize(dmatx, len); dmaStreamSetMode(dmatx, txdmamode | STM32_DMA_CR_PSIZE_HWORD | STM32_DMA_CR_MSIZE_HWORD | STM32_DMA_CR_MINC);
dmaStreamSetMode(dmatx, txdmamode | STM32_DMA_CR_MINC); dmaStreamFlush(w * h);
}
// Copy screen data to buffer
// Warning!!! buffer size must be greater then 3*len + 1 bytes
void ili9341_read_memory(int x, int y, int w, int h, int len, uint16_t *out)
{
uint8_t dummy_tx = 0;
uint8_t *rgbbuf=(uint8_t *)out;
uint16_t data_size = len * 3 + 1;
uint8_t xx[4] = { x >> 8, x, (x+w-1) >> 8, (x+w-1) };
uint8_t yy[4] = { y >> 8, y, (y+h-1) >> 8, (y+h-1) };
send_command(ILI9341_COLUMN_ADDRESS_SET, 4, xx);
send_command(ILI9341_PAGE_ADDRESS_SET, 4, yy);
send_command(ILI9341_MEMORY_READ, 0, NULL);
// Skip SPI rx buffer
while (SPI_RX_IS_NOT_EMPTY)
(void) SPI_READ_DATA;
// Init Rx DMA buffer, size, mode (spi and mem data size is 8 bit)
dmaStreamSetMemory0(dmarx, rgbbuf);
dmaStreamSetTransactionSize(dmarx, data_size);
dmaStreamSetMode(dmarx, rxdmamode | STM32_DMA_CR_PSIZE_BYTE | STM32_DMA_CR_MSIZE_BYTE | STM32_DMA_CR_MINC);
// Init dummy Tx DMA (for rx clock), size, mode (spi and mem data size is 8 bit)
dmaStreamSetMemory0(dmatx, &dummy_tx);
dmaStreamSetTransactionSize(dmatx, data_size);
dmaStreamSetMode(dmatx, txdmamode | STM32_DMA_CR_PSIZE_BYTE | STM32_DMA_CR_MSIZE_BYTE);
// Start DMA exchange
dmaStreamEnable(dmatx); dmaStreamEnable(dmatx);
dmaStreamEnable(dmarx);
// Wait DMA completion
dmaWaitCompletion(dmatx); dmaWaitCompletion(dmatx);
dmaWaitCompletion(dmarx);
CS_HIGH;
// Parce recived data
// Skip dummy 8-bit read
rgbbuf++;
while (len-- > 0) {
uint8_t r, g, b;
// read data is always 18bit
r = rgbbuf[0];
g = rgbbuf[1];
b = rgbbuf[2];
*out++ = RGB565(r,g,b);
rgbbuf+=3;
}
} }
#endif #endif
void void setForegroundColor(uint16_t fg) {foreground_color = fg;}
ili9341_read_memory_raw(uint8_t cmd, int len, uint16_t* out) void setBackgroundColor(uint16_t bg) {background_color = bg;}
{
uint8_t r, g, b;
send_command(cmd, 0, NULL);
ssp_databit8();
// consume old data void ili9341_setRotation(uint8_t r) {
while (!(SPI1->SR & SPI_SR_TXE)); // static const uint8_t rotation_const[]={DISPLAY_ROTATION_0, DISPLAY_ROTATION_90, DISPLAY_ROTATION_180, DISPLAY_ROTATION_270};
// clear OVR send_command(ILI9341_MEMORY_ACCESS_CONTROL, 1, &r);
while (SPI1->SR & SPI_SR_RXNE) r = SPI1->DR;
// require 8bit dummy clock
r = ssp_sendrecvdata(0);
while (len-- > 0) {
// read data is always 18bit
r = ssp_sendrecvdata(0);
g = ssp_sendrecvdata(0);
b = ssp_sendrecvdata(0);
*out++ = ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3);
} }
CS_HIGH; void blit8BitWidthBitmap(uint16_t x, uint16_t y, uint16_t width, uint16_t height, const uint8_t *bitmap){
}
void
ili9341_read_memory(int x, int y, int w, int h, int len, uint16_t *out)
{
uint8_t xx[4] = { x >> 8, x, (x+w-1) >> 8, (x+w-1) };
uint8_t yy[4] = { y >> 8, y, (y+h-1) >> 8, (y+h-1) };
send_command(0x2A, 4, xx);
send_command(0x2B, 4, yy);
ili9341_read_memory_raw(0x2E, len, out);
}
void
ili9341_read_memory_continue(int len, uint16_t* out)
{
ili9341_read_memory_raw(0x3E, len, out);
}
void
ili9341_drawchar_5x7(uint8_t ch, int x, int y, uint16_t fg, uint16_t bg)
{
uint16_t *buf = spi_buffer; uint16_t *buf = spi_buffer;
uint8_t bits; for(uint16_t c = 0; c < height; c++) {
int c, r; uint8_t bits = *bitmap++;
for(c = 0; c < 7; c++) { for (uint16_t r = 0; r < width; r++) {
bits = x5x7_bits[(ch * 7) + c]; *buf++ = (0x80 & bits) ? foreground_color : background_color;
for (r = 0; r < 5; r++) {
*buf++ = (0x80 & bits) ? fg : bg;
bits <<= 1; bits <<= 1;
} }
} }
ili9341_bulk(x, y, 5, 7); ili9341_bulk(x, y, width, height);
} }
void void blit16BitWidthBitmap(uint16_t x, uint16_t y, uint16_t width, uint16_t height, const uint16_t *bitmap){
ili9341_drawstring_5x7(const char *str, int x, int y, uint16_t fg, uint16_t bg)
{
while (*str) {
ili9341_drawchar_5x7(*str, x, y, fg, bg);
x += 5;
str++;
}
}
void
ili9341_drawstring_5x7_inv(const char *str, int x, int y, uint16_t fg, uint16_t bg, bool invert)
{
if (invert)
ili9341_drawstring_5x7(str, x, y, bg, fg);
else
ili9341_drawstring_5x7(str, x, y, fg, bg);
}
void
ili9341_drawchar_size(uint8_t ch, int x, int y, uint16_t fg, uint16_t bg, uint8_t size)
{
uint16_t *buf = spi_buffer; uint16_t *buf = spi_buffer;
uint8_t bits; for(uint16_t c = 0; c < height; c++) {
int c, r; uint16_t bits = *bitmap++;
for(c = 0; c < 7*size; c++) { for (uint16_t r = 0; r < width; r++) {
bits = x5x7_bits[(ch * 7) + (c / size)]; *buf++ = (0x8000 & bits) ? foreground_color : background_color;
for (r = 0; r < 5*size; r++) {
*buf++ = (0x80 & bits) ? fg : bg;
if (r % size == (size-1)) {
bits <<= 1; bits <<= 1;
} }
} }
} ili9341_bulk(x, y, width, height);
ili9341_bulk(x, y, 5*size, 7*size);
} }
void void ili9341_drawchar(uint8_t ch, int x, int y)
ili9341_drawstring_size(const char *str, int x, int y, uint16_t fg, uint16_t bg, uint8_t size) {
blit8BitWidthBitmap(x, y, FONT_GET_WIDTH(ch), FONT_GET_HEIGHT, FONT_GET_DATA(ch));
}
void ili9341_drawstring(const char *str, int x, int y)
{ {
while (*str) { while (*str) {
ili9341_drawchar_size(*str, x, y, fg, bg, size); uint8_t ch = *str++;
x += 5 * size; const uint8_t *char_buf = FONT_GET_DATA(ch);
str++; uint16_t w = FONT_GET_WIDTH(ch);
blit8BitWidthBitmap(x, y, w, FONT_GET_HEIGHT, char_buf);
x+=w;
} }
} }
#define SWAP(x,y) do { int z=x; x = y; y = z; } while(0) void ili9341_drawstringV(const char *str, int x, int y){
ili9341_setRotation(DISPLAY_ROTATION_270);
ili9341_drawstring(str, ILI9341_HEIGHT-y, x);
ili9341_setRotation(DISPLAY_ROTATION_0);
}
void int ili9341_drawchar_size(uint8_t ch, int x, int y, uint8_t size)
ili9341_line(int x0, int y0, int x1, int y1, uint16_t fg)
{ {
uint16_t *buf = spi_buffer;
const uint8_t *char_buf = FONT_GET_DATA(ch);
uint16_t w=FONT_GET_WIDTH(ch);
for(int c = 0; c < FONT_GET_HEIGHT; c++, char_buf++){
for (int i=0;i<size;i++){
uint8_t bits = *char_buf;
for (int r = 0; r < w; r++, bits<<=1)
for (int j=0; j<size; j++)
*buf++ = (0x80 & bits) ? foreground_color : background_color;
}
}
ili9341_bulk(x, y, w*size, FONT_GET_HEIGHT*size);
return w*size;
}
void ili9341_drawfont(uint8_t ch, int x, int y)
{
blit16BitWidthBitmap(x, y, NUM_FONT_GET_WIDTH, NUM_FONT_GET_HEIGHT, NUM_FONT_GET_DATA(ch));
}
void ili9341_drawstring_size(const char *str, int x, int y, uint8_t size)
{
while (*str)
x += ili9341_drawchar_size(*str++, x, y, size);
}
#define SWAP(x,y) { int z=x; x = y; y = z; }
void ili9341_line(int x0, int y0, int x1, int y1)
{
if (x0 > x1) { if (x0 > x1) {
SWAP(x0, x1); SWAP(x0, x1);
SWAP(y0, y1); SWAP(y0, y1);
@ -426,49 +594,34 @@ ili9341_line(int x0, int y0, int x1, int y1, uint16_t fg)
} }
} }
if (dy > 0) if (dy > 0)
ili9341_fill(x0, y0, dx, dy, fg); ili9341_fill(x0, y0, dx, dy, foreground_color);
else else
ili9341_fill(x0, y0+dy, dx, -dy, fg); ili9341_fill(x0, y0+dy, dx, -dy, foreground_color);
x0 += dx; x0 += dx;
y0 += dy; y0 += dy;
} }
} }
const font_t NF20x22 = { 20, 22, 1, 3*22, (const uint8_t *)numfont20x22 };
void
ili9341_drawfont(uint8_t ch, const font_t *font, int x, int y, uint16_t fg, uint16_t bg)
{
uint16_t *buf = spi_buffer;
const uint8_t *bitmap = &font->bitmap[font->slide * ch];
int c, r;
for (c = 0; c < font->height; c++) {
uint8_t bits = *bitmap++;
uint8_t m = 0x80;
for (r = 0; r < font->width; r++) {
*buf++ = (bits & m) ? fg : bg;
m >>= 1;
if (m == 0) {
bits = *bitmap++;
m = 0x80;
}
}
}
ili9341_bulk(x, y, font->width, font->height);
}
#if 0 #if 0
const uint16_t colormap[] = { static const uint16_t colormap[] = {
RGB565(255,0,0), RGB565(0,255,0), RGB565(0,0,255), RGBHEX(0x00ff00), RGBHEX(0x0000ff), RGBHEX(0xff0000),
RGB565(255,255,0), RGB565(0,255,255), RGB565(255,0,255) RGBHEX(0x00ffff), RGBHEX(0xff00ff), RGBHEX(0xffff00)
}; };
void static void ili9341_pixel(int x, int y, int color)
ili9341_test(int mode)
{ {
uint8_t xx[4] = { x >> 8, x, (x+1) >> 8, (x+1) };
uint8_t yy[4] = { y >> 8, y, (y+1) >> 8, (y+1) };
uint8_t cc[2] = { color >> 8, color };
send_command(ILI9341_COLUMN_ADDRESS_SET, 4, xx);
send_command(ILI9341_PAGE_ADDRESS_SET, 4, yy);
send_command(ILI9341_MEMORY_WRITE, 2, cc);
//send_command16(ILI9341_MEMORY_WRITE, color);
}
void ili9341_test(int mode)
{
chMtxLock(&mutex_ili9341);
int x, y; int x, y;
int i; int i;
switch (mode) { switch (mode) {
@ -476,7 +629,7 @@ ili9341_test(int mode)
#if 1 #if 1
ili9341_fill(0, 0, 320, 240, 0); ili9341_fill(0, 0, 320, 240, 0);
for (y = 0; y < 240; y++) { for (y = 0; y < 240; y++) {
ili9341_fill(0, y, 320, 1, RGB565(y, (y + 120) % 256, 240-y)); ili9341_fill(0, y, 320, 1, RGB(240-y, y, (y + 120) % 256));
} }
break; break;
case 1: case 1:
@ -495,7 +648,7 @@ ili9341_test(int mode)
#if 1 #if 1
case 3: case 3:
for (i = 0; i < 10; i++) for (i = 0; i < 10; i++)
ili9341_drawfont(i, &NF20x22, i*20, 120, colormap[i%6], 0x0000); ili9341_drawfont(i, i*20, 120);
break; break;
#endif #endif
#if 0 #if 0
@ -504,11 +657,12 @@ ili9341_test(int mode)
break; break;
#endif #endif
case 4: case 4:
ili9341_line(0, 0, 15, 100, 0xffff); ili9341_line(0, 0, 15, 100);
ili9341_line(0, 0, 100, 100, 0xffff); ili9341_line(0, 0, 100, 100);
ili9341_line(0, 15, 100, 0, 0xffff); ili9341_line(0, 15, 100, 0);
ili9341_line(0, 100, 100, 0, 0xffff); ili9341_line(0, 100, 100, 0);
break; break;
} }
chMtxUnlock(&mutex_ili9341);
} }
#endif #endif

108
main.c
View file

@ -533,32 +533,21 @@ static void cmd_dump(BaseSequentialStream *chp, int argc, char *argv[])
static void cmd_capture(BaseSequentialStream *chp, int argc, char *argv[]) static void cmd_capture(BaseSequentialStream *chp, int argc, char *argv[])
{ {
// read pixel count at one time (PART*2 bytes required for read buffer) // read pixel count at one time (PART*2 bytes required for read buffer)
#define PART 320
(void)argc; (void)argc;
(void)argv; (void)argv;
chMtxLock(&mutex); chMtxLock(&mutex);
// read 2 row pixel time (read buffer limit by 2/3 + 1 from spi_buffer size)
for (int y=0; y < 240; y+=2)
{
// use uint16_t spi_buffer[1024] (defined in ili9341) for read buffer // use uint16_t spi_buffer[1024] (defined in ili9341) for read buffer
uint16_t *buf = &spi_buffer[0]; uint8_t *buf = (uint8_t *)spi_buffer;
int len = 320 * 240; ili9341_read_memory(0, y, 320, 2, 2*320, spi_buffer);
int i; for (int i = 0; i < 4*320; i++) {
ili9341_read_memory(0, 0, 320, 240, PART, buf); streamPut(chp, *buf++);
for (i = 0; i < PART; i++) {
streamPut(chp, buf[i] >> 8);
streamPut(chp, buf[i] & 0xff);
} }
len -= PART;
while (len > 0) {
ili9341_read_memory_continue(PART, buf);
for (i = 0; i < PART; i++) {
streamPut(chp, buf[i] >> 8);
streamPut(chp, buf[i] & 0xff);
} }
len -= PART;
}
//*/
chMtxUnlock(&mutex); chMtxUnlock(&mutex);
} }
@ -602,10 +591,10 @@ static void cmd_sample(BaseSequentialStream *chp, int argc, char *argv[])
config_t config = { config_t config = {
.magic = CONFIG_MAGIC, .magic = CONFIG_MAGIC,
.dac_value = 1922, .dac_value = 1922,
.grid_color = 0x1084, .grid_color = DEFAULT_GRID_COLOR,
.menu_normal_color = 0xffff, .menu_normal_color = DEFAULT_MENU_COLOR,
.menu_active_color = 0x7777, .menu_active_color = DEFAULT_MENU_ACTIVE_COLOR,
.trace_color = { RGB565(0,255,255), RGB565(255,0,40), RGB565(0,0,255), RGB565(50,255,0) }, .trace_color = { DEFAULT_TRACE_1_COLOR, DEFAULT_TRACE_2_COLOR, DEFAULT_TRACE_3_COLOR, DEFAULT_TRACE_4_COLOR },
// .touch_cal = { 693, 605, 124, 171 }, // 2.4 inch LCD panel // .touch_cal = { 693, 605, 124, 171 }, // 2.4 inch LCD panel
.touch_cal = { 338, 522, 153, 192 }, // 2.8 inch LCD panel .touch_cal = { 338, 522, 153, 192 }, // 2.8 inch LCD panel
.default_loadcal = 0, .default_loadcal = 0,
@ -618,10 +607,10 @@ properties_t current_props = {
._frequency1 = 900000000, // end = 900MHz ._frequency1 = 900000000, // end = 900MHz
._sweep_points = 101, ._sweep_points = 101,
._trace = {/*enable, type, channel, polar, scale, refpos*/ ._trace = {/*enable, type, channel, polar, scale, refpos*/
{ 1, TRC_LOGMAG, 0, 0, 1.0, 7.0 }, { 1, TRC_LOGMAG, 0, 0, 1.0, 9.0 },
{ 1, TRC_LOGMAG, 1, 0, 1.0, 7.0 }, { 1, TRC_LOGMAG, 1, 0, 1.0, 9.0 },
{ 1, TRC_SMITH, 0, 1, 1.0, 0.0 }, { 1, TRC_SMITH, 0, 1, 1.0, 0.0 },
{ 1, TRC_PHASE, 1, 0, 1.0, 4.0 } { 1, TRC_PHASE, 1, 0, 1.0, 5.0 }
}, },
._markers = { ._markers = {
{ 1, 30, 0 }, { 0, 40, 0 }, { 0, 60, 0 }, { 0, 80, 0 } { 1, 30, 0 }, { 0, 40, 0 }, { 0, 60, 0 }, { 0, 80, 0 }
@ -1431,17 +1420,17 @@ const struct {
uint16_t refpos; uint16_t refpos;
float scale_unit; float scale_unit;
} trace_info[] = { } trace_info[] = {
{ "LOGMAG", 7, 10 }, { "LOGMAG", 9, 10 },
{ "PHASE", 4, 90 }, { "PHASE", 5, 90 },
{ "DELAY", 4, 1e-9 }, { "DELAY", 5, 1e-9 },
{ "SMITH", 0, 1 }, { "SMITH", 0, 1 },
{ "POLAR", 0, 1 }, { "POLAR", 0, 1 },
{ "LINEAR", 0, 0.125 }, { "LINEAR", 0, 0.125 },
{ "SWR", 0, 1 }, { "SWR", 0, 1 },
{ "REAL", 4, 0.25 }, { "REAL", 5, 0.25 },
{ "IMAG", 4, 0.25 }, { "IMAG", 5, 0.25 },
{ "R", 0, 100 }, { "R", 0, 100 },
{ "X", 4, 100 } { "X", 5, 100 }
}; };
const char * const trc_channel_name[] = { const char * const trc_channel_name[] = {
@ -1552,6 +1541,11 @@ my_atof(const char *p)
return x; return x;
} }
typedef struct {
char *tracename;
uint8_t type;
} type_list;
static void cmd_trace(BaseSequentialStream *chp, int argc, char *argv[]) static void cmd_trace(BaseSequentialStream *chp, int argc, char *argv[])
{ {
int t; int t;
@ -1586,34 +1580,29 @@ static void cmd_trace(BaseSequentialStream *chp, int argc, char *argv[])
chprintf(chp, "%d %s %s\r\n", t, type, channel); chprintf(chp, "%d %s %s\r\n", t, type, channel);
return; return;
} }
if (argc > 1) { if (argc > 1) {
if (strcmp(argv[1], "logmag") == 0) { static const type_list t_list[] = {
set_trace_type(t, TRC_LOGMAG); {"logmag", TRC_LOGMAG},
} else if (strcmp(argv[1], "phase") == 0) { {"phase", TRC_PHASE},
set_trace_type(t, TRC_PHASE); {"polar", TRC_POLAR},
} else if (strcmp(argv[1], "polar") == 0) { {"smith", TRC_SMITH},
set_trace_type(t, TRC_POLAR); {"delay", TRC_DELAY},
} else if (strcmp(argv[1], "smith") == 0) { {"linear", TRC_LINEAR},
set_trace_type(t, TRC_SMITH); {"swr", TRC_SWR},
} else if (strcmp(argv[1], "delay") == 0) { {"real", TRC_REAL},
set_trace_type(t, TRC_DELAY); {"imag", TRC_IMAG},
} else if (strcmp(argv[1], "linear") == 0) { {"r", TRC_R},
set_trace_type(t, TRC_LINEAR); {"x", TRC_X},
} else if (strcmp(argv[1], "swr") == 0) { {"off", TRC_OFF},
set_trace_type(t, TRC_SWR); };
} else if (strcmp(argv[1], "real") == 0) { for (uint16_t i=0; i<sizeof(t_list)/sizeof(type_list); i++){
set_trace_type(t, TRC_REAL); if (strcmp(argv[1], t_list[i].tracename) == 0) {
} else if (strcmp(argv[1], "imag") == 0) { set_trace_type(t, t_list[i].type);
set_trace_type(t, TRC_IMAG); goto check_ch_num;
} else if (strcmp(argv[1], "r") == 0) { }
set_trace_type(t, TRC_R); }
} else if (strcmp(argv[1], "x") == 0) { if (strcmp(argv[1], "scale") == 0 && argc >= 3) {
set_trace_type(t, TRC_X);
} else if (strcmp(argv[1], "linear") == 0) {
set_trace_type(t, TRC_LINEAR);
} else if (strcmp(argv[1], "off") == 0) {
set_trace_type(t, TRC_OFF);
} else if (strcmp(argv[1], "scale") == 0 && argc >= 3) {
//trace[t].scale = my_atof(argv[2]); //trace[t].scale = my_atof(argv[2]);
set_trace_scale(t, my_atof(argv[2])); set_trace_scale(t, my_atof(argv[2]));
goto exit; goto exit;
@ -1625,6 +1614,7 @@ static void cmd_trace(BaseSequentialStream *chp, int argc, char *argv[])
goto usage; goto usage;
} }
} }
check_ch_num:
if (argc > 2) { if (argc > 2) {
int src = atoi(argv[2]); int src = atoi(argv[2]);
if (src != 0 && src != 1) if (src != 0 && src != 1)
@ -1634,7 +1624,7 @@ static void cmd_trace(BaseSequentialStream *chp, int argc, char *argv[])
exit: exit:
return; return;
usage: usage:
chprintf(chp, "trace {0|1|2|3|all} [logmag|phase|smith|linear|delay|swr|real|imag|r|x|off] [src]\r\n"); chprintf(chp, "trace {0|1|2|3|all} [logmag|phase|polar|smith|linear|delay|swr|real|imag|r|x|off] [src]\r\n");
chprintf(chp, "trace {0|1|2|3} {scale|refpos} {value}\r\n"); chprintf(chp, "trace {0|1|2|3} {scale|refpos} {value}\r\n");
} }

4
mcuconf.h
View file

@ -117,7 +117,9 @@
#define STM32_I2C_BUSY_TIMEOUT 50 #define STM32_I2C_BUSY_TIMEOUT 50
#define STM32_I2C_I2C1_IRQ_PRIORITY 3 #define STM32_I2C_I2C1_IRQ_PRIORITY 3
#define STM32_I2C_I2C2_IRQ_PRIORITY 3 #define STM32_I2C_I2C2_IRQ_PRIORITY 3
#define STM32_I2C_USE_DMA TRUE
// I2C1 rx operation use DMA3, some as SPI1 DMA Tx used by LCD
#define STM32_I2C_USE_DMA FALSE
#define STM32_I2C_I2C1_DMA_PRIORITY 1 #define STM32_I2C_I2C1_DMA_PRIORITY 1
#define STM32_I2C_I2C2_DMA_PRIORITY 1 #define STM32_I2C_I2C2_DMA_PRIORITY 1
#define STM32_I2C_I2C1_RX_DMA_STREAM STM32_DMA_STREAM_ID(1, 3) #define STM32_I2C_I2C1_RX_DMA_STREAM STM32_DMA_STREAM_ID(1, 3)

88
nanovna.h
View file

@ -19,6 +19,9 @@
*/ */
#include "ch.h" #include "ch.h"
// Need enable HAL_USE_SPI in halconf.h
#define __USE_DISPLAY_DMA__
/* /*
* main.c * main.c
*/ */
@ -129,7 +132,12 @@ extern void tlv320aic3204_select(int channel);
#define OFFSETX 15 #define OFFSETX 15
#define OFFSETY 0 #define OFFSETY 0
#define WIDTH 291 #define WIDTH 291
#define HEIGHT 233 #define HEIGHT 230
// Smith/polar chart
#define P_CENTER_X 145
#define P_CENTER_Y 115
#define P_RADIUS 115
#define CELLOFFSETX 5 #define CELLOFFSETX 5
#define AREA_WIDTH_NORMAL (WIDTH + CELLOFFSETX*2) #define AREA_WIDTH_NORMAL (WIDTH + CELLOFFSETX*2)
@ -137,21 +145,29 @@ extern void tlv320aic3204_select(int channel);
extern int area_width; extern int area_width;
extern int area_height; extern int area_height;
#define GRIDY 29 #define GRIDY 23
// font // font
extern const uint8_t x5x7_bits []; extern const uint8_t x5x7_bits [];
extern const uint8_t numfont20x22[][22 * 3]; #define FONT_GET_DATA(ch) (&x5x7_bits[ch*7])
#define FONT_GET_WIDTH(ch) (7-(x5x7_bits[ch*7]&3))
#define FONT_GET_HEIGHT 7
extern const uint16_t numfont16x22[];
#define NUM_FONT_GET_DATA(ch) (&numfont16x22[ch*22])
#define NUM_FONT_GET_WIDTH 16
#define NUM_FONT_GET_HEIGHT 22
#define S_DELTA "\004" #define S_DELTA "\004"
#define S_DEGREE "\037"
#define S_SARROW "\030"
#define S_INFINITY "\031"
#define S_LARROW "\032"
#define S_RARROW "\033"
#define S_PI "\034" #define S_PI "\034"
#define S_MICRO "\035" #define S_MICRO "\035"
#define S_OHM "\036" #define S_OHM "\036"
#define S_DEGREE "\037"
#define S_LARROW "\032"
#define S_RARROW "\033"
// trace // trace
#define TRACES_MAX 4 #define TRACES_MAX 4
@ -261,34 +277,46 @@ extern int16_t vbat;
/* /*
* ili9341.c * ili9341.c
*/ */
#define RGB565(b,r,g) ( (((b)<<8)&0xfc00) | (((r)<<2)&0x03e0) | (((g)>>3)&0x001f) ) // SPI bus revert byte order
//gggBBBbb RRRrrGGG
#define RGB565(r,g,b) ( (((g)&0x1c)<<11) | (((b)&0xf8)<<5) | ((r)&0xf8) | (((g)&0xe0)>>5) )
#define RGBHEX(hex) ( (((hex)&0x001c00)<<3) | (((hex)&0x0000f8)<<5) | (((hex)&0xf80000)>>16) | (((hex)&0x00e000)>>13) )
typedef struct { #define DEFAULT_FG_COLOR RGB565(255,255,255)
uint16_t width; #define DEFAULT_BG_COLOR RGB565( 0, 0, 0)
uint16_t height; #define DEFAULT_GRID_COLOR RGB565(128,128,128)
uint16_t scaley; #define DEFAULT_MENU_COLOR RGB565(255,255,255)
uint16_t slide; #define DEFAULT_MENU_TEXT_COLOR RGB565( 0, 0, 0)
const uint8_t *bitmap; #define DEFAULT_MENU_ACTIVE_COLOR RGB565(180,255,180)
} font_t; #define DEFAULT_TRACE_1_COLOR RGB565( 0,255,255)
#define DEFAULT_TRACE_2_COLOR RGB565(255, 0, 40)
#define DEFAULT_TRACE_3_COLOR RGB565( 0, 0,255)
#define DEFAULT_TRACE_4_COLOR RGB565( 50,255, 0)
extern const font_t NF20x22; extern uint16_t foreground_color;
extern uint16_t background_color;
extern uint16_t spi_buffer[1024]; extern uint16_t spi_buffer[1024];
void ili9341_init(void); void ili9341_init(void);
//void ili9341_setRotation(uint8_t r);
void ili9341_test(int mode); void ili9341_test(int mode);
void ili9341_bulk(int x, int y, int w, int h); void ili9341_bulk(int x, int y, int w, int h);
void ili9341_fill(int x, int y, int w, int h, int color); void ili9341_fill(int x, int y, int w, int h, int color);
void ili9341_drawchar_5x7(uint8_t ch, int x, int y, uint16_t fg, uint16_t bg); void setForegroundColor(uint16_t fg);
void ili9341_drawstring_5x7(const char *str, int x, int y, uint16_t fg, uint16_t bg); void setBackgroundColor(uint16_t fg);
void ili9341_drawstring_5x7_inv(const char *str, int x, int y, uint16_t fg, uint16_t bg, bool inv); void blit8BitWidthBitmap(uint16_t x, uint16_t y, uint16_t width, uint16_t height, const uint8_t *bitmap);
void ili9341_drawchar_size(uint8_t ch, int x, int y, uint16_t fg, uint16_t bg, uint8_t size); void blit16BitWidthBitmap(uint16_t x, uint16_t y, uint16_t width, uint16_t height, const uint16_t *bitmap);
void ili9341_drawstring_size(const char *str, int x, int y, uint16_t fg, uint16_t bg, uint8_t size); void ili9341_drawchar(uint8_t ch, int x, int y);
void ili9341_drawfont(uint8_t ch, const font_t *font, int x, int y, uint16_t fg, uint16_t bg); void ili9341_drawstring(const char *str, int x, int y);
void ili9341_drawstringV(const char *str, int x, int y);
int ili9341_drawchar_size(uint8_t ch, int x, int y, uint8_t size);
void ili9341_drawstring_size(const char *str, int x, int y, uint8_t size);
void ili9341_drawfont(uint8_t ch, int x, int y);
void ili9341_read_memory(int x, int y, int w, int h, int len, uint16_t* out); void ili9341_read_memory(int x, int y, int w, int h, int len, uint16_t* out);
void ili9341_read_memory_continue(int len, uint16_t* out); void ili9341_line(int x0, int y0, int x1, int y1);
void ili9341_line(int x0, int y0, int x1, int y1, uint16_t fg); void show_version(void);
void show_logo(void);
/* /*
* flash.c * flash.c
@ -405,14 +433,4 @@ int16_t adc_vbat_read(ADC_TypeDef *adc);
*/ */
#define PULSE do { palClearPad(GPIOC, GPIOC_LED); palSetPad(GPIOC, GPIOC_LED);} while(0) #define PULSE do { palClearPad(GPIOC, GPIOC_LED); palSetPad(GPIOC, GPIOC_LED);} while(0)
// convert vbat [mV] to battery indicator
static inline uint8_t vbat2bati(int16_t vbat)
{
if (vbat < 3200) return 0;
if (vbat < 3450) return 25;
if (vbat < 3700) return 50;
if (vbat < 4100) return 75;
return 100;
}
/*EOF*/ /*EOF*/

1086
numfont20x22.c
View file

File diff suppressed because it is too large Load diff

648
plot.c
View file

File diff suppressed because it is too large Load diff

660
ui.c
View file

File diff suppressed because it is too large Load diff