From d2d09edaf85e38704fc60ac4ac7b0221f73ef0ce Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?King=20K=C3=A9vin?= <kingkevin@cuvoodoo.info>
Date: Mon, 17 Feb 2020 18:04:38 +0100
Subject: [PATCH] vfd_hv518: fix all compilation and definition issues, and put
 some spaces

---
 lib/vfd_hv518.c | 403 +++++++++++++++++++++++-------------------------
 lib/vfd_hv518.h |   5 +-
 2 files changed, 200 insertions(+), 208 deletions(-)

diff --git a/lib/vfd_hv518.c b/lib/vfd_hv518.c
index c429ebc..a760a2b 100644
--- a/lib/vfd_hv518.c
+++ b/lib/vfd_hv518.c
@@ -12,11 +12,11 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  */
-/** library to drive vacuum fluorescent display using supertex HV518 shift register VFD drivers (code)
+/** library to drive vacuum fluorescent display using supertex HV518 shift register VFD drivers
  *  @details the current configuration is for a VFD extracted from a Samsung SER-6500 cash register
  *  @file
  *  @author King Kévin <kingkevin@cuvoodoo.info>
- *  @date 2016
+ *  @date 2016-2020
  *  @note peripherals used: SPI @ref vfd_hv518_spi , GPIO @ref vfd_hv518_gpio , timer @ref vfd_hv518_timer
  */
 /* standard libraries */
@@ -36,131 +36,121 @@
 /** @defgroup vfd_hv518_gpio GPIO to control supertex HV518 VFD drivers
  *  @{
  */
-#define VFD_PORT GPIOA /**< GPIO port */
-#define VFD_PORT_RCC RCC_GPIOA /**< GPIO port peripheral clock */
-#define VFD_STR GPIO6 /**< strobe pin to enable high voltage output, high voltage is output on low */
-#define VFD_NLE GPIO4 /**< latch enable pin, stores the shifted data on low, output the parallel data on high */
+#define VFD_STR_PIN PA6 /**< strobe pin to enable high voltage output, high voltage is output on low */
+#define VFD_NLE_PIN PA4 /**< latch enable pin, stores the shifted data on low, output the parallel data on high */
 /** @} */
 
 /** @defgroup vfd_hv518_spi SPI to send data to supertex HV518 VFD drivers
  *  @{
  */
-#define VFD_SPI_RCC RCC_SPI1 /**< SPI peripheral */
-#define VFD_SPI_PORT GPIOA /**< GPIO port */
-#define VFD_SPI_PORT_RCC RCC_GPIOA /**< GPIO port peripheral clock */
-#define VFD_SPI_IRQ NVIC_SPI1_IRQ /**< SPI peripheral interrupt signal */
-#define VFD_SPI_ISR spi1_isr /**< SPI interrupt service routine */
-#define VFD_CLK GPIO_SPI1_SCK /**< clock signal */
-#define VFD_DIN GPIO_SPI1_MOSI /**< data input, where the data is shifted to */
+#define VFD_SPI 1 /**< SPI peripheral */
 /** @} */
 
 /** @defgroup vfd_hv518_timer timer for automatic display blocks refresh
  *  @{
  */
-#define VFD_TIMER_RCC RCC_TIM2 /**< timer peripheral clock */
-#define VFD_TIMER_IRQ NVIC_TIM2_IRQ /**< timer interrupt signal */
-#define VFD_TIMER_ISR tim2_isr /**< timer interrupt service routine */
+#define VFD_TIMER 2 /**< timer peripheral ID */
 /** @} */
 
 /** ASCII characters encoded for the 7 segments digit block
  *  @note starts with space
  */
 static const uint8_t ascii_7segments[] = {
-	0b00000000, // space
-	0b00110000, // ! (I)
-	0b00100010, // "
-	0b01011100, // # (o)
-	0b01101101, // $ (s)
-	0b01010010, // % (/)
-	0b01111101, // & (6)
-	0b00100000, // '
-	0b00111001, // ( ([)
-	0b00001111, // )
-	0b01110000, // *
-	0b01000110, // +
-	0b00010000, // ,
-	0b01000000, // -
-	0b00010000, // . (,)
-	0b01010010, // /
-	0b00111111, // 0
-	0b00000110, // 1
-	0b01011011, // 2
-	0b01001111, // 3
-	0b01100110, // 4
-	0b01101101, // 5
-	0b01111101, // 6
-	0b00000111, // 7
-	0b01111111, // 8
-	0b01101111, // 9
-	0b01001000, // : (=)
-	0b01001000, // ; (=)
-	0b01011000, // <
-	0b01001000, // =
-	0b01001100, // >
-	0b01010011, // ?
-	0b01111011, // @
-	0b01110111, // A
-	0b01111111, // B
-	0b00111001, // C
-	0b01011110, // D
-	0b01111001, // E
-	0b01110001, // F
-	0b00111101, // G
-	0b01110110, // H
-	0b00110000, // I
-	0b00011110, // J
-	0b01110110, // K
-	0b00111000, // L
-	0b00110111, // M
-	0b00110111, // N
-	0b00111111, // O
-	0b01110011, // P
-	0b01101011, // Q
-	0b00110011, // R
-	0b01101101, // S
-	0b01111000, // T
-	0b00111110, // U
-	0b00111110, // V (U)
-	0b00111110, // W (U)
-	0b01110110, // X (H)
-	0b01101110, // Y
-	0b01011011, // Z
-	0b00111001, // [
-	0b01100100, // '\'
-	0b00001111, // /
-	0b00100011, // ^
-	0b00001000, // _
-	0b00000010, // `
-	0b01011111, // a
-	0b01111100, // b
-	0b01011000, // c
-	0b01011110, // d
-	0b01111011, // e
-	0b01110001, // f
-	0b01101111, // g
-	0b01110100, // h
-	0b00010000, // i
-	0b00001100, // j
-	0b01110110, // k
-	0b00110000, // l
-	0b01010100, // m
-	0b01010100, // n
-	0b01011100, // o
-	0b01110011, // p
-	0b01100111, // q
-	0b01010000, // r
-	0b01101101, // s
-	0b01111000, // t
-	0b00011100, // u
-	0b00011100, // v (u)
-	0b00011100, // w (u)
-	0b01110110, // x
-	0b01101110, // y
-	0b01011011, // z
-	0b00111001, // { ([)
-	0b00110000, // |
-	0b00001111, // } ([)
-	0b01000000, // ~
+	0x00, // 0b00000000, space
+	0x30, // 0b00110000, ! (I)
+	0x22, // 0b00100010, "
+	0x5c, // 0b01011100, # (o)
+	0x6d, // 0b01101101, $ (s)
+	0x52, // 0b01010010, % (/)
+	0x7d, // 0b01111101, & (6)
+	0x20, // 0b00100000, '
+	0x39, // 0b00111001, ( ([)
+	0x0f, // 0b00001111, )
+	0x70, // 0b01110000, *
+	0x46, // 0b01000110, +
+	0x10, // 0b00010000, ,
+	0x40, // 0b01000000, -
+	0x10, // 0b00010000, . (,)
+	0x52, // 0b01010010, /
+	0x3f, // 0b00111111, 0
+	0x06, // 0b00000110, 1
+	0x5b, // 0b01011011, 2
+	0x4f, // 0b01001111, 3
+	0x66, // 0b01100110, 4
+	0x6d, // 0b01101101, 5
+	0x7d, // 0b01111101, 6
+	0x07, // 0b00000111, 7
+	0x7f, // 0b01111111, 8
+	0x6f, // 0b01101111, 9
+	0x48, // 0b01001000, : (=)
+	0x48, // 0b01001000, ; (=)
+	0x58, // 0b01011000, <
+	0x48, // 0b01001000, =
+	0x4c, // 0b01001100, >
+	0x53, // 0b01010011, ?
+	0x7b, // 0b01111011, @
+	0x77, // 0b01110111, A
+	0x7f, // 0b01111111, B
+	0x39, // 0b00111001, C
+	0x5e, // 0b01011110, D
+	0x79, // 0b01111001, E
+	0x71, // 0b01110001, F
+	0x3d, // 0b00111101, G
+	0x76, // 0b01110110, H
+	0x30, // 0b00110000, I
+	0x1e, // 0b00011110, J
+	0x76, // 0b01110110, K
+	0x38, // 0b00111000, L
+	0x37, // 0b00110111, M
+	0x37, // 0b00110111, N
+	0x3f, // 0b00111111, O
+	0x73, // 0b01110011, P
+	0x6b, // 0b01101011, Q
+	0x33, // 0b00110011, R
+	0x6d, // 0b01101101, S
+	0x78, // 0b01111000, T
+	0x3e, // 0b00111110, U
+	0x3e, // 0b00111110, V (U)
+	0x3e, // 0b00111110, W (U)
+	0x76, // 0b01110110, X (H)
+	0x6e, // 0b01101110, Y
+	0x5b, // 0b01011011, Z
+	0x39, // 0b00111001, [
+	0x64, // 0b01100100, '\'
+	0x0f, // 0b00001111, /
+	0x23, // 0b00100011, ^
+	0x08, // 0b00001000, _
+	0x02, // 0b00000010, `
+	0x5f, // 0b01011111, a
+	0x7c, // 0b01111100, b
+	0x58, // 0b01011000, c
+	0x5e, // 0b01011110, d
+	0x7b, // 0b01111011, e
+	0x71, // 0b01110001, f
+	0x6f, // 0b01101111, g
+	0x74, // 0b01110100, h
+	0x10, // 0b00010000, i
+	0x0c, // 0b00001100, j
+	0x76, // 0b01110110, k
+	0x30, // 0b00110000, l
+	0x54, // 0b01010100, m
+	0x54, // 0b01010100, n
+	0x5c, // 0b01011100, o
+	0x73, // 0b01110011, p
+	0x67, // 0b01100111, q
+	0x50, // 0b01010000, r
+	0x6d, // 0b01101101, s
+	0x78, // 0b01111000, t
+	0x1c, // 0b00011100, u
+	0x1c, // 0b00011100, v (u)
+	0x1c, // 0b00011100, w (u)
+	0x76, // 0b01110110, x
+	0x6e, // 0b01101110, y
+	0x5b, // 0b01011011, z
+	0x39, // 0b00111001, { ([)
+	0x30, // 0b00110000, |
+	0x0f, // 0b00001111, } ([)
+	0x40, // 0b01000000, ~
 };
 
 /** font for the 5x7 dot matrix block
@@ -262,7 +252,7 @@ static const uint8_t font5x7[][5] = {
 	{0x00, 0x08, 0x36, 0x41, 0x00}, // {
 	{0x00, 0x00, 0x7F, 0x00, 0x00}, // |
 	{0x00, 0x41, 0x36, 0x08, 0x00}, // }
-	{0b00001000, 0b00000100, 0b00001100, 0b00001000, 0b00000100} // ~
+	{0x08, 0x04, 0x0c, 0x08, 0x04}, // ~ {0b00001000, 0b00000100, 0b00001100, 0b00001000, 0b00000100}
 };
 
 /** pictures for the 5x7 dot matrix block
@@ -271,18 +261,18 @@ static const uint8_t font5x7[][5] = {
 static const uint8_t pict5x7[][5] = {
 	{0x08, 0x08, 0x2A, 0x1C, 0x08}, // ->
 	{0x08, 0x1C, 0x2A, 0x08, 0x08}, // <-
-	{0b01110000, 0b01110000, 0b01111010, 0b01111100, 0b01011000}, // bunny side 1
-	{0b00100000, 0b01110000, 0b01110010, 0b01111100, 0b01011000}, // bunny side 2
-	{0b00111110, 0b01001001, 0b01010110, 0b01001001, 0b00111110}, // bunny face 1
-	{0b00111110, 0b01010001, 0b01100110, 0b01010001, 0b00111110}, // bunny face 2
-	{0b00111000, 0b01010111, 0b01100100, 0b01010111, 0b00111000}, // bunny face 3
-	{0b00111000, 0b01001111, 0b01010100, 0b01001111, 0b00111000}, // bunny face 4
-	{0b00111000, 0b01011110, 0b01101000, 0b01011110, 0b00111000}, // bunny face 5
-	{0b01000001, 0b00110110, 0b00001000, 0b00110110, 0b01000001}, // cross 1
-	{~0b01000001, ~0b00110110, ~0b00001000, ~0b00110110, ~0b01000001}, // cross 1 negated
-	{0b00100010, 0b00010100, 0b00001000, 0b00010100, 0b00100010}, // cross 2
-	{~0b00100010, ~0b00010100, ~0b00001000, ~0b00010100, ~0b00100010}, // cross 2 negated
-	{0x00, 0x00, 0x00, 0x00, 0x00} // nothing
+	{0x70, 0x70, 0x7a, 0x7c, 0x58}, // bunny side 1 {0b01110000, 0b01110000, 0b01111010, 0b01111100, 0b01011000}
+	{0x20, 0x70, 0x72, 0x7c, 0x58}, // bunny side 2 {0b00100000, 0b01110000, 0b01110010, 0b01111100, 0b01011000}
+	{0x3e, 0x49, 0x56, 0x49, 0x3e}, // bunny face 1 {0b00111110, 0b01001001, 0b01010110, 0b01001001, 0b00111110}
+	{0x3e, 0x51, 0x66, 0x51, 0x3e}, // bunny face 2 {0b00111110, 0b01010001, 0b01100110, 0b01010001, 0b00111110}
+	{0x38, 0x57, 0x64, 0x57, 0x38}, // bunny face 3 {0b00111000, 0b01010111, 0b01100100, 0b01010111, 0b00111000}
+	{0x38, 0x4f, 0x54, 0x4f, 0x38}, // bunny face 4 {0b00111000, 0b01001111, 0b01010100, 0b01001111, 0b00111000}
+	{0x38, 0x5e, 0x68, 0x5e, 0x38}, // bunny face 5 {0b00111000, 0b01011110, 0b01101000, 0b01011110, 0b00111000}
+	{0x41, 0x36, 0x08, 0x36, 0x41}, // cross 1 {0b01000001, 0b00110110, 0b00001000, 0b00110110, 0b01000001}
+	{~0x41, ~0x36, ~0x08, ~0x36, ~0x41}, // cross 1 negated {~0b01000001, ~0b00110110, ~0b00001000, ~0b00110110, ~0b01000001}
+	{0x22, 0x14, 0x08, 0x14, 0x22}, // cross 2 {0b00100010, 0b00010100, 0b00001000, 0b00010100, 0b00100010}
+	{~0x22, ~0x14, ~0x08, ~0x14, ~0x22}, // cross 2 negated {~0b00100010, ~0b00010100, ~0b00001000, ~0b00010100, ~0b00100010}
+	{0x00, 0x00, 0x00, 0x00, 0x00}, // nothing
 };
 
 /** the 32 bits values to be shifted out to the VFD driver
@@ -290,7 +280,7 @@ static const uint8_t pict5x7[][5] = {
  *  @note since the bits for digits and matrix are independent, they can be combined
  *  @note we have more matrix (12) than digits (10)
  */
-static uint16_t driver_data[VFD_MATRIX][VFD_DRIVERS*2] = {0};
+static uint16_t driver_data[VFD_MATRIX][VFD_DRIVERS * 2] = {0};
 /** which driver data is being transmitted */
 static volatile uint8_t spi_i = 0;
 /** which grid/part to activate
@@ -304,13 +294,13 @@ static const uint32_t digit_mask = 0x00fffff0;
 
 void vfd_digit(uint8_t nb, char c)
 {
-	if (!(nb<VFD_DIGITS)) { // check the digit exists
+	if (!(nb < VFD_DIGITS)) { // check the digit exists
 		return;
 	}
 
 	uint32_t digit_data = 0; // the data to be shifted out for the driver (for the second driver)
 
-	digit_data = 1<<(4+(9-nb)); // select digit
+	digit_data = 1 << (4 + (9 - nb)); // select digit
 	/* encode segment
 	 * here the bit order (classic 7 segment + underline and dot)
 	 *   3_
@@ -319,78 +309,78 @@ void vfd_digit(uint8_t nb, char c)
 	 *   0_2,
 	 * */
 	if (false) { // add the underline (not encoded)
-		digit_data |= (1<<(14));
+		digit_data |= (1 << 14);
 	}
 	if (c&0x80) { // add the dot (encoded in the 8th bit)
-		digit_data |= (1<<(15));
+		digit_data |= (1 << 15);
 	}
 	if (false) { // add the comma (not encoded)
-		digit_data |= (1<<(16));
+		digit_data |= (1 << 16);
 	}
 
 	c &= 0x7f; // only take the ASCII part
-	if (c>=' ') { // only take printable characters
-		uint8_t i = c-' '; // get index for character
-		if (i<LENGTH(ascii_7segments)) {
-			digit_data |= (ascii_7segments[i]<<(17)); // add encoded segments to memory
+	if (c >= ' ') { // only take printable characters
+		uint8_t i = c - ' '; // get index for character
+		if (i < LENGTH(ascii_7segments)) {
+			digit_data |= (ascii_7segments[i] << 17); // add encoded segments to memory
 		}
 	}
 
 	digit_data &= digit_mask; // be sure only the bits for the digit are used
-	digit_data |= (driver_data[nb][2]+(driver_data[nb][3]<<16))&~digit_mask; // get the existing data and add the bits for the digit
+	digit_data |= (driver_data[nb][2] + (driver_data[nb][3] << 16)) & ~digit_mask; // get the existing data and add the bits for the digit
 	driver_data[nb][2] = digit_data; // write back data (least significant half)
-	driver_data[nb][3] = (digit_data>>16); // write back data (most significant half)
+	driver_data[nb][3] = (digit_data >> 16); // write back data (most significant half)
 }
 
 void vfd_matrix(uint8_t nb, char c)
 {
 	// check the matrix exists
-	if (!(nb<VFD_MATRIX)) {
+	if (!(nb < VFD_MATRIX)) {
 		return;
 	}
 
 	uint32_t matrix_data[VFD_DRIVERS] = {0}; // the data to be shifted out for the driver
 
 	// select matrix
-	if (nb<4) {
-		matrix_data[1] = 1<<(3-nb);
+	if (nb < 4) {
+		matrix_data[1] = 1 << (3 - nb);
 	} else {
-		matrix_data[0] = 1<<(35-nb);
+		matrix_data[0] = 1 << (35 - nb);
 	}
 
-	if ((c<0x80) && (c>=' ')) { // only take printable characters
-		uint8_t i = c-' '; // get index for character
-		if (i<LENGTH(font5x7)) {
-			matrix_data[1] |= font5x7[i][0]<<24;
-			matrix_data[2] |= font5x7[i][1]<<0;
-			matrix_data[2] |= font5x7[i][2]<<8;
-			matrix_data[2] |= font5x7[i][3]<<16;
-			matrix_data[2] |= font5x7[i][4]<<24;
+	if ((c < 0x80) && (c >= ' ')) { // only take printable characters
+		uint8_t i = c - ' '; // get index for character
+		if (i < LENGTH(font5x7)) {
+			matrix_data[1] |= font5x7[i][0] << 24;
+			matrix_data[2] |= font5x7[i][1] << 0;
+			matrix_data[2] |= font5x7[i][2] << 8;
+			matrix_data[2] |= font5x7[i][3] << 16;
+			matrix_data[2] |= font5x7[i][4] << 24;
 		}
-	} else if (c>0x7f) { // the non ASCII character are used for pictures
-		uint8_t i = c-0x80; // get index for character
-		if (i<LENGTH(pict5x7)) {
-			matrix_data[1] |= pict5x7[i][0]<<24;
-			matrix_data[2] |= pict5x7[i][1]<<0;
-			matrix_data[2] |= pict5x7[i][2]<<8;
-			matrix_data[2] |= pict5x7[i][3]<<16;
-			matrix_data[2] |= pict5x7[i][4]<<24;
+	} else if (c > 0x7f) { // the non ASCII character are used for pictures
+		uint8_t i = c - 0x80; // get index for character
+		if (i < LENGTH(pict5x7)) {
+			matrix_data[1] |= pict5x7[i][0] << 24;
+			matrix_data[2] |= pict5x7[i][1] << 0;
+			matrix_data[2] |= pict5x7[i][2] << 8;
+			matrix_data[2] |= pict5x7[i][3] << 16;
+			matrix_data[2] |= pict5x7[i][4] << 24;
 		}
 	}
 
 	matrix_data[1] &= ~digit_mask; // be sure only the bits for the matrix are used
-	matrix_data[1] |= (driver_data[nb][2]+(driver_data[nb][3]<<16))&digit_mask; // get the existing data for the digit
+	matrix_data[1] |= (driver_data[nb][2] + (driver_data[nb][3] << 16)) & digit_mask; // get the existing data for the digit
 	// prepare the data for SPI to shift it out
-	for (uint8_t i=0; i<LENGTH(matrix_data); i++) {
-		driver_data[nb][i*2] = matrix_data[i];
-		driver_data[nb][i*2+1] = matrix_data[i]>>16;
+	for (uint8_t i = 0; i < LENGTH(matrix_data); i++) {
+		driver_data[nb][i * 2] = matrix_data[i];
+		driver_data[nb][i * 2 + 1] = matrix_data[i] >> 16;
 	}
 }
 
 void vfd_clear(void)
 {
-	for (uint8_t i=0; i<LENGTH(driver_data); i++) {
-		for (uint8_t j=0; j<LENGTH(driver_data[0]); j++) {
+	for (uint8_t i = 0; i < LENGTH(driver_data); i++) {
+		for (uint8_t j = 0; j < LENGTH(driver_data[0]); j++) {
 			driver_data[i][j] = 0;
 		}
 	}
@@ -398,8 +388,8 @@ void vfd_clear(void)
 
 void vfd_test(void)
 {
-	for (uint8_t i=0; i<LENGTH(driver_data); i++) {
-		for (uint8_t j=0; j<LENGTH(driver_data[0]); j++) {
+	for (uint8_t i = 0; i < LENGTH(driver_data); i++) {
+		for (uint8_t j = 0; j < LENGTH(driver_data[0]); j++) {
 			driver_data[i][j] = ~0;
 		}
 	}
@@ -407,33 +397,34 @@ void vfd_test(void)
 
 void vfd_on(void)
 {
-	gpio_clear(VFD_PORT, VFD_STR); // enable HV output
-	timer_enable_counter(VFD_TIMER); // start timer to periodically output that to the parts
+	gpio_clear(GPIO_PORT(VFD_STR_PIN), GPIO_PIN(VFD_STR_PIN)); // enable HV output
+	timer_enable_counter(TIM(VFD_TIMER)); // start timer to periodically output that to the parts
 }
 
 void vfd_off(void)
 {
-	gpio_set(VFD_PORT, VFD_STR); // disable HV output
-	timer_disable_counter(VFD_TIMER); // stop timer to periodically output that to the parts
+	gpio_set(GPIO_PORT(VFD_STR_PIN), GPIO_PIN(VFD_STR_PIN)); // disable HV output
+	timer_disable_counter(TIM(VFD_TIMER)); // stop timer to periodically output that to the parts
 }
 
 void vfd_setup(void)
 {
 	/* setup GPIO to control the VFD */
-	rcc_periph_clock_enable(VFD_PORT_RCC); // enable clock for VFD GPIO
-	gpio_set_mode(VFD_PORT, GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, VFD_STR); // set VFD pin to output push-pull
-	gpio_set_mode(VFD_PORT, GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, VFD_NLE); // set VFD pin to output push-pull
-
-	gpio_set(VFD_PORT, VFD_STR); // disable HV output
-	gpio_clear(VFD_PORT, VFD_NLE); // do not output latched data
+	rcc_periph_clock_enable(GPIO_RCC(VFD_STR_PIN)); // enable clock for VFD GPIO
+	gpio_set(GPIO_PORT(VFD_STR_PIN), GPIO_PIN(VFD_STR_PIN)); // disable HV output
+	gpio_set_mode(GPIO_PORT(VFD_STR_PIN), GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO_PIN(VFD_STR_PIN)); // set VFD pin to output push-pull
+	rcc_periph_clock_enable(GPIO_RCC(VFD_NLE_PIN)); // enable clock for VFD GPIO
+	gpio_clear(GPIO_PORT(VFD_NLE_PIN), GPIO_PIN(VFD_NLE_PIN)); // do not output latched data
+	gpio_set_mode(GPIO_PORT(VFD_NLE_PIN), GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_PUSHPULL, GPIO_PIN(VFD_NLE_PIN)); // set VFD pin to output push-pull
 
 	/* setup SPI to transmit data */
-	rcc_periph_clock_enable(VFD_SPI_RCC); // enable SPI clock
-    rcc_periph_clock_enable(VFD_SPI_PORT_RCC); // enable clock for VFD SPI GPIO
-	gpio_set_mode(VFD_SPI_PORT, GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, VFD_CLK); // set VFD pin to alternative function push-pull
-	gpio_set_mode(VFD_SPI_PORT, GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, VFD_DIN); // set VFD pin to alternative function push-pull
+	rcc_periph_clock_enable(RCC_SPI(VFD_SPI)); // enable SPI clock
+    rcc_periph_clock_enable(RCC_SPI_SCK_PORT(VFD_SPI)); // enable clock for VFD SPI GPIO
+    rcc_periph_clock_enable(RCC_SPI_MOSI_PORT(VFD_SPI)); // enable clock for VFD SPI GPIO
+	gpio_set_mode(SPI_SCK_PORT(VFD_SPI), GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, SPI_SCK_PIN(VFD_SPI)); // set VFD pin to alternative function push-pull
+	gpio_set_mode(SPI_MOSI_PORT(VFD_SPI), GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, SPI_MOSI_PIN(VFD_SPI)); // set VFD pin to alternative function push-pull
 
-	spi_reset(VFD_SPI); // clear SPI values
+	spi_reset(SPI(VFD_SPI)); // clear SPI values
 	/* set SPI:
 	 * - use VFD_SPI port
 	 * - divide clock by 8 for generating the baudrate (F_PCLK1 is 36MHz, max HV518 is 6MHz)
@@ -442,56 +433,56 @@ void vfd_setup(void)
 	 * - send 16 bits at a time
 	 * - send least significant bit first (that's how I coded the data)
 	 */
-	spi_init_master(VFD_SPI, SPI_CR1_BAUDRATE_FPCLK_DIV_8, SPI_CR1_CPOL_CLK_TO_1_WHEN_IDLE, SPI_CR1_CPHA_CLK_TRANSITION_2, SPI_CR1_DFF_16BIT, SPI_CR1_LSBFIRST);
+	spi_init_master(SPI(VFD_SPI), SPI_CR1_BAUDRATE_FPCLK_DIV_8, SPI_CR1_CPOL_CLK_TO_1_WHEN_IDLE, SPI_CR1_CPHA_CLK_TRANSITION_2, SPI_CR1_DFF_16BIT, SPI_CR1_LSBFIRST);
 	//spi_set_bidirectional_transmit_only_mode(VFD_SPI); // only use MOSI to transmit
-	spi_set_unidirectional_mode(VFD_SPI); // MISO is unused
+	spi_set_unidirectional_mode(SPI(VFD_SPI)); // MISO is unused
 	/* set NSS high to enable transmission
 	 * the NSS in STM32 can not be used as hardware slave select
 	 * RM0008 reference manual 25.3.1 is misleading
 	 * when hardware NSS is used and output is enabled NSS never goes up after transmission, even if SPI is disabled
 	 * when software NSS is used, NSS can not be set high again, even when writing to the register
 	 * the slave select must be done manually using GPIO */
-	spi_enable_software_slave_management(VFD_SPI);
-	spi_set_nss_high(VFD_SPI); // set NSS high
+	spi_enable_software_slave_management(SPI(VFD_SPI));
+	spi_set_nss_high(SPI(VFD_SPI)); // set NSS high
 
-	nvic_enable_irq(VFD_SPI_IRQ); // enable SPI interrupt
-	spi_enable(VFD_SPI); // enable SPI (the tx empty interrupt will trigger)
+	nvic_enable_irq(SPI_IRQ(VFD_SPI)); // enable SPI interrupt
+	spi_enable(SPI(VFD_SPI)); // enable SPI (the tx empty interrupt will trigger)
 
 	/* setup timer to refresh display */
-	rcc_periph_clock_enable(VFD_TIMER_RCC); // enable clock for timer block
-	rcc_periph_reset_pulse(RST_VFD_TIMER); // reset timer state
-	timer_set_mode(VFD_TIMER, TIM_CR1_CKD_CK_INT, TIM_CR1_CMS_EDGE, TIM_CR1_DIR_UP); // set timer mode, use undivided timer clock,edge alignment (simple count), and count up
-	timer_set_prescaler(VFD_TIMER, (SYSTEM_CLOCK_FREQ/(1<<16))-1); // set the prescaler so this 16 bits timer overflows at 1Hz
-	timer_set_period(VFD_TIMER, 0xffff/LENGTH(driver_data)/100); // set the refresh frequency
-	timer_enable_irq(VFD_TIMER, TIM_DIER_UIE); // enable interrupt for timer
-	nvic_enable_irq(VFD_TIMER_IRQ); // allow interrupt for timer
+	rcc_periph_clock_enable(RCC_TIM(VFD_TIMER)); // enable clock for timer block
+	rcc_periph_reset_pulse(RST_TIM(VFD_TIMER)); // reset timer state
+	timer_set_mode(TIM(VFD_TIMER), TIM_CR1_CKD_CK_INT, TIM_CR1_CMS_EDGE, TIM_CR1_DIR_UP); // set timer mode, use undivided timer clock,edge alignment (simple count), and count up
+	timer_set_prescaler(TIM(VFD_TIMER), (rcc_ahb_frequency / (1 << 16)) - 1); // set the prescaler so this 16 bits timer overflows at 1Hz
+	timer_set_period(TIM(VFD_TIMER), 0xffff / LENGTH(driver_data) / 100); // set the refresh frequency
+	timer_enable_irq(TIM(VFD_TIMER), TIM_DIER_UIE); // enable interrupt for timer
+	nvic_enable_irq(NVIC_TIM_IRQ(VFD_TIMER)); // allow interrupt for timer
 
 	vfd_clear(); // initialize values
 }
 
 /** SPI interrupt service routine called when data has been transmitted */
-void VFD_SPI_ISR(void)
+void SPI_ISR(VFD_SPI)(void)
 {
-	if (SPI_SR(VFD_SPI) & SPI_SR_TXE) { // transmission buffer empty
-		if (spi_i<LENGTH(driver_data[0])) { // check if data is available
-			gpio_clear(VFD_PORT, VFD_NLE); // slave select to latch data
-			spi_send(VFD_SPI, driver_data[vfd_grid][spi_i++]); // send next data
+	if (SPI_SR(SPI(VFD_SPI)) & SPI_SR_TXE) { // transmission buffer empty
+		if (spi_i < LENGTH(driver_data[0])) { // check if data is available
+			gpio_clear(GPIO_PORT(VFD_NLE_PIN), GPIO_PIN(VFD_NLE_PIN)); // slave select to latch data
+			spi_send(SPI(VFD_SPI), driver_data[vfd_grid][spi_i++]); // send next data
 		} else { // all data transmitted
-			spi_disable_tx_buffer_empty_interrupt(VFD_SPI); // no need to wait for new data
-			while (SPI_SR(VFD_SPI) & SPI_SR_BSY); // wait for data to be shifted out
-			spi_disable_tx_buffer_empty_interrupt(VFD_SPI); // no need to wait for new data
-			gpio_set(VFD_PORT, VFD_NLE); // output latched data
+			spi_disable_tx_buffer_empty_interrupt(SPI(VFD_SPI)); // no need to wait for new data
+			while (SPI_SR(SPI(VFD_SPI)) & SPI_SR_BSY); // wait for data to be shifted out
+			spi_disable_tx_buffer_empty_interrupt(SPI(VFD_SPI)); // no need to wait for new data
+			gpio_set(GPIO_PORT(VFD_NLE_PIN), GPIO_PIN(VFD_NLE_PIN)); // output latched data
 		}
 	}
 }
 
 /** timer interrupt service routine called time passed */
-void VFD_TIMER_ISR(void)
+void TIM_ISR(VFD_TIMER)(void)
 {
-	if (timer_get_flag(VFD_TIMER, TIM_SR_UIF)) { // overflow even happened
-		timer_clear_flag(VFD_TIMER, TIM_SR_UIF); // clear flag
+	if (timer_get_flag(TIM(VFD_TIMER), TIM_SR_UIF)) { // overflow even happened
+		timer_clear_flag(TIM(VFD_TIMER), TIM_SR_UIF); // clear flag
     	spi_i = 0; // set the register to shift out
-		spi_enable_tx_buffer_empty_interrupt(VFD_SPI); // enable TX empty interrupt
-		vfd_grid = (vfd_grid+1)%LENGTH(driver_data); // got to next segment
+		spi_enable_tx_buffer_empty_interrupt(SPI(VFD_SPI)); // enable TX empty interrupt
+		vfd_grid = (vfd_grid + 1) % LENGTH(driver_data); // got to next segment
 	}
 }
diff --git a/lib/vfd_hv518.h b/lib/vfd_hv518.h
index 9e86f8e..44f0059 100644
--- a/lib/vfd_hv518.h
+++ b/lib/vfd_hv518.h
@@ -12,13 +12,14 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  */
-/** library to drive vacuum fluorescent display using supertex HV518 shift register VFD drivers (API)
+/** library to drive vacuum fluorescent display using supertex HV518 shift register VFD drivers
  *  @details the current configuration is for a VFD extracted from a Samsung SER-6500 cash register
  *  @file
  *  @author King Kévin <kingkevin@cuvoodoo.info>
- *  @date 2016
+ *  @date 2016-2020
  *  @note peripherals used: SPI @ref vfd_hv518_spi , GPIO @ref vfd_hv518_gpio , timer @ref vfd_hv518_timer
  */
+#pragma once
 
 /** number HV518 VFD drivers */
 #define VFD_DRIVERS 3