kingkevin
/
stm32f1
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

add improved files from vfd driver proect

Browse Source
forumslader-logger
King Kévin 7 years ago
parent 2eff94979e
commit ebab5e223b
6 changed files with 665 additions and 37 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 18
      Makefile
  2. 7
      global.h
  3. 113
      lib/usb_cdcacm.c
  4. 523
      lib/vfd_hv518.c
  5. 39
      lib/vfd_hv518.h
  6. 2
      main.c

18
Makefile
Unescape View File

@ -18,7 +18,7 @@
# be silent per default, but 'make V=1' will show all compiler calls.
ifneq ($(V),1)
Q := @
NULL := 2> /dev/null
NULL := 1> /dev/null 2> /dev/null
endif
# the final binary name (without extension)
@ -94,6 +94,9 @@ OOCD ?= openocd
OOCD_INTERFACE ?= stlink-v2
OOCD_TARGET ?= stm32f1x
# which USB CDC ACM port is used bu the device, so we can reset it
ACMPORT = /dev/ttyACM0
# board specific USB DFU bootloader
BOOTLOADERS = STM32duino-bootloader
BOOTLOADER = $(BOOTLOADERS)/STM32F1/binaries/generic_boot20_pa1.bin
@ -129,12 +132,12 @@ list: $(BINARY).list
%.map: %.elf
@# it's generated along with the elf
%.elf: $(OBJ) $(LDSCRIPT) $(LIB_DIR)/lib$(LIBNAME).a
%.elf: $(LDSCRIPT) $(LIB_DIR)/lib$(LIBNAME).a $(OBJ)
$(info compiling $(@))
$(Q)$(LD) $(LDFLAGS) $(ARCH_FLAGS) $(OBJ) $(LDLIBS) -o $(@)
$(Q)size $(@)
%.o: %.c
@#printf " CC $(*).c\n"
$(Q)$(CC) $(CFLAGS) $(ARCH_FLAGS) -o $(@) -c $(<)
clean:
@ -155,9 +158,14 @@ flash-swd: $(BINARY).hex
$(info flashing $(<) using SWD)
$(Q)$(OOCD) --file interface/$(OOCD_INTERFACE).cfg --file target/$(OOCD_TARGET).cfg --command "init" --command "reset init" --command "flash write_image erase $(<)" --command "reset" --command "shutdown" $(NULL)
flash-dfu: $(BINARY).bin
# reset device by setting the data width to 5 bis on the USB CDC ACM port
reset:
$(Q)stty --file /dev/ttyACM0 115200 raw cs5
$(Q)sleep 0.5
flash-dfu: $(BINARY).bin reset
$(info flashing $(<) using DFU)
$(Q)dfu-util --device 1eaf:0003 --cfg 1 --intf 0 --alt 2 --reset --download $(<)
$(Q)dfu-util --device 1eaf:0003 --cfg 1 --intf 0 --alt 2 --reset --download $(<) $(NULL)
.PHONY: clean elf bin hex srec list bootloader flash flash-swd flash-dfu
.SECONDARY:

7
main.h → global.h
Unescape View File

@ -14,6 +14,12 @@
*/
/* Copyright (c) 2016 King Kévin <kingkevin@cuvoodoo.info> */
/* get the length of an array */
#define LENGTH(x) (sizeof(x) / sizeof((x)[0]))
/* system clock frequency in Hz */
#define SYSTEM_CLOCK_FREQ 72000000
/* LED is on pin 11/PA1 */
#define LED_RCC RCC_GPIOA
#define LED_PORT GPIOA
@ -21,3 +27,4 @@
/* default output (i.e. for printf) */
int _write(int file, char *ptr, int len);

113
lib/usb_cdcacm.c
Unescape View File

@ -24,20 +24,23 @@
#include <libopencm3/stm32/rcc.h> // real-time control clock library
#include <libopencm3/stm32/gpio.h> // general purpose input output library
#include <libopencm3/cm3/nvic.h> // interrupt handler
#include <libopencm3/cm3/scb.h> // reset utilities
#include <libopencmsis/core_cm3.h> // Cortex M3 utilities
#include <libopencm3/usb/usbd.h> // USB library
#include <libopencm3/usb/cdc.h> // USB CDC library
#include "usb_cdcacm.h" // USB CDC ACM header and definitions
/* USB descriptor */
/* USB devices descriptor
* as defined in USB CDC specification section 5
*/
static const struct usb_device_descriptor device_descriptor = {
.bLength = USB_DT_DEVICE_SIZE, // the size of this header in bytes, 18
.bDescriptorType = USB_DT_DEVICE, // a value of 1 indicates that this is a device descriptor
.bcdUSB = 0x0200, // this device supports USB 2.0
.bDeviceClass = USB_CLASS_CDC, // use the CDC device class
.bDeviceSubClass = USB_CDC_SUBCLASS_ACM, // use the ACM sub-class
.bDeviceProtocol = USB_CDC_PROTOCOL_NONE, // use no specific protocol
.bDeviceSubClass = 0, // unused
.bDeviceProtocol = 0, // unused
.bMaxPacketSize0 = 64, // packet size for endpoint zero in bytes
.idVendor = 0xc440, // Vendor ID (CuVo...)
.idProduct = 0x0d00, // product ID within the Vendor ID space (...odoo)
@ -77,6 +80,9 @@ static const struct usb_endpoint_descriptor communication_endpoints[] = {{
.bInterval = 255, // the frequency, in number of frames, that we're going to be sending data
}};
/* functional descriptor
* as defined in USB CDC specification section 5.2.3
*/
static const struct {
struct usb_cdc_header_descriptor header;
struct usb_cdc_call_management_descriptor call_mgmt;
@ -90,8 +96,7 @@ static const struct {
.bcdCDC = 0x0110,
},
.call_mgmt = {
.bFunctionLength =
sizeof(struct usb_cdc_call_management_descriptor),
.bFunctionLength = sizeof(struct usb_cdc_call_management_descriptor),
.bDescriptorType = CS_INTERFACE,
.bDescriptorSubtype = USB_CDC_TYPE_CALL_MANAGEMENT,
.bmCapabilities = 0,
@ -112,6 +117,9 @@ static const struct {
},
};
/* communication class interface descriptor
* as defined in USB CDC specification section 5.1.3
*/
static const struct usb_interface_descriptor communication_interface[] = {{
.bLength = USB_DT_INTERFACE_SIZE,
.bDescriptorType = USB_DT_INTERFACE,
@ -129,6 +137,9 @@ static const struct usb_interface_descriptor communication_interface[] = {{
.extralen = sizeof(cdcacm_functional_descriptors),
}};
/* data class interface descriptor
* as defined in USB CDC specification section 5.1.3
*/
static const struct usb_interface_descriptor data_interface[] = {{
.bLength = USB_DT_INTERFACE_SIZE,
.bDescriptorType = USB_DT_INTERFACE,
@ -158,7 +169,7 @@ static const struct usb_config_descriptor config = {
.bNumInterfaces = 2, // the number of interfaces in this configuration
.bConfigurationValue = 1, // the index of this configuration
.iConfiguration = 0, // a string index describing this configuration (zero means not provided)
.bmAttributes = 0x80, // self powered (0<<6), supports remote wakeup (5<<0)
.bmAttributes = 0x80, // self powered (0<<6), supports remote wakeup (0<<5)
.bMaxPower = 0x32, // the maximum amount of current that this device will draw in 2mA units
// end of header
.interface = interfaces, // pointer to an array of interfaces
@ -181,6 +192,9 @@ static usbd_device *usb_device;
static uint8_t rx_buffer[CDCACM_BUFFER] = {0};
static volatile uint8_t rx_i = 0;
static volatile uint8_t rx_used = 0;
static uint8_t tx_buffer[CDCACM_BUFFER] = {0};
static volatile uint8_t tx_i = 0;
static volatile uint8_t tx_used = 0;
/* show the user how much data received over USB is ready */
volatile uint8_t cdcacm_received = 0; // same as rx_used, but since the user can write this variable we don't rely on it
@ -191,30 +205,35 @@ static int cdcacm_control_request(usbd_device *usbd_dev, struct usb_setup_data *
(void)usbd_dev;
switch (req->bRequest) {
case USB_CDC_REQ_SET_CONTROL_LINE_STATE: {
/*
* This Linux cdc_acm driver requires this to be implemented
* even though it's optional in the CDC spec, and we don't
* advertise it in the ACM functional descriptor.
*/
char local_buf[10];
struct usb_cdc_notification *notif = (void *)local_buf;
/* We echo signals back to host as notification. */
notif->bmRequestType = 0xA1;
notif->bNotification = USB_CDC_NOTIFY_SERIAL_STATE;
notif->wValue = 0;
notif->wIndex = 0;
notif->wLength = 2;
local_buf[8] = req->wValue & 3;
local_buf[9] = 0;
// usbd_ep_write_packet(0x83, buf, 10);
return 1;
case USB_CDC_REQ_SET_CONTROL_LINE_STATE: {
/*
bool dtr = (req->wValue & (1 << 0)) ? true : false;
bool rts = (req->wValue & (1 << 1)) ? true : false;
*/
/* this Linux cdc_acm driver requires this to be implemented
* even though it's optional in the CDC spec, and we don't
* advertise it in the ACM functional descriptor.
*/
return 1;
}
case USB_CDC_REQ_SET_LINE_CODING:
if (*len < sizeof(struct usb_cdc_line_coding))
case USB_CDC_REQ_SET_LINE_CODING:
// ignore if length is wrong
if (*len < sizeof(struct usb_cdc_line_coding)) {
return 0;
}
// get the line coding
struct usb_cdc_line_coding *coding = (struct usb_cdc_line_coding *)*buf;
/* reset device is the data bits is set to 5
* this is used to allowing rebooting the device in DFU mode for reflashing
* to reset the device from the host you can use stty --file /dev/ttyACM0 115200 raw cs5
*/
if (coding->bDataBits==5) {
scb_reset_system(); // reset device
while (true); // wait for the reset to happen
}
return 1;
default:
return 0;
return 1;
}
return 0;
}
@ -238,13 +257,35 @@ static void cdcacm_data_rx_cb(usbd_device *usbd_dev, uint8_t ep)
}
}
static void cdcacm_data_tx_cb(usbd_device *usbd_dev, uint8_t ep)
{
(void)ep;
(void)usbd_dev;
char usb_data[64] = {0}; // buffer to send data
uint16_t usb_length = 0; // length of transmitted data
/* transmit data */
if (tx_used) { // copy received data
for (usb_length=0; usb_length<sizeof(usb_data) && usb_length<tx_used; usb_length++) { // only until buffer is full
usb_data[usb_length] = tx_buffer[(tx_i+usb_length)%sizeof(tx_buffer)]; // put data in transmit data
}
// this could lead to a lock down
// while(usbd_ep_write_packet(usb_device, 0x82, usb_data, usb_length)==0);
// this is less critical
uint8_t transmitted = usbd_ep_write_packet(usb_device, 0x82, usb_data, usb_length); // try to transmit data
tx_i = (tx_i+transmitted)%sizeof(rx_buffer); // update location on buffer
tx_used -= transmitted; // update used size
}
}
static void cdcacm_set_config(usbd_device *usbd_dev, uint16_t wValue)
{
(void)wValue;
(void)usbd_dev;
usbd_ep_setup(usbd_dev, 0x01, USB_ENDPOINT_ATTR_BULK, 64, cdcacm_data_rx_cb);
usbd_ep_setup(usbd_dev, 0x82, USB_ENDPOINT_ATTR_BULK, 64, NULL);
usbd_ep_setup(usbd_dev, 0x82, USB_ENDPOINT_ATTR_BULK, 64, cdcacm_data_tx_cb);
usbd_ep_setup(usbd_dev, 0x83, USB_ENDPOINT_ATTR_INTERRUPT, 16, NULL);
usbd_register_control_callback( usbd_dev, USB_REQ_TYPE_CLASS | USB_REQ_TYPE_INTERFACE, USB_REQ_TYPE_TYPE | USB_REQ_TYPE_RECIPIENT, cdcacm_control_request);
@ -272,13 +313,16 @@ void cdcacm_setup(void)
rx_i = 0;
rx_used = 0;
cdcacm_received = 0;
/* start sending */
usbd_ep_write_packet(usb_device, 0x82, NULL, 0);
}
/* get character from USB CDC ACM (blocking) */
char cdcacm_getchar(void)
{
while (!rx_used) { // idle until data is available
__WFI(); // sleep until interrupt;
__WFI(); // sleep until interrupt (not sure if it's a good idea here
}
char to_return = rx_buffer[rx_i]; // get the next available character
rx_i = (rx_i+1)%sizeof(rx_buffer); // update used buffer
@ -290,7 +334,14 @@ char cdcacm_getchar(void)
/* put character on USB CDC ACM (blocking) */
void cdcacm_putchar(char c)
{
while(usbd_ep_write_packet(usb_device, 0x82, &c, 1)==0); // sending single characters at a time isn't very optimal, but I didn't find a way to do it USB request based
if (tx_used<sizeof(tx_buffer)) { // buffer not full
tx_buffer[(tx_i+tx_used)%sizeof(tx_buffer)] = c; // put character in buffer
tx_used++; // update used buffer
} else { // buffer full
tx_i = (tx_i+1)%sizeof(tx_buffer); // shift start
tx_buffer[(tx_i+tx_used)%sizeof(tx_buffer)] = c; // overwrite old data
}
usbd_ep_write_packet(usb_device, 0x82, NULL, 0); // trigger tx (not sure why cdcacm_data_tx_cb doesn't work else)
}
void usb_wakeup_isr(void) {

523
lib/vfd_hv518.c
Unescape View File

@ -0,0 +1,523 @@
/* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
/* Copyright (c) 2016 King Kévin <kingkevin@cuvoodoo.info> */
/* this library is used to drive the vacuum fluorescent display extracted from a Samsung SER-6500 cash register
* it uses three chained supertex HV518 shift register VFD drivers */
/* standard libraries */
#include <stdint.h> // standard integer types
#include <stdlib.h> // general utilities
/* STM32 (including CM3) libraries */
#include <libopencm3/stm32/rcc.h> // real-time control clock library
#include <libopencm3/stm32/gpio.h> // general purpose input output library
#include <libopencm3/stm32/spi.h> // SPI library
#include <libopencm3/stm32/timer.h> // timer library
#include <libopencm3/cm3/nvic.h> // interrupt handler
#include "global.h" // global definitions
#include "vfd_hv518.h" // VFD library API
/* supertex HV518 VFD driver pins */
/* port on which the pins to control the supertex HV518 VFD driver are
* we use port A because of the SPI interface */
#define VFD_PORT GPIOA
#define VFD_PORT_RCC RCC_GPIOA
/* SPI port to use */
#define VFD_SPI SPI1
#if (VFD_SPI==SPI1)
#define VFD_SPI_RCC RCC_SPI1
#define VFD_SPI_IRQ NVIC_SPI1_IRQ
#elif (VFD_SPI==SPI2)
#define VFD_SPI_RCC RCC_SPI2
#define VFD_SPI_IRQ NVIC_SPI2_IRQ
#endif
/* strobe pin to enable high voltage output
* high voltage is output on low
* drive using a GPIO PA6 (normally MISO) */
#define VFD_STR GPIO6
/* latch enable pin
* store the shifted data on low
* output the parallel data on high
* use GPIO (PA4) (NSS does not work as SS) */
#define VFD_NLE GPIO4
/* clock signal
* drive using SPI SCK (PA5) */
#define VFD_CLK GPIO_SPI1_SCK
/* data input, where the data is shifted to
* drive using SPI MOSI (PA7) */
#define VFD_DIN GPIO_SPI1_MOSI
/* timer for automatic refresh */
#define VFD_TIMER TIM2
#if (VFD_TIMER==TIM2)
#define VFD_TIMER_RCC RCC_TIM2
#define VFD_TIMER_IRQ NVIC_TIM2_IRQ
#elif (VFD_TIMER==TIM3)
#define VFD_TIMER_RCC RCC_TIM3
#define VFD_TIMER_IRQ NVIC_TIM3_IRQ
#elif (VFD_TIMER==TIM4)
#define VFD_TIMER_RCC RCC_TIM4
#define VFD_TIMER_IRQ NVIC_TIM4_IRQ
#elif (VFD_TIMER==TIM5)
#define VFD_TIMER_RCC RCC_TIM5
#define VFD_TIMER_IRQ NVIC_TIM5_IRQ
#endif
/* ASCII characters encoded for 7 segments display
* 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, // ~
};
/* font for the 5x7 dot matrix display
* from http://sunge.awardspace.com/glcd-sd/node4.html
* first value is left-most line
* LSB is top dot, MSB is not used
*/
static const uint8_t font5x7[][5] = {
{0x00, 0x00, 0x00, 0x00, 0x00}, // (space)
{0x00, 0x00, 0x5F, 0x00, 0x00}, // !
{0x00, 0x07, 0x00, 0x07, 0x00}, // "
{0x14, 0x7F, 0x14, 0x7F, 0x14}, // #
{0x24, 0x2A, 0x7F, 0x2A, 0x12}, // $
{0x23, 0x13, 0x08, 0x64, 0x62}, // %
{0x36, 0x49, 0x55, 0x22, 0x50}, // &
{0x00, 0x05, 0x03, 0x00, 0x00}, // '
{0x00, 0x1C, 0x22, 0x41, 0x00}, // (
{0x00, 0x41, 0x22, 0x1C, 0x00}, // )
{0x08, 0x2A, 0x1C, 0x2A, 0x08}, // *
{0x08, 0x08, 0x3E, 0x08, 0x08}, // +
{0x00, 0x50, 0x30, 0x00, 0x00}, // ,
{0x08, 0x08, 0x08, 0x08, 0x08}, // -
{0x00, 0x60, 0x60, 0x00, 0x00}, // .
{0x20, 0x10, 0x08, 0x04, 0x02}, // /
{0x3E, 0x51, 0x49, 0x45, 0x3E}, // 0
{0x00, 0x42, 0x7F, 0x40, 0x00}, // 1
{0x42, 0x61, 0x51, 0x49, 0x46}, // 2
{0x21, 0x41, 0x45, 0x4B, 0x31}, // 3
{0x18, 0x14, 0x12, 0x7F, 0x10}, // 4
{0x27, 0x45, 0x45, 0x45, 0x39}, // 5
{0x3C, 0x4A, 0x49, 0x49, 0x30}, // 6
{0x01, 0x71, 0x09, 0x05, 0x03}, // 7
{0x36, 0x49, 0x49, 0x49, 0x36}, // 8
{0x06, 0x49, 0x49, 0x29, 0x1E}, // 9
{0x00, 0x36, 0x36, 0x00, 0x00}, // :
{0x00, 0x56, 0x36, 0x00, 0x00}, // ;
{0x00, 0x08, 0x14, 0x22, 0x41}, // <
{0x14, 0x14, 0x14, 0x14, 0x14}, // =
{0x41, 0x22, 0x14, 0x08, 0x00}, // >
{0x02, 0x01, 0x51, 0x09, 0x06}, // ?
{0x32, 0x49, 0x79, 0x41, 0x3E}, // @
{0x7E, 0x11, 0x11, 0x11, 0x7E}, // A
{0x7F, 0x49, 0x49, 0x49, 0x36}, // B
{0x3E, 0x41, 0x41, 0x41, 0x22}, // C
{0x7F, 0x41, 0x41, 0x22, 0x1C}, // D
{0x7F, 0x49, 0x49, 0x49, 0x41}, // E
{0x7F, 0x09, 0x09, 0x01, 0x01}, // F
{0x3E, 0x41, 0x41, 0x51, 0x32}, // G
{0x7F, 0x08, 0x08, 0x08, 0x7F}, // H
{0x00, 0x41, 0x7F, 0x41, 0x00}, // I
{0x20, 0x40, 0x41, 0x3F, 0x01}, // J
{0x7F, 0x08, 0x14, 0x22, 0x41}, // K
{0x7F, 0x40, 0x40, 0x40, 0x40}, // L
{0x7F, 0x02, 0x04, 0x02, 0x7F}, // M
{0x7F, 0x04, 0x08, 0x10, 0x7F}, // N
{0x3E, 0x41, 0x41, 0x41, 0x3E}, // O
{0x7F, 0x09, 0x09, 0x09, 0x06}, // P
{0x3E, 0x41, 0x51, 0x21, 0x5E}, // Q
{0x7F, 0x09, 0x19, 0x29, 0x46}, // R
{0x46, 0x49, 0x49, 0x49, 0x31}, // S
{0x01, 0x01, 0x7F, 0x01, 0x01}, // T
{0x3F, 0x40, 0x40, 0x40, 0x3F}, // U
{0x1F, 0x20, 0x40, 0x20, 0x1F}, // V
{0x7F, 0x20, 0x18, 0x20, 0x7F}, // W
{0x63, 0x14, 0x08, 0x14, 0x63}, // X
{0x03, 0x04, 0x78, 0x04, 0x03}, // Y
{0x61, 0x51, 0x49, 0x45, 0x43}, // Z
{0x00, 0x00, 0x7F, 0x41, 0x41}, // [
{0x02, 0x04, 0x08, 0x10, 0x20}, // '\'
{0x41, 0x41, 0x7F, 0x00, 0x00}, // ]
{0x04, 0x02, 0x01, 0x02, 0x04}, // ^
{0x40, 0x40, 0x40, 0x40, 0x40}, // _
{0x00, 0x01, 0x02, 0x04, 0x00}, // `
{0x20, 0x54, 0x54, 0x54, 0x78}, // a
{0x7F, 0x48, 0x44, 0x44, 0x38}, // b
{0x38, 0x44, 0x44, 0x44, 0x20}, // c
{0x38, 0x44, 0x44, 0x48, 0x7F}, // d
{0x38, 0x54, 0x54, 0x54, 0x18}, // e
{0x08, 0x7E, 0x09, 0x01, 0x02}, // f
{0x08, 0x14, 0x54, 0x54, 0x3C}, // g
{0x7F, 0x08, 0x04, 0x04, 0x78}, // h
{0x00, 0x44, 0x7D, 0x40, 0x00}, // i
{0x20, 0x40, 0x44, 0x3D, 0x00}, // j
{0x00, 0x7F, 0x10, 0x28, 0x44}, // k
{0x00, 0x41, 0x7F, 0x40, 0x00}, // l
{0x7C, 0x04, 0x18, 0x04, 0x78}, // m
{0x7C, 0x08, 0x04, 0x04, 0x78}, // n
{0x38, 0x44, 0x44, 0x44, 0x38}, // o
{0x7C, 0x14, 0x14, 0x14, 0x08}, // p
{0x08, 0x14, 0x14, 0x18, 0x7C}, // q
{0x7C, 0x08, 0x04, 0x04, 0x08}, // r
{0x48, 0x54, 0x54, 0x54, 0x20}, // s
{0x04, 0x3F, 0x44, 0x40, 0x20}, // t
{0x3C, 0x40, 0x40, 0x20, 0x7C}, // u
{0x1C, 0x20, 0x40, 0x20, 0x1C}, // v
{0x3C, 0x40, 0x30, 0x40, 0x3C}, // w
{0x44, 0x28, 0x10, 0x28, 0x44}, // x
{0x0C, 0x50, 0x50, 0x50, 0x3C}, // y
{0x44, 0x64, 0x54, 0x4C, 0x44}, // z
{0x00, 0x08, 0x36, 0x41, 0x00}, // {
{0x00, 0x00, 0x7F, 0x00, 0x00}, // |
{0x00, 0x41, 0x36, 0x08, 0x00}, // }
{0b00001000, 0b00000100, 0b00001100, 0b00001000, 0b00000100} // ~
};
/* pictures for the 5x7 dot matrix display
* first value is left-most line
* LSB is top dot, MSB is not used
*/
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
};
/* the 32 bits values to be shifted out to the VFD driver
* split into 16 bit for SPI transfer
* since the bits for digits and matrix are independent, they can be combined
* we have more matrix (12) than digits (10)
*/
static uint16_t driver_data[VFD_MATRIX][VFD_DRIVERS*2] = {0};
static volatile uint8_t spi_i = 0; // which driver data is being transmitted
static volatile uint8_t vfd_grid = 0; // which grid/part to activate (single digits and matrix can be combined)
static const uint32_t digit_mask = 0x00fffff0; // the bits used for selecting then digit and 7 segment anodes (for the second driver)
/* set digit <nb> to ASCII character <c>
* use the MSB of <c> to enable the dot */
void vfd_digit(uint8_t nb, char c)
{
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
/* encode segment
* here the bit order (classic 7 segment + underline and dot)
* 3_
* 8|9_|4
* 7|6_|5.1
* 0_2,
* */
if (false) { // add the underline (not encoded)
digit_data |= (1<<(14));
}
if (c&0x80) { // add the dot (encoded in the 8th bit)
digit_data |= (1<<(15));
}
if (false) { // add the comma (not encoded)
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
}
}
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
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)
}
/* set dot matrix <nb> to ASCII character <c>
* non ASCII characters are used for pictures */
void vfd_matrix(uint8_t nb, char c)
{
// check the matrix exists
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);
} else {
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;
}
} 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
// 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;
}
}
/* clear VFD display */
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++) {
driver_data[i][j] = 0;
}
}
}
/* test VFD display (light up all anodes) */
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++) {
driver_data[i][j] = ~0;
}
}
}
/* switch VFD display on */
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
}
/* switch VFD display off */
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
}
/* setup VFD */
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
/* setup SPI to transmit data */
rcc_periph_clock_enable(VFD_SPI_RCC); // enable SPI clock
gpio_set_mode(VFD_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_PORT, GPIO_MODE_OUTPUT_50_MHZ, GPIO_CNF_OUTPUT_ALTFN_PUSHPULL, VFD_DIN); // set VFD pin to alternative function push-pull
spi_reset(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)
* - clock idle high polarity
* - data is valid on rising edge (second clock phase)
* - 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_set_bidirectional_transmit_only_mode(VFD_SPI); // only use MOSI to transmit
spi_set_unidirectional_mode(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
nvic_enable_irq(VFD_SPI_IRQ); // enable SPI interrupt
spi_enable(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
timer_reset(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
vfd_clear(); // initialize values
}
#if (VFD_SPI==SPI1)
void spi1_isr(void)
#elif (VFD_SPI==SPI2)
void spi2_isr(void)
#endif
{
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
} 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
}
}
}
#if (VFD_TIMER==TIM2)
void tim2_isr(void)
#elif (VFD_TIMER==TIM3)
void tim3_isr(void)
#elif (VFD_TIMER==TIM4)
void tim4_isr(void)
#elif (VFD_TIMER==TIM5)
void tim5_isr(void)
#endif
{
if (timer_get_flag(VFD_TIMER, TIM_SR_UIF)) { // overflow even happened
timer_clear_flag(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
}
}

39
lib/vfd_hv518.h
Unescape View File

@ -0,0 +1,39 @@
/* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
/* Copyright (c) 2016 King Kévin <kingkevin@cuvoodoo.info> */
/* this library is used to drive the vacuum fluorescent display extracted from a Samsung SER-6500 cash register
* it uses three chained supertex HV518 shift register VFD drivers */
/* the number of blocks available on the VFD */
#define VFD_DRIVERS 3
#define VFD_DIGITS 10
#define VFD_MATRIX 12
/* set digit <nb> to ASCII character <c>
* use the MSB of <c> to enable the dot */
void vfd_digit(uint8_t nb, char c);
/* set dot matrix <nb> to ASCII character <c>
* non ASCII characters are used for pictures */
void vfd_matrix(uint8_t nb, char c);
/* clear VFD display */
void vfd_clear(void);
/* test VFD display (light up all anodes) */
void vfd_test(void);
/* transmit every digit and matrix */
void vfd_on(void);
/* switch VFD display off */
void vfd_off(void);
/* setup VFD */
void vfd_setup(void);

2
main.c
Unescape View File

@ -28,7 +28,7 @@
#include <libopencmsis/core_cm3.h> // Cortex M3 utilities
/* own libraries */
#include "main.h" // board definitions
#include "global.h" // board definitions
#include "usart.h" // USART utilities
#include "usb_cdcacm.h" // USB CDC ACM utilities

Write Preview
Loading…
Cancel
Save