not sure - updated things

spiricom committed 6 years ago

Commit a80af551 parent e586373112 files · +21948 −29863Browse files

Unified · Split

112 files

.DS_Store +0 −0
LEAF/.DS_Store +0 −0
LEAF/Inc/.DS_Store +0 −0
LEAF/Inc/MIDI_application.h +50 −0
LEAF/Inc/adc.h +58 −0
LEAF/Inc/audiostream.h +93 −0
LEAF/Inc/bdma.h +56 −0
LEAF/Inc/bsp_driver_sd.h +84 −0
LEAF/Inc/codec.h +162 −0
LEAF/Inc/custom_fonts.h +6894 −0
LEAF/Inc/debug.h +56 −0
LEAF/Inc/dma.h +56 −0
LEAF/Inc/eeprom.h +125 −0
LEAF/Inc/fatfs.h +49 −0
LEAF/Inc/fatfs_platform.h +26 −0
LEAF/Inc/ffconf.h +269 −0
LEAF/Inc/fmc.h +60 −0
LEAF/Inc/gfx.h +120 −0
LEAF/Inc/gfx_font.h +24 −0
LEAF/Inc/gpio.h +57 −0
LEAF/Inc/i2c.h +60 −0
LEAF/Inc/leaf-analysis.h +0 −258
LEAF/Inc/leaf-delay.h +0 −221
LEAF/Inc/leaf-distortion.h +0 −148
LEAF/Inc/leaf-dynamics.h +0 −90
LEAF/Inc/leaf-effects.h +0 −316
LEAF/Inc/leaf-electrical.h +0 −95
LEAF/Inc/leaf-envelopes.h +0 −154
LEAF/Inc/leaf-filters.h +0 −358
LEAF/Inc/leaf-global.h +0 −39
LEAF/Inc/leaf-instruments.h +0 −201
LEAF/Inc/leaf-math.h +0 −179
LEAF/Inc/leaf-mempool.h +0 −127
LEAF/Inc/leaf-midi.h +0 −133
LEAF/Inc/leaf-oscillators.h +0 −208
LEAF/Inc/leaf-physical.h +0 −251
LEAF/Inc/leaf-reverb.h +0 −167
LEAF/Inc/leaf-sampling.h +0 −176
LEAF/Inc/leaf-tables.h +0 −100
LEAF/Inc/main.h +81 −0
LEAF/Inc/oled.h +90 −0
LEAF/Inc/rng.h +58 −0
LEAF/Inc/sai.h +59 −0
LEAF/Inc/sd_diskio.h +45 −0
LEAF/Inc/sdmmc.h +58 −0
LEAF/Inc/sfx.h +177 −0
LEAF/Inc/ssd1306.h +127 −0
LEAF/Inc/stm32h7xx_hal_conf.h +493 −0
LEAF/Inc/stm32h7xx_it.h +81 −0
LEAF/Inc/sys.h +56 −0
LEAF/Inc/tim.h +62 −0
LEAF/Inc/tunings.h +20 −0
LEAF/Inc/ui.h +116 −0
LEAF/Inc/usb_host.h +94 −0
LEAF/Inc/usbh_MIDI.h +211 −0
LEAF/Inc/usbh_conf.h +199 −0
LEAF/Inc/usbh_platform.h +44 −0
LEAF/Src/.DS_Store +0 −0
LEAF/Src/MIDI_application.c +192 −0
LEAF/Src/adc.c +239 −0
LEAF/Src/audiostream.c +518 −0
LEAF/Src/bdma.c +66 −0
LEAF/Src/bsp_driver_sd.c +307 −0
LEAF/Src/codec.c +125 −0
LEAF/Src/debug.c +37 −0
LEAF/Src/dma.c +72 −0
LEAF/Src/eeprom.c +718 −0
LEAF/Src/fatfs.c +56 −0
LEAF/Src/fatfs_platform.c +31 −0
LEAF/Src/fmc.c +281 −0
LEAF/Src/gfx.c +983 −0
LEAF/Src/gfx_font.c +281 −0
LEAF/Src/gpio.c +176 −0
LEAF/Src/i2c.c +242 −0
LEAF/Src/leaf-analysis.c +0 −946
LEAF/Src/leaf-delay.c +0 −928
LEAF/Src/leaf-distortion.c +0 −587
LEAF/Src/leaf-dynamics.c +0 −221
LEAF/Src/leaf-effects.c +0 −1676
LEAF/Src/leaf-electrical.c +0 −551
LEAF/Src/leaf-envelopes.c +0 −760
LEAF/Src/leaf-filters.c +0 −1243
LEAF/Src/leaf-instruments.c +0 −706
LEAF/Src/leaf-math.c +0 −485
LEAF/Src/leaf-mempool.c +0 −397
LEAF/Src/leaf-midi.c +0 −681
LEAF/Src/leaf-oscillators.c +0 −863
LEAF/Src/leaf-physical.c +0 −747
LEAF/Src/leaf-reverb.c +0 −925
LEAF/Src/leaf-sampling.c +0 −834
LEAF/Src/leaf-tables.c +0 −14042
LEAF/Src/leaf.c +0 −54
LEAF/Src/main.c +603 −0
LEAF/Src/oled.c +505 −0
LEAF/Src/rng.c +78 −0
LEAF/Src/sai.c +227 −0
LEAF/Src/sd_diskio.c +261 −0
LEAF/Src/sdmmc.c +127 −0
LEAF/Src/sfx.c +1629 −0
LEAF/Src/ssd1306.c +299 −0
LEAF/Src/stm32h7xx_hal_msp.c +83 −0
LEAF/Src/stm32h7xx_it.c +378 −0
LEAF/Src/sys.c +37 −0
LEAF/Src/syscalls.c +204 −0
LEAF/Src/system_stm32h7xx.c +365 −0
LEAF/Src/tim.c +232 −0
LEAF/Src/tunings.c +229 −0
LEAF/Src/ui.c +679 −0
LEAF/Src/usb_host.c +178 −0
LEAF/Src/usbh_MIDI.c +542 −0
LEAF/Src/usbh_conf.c +548 −0
LEAF/Src/usbh_platform.c +54 −0

.DS_Store+0−0

Binary file not shown.

LEAF/.DS_Store+0−0

Binary file not shown.

LEAF/Inc/.DS_Store+0−0

Binary file not shown.

LEAF/Inc/MIDI_application.h+50−0

@@ -0,0 +1,50 @@
	1	/*
	2	* MIDI_application.h
	3	* Created on: 6 d�c. 2014
	4	* Author: Xavier Halgand
	5	*
	6	* Modified on: 9/12/16 by C.P. to handle the MIDI_IDLE state properly, and
	7	* added required code to be compatible with "NucleoSynth"
	8	*
	9	*/
	10
	11	#ifndef MIDI_APPLICATION_H_
	12	#define MIDI_APPLICATION_H_
	13
	14	/* Includes ------------------------------------------------------------------*/
	15
	16	#include "stdio.h"
	17	#include "usbh_core.h"
	18	#include "usbh_MIDI.h"
	19	#include "main.h"
	20
	21	#include <math.h>
	22	#include <stdint.h>
	23	#include <stdbool.h>
	24
	25	/------------------------------------------------------------------------------/
	26	typedef enum
	27	{
	28	MIDI_APPLICATION_IDLE = 0,
	29	MIDI_APPLICATION_START,
	30	MIDI_APPLICATION_READY,
	31	MIDI_APPLICATION_RUNNING,
	32	MIDI_APPLICATION_DISCONNECT
	33	}
	34	MIDI_ApplicationTypeDef;
	35
	36
	37	#define RX_BUFF_SIZE 64 /* Max Received data 64 bytes */
	38
	39	extern uint8_t MIDI_RX_Buffer[RX_BUFF_SIZE];// __ATTR_RAM_D2; // MIDI reception buffer
	40	extern uint8_t CCs[128];
	41
	42	extern uint8_t MIDIStartOfFrame;
	43
	44	/* Exported functions ------------------------------------------------------- */
	45	void MIDI_Application(void);
	46	void LocalMidiHandler(uint8_t param, uint8_t data);
	47	void ProcessReceivedMidiDatas(uint32_t myLength);
	48
	49	/------------------------------------------------------------------------------/
	50	#endif /* MIDI_APPLICATION_H_ */

LEAF/Inc/adc.h+58−0

@@ -0,0 +1,58 @@
	1	/**
	2	******************************************************************************
	3	* File Name : ADC.h
	4	* Description : This file provides code for the configuration
	5	* of the ADC instances.
	6	******************************************************************************
	7	* @attention
	8	*
	9	* <h2><center>© Copyright (c) 2020 STMicroelectronics.
	10	* All rights reserved.</center></h2>
	11	*
	12	* This software component is licensed by ST under Ultimate Liberty license
	13	* SLA0044, the "License"; You may not use this file except in compliance with
	14	* the License. You may obtain a copy of the License at:
	15	* www.st.com/SLA0044
	16	*
	17	******************************************************************************
	18	*/
	19	/* Define to prevent recursive inclusion -------------------------------------*/
	20	#ifndef __adc_H
	21	#define __adc_H
	22	#ifdef __cplusplus
	23	extern "C" {
	24	#endif
	25
	26	/* Includes ------------------------------------------------------------------*/
	27	#include "main.h"
	28
	29	/* USER CODE BEGIN Includes */
	30
	31	/* USER CODE END Includes */
	32
	33	extern ADC_HandleTypeDef hadc1;
	34
	35	/* USER CODE BEGIN Private defines */
	36
	37	/* USER CODE END Private defines */
	38
	39	void MX_ADC1_Init(void);
	40
	41	/* USER CODE BEGIN Prototypes */
	42
	43	/* USER CODE END Prototypes */
	44
	45	#ifdef __cplusplus
	46	}
	47	#endif
	48	#endif /__ adc_H /
	49
	50	/**
	51	* @}
	52	*/
	53
	54	/**
	55	* @}
	56	*/
	57
	58	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

LEAF/Inc/audiostream.h+93−0

@@ -0,0 +1,93 @@
	1	/**
	2	******************************************************************************
	3	* @file Audio_playback_and_record/inc/waveplayer.h
	4	* @author MCD Application Team
	5	* @version V1.1.0
	6	* @date 26-June-2014
	7	* @brief Header for waveplayer.c module.
	8	******************************************************************************
	9	* @attention
	10	*
	11	* <h2><center>© COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
	12	*
	13	* Licensed under MCD-ST Liberty SW License Agreement V2, (the "License");
	14	* You may not use this file except in compliance with the License.
	15	* You may obtain a copy of the License at:
	16	*
	17	* http://www.st.com/software_license_agreement_liberty_v2
	18	*
	19	* Unless required by applicable law or agreed to in writing, software
	20	* distributed under the License is distributed on an "AS IS" BASIS,
	21	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	22	* See the License for the specific language governing permissions and
	23	* limitations under the License.
	24	*
	25	******************************************************************************
	26	*/
	27	/* Define to prevent recursive inclusion -------------------------------------*/
	28	#ifndef __AUDIOSTREAM_H
	29	#define __AUDIOSTREAM_H
	30
	31	/* Includes ------------------------------------------------------------------*/
	32	#include "stm32h7xx_hal.h"
	33	#include "leaf.h"
	34	#include "main.h"
	35
	36	#define AUDIO_FRAME_SIZE 128
	37	#define HALF_BUFFER_SIZE AUDIO_FRAME_SIZE * 2 //number of samples per half of the "double-buffer" (twice the audio frame size because there are interleaved samples for both left and right channels)
	38	#define AUDIO_BUFFER_SIZE AUDIO_FRAME_SIZE * 4 //number of samples in the whole data structure (four times the audio frame size because of stereo and also double-buffering/ping-ponging)
	39
	40
	41	extern int32_t audioOutBuffer[AUDIO_BUFFER_SIZE];
	42	extern int32_t audioInBuffer[AUDIO_BUFFER_SIZE];
	43	extern tMempool smallPool;
	44	extern tMempool largePool;
	45	extern uint8_t codecReady;
	46	extern float sample;
	47	extern float rightOut;
	48	extern float rightIn;
	49	extern tRamp adc[6];
	50	extern float smoothedADC[6];
	51	extern float audioDisplayBuffer[128];
	52	extern uint8_t displayBufferIndex;
	53
	54	/* Exported types ------------------------------------------------------------*/
	55	typedef enum
	56	{
	57	BUFFER_OFFSET_NONE = 0,
	58	BUFFER_OFFSET_HALF,
	59	BUFFER_OFFSET_FULL,
	60	}BUFFER_StateTypeDef;
	61
	62	#ifdef SAMPLERATE96K
	63	#define SAMPLE_RATE 96000.f
	64	#else
	65	#define SAMPLE_RATE 48000.f
	66	#endif
	67
	68	typedef enum BOOL {
	69	FALSE = 0,
	70	TRUE
	71	} BOOL;
	72
	73	#define INV_SAMPLE_RATE 1.f/SAMPLE_RATE
	74	#define SAMPLE_RATE_MS (SAMPLE_RATE / 1000.f)
	75	#define INV_SR_MS 1.f/SAMPLE_RATE_MS
	76	#define SAMPLE_RATE_DIV_PARAMS SAMPLE_RATE / 3
	77	#define SAMPLE_RATE_DIV_PARAMS_MS (SAMPLE_RATE_DIV_PARAMS / 1000.f)
	78	#define INV_SR_DIV_PARAMS_MS 1.f/SAMPLE_RATE_DIV_PARAMS_MS
	79
	80	/* Exported macro ------------------------------------------------------------*/
	81	/* Exported functions ------------------------------------------------------- */
	82	void audioInit(I2C_HandleTypeDef* hi2c, SAI_HandleTypeDef* hsaiOut, SAI_HandleTypeDef* hsaiIn);
	83
	84	void initFunctionPointers(void);
	85
	86	void audioFrame(uint16_t buffer_offset);
	87
	88	void DMA1_TransferCpltCallback(DMA_HandleTypeDef *hdma);
	89	void DMA1_HalfTransferCpltCallback(DMA_HandleTypeDef *hdma);
	90
	91	#endif /* __AUDIOSTREAM_H */
	92
	93	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

LEAF/Inc/bdma.h+56−0

@@ -0,0 +1,56 @@
	1	/**
	2	******************************************************************************
	3	* File Name : dma.h
	4	* Description : This file contains all the function prototypes for
	5	* the dma.c file
	6	******************************************************************************
	7	* @attention
	8	*
	9	* <h2><center>© Copyright (c) 2020 STMicroelectronics.
	10	* All rights reserved.</center></h2>
	11	*
	12	* This software component is licensed by ST under Ultimate Liberty license
	13	* SLA0044, the "License"; You may not use this file except in compliance with
	14	* the License. You may obtain a copy of the License at:
	15	* www.st.com/SLA0044
	16	*
	17	******************************************************************************
	18	*/
	19	/* Define to prevent recursive inclusion -------------------------------------*/
	20	#ifndef __bdma_H
	21	#define __bdma_H
	22
	23	#ifdef __cplusplus
	24	extern "C" {
	25	#endif
	26
	27	/* Includes ------------------------------------------------------------------*/
	28	#include "main.h"
	29
	30	/* DMA memory to memory transfer handles -------------------------------------*/
	31
	32	/* USER CODE BEGIN Includes */
	33
	34	/* USER CODE END Includes */
	35
	36	/* USER CODE BEGIN Private defines */
	37
	38	/* USER CODE END Private defines */
	39
	40	void MX_BDMA_Init(void);
	41
	42	/* USER CODE BEGIN Prototypes */
	43
	44	/* USER CODE END Prototypes */
	45
	46	#ifdef __cplusplus
	47	}
	48	#endif
	49
	50	#endif /* __bdma_H */
	51
	52	/**
	53	* @}
	54	*/
	55
	56	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

LEAF/Inc/bsp_driver_sd.h+84−0

@@ -0,0 +1,84 @@
	1	/**
	2	******************************************************************************
	3	* @file bsp_driver_sd.h (based on stm32h743i_eval_sd.h)
	4	* @brief This file contains the common defines and functions prototypes for
	5	* the bsp_driver_sd.c driver.
	6	******************************************************************************
	7	* @attention
	8	*
	9	* <h2><center>© Copyright (c) 2020 STMicroelectronics.
	10	* All rights reserved.</center></h2>
	11	*
	12	* This software component is licensed by ST under Ultimate Liberty license
	13	* SLA0044, the "License"; You may not use this file except in compliance with
	14	* the License. You may obtain a copy of the License at:
	15	* www.st.com/SLA0044
	16	*
	17	******************************************************************************
	18	*/
	19
	20	/* Define to prevent recursive inclusion -------------------------------------*/
	21	#ifndef __STM32H7_SD_H
	22	#define __STM32H7_SD_H
	23
	24	#ifdef __cplusplus
	25	extern "C" {
	26	#endif
	27
	28	/* Includes ------------------------------------------------------------------*/
	29	#include "stm32h7xx_hal.h"
	30	#include "fatfs_platform.h"
	31
	32	/* Exported types --------------------------------------------------------*/
	33	/**
	34	* @brief SD Card information structure
	35	*/
	36	#define BSP_SD_CardInfo HAL_SD_CardInfoTypeDef
	37
	38	/* Exported constants --------------------------------------------------------*/
	39	/**
	40	* @brief SD status structure definition
	41	*/
	42	#define MSD_OK ((uint8_t)0x00)
	43	#define MSD_ERROR ((uint8_t)0x01)
	44	#define MSD_ERROR_SD_NOT_PRESENT ((uint8_t)0x02)
	45
	46	/**
	47	* @brief SD transfer state definition
	48	*/
	49	#define SD_TRANSFER_OK ((uint8_t)0x00)
	50	#define SD_TRANSFER_BUSY ((uint8_t)0x01)
	51
	52	#define SD_PRESENT ((uint8_t)0x01)
	53	#define SD_NOT_PRESENT ((uint8_t)0x00)
	54	#define SD_DATATIMEOUT ((uint32_t)100000000)
	55
	56	/* USER CODE BEGIN BSP_H_CODE */
	57	#define SD_DetectIRQHandler() HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_8)
	58
	59	/* Exported functions --------------------------------------------------------*/
	60	uint8_t BSP_SD_Init(void);
	61	uint8_t BSP_SD_ITConfig(void);
	62	uint8_t BSP_SD_ReadBlocks(uint32_t *pData, uint32_t ReadAddr, uint32_t NumOfBlocks, uint32_t Timeout);
	63	uint8_t BSP_SD_WriteBlocks(uint32_t *pData, uint32_t WriteAddr, uint32_t NumOfBlocks, uint32_t Timeout);
	64	uint8_t BSP_SD_ReadBlocks_DMA(uint32_t *pData, uint32_t ReadAddr, uint32_t NumOfBlocks);
	65	uint8_t BSP_SD_WriteBlocks_DMA(uint32_t *pData, uint32_t WriteAddr, uint32_t NumOfBlocks);
	66	uint8_t BSP_SD_Erase(uint32_t StartAddr, uint32_t EndAddr);
	67	uint8_t BSP_SD_GetCardState(void);
	68	void BSP_SD_GetCardInfo(BSP_SD_CardInfo *CardInfo);
	69	uint8_t BSP_SD_IsDetected(void);
	70
	71	/* These functions can be modified in case the current settings (e.g. DMA stream)
	72	need to be changed for specific application needs */
	73	void BSP_SD_AbortCallback(void);
	74	void BSP_SD_WriteCpltCallback(void);
	75	void BSP_SD_ReadCpltCallback(void);
	76	/* USER CODE END BSP_H_CODE */
	77
	78	#ifdef __cplusplus
	79	}
	80	#endif
	81
	82	#endif /* __STM32H7_SD_H */
	83
	84	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

LEAF/Inc/codec.h+162−0

@@ -0,0 +1,162 @@
	1	#include "stm32h7xx_hal.h"
	2
	3	#define CODEC_I2C_ADDRESS (0x10 << 1) // 7-bit address goes one bit over to the left to make room for R/W bit
	4
	5	void AudioCodec_init(I2C_HandleTypeDef* hi2c);
	6
	7
	8
	9
	10
	11
	12	//Settings for CS4271
	13	// translated from the datasheet by JS
	14
	15	// 01h mode control 1
	16	//
	17	// M1 M0 ratio1 ratio0 m/s dac_dif2 dac_dif1 dac_dif0 // unsure if setting bit selects master means 1
	18	// for 48k == 0 1 0 0 0 0 0 1 ( ratio bit chosen as 0 0 based on assumption of 256X master clock)
	19	// == 0x41
	20	// for 96k == 1 0 0 0 0 0 0 1 ( ratio bit chosen as 0 0 based on assumption of <= 256X master clock)
	21	// == 0x81
	22	// for 192k == 1 1 1 0 0 0 0 1 ( ratio bit chosen as 1 0 based on assumption of 256X master clock, choose 0 0 (full word would be 0xc1 instead of 0xe1) instead if using something like 64X)
	23	// == 0xe1
	24
	25	// 02h DAC control
	26	// AMUTE, FILT_SEL, DEM1, DEM0, RMP_UP, RMP_DN, INV_A, INV_B
	27	// 0 0 0 0 1 1 0 0
	28	// == 0x0c
	29
	30	// 03h dac volume and mixing
	31	// (NA) B=A soft zerocross ATAPI3 ATAPI2 ATAPI1 ATAPI0 (B=A makes channel volumes not independent)
	32	// 0 1 1 1 1 0 0 1 (the last four bits set channel L to go to output A and channel R to go to output B, but this is easily changed with mixing or reversal)
	33	// == 0x79
	34
	35	// 04h Volume A
	36	// MUTE vol6 vol5 vol4 vol3 vol2 vol1 vol0
	37	// 0 0 0 0 0 0 0 0
	38	// == 0x00
	39
	40	// 05h Volume B
	41	// MUTE vol6 vol5 vol4 vol3 vol2 vol1 vol0
	42	// 0 0 0 0 0 0 0 0
	43	// == 0x00
	44
	45	// 06h ADC control
	46	// (NA) (NA) Dither16 ADC_DIF MUTEA MUTEB HPFDisableA HPFDisableB
	47	// 0 0 0 1 0 0 0 0
	48	// ==0x10
	49
	50	// 07h mode control 2
	51	// (NA) (NA) (NA) LOOP MUTECA=B FREEZE CPEN PDN
	52	// for power down version == 0 0 0 0 0 1 1 1
	53	// == 0x07
	54	// to send dry ADC input into DAC == 0 0 0 1 0 0 1 0
	55	// == 0x12
	56	// for normal operation == 0 0 0 0 0 0 1 0
	57	// == 0x02
	58
	59	/*
	60
	61
	62	#ifndef ADCHPD
	63	#define ADCHPD 0
	64	#elif (ADCHPD == 0)\|\|(ADCHPD == 1)
	65	#else
	66	#error ADCHPD value not defined
	67	#endif
	68
	69	#ifndef ADCS
	70	#define ADCS 2
	71	#elif (ADCS >=0)&&(ADCS <= 2)
	72	#else
	73	#error ADCS value not defined
	74	#endif
	75
	76	#ifndef HYST
	77	#define HYST 32
	78	#elif (HYST >= 0)&&(HYST <= 255)
	79	#else
	80	#error HYST value not defined
	81	#endif
	82
	83	#ifndef LINVOL
	84	#define LINVOL 0x17
	85	#elif (LINVOL >= 0) && (LINVOL <= 0x1f)
	86	#else
	87	#error LINVOL value not defined
	88	#endif
	89
	90	#ifndef RINVOL
	91	#define RINVOL 0x17
	92	#elif (RINVOL >= 0) && (RINVOL <= 0x1f)
	93	#else
	94	#error RINVOL value not defined
	95	#endif
	96
	97	#ifndef LHPVOL
	98	#define LHPVOL 127
	99	#elif (LHPVOL == 0) \|\| ((LHPVOL >= 0x30) && (LHPVOL <= 0x7f))
	100	#else
	101	#error LHPVOL value not defined
	102	#endif
	103
	104	#ifndef RHPVOL
	105	#define RHPVOL 127
	106	#elif (RHPVOL == 0) \|\| ((RHPVOL >= 0x30) && (RHPVOL <= 0x7f))
	107	#else
	108	#error RHPVOL value not defined
	109	#endif
	110
	111	#ifndef MICBOOST
	112	#define MICBOOST 0
	113	#elif (MICBOOST == 0)\|\|(MICBOOST == 1)
	114	#else
	115	#error MICBOOST value not defined
	116	#endif
	117
	118	// 1 = muted
	119	#ifndef MUTEMIC
	120	#define MUTEMIC 1
	121	#elif (MUTEMIC == 0)\|\|(MUTEMIC == 1)
	122	#else
	123	#error MUTEMIC value not defined
	124	#endif
	125
	126	// 0 = line inputs, 1 = mic in
	127	#ifndef INSEL
	128	#define INSEL 0
	129	#elif (INSEL == 0)\|\|(INSEL == 1)
	130	#else
	131	#error INSEL value not defined
	132	#endif
	133
	134	#ifndef BYPASS
	135	#define BYPASS 0 //setting this to 1 passes the line input straight to the line output
	136	#elif (BYPASS == 0)\|\|(BYPASS == 1)
	137	#else
	138	#error BYPASS value not defined
	139	#endif
	140
	141	#ifndef DACSEL
	142	#define DACSEL 1
	143	#elif (DACSEL == 0)\|\|(DACSEL == 1)
	144	#else
	145	#error DACSEL value not defined
	146	#endif
	147
	148	#ifndef SIDETONE
	149	#define SIDETONE 0 // setting this to 1 passes the mic input straight to the line output
	150	#elif (SIDETONE == 0)\|\|(SIDETONE == 1)
	151	#else
	152	#error SIDETONE value not defined
	153	#endif
	154
	155	#ifndef SIDEATT
	156	#define SIDEATT 0
	157	#elif (SIDEATT >= 0)&&(SIDEATT <= 3)
	158	#else
	159	#error SIDEATT value not defined
	160	#endif
	161
	162	*/

LEAF/Inc/custom_fonts.h+6894−0

@@ -0,0 +1,6894 @@
	1	/*
	2	* gothic_font.h
	3	*
	4	* Created on: Jul 8, 2018
	5	* Author: jeffsnyder
	6	*/
	7
	8	#ifndef CUSTOM_FONTS_H_
	9	#define CUSTOM_FONTS_H_
	10
	11	#include "stm32h7xx_hal.h"
	12	#include "gfx_font.h"
	13
	14
	15	#define PROGMEM
	16
	17	// Created by http://oleddisplay.squix.ch/ Consider a donation
	18	// In case of problems make sure that you are using the font file with the correct version!
	19	const uint8_t Monospaced_plain_18Bitmaps[] PROGMEM = {
	20
	21	// Bitmap Data:
	22	0x00, // ' '
	23	0xFF,0xFF,0xC3,0xC0, // '!'
	24	0xCF,0x3C,0xF3,0xCC, // '"'
	25	0x04,0xC1,0x90,0x32,0x04,0xC7,0xFE,0xFF,0xC6,0x40,0x98,0xFF,0xDF,0xF8,0xC8,0x11,0x02,0x60,0xCC,0x00, // '#'
	26	0x08,0x04,0x0F,0x8F,0xEC,0x96,0x43,0x20,0xF0,0x0F,0x04,0xC2,0x71,0x3F,0xF3,0xF0,0x20,0x10,0x08,0x00, // '$'
	27	0x78,0x19,0x83,0x30,0x66,0x0C,0xC0,0xF3,0x83,0x83,0x9E,0x06,0x60,0xCC,0x19,0x83,0x30,0x3C, // '%'
	28	0x1F,0x0F,0xC3,0x00,0xC0,0x18,0x0F,0x06,0xCF,0x3B,0xC7,0xF0,0xEE,0x31,0xF6,0x3D,0xC0, // '&'
	29	0xFF,0xC0, // '''
	30	0x32,0x66,0x4C,0xCC,0xCC,0xC4,0x66,0x23, // '('
	31	0xC4,0x66,0x23,0x33,0x33,0x32,0x66,0x4C, // ')'
	32	0x11,0x25,0x51,0xC3,0x8A,0xA4,0x88, // '*'
	33	0x0C,0x03,0x00,0xC0,0x30,0xFF,0xFF,0xF0,0xC0,0x30,0x0C,0x03,0x00, // '+'
	34	0x6D,0xE8, // ','
	35	0xFF,0xC0, // '-'
	36	0xFC, // '.'
	37	0x01,0x81,0x80,0xC0,0xC0,0x60,0x60,0x30,0x38,0x18,0x0C,0x0C,0x06,0x06,0x03,0x03,0x00, // '/'
	38	0x3E,0x3F,0x98,0xD8,0x3C,0x1E,0x6F,0x37,0x83,0xC1,0xE0,0xD8,0xCF,0xE3,0xE0, // '0'
	39	0x38,0xF8,0xD8,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0xFF,0xFF, // '1'
	40	0x7E,0x7F,0xA0,0xE0,0x30,0x18,0x1C,0x0C,0x1C,0x1C,0x1C,0x18,0x1F,0xFF,0xF8, // '2'
	41	0x7E,0x7F,0xA0,0xE0,0x30,0x39,0xF8,0xFC,0x07,0x01,0x80,0xE0,0xFF,0xE7,0xE0, // '3'
	42	0x06,0x07,0x03,0x82,0xC3,0x61,0x31,0x99,0x8C,0xFF,0xFF,0xC1,0x80,0xC0,0x60, // '4'
	43	0x7F,0x3F,0x98,0x0C,0x07,0xE3,0xF9,0x0E,0x03,0x01,0x80,0xE0,0xFF,0xE7,0xE0, // '5'
	44	0x1E,0x3F,0x9C,0x5C,0x0C,0x06,0xF3,0xFD,0xC7,0xC1,0xE0,0xD8,0xEF,0xE3,0xE0, // '6'
	45	0xFF,0xFF,0xC0,0xC0,0x60,0x70,0x30,0x18,0x18,0x0C,0x0E,0x06,0x03,0x03,0x00, // '7'
	46	0x3E,0x3F,0xB0,0x78,0x3C,0x1B,0xF9,0xFD,0xC7,0xC1,0xE0,0xF8,0xEF,0xE3,0xE0, // '8'
	47	0x3E,0x3F,0xB8,0xD8,0x3C,0x1F,0x1D,0xFE,0x7B,0x01,0x81,0xD1,0xCF,0xE3,0xC0, // '9'
	48	0xFC,0x0F,0xC0, // ':'
	49	0x6D,0x80,0x1B,0x7A,0x00, // ';'
	50	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0xc0, 0x1c, 0x03, 0xc0, 0x7c, 0x0f,
	51	0xc1, 0xfc, 0x0f, 0xc0, 0x7c, 0x03, 0xc0, 0x1c, 0x00, 0xc0, 0x04, // '<'
	52	0xFF,0xFF,0xC0,0x00,0x0F,0xFF,0xFC, // '='
	53	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x60, 0x07, 0x00, 0x78, 0x07, 0xc0, 0x7e,
	54	0x07, 0xf0, 0x7e, 0x07, 0xc0, 0x78, 0x07, 0x00, 0x60, 0x04, 0x00, // '>'
	55	0x7D,0xFE,0x18,0x30,0xE3,0x8E,0x18,0x30,0x60,0x01,0x83,0x00, // '?'
	56	0x1E,0x19,0x98,0x6C,0xFC,0xDE,0x6F,0x37,0x9B,0xCD,0xE6,0xF1,0xEC,0x06,0x01,0x80,0x78, // '@'
	57	0x1C,0x0E,0x07,0x03,0x83,0x61,0xB0,0xD8,0x6C,0x7F,0x3F,0x98,0xD8,0x3C,0x18, // 'A'
	58	0xFE,0x7F,0xB0,0x78,0x3C,0x1F,0xFB,0xFD,0x87,0xC1,0xE0,0xF0,0xFF,0xEF,0xE0, // 'B'
	59	0x1F,0x1F,0xDC,0x3C,0x0C,0x06,0x03,0x01,0x80,0xC0,0x70,0x1C,0x27,0xF1,0xF0, // 'C'
	60	0xFC,0x7F,0x31,0xD8,0x7C,0x1E,0x0F,0x07,0x83,0xC1,0xE1,0xF1,0xDF,0xCF,0xC0, // 'D'
	61	0xFF,0xFF,0xF0,0x18,0x0C,0x07,0xFF,0xFF,0x80,0xC0,0x60,0x30,0x1F,0xFF,0xF8, // 'E'
	62	0xFF,0xFF,0xF0,0x18,0x0C,0x07,0xFB,0xFD,0x80,0xC0,0x60,0x30,0x18,0x0C,0x00, // 'F'
	63	0x1F,0x1F,0xDC,0x3C,0x0C,0x06,0x3F,0x1F,0x83,0xC1,0xF0,0xD8,0x67,0xF1,0xE0, // 'G'
	64	0xC1,0xE0,0xF0,0x78,0x3C,0x1F,0xFF,0xFF,0x83,0xC1,0xE0,0xF0,0x78,0x3C,0x18, // 'H'
	65	0xFF,0xFF,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0xFF,0xFF, // 'I'
	66	0x3E,0x7C,0x18,0x30,0x60,0xC1,0x83,0x06,0x0E,0x1F,0xE7,0x80, // 'J'
	67	0xC1,0xB0,0xCC,0x63,0x30,0xD8,0x3E,0x0F,0x83,0x30,0xCE,0x31,0x8C,0x33,0x0E,0xC1,0x80, // 'K'
	68	0xC0,0x60,0x30,0x18,0x0C,0x06,0x03,0x01,0x80,0xC0,0x60,0x30,0x1F,0xFF,0xF8, // 'L'
	69	0xE3,0xF1,0xF8,0xFE,0xFD,0x5E,0xAF,0x77,0x93,0xC1,0xE0,0xF0,0x78,0x3C,0x18, // 'M'
	70	0xE1,0xF0,0xFC,0x7A,0x3D,0x1E,0xCF,0x27,0x9B,0xC5,0xE2,0xF1,0xF8,0x7C,0x38, // 'N'
	71	0x3E,0x3F,0x98,0xD8,0x3C,0x1E,0x0F,0x07,0x83,0xC1,0xE0,0xD8,0xCF,0xE3,0xE0, // 'O'
	72	0xFE,0x7F,0xB0,0xF8,0x3C,0x1E,0x1F,0xFD,0xFC,0xC0,0x60,0x30,0x18,0x0C,0x00, // 'P'
	73	0x3E,0x3F,0x98,0xD8,0x3C,0x1E,0x0F,0x07,0x83,0xC1,0xE0,0xD8,0xCF,0xE3,0xE0,0x38,0x0C, // 'Q'
	74	0xFE,0x3F,0xCC,0x3B,0x06,0xC1,0xB0,0xEF,0xF3,0xF8,0xC3,0x30,0xEC,0x1B,0x06,0xC0,0xC0, // 'R'
	75	0x3E,0x3F,0xB8,0x58,0x0C,0x03,0xE0,0xFC,0x07,0x01,0x80,0xE0,0xFF,0xE7,0xE0, // 'S'
	76	0xFF,0xFF,0xF0,0xC0,0x30,0x0C,0x03,0x00,0xC0,0x30,0x0C,0x03,0x00,0xC0,0x30,0x0C,0x00, // 'T'
	77	0xC1,0xE0,0xF0,0x78,0x3C,0x1E,0x0F,0x07,0x83,0xC1,0xE0,0xF8,0xEF,0xE3,0xE0, // 'U'
	78	0xC1,0xE0,0xD8,0xCC,0x66,0x33,0xB8,0xD8,0x6C,0x36,0x0E,0x07,0x03,0x81,0xC0, // 'V'
	79	0xC0,0x78,0x0F,0x01,0xB0,0x66,0xEC,0xDD,0x9A,0xB3,0x56,0x6A,0xCF,0x78,0xC6,0x18,0xC3,0x18, // 'W'
	80	0xE3,0xB1,0x9D,0x86,0xC1,0xC0,0xE0,0x70,0x38,0x3E,0x1B,0x1D,0xCC,0x6E,0x38, // 'X'
	81	0xE1,0xD8,0x67,0x38,0xCC,0x1E,0x07,0x80,0xC0,0x30,0x0C,0x03,0x00,0xC0,0x30,0x0C,0x00, // 'Y'
	82	0xFF,0xFF,0xC0,0xC0,0xE0,0x60,0x60,0x70,0x30,0x38,0x38,0x18,0x1F,0xFF,0xF8, // 'Z'
	83	0xFF,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xFF, // '['
	84	0xC0,0x30,0x18,0x06,0x03,0x00,0xC0,0x60,0x38,0x0C,0x06,0x01,0x80,0xC0,0x30,0x18,0x06, // '\'
	85	0xFF,0x33,0x33,0x33,0x33,0x33,0x33,0xFF, // ']'
	86	0x0C,0x07,0x83,0x31,0x86,0xC0,0xC0, // '^'
	87	0xFF,0xFF,0xFC, // '_'
	88	0xC6,0x30, // '`'
	89	0x3E,0x3F,0x90,0xE0,0x33,0xFF,0xFF,0x07,0x87,0xFF,0xBE,0xC0, // 'a'
	90	0xC0,0x60,0x30,0x18,0x0D,0xE7,0xFB,0x8F,0x83,0xC1,0xE0,0xF0,0x7C,0x7F,0xF6,0xF0, // 'b'
	91	0x1E,0x7F,0x61,0xC0,0xC0,0xC0,0xC0,0x61,0x7F,0x1E, // 'c'
	92	0x01,0x80,0xC0,0x60,0x33,0xDB,0xFF,0x8F,0x83,0xC1,0xE0,0xF0,0x7C,0x77,0xF9,0xEC, // 'd'
	93	0x3E,0x3F,0x98,0xF8,0x3F,0xFF,0xFF,0x00,0xC1,0x7F,0x8F,0x80, // 'e'
	94	0x0F,0x1F,0x18,0x18,0xFF,0xFF,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, // 'f'
	95	0x3D,0xBF,0xF8,0xF8,0x3C,0x1E,0x0F,0x07,0xC7,0x7F,0x9E,0xC0,0x68,0x77,0xF1,0xF0, // 'g'
	96	0xC0,0x60,0x30,0x18,0x0C,0xE7,0xFB,0x8F,0x83,0xC1,0xE0,0xF0,0x78,0x3C,0x1E,0x0C, // 'h'
	97	0x18,0x18,0x00,0x00,0xF8,0xF8,0x18,0x18,0x18,0x18,0x18,0x18,0xFF,0xFF, // 'i'
	98	0x0C,0x30,0x00,0x7D,0xF0,0xC3,0x0C,0x30,0xC3,0x0C,0x30,0xC3,0xFB,0xC0, // 'j'
	99	0xC0,0x60,0x30,0x18,0x0C,0x3E,0x3B,0x39,0xB8,0xF8,0x7E,0x33,0x18,0xCC,0x76,0x1C, // 'k'
	100	0xF8,0xF8,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x0F,0x0F, // 'l'
	101	0xDB,0xBF,0xFC,0xCF,0x33,0xCC,0xF3,0x3C,0xCF,0x33,0xCC,0xF3,0x30, // 'm'
	102	0xCE,0x7F,0xB8,0xF8,0x3C,0x1E,0x0F,0x07,0x83,0xC1,0xE0,0xC0, // 'n'
	103	0x3E,0x3F,0xB8,0xF8,0x3C,0x1E,0x0F,0x07,0xC7,0x7F,0x1F,0x00, // 'o'
	104	0xDE,0x7F,0xB8,0xF8,0x3C,0x1E,0x0F,0x07,0xC7,0xFF,0x6F,0x30,0x18,0x0C,0x06,0x00, // 'p'
	105	0x3D,0xBF,0xF8,0xF8,0x3C,0x1E,0x0F,0x07,0xC7,0x7F,0x9E,0xC0,0x60,0x30,0x18,0x0C, // 'q'
	106	0xDD,0xBF,0x8E,0x0C,0x18,0x30,0x60,0xC1,0x80, // 'r'
	107	0x3F,0x7F,0xF0,0x3F,0x07,0xF0,0x3C,0x07,0x03,0xFF,0xBF,0x00, // 's'
	108	0x18,0x0C,0x06,0x1F,0xFF,0xF8,0xC0,0x60,0x30,0x18,0x0C,0x06,0x03,0xF0,0xF8, // 't'
	109	0xC1,0xE0,0xF0,0x78,0x3C,0x1E,0x0F,0x07,0xC7,0x7F,0x9C,0xC0, // 'u'
	110	0xC1,0xB1,0x98,0xCC,0x63,0x61,0xB0,0xD8,0x38,0x1C,0x0E,0x00, // 'v'
	111	0xC0,0x78,0x0D,0x83,0x32,0x66,0xEC,0xD5,0x8E,0xE1,0xDC,0x31,0x86,0x30, // 'w'
	112	0xE3,0xBB,0x8D,0x83,0x81,0xC0,0xE0,0xF8,0x6C,0x63,0x71,0xC0, // 'x'
	113	0xC1,0xB1,0x98,0xCE,0x63,0x61,0xB0,0x78,0x38,0x0C,0x0E,0x06,0x03,0x07,0x83,0x80, // 'y'
	114	0xFF,0xFF,0xC1,0xC1,0xC1,0xC0,0xC0,0xC0,0xE0,0xFF,0xFF,0xC0, // 'z'
	115	0x0F,0x1F,0x18,0x18,0x18,0x18,0x18,0xF0,0xF0,0x38,0x18,0x18,0x18,0x18,0x18,0x1F,0x0F, // '{'
	116	0xFF,0xFF,0xFF,0xFF,0xF0, // '\|'
	117	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x1f, 0x81, 0x98, 0x19, 0x81, 0x98, 0x7f,
	118	0xe7, 0xfe, 0x7f, 0xe7, 0xfe, 0x7f, 0xe7, 0xfe, 0x7f, 0xe0, 0x00// lock icon
	119	//0xF0,0xF8,0x18,0x18,0x18,0x18,0x18,0x0F,0x0F,0x1C,0x18,0x18,0x18,0x18,0x18,0xF8,0xF0 // '}'
	120	};
	121	const GFXglyph Monospaced_plain_18Glyphs[] PROGMEM = {
	122	// bitmapOffset, width, height, xAdvance, xOffset, yOffset
	123	{ 0, 1, 1, 12, 0, 0 }, // ' '
	124	{ 1, 2, 13, 12, 5, -13 }, // '!'
	125	{ 5, 6, 5, 12, 3, -13 }, // '"'
	126	{ 9, 11, 14, 12, 0, -14 }, // '#'
	127	{ 29, 9, 17, 12, 1, -14 }, // '$'
	128	{ 49, 11, 13, 12, 0, -13 }, // '%'
	129	{ 67, 10, 13, 12, 1, -13 }, // '&'
	130	{ 84, 2, 5, 12, 5, -13 }, // '''
	131	{ 86, 4, 16, 12, 4, -14 }, // '('
	132	{ 94, 4, 16, 12, 3, -14 }, // ')'
	133	{ 102, 7, 8, 12, 2, -13 }, // '*'
	134	{ 109, 10, 10, 12, 1, -11 }, // '+'
	135	{ 122, 3, 5, 12, 3, -3 }, // ','
	136	{ 124, 5, 2, 12, 3, -6 }, // '-'
	137	{ 126, 2, 3, 12, 4, -3 }, // '.'
	138	{ 127, 9, 15, 12, 1, -13 }, // '/'
	139	{ 144, 9, 13, 12, 1, -13 }, // '0'
	140	{ 159, 8, 13, 12, 2, -13 }, // '1'
	141	{ 172, 9, 13, 12, 1, -13 }, // '2'
	142	{ 187, 9, 13, 12, 1, -13 }, // '3'
	143	{ 202, 9, 13, 12, 1, -13 }, // '4'
	144	{ 217, 9, 13, 12, 1, -13 }, // '5'
	145	{ 232, 9, 13, 12, 1, -13 }, // '6'
	146	{ 247, 9, 13, 12, 1, -13 }, // '7'
	147	{ 262, 9, 13, 12, 1, -13 }, // '8'
	148	{ 277, 9, 13, 12, 1, -13 }, // '9'
	149	{ 292, 2, 9, 12, 4, -9 }, // ':'
	150	{ 295, 3, 11, 12, 3, -9 }, // ';'
	151	{ 300, 12, 18, 12, 0, -18 }, // '<'
	152	{ 327, 9, 6, 12, 1, -9 }, // '='
	153	{ 334, 12, 18, 12, 0, -18 }, // '>'
	154	{ 361, 7, 13, 12, 2, -13 }, // '?'
	155	{ 373, 9, 15, 12, 1, -12 }, // '@'
	156	{ 390, 9, 13, 12, 1, -13 }, // 'A'
	157	{ 405, 9, 13, 12, 1, -13 }, // 'B'
	158	{ 420, 9, 13, 12, 1, -13 }, // 'C'
	159	{ 435, 9, 13, 12, 1, -13 }, // 'D'
	160	{ 450, 9, 13, 12, 1, -13 }, // 'E'
	161	{ 465, 9, 13, 12, 1, -13 }, // 'F'
	162	{ 480, 9, 13, 12, 1, -13 }, // 'G'
	163	{ 495, 9, 13, 12, 1, -13 }, // 'H'
	164	{ 510, 8, 13, 12, 2, -13 }, // 'I'
	165	{ 524, 7, 13, 12, 1, -13 }, // 'J'
	166	{ 535, 10, 13, 12, 1, -13 }, // 'K'
	167	{ 552, 9, 13, 12, 1, -13 }, // 'L'
	168	{ 567, 9, 13, 12, 1, -13 }, // 'M'
	169	{ 582, 9, 13, 12, 1, -13 }, // 'N'
	170	{ 597, 9, 13, 12, 1, -13 }, // 'O'
	171	{ 612, 9, 13, 12, 1, -13 }, // 'P'
	172	{ 627, 9, 15, 12, 1, -13 }, // 'Q'
	173	{ 644, 10, 13, 12, 1, -13 }, // 'R'
	174	{ 661, 9, 13, 12, 1, -13 }, // 'S'
	175	{ 676, 10, 13, 12, 1, -13 }, // 'T'
	176	{ 693, 9, 13, 12, 1, -13 }, // 'U'
	177	{ 708, 9, 13, 12, 1, -13 }, // 'V'
	178	{ 723, 11, 13, 12, 0, -13 }, // 'W'
	179	{ 741, 9, 13, 12, 1, -13 }, // 'X'
	180	{ 756, 10, 13, 12, 1, -13 }, // 'Y'
	181	{ 773, 9, 13, 12, 1, -13 }, // 'Z'
	182	{ 788, 4, 16, 12, 4, -14 }, // '['
	183	{ 796, 9, 15, 12, 1, -13 }, // '\'
	184	{ 813, 4, 16, 12, 3, -14 }, // ']'
	185	{ 821, 10, 5, 12, 1, -13 }, // '^'
	186	{ 828, 11, 2, 12, 0, 2 }, // '_'
	187	{ 831, 4, 3, 12, 2, -14 }, // '`'
	188	{ 833, 9, 10, 12, 1, -10 }, // 'a'
	189	{ 845, 9, 14, 12, 1, -14 }, // 'b'
	190	{ 861, 8, 10, 12, 1, -10 }, // 'c'
	191	{ 871, 9, 14, 12, 1, -14 }, // 'd'
	192	{ 887, 9, 10, 12, 1, -10 }, // 'e'
	193	{ 899, 8, 14, 12, 1, -14 }, // 'f'
	194	{ 913, 9, 14, 12, 1, -10 }, // 'g'
	195	{ 929, 9, 14, 12, 1, -14 }, // 'h'
	196	{ 945, 8, 14, 12, 2, -14 }, // 'i'
	197	{ 959, 6, 18, 12, 1, -14 }, // 'j'
	198	{ 973, 9, 14, 12, 1, -14 }, // 'k'
	199	{ 989, 8, 14, 12, 1, -14 }, // 'l'
	200	{ 1003, 10, 10, 12, 1, -10 }, // 'm'
	201	{ 1017, 9, 10, 12, 1, -10 }, // 'n'
	202	{ 1028, 9, 10, 12, 1, -10 }, // 'o'
	203	{ 1040, 9, 14, 12, 1, -10 }, // 'p'
	204	{ 1056, 9, 14, 12, 1, -10 }, // 'q'
	205	{ 1072, 7, 10, 12, 3, -10 }, // 'r'
	206	{ 1081, 9, 10, 12, 1, -10 }, // 's'
	207	{ 1093, 9, 13, 12, 1, -13 }, // 't'
	208	{ 1108, 9, 10, 12, 1, -10 }, // 'u'
	209	{ 1120, 9, 10, 12, 1, -10 }, // 'v'
	210	{ 1132, 11, 10, 12, 0, -10 }, // 'w'
	211	{ 1146, 9, 10, 12, 1, -10 }, // 'x'
	212	{ 1158, 9, 14, 12, 1, -10 }, // 'y'
	213	{ 1174, 9, 10, 12, 1, -10 }, // 'z'
	214	{ 1186, 8, 17, 12, 2, -14 }, // '{'
	215	{ 1203, 2, 18, 12, 5, -14 }, // '\|'
	216	{ 1208, 12, 18, 12, 0, -18 } // lock icon
	217	//{ 1176, 8, 17, 12, 2, -14 } // '}'
	218	};
	219	const GFXfont Monospaced_plain_18 PROGMEM = {
	220	(uint8_t )Monospaced_plain_18Bitmaps,(GFXglyph )Monospaced_plain_18Glyphs,0x20, 0x7E, 16};
	221
	222
	223	const uint8_t FreeMono9pt7bBitmaps[] = {
	224	0xAA, 0xA8, 0x0C, 0xED, 0x24, 0x92, 0x48, 0x24, 0x48, 0x91, 0x2F, 0xE4,
	225	0x89, 0x7F, 0x28, 0x51, 0x22, 0x40, 0x08, 0x3E, 0x62, 0x40, 0x30, 0x0E,
	226	0x01, 0x81, 0xC3, 0xBE, 0x08, 0x08, 0x71, 0x12, 0x23, 0x80, 0x23, 0xB8,
	227	0x0E, 0x22, 0x44, 0x70, 0x38, 0x81, 0x02, 0x06, 0x1A, 0x65, 0x46, 0xC8,
	228	0xEC, 0xE9, 0x24, 0x5A, 0xAA, 0xA9, 0x40, 0xA9, 0x55, 0x5A, 0x80, 0x10,
	229	0x22, 0x4B, 0xE3, 0x05, 0x11, 0x00, 0x10, 0x20, 0x47, 0xF1, 0x02, 0x04,
	230	0x00, 0x6B, 0x48, 0xFF, 0x00, 0xF0, 0x02, 0x08, 0x10, 0x60, 0x81, 0x04,
	231	0x08, 0x20, 0x41, 0x02, 0x08, 0x00, 0x38, 0x8A, 0x0C, 0x18, 0x30, 0x60,
	232	0xC1, 0x82, 0x88, 0xE0, 0x27, 0x28, 0x42, 0x10, 0x84, 0x21, 0x3E, 0x38,
	233	0x8A, 0x08, 0x10, 0x20, 0x82, 0x08, 0x61, 0x03, 0xF8, 0x7C, 0x06, 0x02,
	234	0x02, 0x1C, 0x06, 0x01, 0x01, 0x01, 0x42, 0x3C, 0x18, 0xA2, 0x92, 0x8A,
	235	0x28, 0xBF, 0x08, 0x21, 0xC0, 0x7C, 0x81, 0x03, 0xE4, 0x40, 0x40, 0x81,
	236	0x03, 0x88, 0xE0, 0x1E, 0x41, 0x04, 0x0B, 0x98, 0xB0, 0xC1, 0xC2, 0x88,
	237	0xE0, 0xFE, 0x04, 0x08, 0x20, 0x40, 0x82, 0x04, 0x08, 0x20, 0x40, 0x38,
	238	0x8A, 0x0C, 0x14, 0x47, 0x11, 0x41, 0x83, 0x8C, 0xE0, 0x38, 0x8A, 0x1C,
	239	0x18, 0x68, 0xCE, 0x81, 0x04, 0x13, 0xC0, 0xF0, 0x0F, 0x6C, 0x00, 0xD2,
	240	0xD2, 0x00, 0x03, 0x04, 0x18, 0x60, 0x60, 0x18, 0x04, 0x03, 0xFF, 0x80,
	241	0x00, 0x1F, 0xF0, 0x40, 0x18, 0x03, 0x00, 0x60, 0x20, 0x60, 0xC0, 0x80,
	242	0x3D, 0x84, 0x08, 0x30, 0xC2, 0x00, 0x00, 0x00, 0x30, 0x3C, 0x46, 0x82,
	243	0x8E, 0xB2, 0xA2, 0xA2, 0x9F, 0x80, 0x80, 0x40, 0x3C, 0x3C, 0x01, 0x40,
	244	0x28, 0x09, 0x01, 0x10, 0x42, 0x0F, 0xC1, 0x04, 0x40, 0x9E, 0x3C, 0xFE,
	245	0x21, 0x90, 0x48, 0x67, 0xE2, 0x09, 0x02, 0x81, 0x41, 0xFF, 0x80, 0x3E,
	246	0xB0, 0xF0, 0x30, 0x08, 0x04, 0x02, 0x00, 0x80, 0x60, 0x8F, 0x80, 0xFE,
	247	0x21, 0x90, 0x68, 0x14, 0x0A, 0x05, 0x02, 0x83, 0x43, 0x7F, 0x00, 0xFF,
	248	0x20, 0x90, 0x08, 0x87, 0xC2, 0x21, 0x00, 0x81, 0x40, 0xFF, 0xC0, 0xFF,
	249	0xA0, 0x50, 0x08, 0x87, 0xC2, 0x21, 0x00, 0x80, 0x40, 0x78, 0x00, 0x1E,
	250	0x98, 0x6C, 0x0A, 0x00, 0x80, 0x20, 0xF8, 0x0B, 0x02, 0x60, 0x87, 0xC0,
	251	0xE3, 0xA0, 0x90, 0x48, 0x27, 0xF2, 0x09, 0x04, 0x82, 0x41, 0x71, 0xC0,
	252	0xF9, 0x08, 0x42, 0x10, 0x84, 0x27, 0xC0, 0x1F, 0x02, 0x02, 0x02, 0x02,
	253	0x02, 0x82, 0x82, 0xC6, 0x78, 0xE3, 0xA1, 0x11, 0x09, 0x05, 0x83, 0x21,
	254	0x08, 0x84, 0x41, 0x70, 0xC0, 0xE0, 0x40, 0x40, 0x40, 0x40, 0x40, 0x41,
	255	0x41, 0x41, 0xFF, 0xE0, 0xEC, 0x19, 0x45, 0x28, 0xA4, 0xA4, 0x94, 0x91,
	256	0x12, 0x02, 0x40, 0x5C, 0x1C, 0xC3, 0xB0, 0x94, 0x4A, 0x24, 0x92, 0x49,
	257	0x14, 0x8A, 0x43, 0x70, 0x80, 0x1E, 0x31, 0x90, 0x50, 0x18, 0x0C, 0x06,
	258	0x02, 0x82, 0x63, 0x0F, 0x00, 0xFE, 0x43, 0x41, 0x41, 0x42, 0x7C, 0x40,
	259	0x40, 0x40, 0xF0, 0x1C, 0x31, 0x90, 0x50, 0x18, 0x0C, 0x06, 0x02, 0x82,
	260	0x63, 0x1F, 0x04, 0x07, 0x92, 0x30, 0xFE, 0x21, 0x90, 0x48, 0x24, 0x23,
	261	0xE1, 0x10, 0x84, 0x41, 0x70, 0xC0, 0x3A, 0xCD, 0x0A, 0x03, 0x01, 0x80,
	262	0xC1, 0xC7, 0x78, 0xFF, 0xC4, 0x62, 0x21, 0x00, 0x80, 0x40, 0x20, 0x10,
	263	0x08, 0x1F, 0x00, 0xE3, 0xA0, 0x90, 0x48, 0x24, 0x12, 0x09, 0x04, 0x82,
	264	0x22, 0x0E, 0x00, 0xF1, 0xE8, 0x10, 0x82, 0x10, 0x42, 0x10, 0x22, 0x04,
	265	0x80, 0x50, 0x0C, 0x00, 0x80, 0xF1, 0xE8, 0x09, 0x11, 0x25, 0x44, 0xA8,
	266	0x55, 0x0C, 0xA1, 0x8C, 0x31, 0x84, 0x30, 0xE3, 0xA0, 0x88, 0x82, 0x80,
	267	0x80, 0xC0, 0x90, 0x44, 0x41, 0x71, 0xC0, 0xE3, 0xA0, 0x88, 0x82, 0x81,
	268	0x40, 0x40, 0x20, 0x10, 0x08, 0x1F, 0x00, 0xFD, 0x0A, 0x20, 0x81, 0x04,
	269	0x10, 0x21, 0x83, 0xFC, 0xEA, 0xAA, 0xAA, 0xC0, 0x80, 0x81, 0x03, 0x02,
	270	0x04, 0x04, 0x08, 0x08, 0x10, 0x10, 0x20, 0x20, 0xD5, 0x55, 0x55, 0xC0,
	271	0x10, 0x51, 0x22, 0x28, 0x20, 0xFF, 0xE0, 0x88, 0x80, 0x7E, 0x00, 0x80,
	272	0x47, 0xEC, 0x14, 0x0A, 0x0C, 0xFB, 0xC0, 0x20, 0x10, 0x0B, 0xC6, 0x12,
	273	0x05, 0x02, 0x81, 0x40, 0xB0, 0xB7, 0x80, 0x3A, 0x8E, 0x0C, 0x08, 0x10,
	274	0x10, 0x9E, 0x03, 0x00, 0x80, 0x47, 0xA4, 0x34, 0x0A, 0x05, 0x02, 0x81,
	275	0x21, 0x8F, 0x60, 0x3C, 0x43, 0x81, 0xFF, 0x80, 0x80, 0x61, 0x3E, 0x3D,
	276	0x04, 0x3E, 0x41, 0x04, 0x10, 0x41, 0x0F, 0x80, 0x3D, 0xA1, 0xA0, 0x50,
	277	0x28, 0x14, 0x09, 0x0C, 0x7A, 0x01, 0x01, 0x87, 0x80, 0xC0, 0x20, 0x10,
	278	0x0B, 0xC6, 0x32, 0x09, 0x04, 0x82, 0x41, 0x20, 0xB8, 0xE0, 0x10, 0x01,
	279	0xC0, 0x81, 0x02, 0x04, 0x08, 0x11, 0xFC, 0x10, 0x3E, 0x10, 0x84, 0x21,
	280	0x08, 0x42, 0x3F, 0x00, 0xC0, 0x40, 0x40, 0x4F, 0x44, 0x58, 0x70, 0x48,
	281	0x44, 0x42, 0xC7, 0x70, 0x20, 0x40, 0x81, 0x02, 0x04, 0x08, 0x10, 0x23,
	282	0xF8, 0xB7, 0x64, 0x62, 0x31, 0x18, 0x8C, 0x46, 0x23, 0x91, 0x5E, 0x31,
	283	0x90, 0x48, 0x24, 0x12, 0x09, 0x05, 0xC7, 0x3E, 0x31, 0xA0, 0x30, 0x18,
	284	0x0C, 0x05, 0x8C, 0x7C, 0xDE, 0x30, 0x90, 0x28, 0x14, 0x0A, 0x05, 0x84,
	285	0xBC, 0x40, 0x20, 0x38, 0x00, 0x3D, 0xA1, 0xA0, 0x50, 0x28, 0x14, 0x09,
	286	0x0C, 0x7A, 0x01, 0x00, 0x80, 0xE0, 0xCE, 0xA1, 0x82, 0x04, 0x08, 0x10,
	287	0x7C, 0x3A, 0x8D, 0x0B, 0x80, 0xF0, 0x70, 0xDE, 0x40, 0x40, 0xFC, 0x40,
	288	0x40, 0x40, 0x40, 0x40, 0x41, 0x3E, 0xC3, 0x41, 0x41, 0x41, 0x41, 0x41,
	289	0x43, 0x3D, 0xE3, 0xA0, 0x90, 0x84, 0x42, 0x20, 0xA0, 0x50, 0x10, 0xE3,
	290	0xC0, 0x92, 0x4B, 0x25, 0x92, 0xA9, 0x98, 0x44, 0xE3, 0x31, 0x05, 0x01,
	291	0x01, 0x41, 0x11, 0x05, 0xC7, 0xE3, 0xA0, 0x90, 0x84, 0x42, 0x40, 0xA0,
	292	0x60, 0x10, 0x10, 0x08, 0x3E, 0x00, 0xFD, 0x08, 0x20, 0x82, 0x08, 0x10,
	293	0xBF, 0x29, 0x24, 0xA2, 0x49, 0x26, 0xFF, 0xF8, 0x89, 0x24, 0x8A, 0x49,
	294	0x2C, 0x61, 0x24, 0x30 };
	295
	296	const GFXglyph FreeMono9pt7bGlyphs[] = {
	297	{ 0, 0, 0, 11, 0, 1 }, // 0x20 ' '
	298	{ 0, 2, 11, 11, 4, -10 }, // 0x21 '!'
	299	{ 3, 6, 5, 11, 2, -10 }, // 0x22 '"'
	300	{ 7, 7, 12, 11, 2, -10 }, // 0x23 '#'
	301	{ 18, 8, 12, 11, 1, -10 }, // 0x24 '$'
	302	{ 30, 7, 11, 11, 2, -10 }, // 0x25 '%'
	303	{ 40, 7, 10, 11, 2, -9 }, // 0x26 '&'
	304	{ 49, 3, 5, 11, 4, -10 }, // 0x27 '''
	305	{ 51, 2, 13, 11, 5, -10 }, // 0x28 '('
	306	{ 55, 2, 13, 11, 4, -10 }, // 0x29 ')'
	307	{ 59, 7, 7, 11, 2, -10 }, // 0x2A '*'
	308	{ 66, 7, 7, 11, 2, -8 }, // 0x2B '+'
	309	{ 73, 3, 5, 11, 2, -1 }, // 0x2C ','
	310	{ 75, 9, 1, 11, 1, -5 }, // 0x2D '-'
	311	{ 77, 2, 2, 11, 4, -1 }, // 0x2E '.'
	312	{ 78, 7, 13, 11, 2, -11 }, // 0x2F '/'
	313	{ 90, 7, 11, 11, 2, -10 }, // 0x30 '0'
	314	{ 100, 5, 11, 11, 3, -10 }, // 0x31 '1'
	315	{ 107, 7, 11, 11, 2, -10 }, // 0x32 '2'
	316	{ 117, 8, 11, 11, 1, -10 }, // 0x33 '3'
	317	{ 128, 6, 11, 11, 3, -10 }, // 0x34 '4'
	318	{ 137, 7, 11, 11, 2, -10 }, // 0x35 '5'
	319	{ 147, 7, 11, 11, 2, -10 }, // 0x36 '6'
	320	{ 157, 7, 11, 11, 2, -10 }, // 0x37 '7'
	321	{ 167, 7, 11, 11, 2, -10 }, // 0x38 '8'
	322	{ 177, 7, 11, 11, 2, -10 }, // 0x39 '9'
	323	{ 187, 2, 8, 11, 4, -7 }, // 0x3A ':'
	324	{ 189, 3, 11, 11, 3, -7 }, // 0x3B ';'
	325	{ 194, 8, 8, 11, 1, -8 }, // 0x3C '<'
	326	{ 202, 9, 4, 11, 1, -6 }, // 0x3D '='
	327	{ 207, 9, 8, 11, 1, -8 }, // 0x3E '>'
	328	{ 216, 7, 10, 11, 2, -9 }, // 0x3F '?'
	329	{ 225, 8, 12, 11, 2, -10 }, // 0x40 '@'
	330	{ 237, 11, 10, 11, 0, -9 }, // 0x41 'A'
	331	{ 251, 9, 10, 11, 1, -9 }, // 0x42 'B'
	332	{ 263, 9, 10, 11, 1, -9 }, // 0x43 'C'
	333	{ 275, 9, 10, 11, 1, -9 }, // 0x44 'D'
	334	{ 287, 9, 10, 11, 1, -9 }, // 0x45 'E'
	335	{ 299, 9, 10, 11, 1, -9 }, // 0x46 'F'
	336	{ 311, 10, 10, 11, 1, -9 }, // 0x47 'G'
	337	{ 324, 9, 10, 11, 1, -9 }, // 0x48 'H'
	338	{ 336, 5, 10, 11, 3, -9 }, // 0x49 'I'
	339	{ 343, 8, 10, 11, 2, -9 }, // 0x4A 'J'
	340	{ 353, 9, 10, 11, 1, -9 }, // 0x4B 'K'
	341	{ 365, 8, 10, 11, 2, -9 }, // 0x4C 'L'
	342	{ 375, 11, 10, 11, 0, -9 }, // 0x4D 'M'
	343	{ 389, 9, 10, 11, 1, -9 }, // 0x4E 'N'
	344	{ 401, 9, 10, 11, 1, -9 }, // 0x4F 'O'
	345	{ 413, 8, 10, 11, 1, -9 }, // 0x50 'P'
	346	{ 423, 9, 13, 11, 1, -9 }, // 0x51 'Q'
	347	{ 438, 9, 10, 11, 1, -9 }, // 0x52 'R'
	348	{ 450, 7, 10, 11, 2, -9 }, // 0x53 'S'
	349	{ 459, 9, 10, 11, 1, -9 }, // 0x54 'T'
	350	{ 471, 9, 10, 11, 1, -9 }, // 0x55 'U'
	351	{ 483, 11, 10, 11, 0, -9 }, // 0x56 'V'
	352	{ 497, 11, 10, 11, 0, -9 }, // 0x57 'W'
	353	{ 511, 9, 10, 11, 1, -9 }, // 0x58 'X'
	354	{ 523, 9, 10, 11, 1, -9 }, // 0x59 'Y'
	355	{ 535, 7, 10, 11, 2, -9 }, // 0x5A 'Z'
	356	{ 544, 2, 13, 11, 5, -10 }, // 0x5B '['
	357	{ 548, 7, 13, 11, 2, -11 }, // 0x5C '\'
	358	{ 560, 2, 13, 11, 4, -10 }, // 0x5D ']'
	359	{ 564, 7, 5, 11, 2, -10 }, // 0x5E '^'
	360	{ 569, 11, 1, 11, 0, 2 }, // 0x5F '_'
	361	{ 571, 3, 3, 11, 3, -11 }, // 0x60 '`'
	362	{ 573, 9, 8, 11, 1, -7 }, // 0x61 'a'
	363	{ 582, 9, 11, 11, 1, -10 }, // 0x62 'b'
	364	{ 595, 7, 8, 11, 2, -7 }, // 0x63 'c'
	365	{ 602, 9, 11, 11, 1, -10 }, // 0x64 'd'
	366	{ 615, 8, 8, 11, 1, -7 }, // 0x65 'e'
	367	{ 623, 6, 11, 11, 3, -10 }, // 0x66 'f'
	368	{ 632, 9, 11, 11, 1, -7 }, // 0x67 'g'
	369	{ 645, 9, 11, 11, 1, -10 }, // 0x68 'h'
	370	{ 658, 7, 10, 11, 2, -9 }, // 0x69 'i'
	371	{ 667, 5, 13, 11, 3, -9 }, // 0x6A 'j'
	372	{ 676, 8, 11, 11, 2, -10 }, // 0x6B 'k'
	373	{ 687, 7, 11, 11, 2, -10 }, // 0x6C 'l'
	374	{ 697, 9, 8, 11, 1, -7 }, // 0x6D 'm'
	375	{ 706, 9, 8, 11, 1, -7 }, // 0x6E 'n'
	376	{ 715, 9, 8, 11, 1, -7 }, // 0x6F 'o'
	377	{ 724, 9, 11, 11, 1, -7 }, // 0x70 'p'
	378	{ 737, 9, 11, 11, 1, -7 }, // 0x71 'q'
	379	{ 750, 7, 8, 11, 3, -7 }, // 0x72 'r'
	380	{ 757, 7, 8, 11, 2, -7 }, // 0x73 's'
	381	{ 764, 8, 10, 11, 2, -9 }, // 0x74 't'
	382	{ 774, 8, 8, 11, 1, -7 }, // 0x75 'u'
	383	{ 782, 9, 8, 11, 1, -7 }, // 0x76 'v'
	384	{ 791, 9, 8, 11, 1, -7 }, // 0x77 'w'
	385	{ 800, 9, 8, 11, 1, -7 }, // 0x78 'x'
	386	{ 809, 9, 11, 11, 1, -7 }, // 0x79 'y'
	387	{ 822, 7, 8, 11, 2, -7 }, // 0x7A 'z'
	388	{ 829, 3, 13, 11, 4, -10 }, // 0x7B '{'
	389	{ 834, 1, 13, 11, 5, -10 }, // 0x7C '\|'
	390	{ 836, 3, 13, 11, 4, -10 }, // 0x7D '}'
	391	{ 841, 7, 3, 11, 2, -6 } }; // 0x7E '~'
	392
	393	const GFXfont FreeMono9pt7b = {
	394	(uint8_t *)FreeMono9pt7bBitmaps,
	395	(GFXglyph *)FreeMono9pt7bGlyphs,
	396	0x20, 0x7E, 18 };
	397	const uint8_t FreeSans12pt7bBitmaps[] PROGMEM = {
	398	0xFF, 0xFF, 0xFF, 0xF0, 0xF0, 0xCF, 0x3C, 0xF3, 0x8A, 0x20, 0x06, 0x30,
	399	0x31, 0x03, 0x18, 0x18, 0xC7, 0xFF, 0xBF, 0xFC, 0x31, 0x03, 0x18, 0x18,
	400	0xC7, 0xFF, 0xBF, 0xFC, 0x31, 0x01, 0x18, 0x18, 0xC0, 0xC6, 0x06, 0x30,
	401	0x04, 0x03, 0xE1, 0xFF, 0x72, 0x6C, 0x47, 0x88, 0xF1, 0x07, 0x20, 0x7E,
	402	0x03, 0xF0, 0x17, 0x02, 0x3C, 0x47, 0x88, 0xF1, 0x1B, 0x26, 0x7F, 0xC3,
	403	0xE0, 0x10, 0x02, 0x00, 0x00, 0x06, 0x03, 0xC0, 0x40, 0x7E, 0x0C, 0x0E,
	404	0x70, 0x80, 0xC3, 0x18, 0x0C, 0x31, 0x00, 0xE7, 0x30, 0x07, 0xE6, 0x00,
	405	0x3C, 0x40, 0x00, 0x0C, 0x7C, 0x00, 0x8F, 0xE0, 0x19, 0xC7, 0x01, 0x18,
	406	0x30, 0x31, 0x83, 0x02, 0x1C, 0x70, 0x40, 0xFE, 0x04, 0x07, 0xC0, 0x0F,
	407	0x00, 0x7E, 0x03, 0x9C, 0x0C, 0x30, 0x30, 0xC0, 0xE7, 0x01, 0xF8, 0x03,
	408	0x80, 0x3E, 0x01, 0xCC, 0x6E, 0x19, 0xB0, 0x7C, 0xC0, 0xF3, 0x03, 0xCE,
	409	0x1F, 0x9F, 0xE6, 0x1E, 0x1C, 0xFF, 0xA0, 0x08, 0x8C, 0x66, 0x31, 0x98,
	410	0xC6, 0x31, 0x8C, 0x63, 0x08, 0x63, 0x08, 0x61, 0x0C, 0x20, 0x82, 0x18,
	411	0xC3, 0x18, 0xC3, 0x18, 0xC6, 0x31, 0x8C, 0x62, 0x31, 0x88, 0xC4, 0x62,
	412	0x00, 0x10, 0x23, 0x5B, 0xE3, 0x8D, 0x91, 0x00, 0x0C, 0x03, 0x00, 0xC0,
	413	0x30, 0xFF, 0xFF, 0xF0, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0xF5, 0x60,
	414	0xFF, 0xF0, 0xF0, 0x02, 0x0C, 0x10, 0x20, 0xC1, 0x02, 0x0C, 0x10, 0x20,
	415	0xC1, 0x02, 0x0C, 0x10, 0x20, 0xC1, 0x00, 0x1F, 0x07, 0xF1, 0xC7, 0x30,
	416	0x6E, 0x0F, 0x80, 0xF0, 0x1E, 0x03, 0xC0, 0x78, 0x0F, 0x01, 0xE0, 0x3C,
	417	0x0E, 0xC1, 0x9C, 0x71, 0xFC, 0x1F, 0x00, 0x08, 0xCF, 0xFF, 0x8C, 0x63,
	418	0x18, 0xC6, 0x31, 0x8C, 0x63, 0x18, 0x1F, 0x0F, 0xF9, 0x87, 0x60, 0x7C,
	419	0x06, 0x00, 0xC0, 0x18, 0x07, 0x01, 0xC0, 0xF0, 0x78, 0x1C, 0x06, 0x00,
	420	0x80, 0x30, 0x07, 0xFF, 0xFF, 0xE0, 0x3F, 0x0F, 0xF3, 0x87, 0x60, 0x6C,
	421	0x0C, 0x01, 0x80, 0x70, 0x7C, 0x0F, 0x80, 0x18, 0x01, 0x80, 0x3C, 0x07,
	422	0x80, 0xD8, 0x73, 0xFC, 0x1F, 0x00, 0x01, 0x80, 0x70, 0x0E, 0x03, 0xC0,
	423	0xD8, 0x1B, 0x06, 0x61, 0x8C, 0x21, 0x8C, 0x33, 0x06, 0x7F, 0xFF, 0xFE,
	424	0x03, 0x00, 0x60, 0x0C, 0x01, 0x80, 0x3F, 0xCF, 0xF9, 0x80, 0x30, 0x06,
	425	0x00, 0xDE, 0x1F, 0xE7, 0x0E, 0x00, 0xE0, 0x0C, 0x01, 0x80, 0x30, 0x07,
	426	0x81, 0xF8, 0x73, 0xFC, 0x1F, 0x00, 0x0F, 0x07, 0xF9, 0xC3, 0x30, 0x74,
	427	0x01, 0x80, 0x33, 0xC7, 0xFE, 0xF0, 0xDC, 0x1F, 0x01, 0xE0, 0x3C, 0x06,
	428	0xC1, 0xDC, 0x71, 0xFC, 0x1F, 0x00, 0xFF, 0xFF, 0xFC, 0x01, 0x00, 0x60,
	429	0x18, 0x02, 0x00, 0xC0, 0x30, 0x06, 0x01, 0x80, 0x30, 0x04, 0x01, 0x80,
	430	0x30, 0x06, 0x01, 0x80, 0x30, 0x00, 0x1F, 0x07, 0xF1, 0xC7, 0x30, 0x66,
	431	0x0C, 0xC1, 0x8C, 0x61, 0xFC, 0x3F, 0x8E, 0x3B, 0x01, 0xE0, 0x3C, 0x07,
	432	0x80, 0xD8, 0x31, 0xFC, 0x1F, 0x00, 0x1F, 0x07, 0xF1, 0xC7, 0x70, 0x6C,
	433	0x07, 0x80, 0xF0, 0x1E, 0x07, 0x61, 0xEF, 0xFC, 0x79, 0x80, 0x30, 0x05,
	434	0x81, 0x98, 0x73, 0xFC, 0x1E, 0x00, 0xF0, 0x00, 0x03, 0xC0, 0xF0, 0x00,
	435	0x0F, 0x56, 0x00, 0x00, 0x07, 0x01, 0xE0, 0xF8, 0x3C, 0x0F, 0x00, 0xE0,
	436	0x07, 0xC0, 0x0F, 0x00, 0x3C, 0x00, 0xF0, 0x01, 0xFF, 0xFF, 0xFF, 0x00,
	437	0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x0E, 0x00, 0x78, 0x01, 0xF0, 0x07,
	438	0xC0, 0x0F, 0x00, 0x70, 0x1E, 0x0F, 0x03, 0xC0, 0xF0, 0x08, 0x00, 0x1F,
	439	0x1F, 0xEE, 0x1B, 0x03, 0xC0, 0xC0, 0x30, 0x0C, 0x06, 0x03, 0x81, 0xC0,
	440	0xE0, 0x30, 0x0C, 0x03, 0x00, 0x00, 0x00, 0x0C, 0x03, 0x00, 0x00, 0xFE,
	441	0x00, 0x0F, 0xFE, 0x00, 0xF0, 0x3E, 0x07, 0x00, 0x3C, 0x38, 0x00, 0x30,
	442	0xC1, 0xE0, 0x66, 0x0F, 0xD9, 0xD8, 0x61, 0xC3, 0xC3, 0x07, 0x0F, 0x1C,
	443	0x1C, 0x3C, 0x60, 0x60, 0xF1, 0x81, 0x83, 0xC6, 0x06, 0x1B, 0x18, 0x38,
	444	0xEE, 0x71, 0xE7, 0x18, 0xFD, 0xF8, 0x71, 0xE7, 0xC0, 0xE0, 0x00, 0x01,
	445	0xE0, 0x00, 0x01, 0xFF, 0xC0, 0x01, 0xFC, 0x00, 0x03, 0xC0, 0x03, 0xC0,
	446	0x03, 0xC0, 0x07, 0xE0, 0x06, 0x60, 0x06, 0x60, 0x0E, 0x70, 0x0C, 0x30,
	447	0x0C, 0x30, 0x1C, 0x38, 0x18, 0x18, 0x1F, 0xF8, 0x3F, 0xFC, 0x30, 0x1C,
	448	0x30, 0x0C, 0x70, 0x0E, 0x60, 0x06, 0x60, 0x06, 0xFF, 0xC7, 0xFF, 0x30,
	449	0x19, 0x80, 0x6C, 0x03, 0x60, 0x1B, 0x00, 0xD8, 0x0C, 0xFF, 0xC7, 0xFF,
	450	0x30, 0x0D, 0x80, 0x3C, 0x01, 0xE0, 0x0F, 0x00, 0x78, 0x06, 0xFF, 0xF7,
	451	0xFE, 0x00, 0x07, 0xE0, 0x3F, 0xF0, 0xE0, 0x73, 0x80, 0x66, 0x00, 0x6C,
	452	0x00, 0x30, 0x00, 0x60, 0x00, 0xC0, 0x01, 0x80, 0x03, 0x00, 0x06, 0x00,
	453	0x06, 0x00, 0x6C, 0x00, 0xDC, 0x03, 0x1E, 0x0E, 0x1F, 0xF8, 0x0F, 0xC0,
	454	0xFF, 0x83, 0xFF, 0x8C, 0x07, 0x30, 0x0E, 0xC0, 0x1B, 0x00, 0x7C, 0x00,
	455	0xF0, 0x03, 0xC0, 0x0F, 0x00, 0x3C, 0x00, 0xF0, 0x03, 0xC0, 0x1F, 0x00,
	456	0x6C, 0x03, 0xB0, 0x1C, 0xFF, 0xE3, 0xFF, 0x00, 0xFF, 0xFF, 0xFF, 0xC0,
	457	0x0C, 0x00, 0xC0, 0x0C, 0x00, 0xC0, 0x0C, 0x00, 0xFF, 0xEF, 0xFE, 0xC0,
	458	0x0C, 0x00, 0xC0, 0x0C, 0x00, 0xC0, 0x0C, 0x00, 0xFF, 0xFF, 0xFF, 0xFF,
	459	0xFF, 0xFF, 0x00, 0x60, 0x0C, 0x01, 0x80, 0x30, 0x06, 0x00, 0xFF, 0xDF,
	460	0xFB, 0x00, 0x60, 0x0C, 0x01, 0x80, 0x30, 0x06, 0x00, 0xC0, 0x18, 0x00,
	461	0x07, 0xF0, 0x1F, 0xFC, 0x3C, 0x1E, 0x70, 0x06, 0x60, 0x03, 0xE0, 0x00,
	462	0xC0, 0x00, 0xC0, 0x00, 0xC0, 0x7F, 0xC0, 0x7F, 0xC0, 0x03, 0xC0, 0x03,
	463	0x60, 0x03, 0x60, 0x07, 0x30, 0x0F, 0x3C, 0x1F, 0x1F, 0xFB, 0x07, 0xE1,
	464	0xC0, 0x1E, 0x00, 0xF0, 0x07, 0x80, 0x3C, 0x01, 0xE0, 0x0F, 0x00, 0x78,
	465	0x03, 0xFF, 0xFF, 0xFF, 0xF0, 0x07, 0x80, 0x3C, 0x01, 0xE0, 0x0F, 0x00,
	466	0x78, 0x03, 0xC0, 0x1E, 0x00, 0xC0, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0x01,
	467	0x80, 0xC0, 0x60, 0x30, 0x18, 0x0C, 0x06, 0x03, 0x01, 0x80, 0xC0, 0x60,
	468	0x3C, 0x1E, 0x0F, 0x07, 0xC7, 0x7F, 0x1F, 0x00, 0xC0, 0x3B, 0x01, 0xCC,
	469	0x0E, 0x30, 0x70, 0xC3, 0x83, 0x1C, 0x0C, 0xE0, 0x33, 0x80, 0xDE, 0x03,
	470	0xDC, 0x0E, 0x38, 0x30, 0x60, 0xC1, 0xC3, 0x03, 0x8C, 0x06, 0x30, 0x1C,
	471	0xC0, 0x3B, 0x00, 0x60, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0x30, 0x0C,
	472	0x03, 0x00, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0x30, 0x0C, 0x03, 0x00,
	473	0xFF, 0xFF, 0xF0, 0xE0, 0x07, 0xE0, 0x07, 0xF0, 0x0F, 0xF0, 0x0F, 0xD0,
	474	0x0F, 0xD8, 0x1B, 0xD8, 0x1B, 0xD8, 0x1B, 0xCC, 0x33, 0xCC, 0x33, 0xCC,
	475	0x33, 0xC6, 0x63, 0xC6, 0x63, 0xC6, 0x63, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3,
	476	0xC3, 0xC1, 0x83, 0xE0, 0x1F, 0x00, 0xFC, 0x07, 0xE0, 0x3D, 0x81, 0xEE,
	477	0x0F, 0x30, 0x79, 0xC3, 0xC6, 0x1E, 0x18, 0xF0, 0xE7, 0x83, 0x3C, 0x1D,
	478	0xE0, 0x6F, 0x01, 0xF8, 0x0F, 0xC0, 0x3E, 0x01, 0xC0, 0x03, 0xE0, 0x0F,
	479	0xFC, 0x0F, 0x07, 0x86, 0x00, 0xC6, 0x00, 0x33, 0x00, 0x1B, 0x00, 0x07,
	480	0x80, 0x03, 0xC0, 0x01, 0xE0, 0x00, 0xF0, 0x00, 0x78, 0x00, 0x36, 0x00,
	481	0x33, 0x00, 0x18, 0xC0, 0x18, 0x78, 0x3C, 0x1F, 0xFC, 0x03, 0xF8, 0x00,
	482	0xFF, 0x8F, 0xFE, 0xC0, 0x6C, 0x03, 0xC0, 0x3C, 0x03, 0xC0, 0x3C, 0x07,
	483	0xFF, 0xEF, 0xFC, 0xC0, 0x0C, 0x00, 0xC0, 0x0C, 0x00, 0xC0, 0x0C, 0x00,
	484	0xC0, 0x0C, 0x00, 0x03, 0xE0, 0x0F, 0xFC, 0x0F, 0x07, 0x86, 0x00, 0xC6,
	485	0x00, 0x33, 0x00, 0x1B, 0x00, 0x07, 0x80, 0x03, 0xC0, 0x01, 0xE0, 0x00,
	486	0xF0, 0x00, 0x78, 0x00, 0x36, 0x00, 0x33, 0x01, 0x98, 0xC0, 0xFC, 0x78,
	487	0x3C, 0x1F, 0xFF, 0x03, 0xF9, 0x80, 0x00, 0x40, 0xFF, 0xC3, 0xFF, 0xCC,
	488	0x03, 0xB0, 0x06, 0xC0, 0x1B, 0x00, 0x6C, 0x01, 0xB0, 0x0C, 0xFF, 0xE3,
	489	0xFF, 0xCC, 0x03, 0xB0, 0x06, 0xC0, 0x1B, 0x00, 0x6C, 0x01, 0xB0, 0x06,
	490	0xC0, 0x1B, 0x00, 0x70, 0x0F, 0xE0, 0x7F, 0xC3, 0x83, 0x9C, 0x07, 0x60,
	491	0x0D, 0x80, 0x06, 0x00, 0x1E, 0x00, 0x3F, 0x80, 0x3F, 0xC0, 0x0F, 0x80,
	492	0x07, 0xC0, 0x0F, 0x00, 0x3E, 0x00, 0xDE, 0x0E, 0x3F, 0xF0, 0x3F, 0x80,
	493	0xFF, 0xFF, 0xFF, 0x06, 0x00, 0x60, 0x06, 0x00, 0x60, 0x06, 0x00, 0x60,
	494	0x06, 0x00, 0x60, 0x06, 0x00, 0x60, 0x06, 0x00, 0x60, 0x06, 0x00, 0x60,
	495	0x06, 0x00, 0x60, 0xC0, 0x1E, 0x00, 0xF0, 0x07, 0x80, 0x3C, 0x01, 0xE0,
	496	0x0F, 0x00, 0x78, 0x03, 0xC0, 0x1E, 0x00, 0xF0, 0x07, 0x80, 0x3C, 0x01,
	497	0xE0, 0x0F, 0x80, 0xEE, 0x0E, 0x3F, 0xE0, 0x7C, 0x00, 0x60, 0x06, 0xC0,
	498	0x1D, 0xC0, 0x31, 0x80, 0x63, 0x01, 0xC7, 0x03, 0x06, 0x06, 0x0C, 0x1C,
	499	0x1C, 0x30, 0x18, 0x60, 0x31, 0xC0, 0x73, 0x00, 0x66, 0x00, 0xDC, 0x01,
	500	0xF0, 0x01, 0xE0, 0x03, 0xC0, 0x07, 0x00, 0xE0, 0x30, 0x1D, 0x80, 0xE0,
	501	0x76, 0x07, 0x81, 0xD8, 0x1E, 0x06, 0x70, 0x7C, 0x18, 0xC1, 0xB0, 0xE3,
	502	0x0C, 0xC3, 0x8C, 0x33, 0x0C, 0x38, 0xC6, 0x30, 0x67, 0x18, 0xC1, 0x98,
	503	0x67, 0x06, 0x61, 0xD8, 0x1D, 0x83, 0x60, 0x3C, 0x0D, 0x80, 0xF0, 0x3E,
	504	0x03, 0xC0, 0x70, 0x0F, 0x01, 0xC0, 0x18, 0x07, 0x00, 0x70, 0x0E, 0x60,
	505	0x38, 0xE0, 0x60, 0xE1, 0xC0, 0xC3, 0x01, 0xCC, 0x01, 0xF8, 0x01, 0xE0,
	506	0x03, 0x80, 0x07, 0x80, 0x1F, 0x00, 0x33, 0x00, 0xE7, 0x03, 0x86, 0x06,
	507	0x0E, 0x1C, 0x0E, 0x70, 0x0C, 0xC0, 0x1C, 0x60, 0x06, 0x70, 0x0E, 0x30,
	508	0x1C, 0x38, 0x18, 0x1C, 0x38, 0x0C, 0x30, 0x0E, 0x70, 0x06, 0x60, 0x03,
	509	0xC0, 0x03, 0xC0, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01,
	510	0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0xFF, 0xFF, 0xFF, 0xC0, 0x0E,
	511	0x00, 0xE0, 0x0E, 0x00, 0x60, 0x07, 0x00, 0x70, 0x07, 0x00, 0x30, 0x03,
	512	0x80, 0x38, 0x03, 0x80, 0x18, 0x01, 0xC0, 0x1C, 0x00, 0xFF, 0xFF, 0xFF,
	513	0xC0, 0xFF, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCF,
	514	0xF0, 0x81, 0x81, 0x02, 0x06, 0x04, 0x08, 0x18, 0x10, 0x20, 0x60, 0x40,
	515	0x81, 0x81, 0x02, 0x06, 0x04, 0xFF, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33,
	516	0x33, 0x33, 0x33, 0x3F, 0xF0, 0x0C, 0x0E, 0x05, 0x86, 0xC3, 0x21, 0x19,
	517	0x8C, 0x83, 0xC1, 0x80, 0xFF, 0xFE, 0xE3, 0x8C, 0x30, 0x3F, 0x07, 0xF8,
	518	0xE1, 0xCC, 0x0C, 0x00, 0xC0, 0x1C, 0x3F, 0xCF, 0x8C, 0xC0, 0xCC, 0x0C,
	519	0xE3, 0xC7, 0xEF, 0x3C, 0x70, 0xC0, 0x0C, 0x00, 0xC0, 0x0C, 0x00, 0xC0,
	520	0x0C, 0xF8, 0xDF, 0xCF, 0x0E, 0xE0, 0x7C, 0x03, 0xC0, 0x3C, 0x03, 0xC0,
	521	0x3C, 0x03, 0xE0, 0x6F, 0x0E, 0xDF, 0xCC, 0xF8, 0x1F, 0x0F, 0xE7, 0x1B,
	522	0x83, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0x38, 0x37, 0x1C, 0xFE, 0x1F,
	523	0x00, 0x00, 0x60, 0x0C, 0x01, 0x80, 0x30, 0x06, 0x3C, 0xCF, 0xFB, 0x8F,
	524	0xE0, 0xF8, 0x0F, 0x01, 0xE0, 0x3C, 0x07, 0x80, 0xF8, 0x3B, 0x8F, 0x3F,
	525	0x63, 0xCC, 0x1F, 0x07, 0xF1, 0xC7, 0x70, 0x3C, 0x07, 0xFF, 0xFF, 0xFE,
	526	0x00, 0xC0, 0x1C, 0x0D, 0xC3, 0x1F, 0xE1, 0xF0, 0x3B, 0xD8, 0xC6, 0x7F,
	527	0xEC, 0x63, 0x18, 0xC6, 0x31, 0x8C, 0x63, 0x00, 0x1E, 0x67, 0xFD, 0xC7,
	528	0xF0, 0x7C, 0x07, 0x80, 0xF0, 0x1E, 0x03, 0xC0, 0x7C, 0x1D, 0xC7, 0x9F,
	529	0xB1, 0xE6, 0x00, 0xC0, 0x3E, 0x0E, 0x7F, 0xC7, 0xE0, 0xC0, 0x30, 0x0C,
	530	0x03, 0x00, 0xC0, 0x33, 0xCD, 0xFB, 0xC7, 0xE0, 0xF0, 0x3C, 0x0F, 0x03,
	531	0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x30, 0xF0, 0x3F, 0xFF, 0xFF,
	532	0xF0, 0x33, 0x00, 0x03, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x3F,
	533	0xE0, 0xC0, 0x18, 0x03, 0x00, 0x60, 0x0C, 0x01, 0x83, 0x30, 0xC6, 0x30,
	534	0xCC, 0x1B, 0x83, 0xF0, 0x77, 0x0C, 0x61, 0x8E, 0x30, 0xE6, 0x0C, 0xC1,
	535	0xD8, 0x18, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0xCF, 0x1F, 0x6F, 0xDF, 0xFC,
	536	0x78, 0xFC, 0x18, 0x3C, 0x0C, 0x1E, 0x06, 0x0F, 0x03, 0x07, 0x81, 0x83,
	537	0xC0, 0xC1, 0xE0, 0x60, 0xF0, 0x30, 0x78, 0x18, 0x3C, 0x0C, 0x18, 0xCF,
	538	0x37, 0xEF, 0x1F, 0x83, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C,
	539	0x0F, 0x03, 0xC0, 0xC0, 0x1F, 0x07, 0xF1, 0xC7, 0x70, 0x7C, 0x07, 0x80,
	540	0xF0, 0x1E, 0x03, 0xC0, 0x7C, 0x1D, 0xC7, 0x1F, 0xC1, 0xF0, 0xCF, 0x8D,
	541	0xFC, 0xF0, 0xEE, 0x06, 0xC0, 0x3C, 0x03, 0xC0, 0x3C, 0x03, 0xC0, 0x3E,
	542	0x07, 0xF0, 0xEF, 0xFC, 0xCF, 0x8C, 0x00, 0xC0, 0x0C, 0x00, 0xC0, 0x00,
	543	0x1E, 0x67, 0xFD, 0xC7, 0xF0, 0x7C, 0x07, 0x80, 0xF0, 0x1E, 0x03, 0xC0,
	544	0x7C, 0x1D, 0xC7, 0x9F, 0xF1, 0xE6, 0x00, 0xC0, 0x18, 0x03, 0x00, 0x60,
	545	0xCF, 0x7F, 0x38, 0xC3, 0x0C, 0x30, 0xC3, 0x0C, 0x30, 0xC0, 0x3E, 0x1F,
	546	0xEE, 0x1B, 0x00, 0xC0, 0x3C, 0x07, 0xF0, 0x3E, 0x01, 0xF0, 0x3E, 0x1D,
	547	0xFE, 0x3E, 0x00, 0x63, 0x19, 0xFF, 0xB1, 0x8C, 0x63, 0x18, 0xC6, 0x31,
	548	0xE7, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0,
	549	0xF0, 0x7E, 0x3D, 0xFB, 0x3C, 0xC0, 0xE0, 0x66, 0x06, 0x60, 0x67, 0x0C,
	550	0x30, 0xC3, 0x0C, 0x39, 0x81, 0x98, 0x19, 0x81, 0xF0, 0x0F, 0x00, 0xE0,
	551	0x0E, 0x00, 0xC1, 0xC1, 0xB0, 0xE1, 0xD8, 0x70, 0xCC, 0x2C, 0x66, 0x36,
	552	0x31, 0x9B, 0x18, 0xCD, 0x98, 0x64, 0x6C, 0x16, 0x36, 0x0F, 0x1A, 0x07,
	553	0x8F, 0x03, 0x83, 0x80, 0xC1, 0xC0, 0x60, 0xEE, 0x18, 0xC6, 0x0C, 0xC1,
	554	0xF0, 0x1C, 0x01, 0x80, 0x78, 0x1B, 0x03, 0x30, 0xC7, 0x30, 0x66, 0x06,
	555	0xE0, 0x6C, 0x0D, 0x83, 0x38, 0x63, 0x0C, 0x63, 0x0E, 0x60, 0xCC, 0x1B,
	556	0x03, 0x60, 0x3C, 0x07, 0x00, 0xE0, 0x18, 0x03, 0x00, 0xE0, 0x78, 0x0E,
	557	0x00, 0xFF, 0xFF, 0xF0, 0x18, 0x0C, 0x07, 0x03, 0x81, 0xC0, 0x60, 0x30,
	558	0x18, 0x0E, 0x03, 0xFF, 0xFF, 0xC0, 0x19, 0xCC, 0x63, 0x18, 0xC6, 0x31,
	559	0x99, 0x86, 0x18, 0xC6, 0x31, 0x8C, 0x63, 0x1C, 0x60, 0xFF, 0xFF, 0xFF,
	560	0xFF, 0xFF, 0xFC, 0xC7, 0x18, 0xC6, 0x31, 0x8C, 0x63, 0x0C, 0x33, 0x31,
	561	0x8C, 0x63, 0x18, 0xC6, 0x73, 0x00, 0x70, 0x3E, 0x09, 0xE4, 0x1F, 0x03,
	562	0x80 };
	563
	564	const GFXglyph FreeSans12pt7bGlyphs[] PROGMEM = {
	565	{ 0, 0, 0, 6, 0, 1 }, // 0x20 ' '
	566	{ 0, 2, 18, 8, 3, -17 }, // 0x21 '!'
	567	{ 5, 6, 6, 8, 1, -16 }, // 0x22 '"'
	568	{ 10, 13, 16, 13, 0, -15 }, // 0x23 '#'
	569	{ 36, 11, 20, 13, 1, -17 }, // 0x24 '$'
	570	{ 64, 20, 17, 21, 1, -16 }, // 0x25 '%'
	571	{ 107, 14, 17, 16, 1, -16 }, // 0x26 '&'
	572	{ 137, 2, 6, 5, 1, -16 }, // 0x27 '''
	573	{ 139, 5, 23, 8, 2, -17 }, // 0x28 '('
	574	{ 154, 5, 23, 8, 1, -17 }, // 0x29 ')'
	575	{ 169, 7, 7, 9, 1, -17 }, // 0x2A '*'
	576	{ 176, 10, 11, 14, 2, -10 }, // 0x2B '+'
	577	{ 190, 2, 6, 7, 2, -1 }, // 0x2C ','
	578	{ 192, 6, 2, 8, 1, -7 }, // 0x2D '-'
	579	{ 194, 2, 2, 6, 2, -1 }, // 0x2E '.'
	580	{ 195, 7, 18, 7, 0, -17 }, // 0x2F '/'
	581	{ 211, 11, 17, 13, 1, -16 }, // 0x30 '0'
	582	{ 235, 5, 17, 13, 3, -16 }, // 0x31 '1'
	583	{ 246, 11, 17, 13, 1, -16 }, // 0x32 '2'
	584	{ 270, 11, 17, 13, 1, -16 }, // 0x33 '3'
	585	{ 294, 11, 17, 13, 1, -16 }, // 0x34 '4'
	586	{ 318, 11, 17, 13, 1, -16 }, // 0x35 '5'
	587	{ 342, 11, 17, 13, 1, -16 }, // 0x36 '6'
	588	{ 366, 11, 17, 13, 1, -16 }, // 0x37 '7'
	589	{ 390, 11, 17, 13, 1, -16 }, // 0x38 '8'
	590	{ 414, 11, 17, 13, 1, -16 }, // 0x39 '9'
	591	{ 438, 2, 13, 6, 2, -12 }, // 0x3A ':'
	592	{ 442, 2, 16, 6, 2, -11 }, // 0x3B ';'
	593	{ 446, 12, 12, 14, 1, -11 }, // 0x3C '<'
	594	{ 464, 12, 6, 14, 1, -8 }, // 0x3D '='
	595	{ 473, 12, 12, 14, 1, -11 }, // 0x3E '>'
	596	{ 491, 10, 18, 13, 2, -17 }, // 0x3F '?'
	597	{ 514, 22, 21, 24, 1, -17 }, // 0x40 '@'
	598	{ 572, 16, 18, 16, 0, -17 }, // 0x41 'A'
	599	{ 608, 13, 18, 16, 2, -17 }, // 0x42 'B'
	600	{ 638, 15, 18, 17, 1, -17 }, // 0x43 'C'
	601	{ 672, 14, 18, 17, 2, -17 }, // 0x44 'D'
	602	{ 704, 12, 18, 15, 2, -17 }, // 0x45 'E'
	603	{ 731, 11, 18, 14, 2, -17 }, // 0x46 'F'
	604	{ 756, 16, 18, 18, 1, -17 }, // 0x47 'G'
	605	{ 792, 13, 18, 17, 2, -17 }, // 0x48 'H'
	606	{ 822, 2, 18, 7, 2, -17 }, // 0x49 'I'
	607	{ 827, 9, 18, 13, 1, -17 }, // 0x4A 'J'
	608	{ 848, 14, 18, 16, 2, -17 }, // 0x4B 'K'
	609	{ 880, 10, 18, 14, 2, -17 }, // 0x4C 'L'
	610	{ 903, 16, 18, 20, 2, -17 }, // 0x4D 'M'
	611	{ 939, 13, 18, 18, 2, -17 }, // 0x4E 'N'
	612	{ 969, 17, 18, 19, 1, -17 }, // 0x4F 'O'
	613	{ 1008, 12, 18, 16, 2, -17 }, // 0x50 'P'
	614	{ 1035, 17, 19, 19, 1, -17 }, // 0x51 'Q'
	615	{ 1076, 14, 18, 17, 2, -17 }, // 0x52 'R'
	616	{ 1108, 14, 18, 16, 1, -17 }, // 0x53 'S'
	617	{ 1140, 12, 18, 15, 1, -17 }, // 0x54 'T'
	618	{ 1167, 13, 18, 17, 2, -17 }, // 0x55 'U'
	619	{ 1197, 15, 18, 15, 0, -17 }, // 0x56 'V'
	620	{ 1231, 22, 18, 22, 0, -17 }, // 0x57 'W'
	621	{ 1281, 15, 18, 16, 0, -17 }, // 0x58 'X'
	622	{ 1315, 16, 18, 16, 0, -17 }, // 0x59 'Y'
	623	{ 1351, 13, 18, 15, 1, -17 }, // 0x5A 'Z'
	624	{ 1381, 4, 23, 7, 2, -17 }, // 0x5B '['
	625	{ 1393, 7, 18, 7, 0, -17 }, // 0x5C '\'
	626	{ 1409, 4, 23, 7, 1, -17 }, // 0x5D ']'
	627	{ 1421, 9, 9, 11, 1, -16 }, // 0x5E '^'
	628	{ 1432, 15, 1, 13, -1, 4 }, // 0x5F '_'
	629	{ 1434, 5, 4, 6, 1, -17 }, // 0x60 '`'
	630	{ 1437, 12, 13, 13, 1, -12 }, // 0x61 'a'
	631	{ 1457, 12, 18, 13, 1, -17 }, // 0x62 'b'
	632	{ 1484, 10, 13, 12, 1, -12 }, // 0x63 'c'
	633	{ 1501, 11, 18, 13, 1, -17 }, // 0x64 'd'
	634	{ 1526, 11, 13, 13, 1, -12 }, // 0x65 'e'
	635	{ 1544, 5, 18, 7, 1, -17 }, // 0x66 'f'
	636	{ 1556, 11, 18, 13, 1, -12 }, // 0x67 'g'
	637	{ 1581, 10, 18, 13, 1, -17 }, // 0x68 'h'
	638	{ 1604, 2, 18, 5, 2, -17 }, // 0x69 'i'
	639	{ 1609, 4, 23, 6, 0, -17 }, // 0x6A 'j'
	640	{ 1621, 11, 18, 12, 1, -17 }, // 0x6B 'k'
	641	{ 1646, 2, 18, 5, 1, -17 }, // 0x6C 'l'
	642	{ 1651, 17, 13, 19, 1, -12 }, // 0x6D 'm'
	643	{ 1679, 10, 13, 13, 1, -12 }, // 0x6E 'n'
	644	{ 1696, 11, 13, 13, 1, -12 }, // 0x6F 'o'
	645	{ 1714, 12, 17, 13, 1, -12 }, // 0x70 'p'
	646	{ 1740, 11, 17, 13, 1, -12 }, // 0x71 'q'
	647	{ 1764, 6, 13, 8, 1, -12 }, // 0x72 'r'
	648	{ 1774, 10, 13, 12, 1, -12 }, // 0x73 's'
	649	{ 1791, 5, 16, 7, 1, -15 }, // 0x74 't'
	650	{ 1801, 10, 13, 13, 1, -12 }, // 0x75 'u'
	651	{ 1818, 12, 13, 12, 0, -12 }, // 0x76 'v'
	652	{ 1838, 17, 13, 17, 0, -12 }, // 0x77 'w'
	653	{ 1866, 11, 13, 11, 0, -12 }, // 0x78 'x'
	654	{ 1884, 11, 18, 11, 0, -12 }, // 0x79 'y'
	655	{ 1909, 10, 13, 12, 1, -12 }, // 0x7A 'z'
	656	{ 1926, 5, 23, 8, 1, -17 }, // 0x7B '{'
	657	{ 1941, 2, 23, 6, 2, -17 }, // 0x7C '\|'
	658	{ 1947, 5, 23, 8, 2, -17 }, // 0x7D '}'
	659	{ 1962, 10, 5, 12, 1, -10 } }; // 0x7E '~'
	660
	661	const GFXfont FreeSans12pt7b PROGMEM = {
	662	(uint8_t *)FreeSans12pt7bBitmaps,
	663	(GFXglyph *)FreeSans12pt7bGlyphs,
	664	0x20, 0x7E, 29 };
	665
	666	// Approx. 2641 bytes
	667	const uint8_t FreeSans9pt7bBitmaps[] PROGMEM = {
	668	0xFF, 0xFF, 0xF8, 0xC0, 0xDE, 0xF7, 0x20, 0x09, 0x86, 0x41, 0x91, 0xFF,
	669	0x13, 0x04, 0xC3, 0x20, 0xC8, 0xFF, 0x89, 0x82, 0x61, 0x90, 0x10, 0x1F,
	670	0x14, 0xDA, 0x3D, 0x1E, 0x83, 0x40, 0x78, 0x17, 0x08, 0xF4, 0x7A, 0x35,
	671	0x33, 0xF0, 0x40, 0x20, 0x38, 0x10, 0xEC, 0x20, 0xC6, 0x20, 0xC6, 0x40,
	672	0xC6, 0x40, 0x6C, 0x80, 0x39, 0x00, 0x01, 0x3C, 0x02, 0x77, 0x02, 0x63,
	673	0x04, 0x63, 0x04, 0x77, 0x08, 0x3C, 0x0E, 0x06, 0x60, 0xCC, 0x19, 0x81,
	674	0xE0, 0x18, 0x0F, 0x03, 0x36, 0xC2, 0xD8, 0x73, 0x06, 0x31, 0xE3, 0xC4,
	675	0xFE, 0x13, 0x26, 0x6C, 0xCC, 0xCC, 0xC4, 0x66, 0x23, 0x10, 0x8C, 0x46,
	676	0x63, 0x33, 0x33, 0x32, 0x66, 0x4C, 0x80, 0x25, 0x7E, 0xA5, 0x00, 0x30,
	677	0xC3, 0x3F, 0x30, 0xC3, 0x0C, 0xD6, 0xF0, 0xC0, 0x08, 0x44, 0x21, 0x10,
	678	0x84, 0x42, 0x11, 0x08, 0x00, 0x3C, 0x66, 0x42, 0xC3, 0xC3, 0xC3, 0xC3,
	679	0xC3, 0xC3, 0xC3, 0x42, 0x66, 0x3C, 0x11, 0x3F, 0x33, 0x33, 0x33, 0x33,
	680	0x30, 0x3E, 0x31, 0xB0, 0x78, 0x30, 0x18, 0x1C, 0x1C, 0x1C, 0x18, 0x18,
	681	0x10, 0x08, 0x07, 0xF8, 0x3C, 0x66, 0xC3, 0xC3, 0x03, 0x06, 0x1C, 0x07,
	682	0x03, 0xC3, 0xC3, 0x66, 0x3C, 0x0C, 0x18, 0x71, 0x62, 0xC9, 0xA3, 0x46,
	683	0xFE, 0x18, 0x30, 0x60, 0xC0, 0x7F, 0x20, 0x10, 0x08, 0x08, 0x07, 0xF3,
	684	0x8C, 0x03, 0x01, 0x80, 0xF0, 0x6C, 0x63, 0xE0, 0x1E, 0x31, 0x98, 0x78,
	685	0x0C, 0x06, 0xF3, 0x8D, 0x83, 0xC1, 0xE0, 0xD0, 0x6C, 0x63, 0xE0, 0xFF,
	686	0x03, 0x02, 0x06, 0x04, 0x0C, 0x08, 0x18, 0x18, 0x18, 0x10, 0x30, 0x30,
	687	0x3E, 0x31, 0xB0, 0x78, 0x3C, 0x1B, 0x18, 0xF8, 0xC6, 0xC1, 0xE0, 0xF0,
	688	0x6C, 0x63, 0xE0, 0x3C, 0x66, 0xC2, 0xC3, 0xC3, 0xC3, 0x67, 0x3B, 0x03,
	689	0x03, 0xC2, 0x66, 0x3C, 0xC0, 0x00, 0x30, 0xC0, 0x00, 0x00, 0x64, 0xA0,
	690	0x00, 0x81, 0xC7, 0x8E, 0x0C, 0x07, 0x80, 0x70, 0x0E, 0x01, 0x80, 0xFF,
	691	0x80, 0x00, 0x1F, 0xF0, 0x00, 0x70, 0x0E, 0x01, 0xC0, 0x18, 0x38, 0x71,
	692	0xC0, 0x80, 0x00, 0x3E, 0x31, 0xB0, 0x78, 0x30, 0x18, 0x18, 0x38, 0x18,
	693	0x18, 0x0C, 0x00, 0x00, 0x01, 0x80, 0x03, 0xF0, 0x06, 0x0E, 0x06, 0x01,
	694	0x86, 0x00, 0x66, 0x1D, 0xBB, 0x31, 0xCF, 0x18, 0xC7, 0x98, 0x63, 0xCC,
	695	0x31, 0xE6, 0x11, 0xB3, 0x99, 0xCC, 0xF7, 0x86, 0x00, 0x01, 0x80, 0x00,
	696	0x70, 0x40, 0x0F, 0xE0, 0x06, 0x00, 0xF0, 0x0F, 0x00, 0x90, 0x19, 0x81,
	697	0x98, 0x10, 0x83, 0x0C, 0x3F, 0xC2, 0x04, 0x60, 0x66, 0x06, 0xC0, 0x30,
	698	0xFF, 0x18, 0x33, 0x03, 0x60, 0x6C, 0x0D, 0x83, 0x3F, 0xC6, 0x06, 0xC0,
	699	0x78, 0x0F, 0x01, 0xE0, 0x6F, 0xF8, 0x1F, 0x86, 0x19, 0x81, 0xA0, 0x3C,
	700	0x01, 0x80, 0x30, 0x06, 0x00, 0xC0, 0x68, 0x0D, 0x83, 0x18, 0x61, 0xF0,
	701	0xFF, 0x18, 0x33, 0x03, 0x60, 0x3C, 0x07, 0x80, 0xF0, 0x1E, 0x03, 0xC0,
	702	0x78, 0x0F, 0x03, 0x60, 0xCF, 0xF0, 0xFF, 0xE0, 0x30, 0x18, 0x0C, 0x06,
	703	0x03, 0xFD, 0x80, 0xC0, 0x60, 0x30, 0x18, 0x0F, 0xF8, 0xFF, 0xC0, 0xC0,
	704	0xC0, 0xC0, 0xC0, 0xFE, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0x0F, 0x83,
	705	0x0E, 0x60, 0x66, 0x03, 0xC0, 0x0C, 0x00, 0xC1, 0xFC, 0x03, 0xC0, 0x36,
	706	0x03, 0x60, 0x73, 0x0F, 0x0F, 0x10, 0xC0, 0x78, 0x0F, 0x01, 0xE0, 0x3C,
	707	0x07, 0x80, 0xFF, 0xFE, 0x03, 0xC0, 0x78, 0x0F, 0x01, 0xE0, 0x3C, 0x06,
	708	0xFF, 0xFF, 0xFF, 0xC0, 0x06, 0x0C, 0x18, 0x30, 0x60, 0xC1, 0x83, 0x07,
	709	0x8F, 0x1E, 0x27, 0x80, 0xC0, 0xD8, 0x33, 0x0C, 0x63, 0x0C, 0xC1, 0xB8,
	710	0x3F, 0x07, 0x30, 0xC3, 0x18, 0x63, 0x06, 0x60, 0x6C, 0x0C, 0xC0, 0xC0,
	711	0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xFF, 0xE0,
	712	0x3F, 0x01, 0xFC, 0x1F, 0xE0, 0xFD, 0x05, 0xEC, 0x6F, 0x63, 0x79, 0x13,
	713	0xCD, 0x9E, 0x6C, 0xF1, 0x47, 0x8E, 0x3C, 0x71, 0x80, 0xE0, 0x7C, 0x0F,
	714	0xC1, 0xE8, 0x3D, 0x87, 0x98, 0xF1, 0x1E, 0x33, 0xC3, 0x78, 0x6F, 0x07,
	715	0xE0, 0x7C, 0x0E, 0x0F, 0x81, 0x83, 0x18, 0x0C, 0xC0, 0x6C, 0x01, 0xE0,
	716	0x0F, 0x00, 0x78, 0x03, 0xC0, 0x1B, 0x01, 0x98, 0x0C, 0x60, 0xC0, 0xF8,
	717	0x00, 0xFF, 0x30, 0x6C, 0x0F, 0x03, 0xC0, 0xF0, 0x6F, 0xF3, 0x00, 0xC0,
	718	0x30, 0x0C, 0x03, 0x00, 0xC0, 0x00, 0x0F, 0x81, 0x83, 0x18, 0x0C, 0xC0,
	719	0x6C, 0x01, 0xE0, 0x0F, 0x00, 0x78, 0x03, 0xC0, 0x1B, 0x01, 0x98, 0x6C,
	720	0x60, 0xC0, 0xFB, 0x00, 0x08, 0xFF, 0x8C, 0x0E, 0xC0, 0x6C, 0x06, 0xC0,
	721	0x6C, 0x0C, 0xFF, 0x8C, 0x0E, 0xC0, 0x6C, 0x06, 0xC0, 0x6C, 0x06, 0xC0,
	722	0x70, 0x3F, 0x18, 0x6C, 0x0F, 0x03, 0xC0, 0x1E, 0x01, 0xF0, 0x0E, 0x00,
	723	0xF0, 0x3C, 0x0D, 0x86, 0x3F, 0x00, 0xFF, 0x86, 0x03, 0x01, 0x80, 0xC0,
	724	0x60, 0x30, 0x18, 0x0C, 0x06, 0x03, 0x01, 0x80, 0xC0, 0xC0, 0x78, 0x0F,
	725	0x01, 0xE0, 0x3C, 0x07, 0x80, 0xF0, 0x1E, 0x03, 0xC0, 0x78, 0x0F, 0x01,
	726	0xB0, 0x61, 0xF0, 0xC0, 0x6C, 0x0D, 0x81, 0x10, 0x63, 0x0C, 0x61, 0x04,
	727	0x60, 0xCC, 0x19, 0x01, 0x60, 0x3C, 0x07, 0x00, 0x60, 0xC1, 0x81, 0x30,
	728	0xE1, 0x98, 0x70, 0xCC, 0x28, 0x66, 0x26, 0x21, 0x13, 0x30, 0xC8, 0x98,
	729	0x6C, 0x4C, 0x14, 0x34, 0x0A, 0x1A, 0x07, 0x07, 0x03, 0x03, 0x80, 0x81,
	730	0x80, 0x60, 0x63, 0x0C, 0x30, 0xC1, 0x98, 0x0F, 0x00, 0xE0, 0x06, 0x00,
	731	0xF0, 0x19, 0x01, 0x98, 0x30, 0xC6, 0x0E, 0x60, 0x60, 0xC0, 0x36, 0x06,
	732	0x30, 0xC3, 0x0C, 0x19, 0x81, 0xD8, 0x0F, 0x00, 0x60, 0x06, 0x00, 0x60,
	733	0x06, 0x00, 0x60, 0x06, 0x00, 0xFF, 0xC0, 0x60, 0x30, 0x0C, 0x06, 0x03,
	734	0x01, 0xC0, 0x60, 0x30, 0x18, 0x06, 0x03, 0x00, 0xFF, 0xC0, 0xFB, 0x6D,
	735	0xB6, 0xDB, 0x6D, 0xB6, 0xE0, 0x84, 0x10, 0x84, 0x10, 0x84, 0x10, 0x84,
	736	0x10, 0x80, 0xED, 0xB6, 0xDB, 0x6D, 0xB6, 0xDB, 0xE0, 0x30, 0x60, 0xA2,
	737	0x44, 0xD8, 0xA1, 0x80, 0xFF, 0xC0, 0xC6, 0x30, 0x7E, 0x71, 0xB0, 0xC0,
	738	0x60, 0xF3, 0xDB, 0x0D, 0x86, 0xC7, 0x3D, 0xC0, 0xC0, 0x60, 0x30, 0x1B,
	739	0xCE, 0x36, 0x0F, 0x07, 0x83, 0xC1, 0xE0, 0xF0, 0x7C, 0x6D, 0xE0, 0x3C,
	740	0x66, 0xC3, 0xC0, 0xC0, 0xC0, 0xC0, 0xC3, 0x66, 0x3C, 0x03, 0x03, 0x03,
	741	0x3B, 0x67, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0x67, 0x3B, 0x3C, 0x66,
	742	0xC3, 0xC3, 0xFF, 0xC0, 0xC0, 0xC3, 0x66, 0x3C, 0x36, 0x6F, 0x66, 0x66,
	743	0x66, 0x66, 0x60, 0x3B, 0x67, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0x67,
	744	0x3B, 0x03, 0x03, 0xC6, 0x7C, 0xC0, 0xC0, 0xC0, 0xDE, 0xE3, 0xC3, 0xC3,
	745	0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xFF, 0xFF, 0xC0, 0x30, 0x03,
	746	0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0xE0, 0xC0, 0x60, 0x30, 0x18, 0x4C,
	747	0x46, 0x63, 0x61, 0xF0, 0xEC, 0x62, 0x31, 0x98, 0x6C, 0x30, 0xFF, 0xFF,
	748	0xFF, 0xC0, 0xDE, 0xF7, 0x1C, 0xF0, 0xC7, 0x86, 0x3C, 0x31, 0xE1, 0x8F,
	749	0x0C, 0x78, 0x63, 0xC3, 0x1E, 0x18, 0xC0, 0xDE, 0xE3, 0xC3, 0xC3, 0xC3,
	750	0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0x3C, 0x66, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3,
	751	0xC3, 0x66, 0x3C, 0xDE, 0x71, 0xB0, 0x78, 0x3C, 0x1E, 0x0F, 0x07, 0x83,
	752	0xE3, 0x6F, 0x30, 0x18, 0x0C, 0x00, 0x3B, 0x67, 0xC3, 0xC3, 0xC3, 0xC3,
	753	0xC3, 0xC3, 0x67, 0x3B, 0x03, 0x03, 0x03, 0xDF, 0x31, 0x8C, 0x63, 0x18,
	754	0xC6, 0x00, 0x3E, 0xE3, 0xC0, 0xC0, 0xE0, 0x3C, 0x07, 0xC3, 0xE3, 0x7E,
	755	0x66, 0xF6, 0x66, 0x66, 0x66, 0x67, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3,
	756	0xC3, 0xC3, 0xC7, 0x7B, 0xC1, 0xA0, 0x98, 0xCC, 0x42, 0x21, 0xB0, 0xD0,
	757	0x28, 0x1C, 0x0C, 0x00, 0xC6, 0x1E, 0x38, 0x91, 0xC4, 0xCA, 0x66, 0xD3,
	758	0x16, 0xD0, 0xA6, 0x87, 0x1C, 0x38, 0xC0, 0xC6, 0x00, 0x43, 0x62, 0x36,
	759	0x1C, 0x18, 0x1C, 0x3C, 0x26, 0x62, 0x43, 0xC1, 0x21, 0x98, 0xCC, 0x42,
	760	0x61, 0xB0, 0xD0, 0x38, 0x1C, 0x0C, 0x06, 0x03, 0x01, 0x03, 0x00, 0xFE,
	761	0x0C, 0x30, 0xC1, 0x86, 0x18, 0x20, 0xC1, 0xFC, 0x36, 0x66, 0x66, 0x6E,
	762	0xCE, 0x66, 0x66, 0x66, 0x30, 0xFF, 0xFF, 0xFF, 0xFF, 0xC0, 0xC6, 0x66,
	763	0x66, 0x67, 0x37, 0x66, 0x66, 0x66, 0xC0, 0x61, 0x24, 0x38 };
	764
	765	const GFXglyph FreeSans9pt7bGlyphs[] PROGMEM = {
	766	{ 0, 0, 0, 5, 0, 1 }, // 0x20 ' '
	767	{ 0, 2, 13, 6, 2, -12 }, // 0x21 '!'
	768	{ 4, 5, 4, 6, 1, -12 }, // 0x22 '"'
	769	{ 7, 10, 12, 10, 0, -11 }, // 0x23 '#'
	770	{ 22, 9, 16, 10, 1, -13 }, // 0x24 '$'
	771	{ 40, 16, 13, 16, 1, -12 }, // 0x25 '%'
	772	{ 66, 11, 13, 12, 1, -12 }, // 0x26 '&'
	773	{ 84, 2, 4, 4, 1, -12 }, // 0x27 '''
	774	{ 85, 4, 17, 6, 1, -12 }, // 0x28 '('
	775	{ 94, 4, 17, 6, 1, -12 }, // 0x29 ')'
	776	{ 103, 5, 5, 7, 1, -12 }, // 0x2A '*'
	777	{ 107, 6, 8, 11, 3, -7 }, // 0x2B '+'
	778	{ 113, 2, 4, 5, 2, 0 }, // 0x2C ','
	779	{ 114, 4, 1, 6, 1, -4 }, // 0x2D '-'
	780	{ 115, 2, 1, 5, 1, 0 }, // 0x2E '.'
	781	{ 116, 5, 13, 5, 0, -12 }, // 0x2F '/'
	782	{ 125, 8, 13, 10, 1, -12 }, // 0x30 '0'
	783	{ 138, 4, 13, 10, 3, -12 }, // 0x31 '1'
	784	{ 145, 9, 13, 10, 1, -12 }, // 0x32 '2'
	785	{ 160, 8, 13, 10, 1, -12 }, // 0x33 '3'
	786	{ 173, 7, 13, 10, 2, -12 }, // 0x34 '4'
	787	{ 185, 9, 13, 10, 1, -12 }, // 0x35 '5'
	788	{ 200, 9, 13, 10, 1, -12 }, // 0x36 '6'
	789	{ 215, 8, 13, 10, 0, -12 }, // 0x37 '7'
	790	{ 228, 9, 13, 10, 1, -12 }, // 0x38 '8'
	791	{ 243, 8, 13, 10, 1, -12 }, // 0x39 '9'
	792	{ 256, 2, 10, 5, 1, -9 }, // 0x3A ':'
	793	{ 259, 3, 12, 5, 1, -8 }, // 0x3B ';'
	794	{ 264, 9, 9, 11, 1, -8 }, // 0x3C '<'
	795	{ 275, 9, 4, 11, 1, -5 }, // 0x3D '='
	796	{ 280, 9, 9, 11, 1, -8 }, // 0x3E '>'
	797	{ 291, 9, 13, 10, 1, -12 }, // 0x3F '?'
	798	{ 306, 17, 16, 18, 1, -12 }, // 0x40 '@'
	799	{ 340, 12, 13, 12, 0, -12 }, // 0x41 'A'
	800	{ 360, 11, 13, 12, 1, -12 }, // 0x42 'B'
	801	{ 378, 11, 13, 13, 1, -12 }, // 0x43 'C'
	802	{ 396, 11, 13, 13, 1, -12 }, // 0x44 'D'
	803	{ 414, 9, 13, 11, 1, -12 }, // 0x45 'E'
	804	{ 429, 8, 13, 11, 1, -12 }, // 0x46 'F'
	805	{ 442, 12, 13, 14, 1, -12 }, // 0x47 'G'
	806	{ 462, 11, 13, 13, 1, -12 }, // 0x48 'H'
	807	{ 480, 2, 13, 5, 2, -12 }, // 0x49 'I'
	808	{ 484, 7, 13, 10, 1, -12 }, // 0x4A 'J'
	809	{ 496, 11, 13, 12, 1, -12 }, // 0x4B 'K'
	810	{ 514, 8, 13, 10, 1, -12 }, // 0x4C 'L'
	811	{ 527, 13, 13, 15, 1, -12 }, // 0x4D 'M'
	812	{ 549, 11, 13, 13, 1, -12 }, // 0x4E 'N'
	813	{ 567, 13, 13, 14, 1, -12 }, // 0x4F 'O'
	814	{ 589, 10, 13, 12, 1, -12 }, // 0x50 'P'
	815	{ 606, 13, 14, 14, 1, -12 }, // 0x51 'Q'
	816	{ 629, 12, 13, 13, 1, -12 }, // 0x52 'R'
	817	{ 649, 10, 13, 12, 1, -12 }, // 0x53 'S'
	818	{ 666, 9, 13, 11, 1, -12 }, // 0x54 'T'
	819	{ 681, 11, 13, 13, 1, -12 }, // 0x55 'U'
	820	{ 699, 11, 13, 12, 0, -12 }, // 0x56 'V'
	821	{ 717, 17, 13, 17, 0, -12 }, // 0x57 'W'
	822	{ 745, 12, 13, 12, 0, -12 }, // 0x58 'X'
	823	{ 765, 12, 13, 12, 0, -12 }, // 0x59 'Y'
	824	{ 785, 10, 13, 11, 1, -12 }, // 0x5A 'Z'
	825	{ 802, 3, 17, 5, 1, -12 }, // 0x5B '['
	826	{ 809, 5, 13, 5, 0, -12 }, // 0x5C '\'
	827	{ 818, 3, 17, 5, 0, -12 }, // 0x5D ']'
	828	{ 825, 7, 7, 8, 1, -12 }, // 0x5E '^'
	829	{ 832, 10, 1, 10, 0, 3 }, // 0x5F '_'
	830	{ 834, 4, 3, 5, 0, -12 }, // 0x60 '`'
	831	{ 836, 9, 10, 10, 1, -9 }, // 0x61 'a'
	832	{ 848, 9, 13, 10, 1, -12 }, // 0x62 'b'
	833	{ 863, 8, 10, 9, 1, -9 }, // 0x63 'c'
	834	{ 873, 8, 13, 10, 1, -12 }, // 0x64 'd'
	835	{ 886, 8, 10, 10, 1, -9 }, // 0x65 'e'
	836	{ 896, 4, 13, 5, 1, -12 }, // 0x66 'f'
	837	{ 903, 8, 14, 10, 1, -9 }, // 0x67 'g'
	838	{ 917, 8, 13, 10, 1, -12 }, // 0x68 'h'
	839	{ 930, 2, 13, 4, 1, -12 }, // 0x69 'i'
	840	{ 934, 4, 17, 4, 0, -12 }, // 0x6A 'j'
	841	{ 943, 9, 13, 9, 1, -12 }, // 0x6B 'k'
	842	{ 958, 2, 13, 4, 1, -12 }, // 0x6C 'l'
	843	{ 962, 13, 10, 15, 1, -9 }, // 0x6D 'm'
	844	{ 979, 8, 10, 10, 1, -9 }, // 0x6E 'n'
	845	{ 989, 8, 10, 10, 1, -9 }, // 0x6F 'o'
	846	{ 999, 9, 13, 10, 1, -9 }, // 0x70 'p'
	847	{ 1014, 8, 13, 10, 1, -9 }, // 0x71 'q'
	848	{ 1027, 5, 10, 6, 1, -9 }, // 0x72 'r'
	849	{ 1034, 8, 10, 9, 1, -9 }, // 0x73 's'
	850	{ 1044, 4, 12, 5, 1, -11 }, // 0x74 't'
	851	{ 1050, 8, 10, 10, 1, -9 }, // 0x75 'u'
	852	{ 1060, 9, 10, 9, 0, -9 }, // 0x76 'v'
	853	{ 1072, 13, 10, 13, 0, -9 }, // 0x77 'w'
	854	{ 1089, 8, 10, 9, 0, -9 }, // 0x78 'x'
	855	{ 1099, 9, 14, 9, 0, -9 }, // 0x79 'y'
	856	{ 1115, 7, 10, 9, 1, -9 }, // 0x7A 'z'
	857	{ 1124, 4, 17, 6, 1, -12 }, // 0x7B '{'
	858	{ 1133, 2, 17, 4, 2, -12 }, // 0x7C '\|'
	859	{ 1138, 4, 17, 6, 1, -12 }, // 0x7D '}'
	860	{ 1147, 7, 3, 9, 1, -7 } }; // 0x7E '~'
	861
	862	const GFXfont FreeSans9pt7b PROGMEM = {
	863	(uint8_t *)FreeSans9pt7bBitmaps,
	864	(GFXglyph *)FreeSans9pt7bGlyphs,
	865	0x20, 0x7E, 22 };
	866
	867	// Approx. 1822 bytes
	868	// Created by http://oleddisplay.squix.ch/ Consider a donation
	869	// In case of problems make sure that you are using the font file with the correct version!
	870	const uint8_t URW_Gothic_L_Book_16Bitmaps[] PROGMEM = {
	871
	872	// Bitmap Data:
	873	0x00, // ' '
	874	0xFF,0xB0, // '!'
	875	0xB6,0xD0, // '"'
	876	0x11,0x08,0x84,0x82,0x4F,0xF9,0x10,0x89,0xFF,0x24,0x22,0x11,0x08,0x80, // '#'
	877	0x21,0xCC,0xA1,0x83,0x07,0x06,0x04,0x18,0x72,0x70,0x80, // '$'
	878	0x78,0x8C,0xD8,0x85,0x08,0x70,0xCE,0x07,0xA0,0x06,0x00,0x5E,0x0F,0x30,0xA1,0x0B,0x31,0x1E, // '%'
	879	0x3C,0x08,0xC1,0x08,0x21,0x03,0xC4,0xF1,0x13,0x64,0x38,0x83,0x10,0x71,0x1B,0x1E,0x30, // '&'
	880	0xF0, // '''
	881	0x13,0x64,0x88,0x88,0x8C,0x46,0x30, // '('
	882	0x8C,0x62,0x11,0x11,0x13,0x26,0xC8, // ')'
	883	0x52,0xBE,0x45,0x00, // '*'
	884	0x10,0x20,0x40,0x8F,0xE2,0x04,0x08, // '+'
	885	0x29,0x00, // ','
	886	0xF0, // '-'
	887	0xC0, // '.'
	888	0x08,0x46,0x21,0x18,0x84,0x62,0x11,0x88,0x40, // '/'
	889	0x38,0x8A,0x0C,0x18,0x30,0x60,0xC1,0x83,0x05,0x11,0xC0, // '0'
	890	0xE4,0x92,0x49,0x24,0x90, // '1'
	891	0x79,0x8A,0x0C,0x10,0x20,0x83,0x0C,0x30,0xC3,0x07,0xF0, // '2'
	892	0x3C,0x26,0x42,0x02,0x06,0x1C,0x02,0x01,0xC1,0x41,0x62,0x3C, // '3'
	893	0x06,0x06,0x0A,0x0A,0x12,0x32,0x22,0x42,0xC2,0xFF,0x02,0x02, // '4'
	894	0x3E,0x20,0x60,0x40,0x7C,0x62,0x01,0x01,0x81,0xC1,0x62,0x3C, // '5'
	895	0x08,0x18,0x10,0x20,0x7C,0x42,0x81,0x81,0x81,0x81,0x42,0x3C, // '6'
	896	0xFE,0x0C,0x10,0x20,0x81,0x04,0x08,0x30,0x41,0x82,0x00, // '7'
	897	0x38,0x89,0x12,0x26,0x47,0x11,0x41,0x83,0x05,0x11,0xC0, // '8'
	898	0x3C,0x42,0x81,0x81,0x81,0x81,0x42,0x3E,0x04,0x08,0x18,0x10, // '9'
	899	0xC3, // ':'
	900	0x50,0x07,0x80, // ';'
	901	0x01,0x06,0x38,0xE0,0xC0,0x70,0x0C,0x03, // '<'
	902	0xFF,0x00,0x00,0xFF, // '='
	903	0x80,0xE0,0x38,0x06,0x03,0x1C,0x70,0xC0, // '>'
	904	0x38,0x8A,0x0C,0x10,0x20,0x82,0x08,0x10,0x00,0x40,0x80, // '?'
	905	0x0F,0x83,0x04,0x67,0xA4,0xC9,0x88,0x99,0x09,0x91,0x19,0x12,0x53,0x64,0xDC,0x30,0x60,0xF8, // '@'
	906	0x06,0x00,0x60,0x0B,0x00,0x90,0x19,0x01,0x08,0x30,0x83,0xFC,0x20,0x46,0x06,0x40,0x2C,0x02, // 'A'
	907	0xFC,0x86,0x82,0x82,0x86,0xFC,0x82,0x81,0x81,0x81,0x82,0xFC, // 'B'
	908	0x0F,0x86,0x19,0x00,0xA0,0x08,0x01,0x00,0x20,0x04,0x00,0x40,0x08,0x04,0xC3,0x07,0xC0, // 'C'
	909	0xFC,0x20,0xC8,0x0A,0x03,0x80,0x60,0x18,0x06,0x01,0x80,0xE0,0x28,0x33,0xF0, // 'D'
	910	0xFE,0x08,0x20,0x82,0x0F,0xE0,0x82,0x08,0x3F, // 'E'
	911	0xFE,0x08,0x20,0x82,0x0F,0xE0,0x82,0x08,0x20, // 'F'
	912	0x0F,0x83,0x0C,0x40,0x24,0x00,0x80,0x08,0x00,0x80,0x08,0xFF,0x40,0x14,0x02,0x30,0x60,0xF8, // 'G'
	913	0x80,0xC0,0x60,0x30,0x18,0x0F,0xFE,0x03,0x01,0x80,0xC0,0x60,0x30,0x10, // 'H'
	914	0xFF,0xF0, // 'I'
	915	0x04,0x10,0x41,0x04,0x10,0x41,0x06,0x1C,0xDE, // 'J'
	916	0x83,0x86,0x8C,0x88,0x90,0xB0,0xF0,0xD8,0x88,0x84,0x86,0x83, // 'K'
	917	0x82,0x08,0x20,0x82,0x08,0x20,0x82,0x08,0x3F, // 'L'
	918	0xC0,0x3C,0x03,0xE0,0x7A,0x05,0xB0,0xD9,0x09,0x90,0x98,0x91,0x89,0x18,0xF1,0x86,0x18,0x61, // 'M'
	919	0xC0,0x78,0x1A,0x06,0x41,0x98,0x63,0x18,0x46,0x09,0x83,0x60,0x78,0x0E,0x01, // 'N'
	920	0x0F,0x03,0x0C,0x40,0x24,0x02,0x80,0x18,0x01,0x80,0x18,0x01,0x40,0x24,0x02,0x30,0xC0,0xF0, // 'O'
	921	0xFC,0x82,0x81,0x81,0x81,0x82,0xFC,0x80,0x80,0x80,0x80,0x80, // 'P'
	922	0x0F,0x83,0x0C,0x40,0x24,0x03,0x80,0x18,0x01,0x80,0x1F,0xC1,0x43,0x36,0x0A,0x30,0xC0,0xFB, // 'Q'
	923	0xFC,0x82,0x81,0x81,0x81,0x83,0x9E,0x98,0x88,0x84,0x86,0x82, // 'R'
	924	0x7B,0x38,0x60,0xC1,0xC1,0x81,0x06,0x1C,0xDE, // 'S'
	925	0xFE,0x20,0x40,0x81,0x02,0x04,0x08,0x10,0x20,0x40,0x80, // 'T'
	926	0x81,0x81,0x81,0x81,0x81,0x81,0x81,0x81,0x81,0x81,0x42,0x3C, // 'U'
	927	0xC0,0x28,0x09,0x01,0x10,0x62,0x08,0x61,0x04,0x40,0x88,0x0B,0x01,0x40,0x38,0x02,0x00, // 'V'
	928	0xC1,0x02,0x83,0x05,0x0E,0x12,0x14,0x26,0x28,0x44,0x49,0x89,0x92,0x12,0x24,0x14,0x68,0x28,0x70,0x60,0xC0,0xC1,0x80, // 'W'
	929	0x40,0x98,0x42,0x30,0x48,0x1C,0x03,0x00,0xC0,0x58,0x32,0x08,0x44,0x1B,0x02, // 'X'
	930	0x80,0xA0,0x90,0x44,0x42,0x20,0xA0,0x50,0x10,0x08,0x04,0x02,0x01,0x00, // 'Y'
	931	0xFE,0x02,0x06,0x04,0x08,0x18,0x10,0x30,0x20,0x40,0x40,0xFF, // 'Z'
	932	0x2E,0x49,0x24,0x92,0x66,0x40, // '['
	933	0x41,0x06,0x08,0x20,0x41,0x06,0x08,0x20,0x41, // '\'
	934	0x99,0x92,0x49,0x24,0x9D,0x00, // ']'
	935	0x0C,0x06,0x05,0x82,0x42,0x21,0x09,0x84,0x81,0xC0,0x80, // '^'
	936	0xFF, // '_'
	937	0xC3, // '`'
	938	0x3E,0xB1,0xF0,0x70,0x18,0x0C,0x07,0x06,0xC7,0x3E,0x80, // 'a'
	939	0x80,0x40,0x20,0x17,0xCE,0x36,0x0E,0x03,0x01,0x80,0xE0,0xF8,0xD7,0xC0, // 'b'
	940	0x3E,0x31,0xB0,0x70,0x08,0x04,0x03,0x06,0xC6,0x3E,0x00, // 'c'
	941	0x00,0x80,0x40,0x27,0xD6,0x3E,0x0E,0x03,0x01,0x80,0xE0,0xD8,0xE3,0xD0, // 'd'
	942	0x3C,0x21,0xA0,0x50,0x3F,0xFC,0x02,0x04,0x86,0x3C,0x00, // 'e'
	943	0x34,0x4F,0x44,0x44,0x44,0x44, // 'f'
	944	0x3E,0xB1,0xF0,0x70,0x18,0x0C,0x07,0x06,0xC7,0x3E,0xE0,0x58,0x47,0xC0, // 'g'
	945	0x80,0x80,0x80,0xBC,0xC2,0x81,0x81,0x81,0x81,0x81,0x81,0x81, // 'h'
	946	0xDF,0xF0, // 'i'
	947	0x24,0x12,0x49,0x24,0x92,0xF0, // 'j'
	948	0x81,0x02,0x04,0x28,0xD3,0x24,0x50,0xF1,0xB2,0x34,0x20, // 'k'
	949	0xFF,0xF0, // 'l'
	950	0xB8,0xE6,0x28,0xA0,0x83,0x04,0x18,0x20,0xC1,0x06,0x08,0x30,0x41,0x82,0x08, // 'm'
	951	0xBC,0xC2,0x81,0x81,0x81,0x81,0x81,0x81,0x81, // 'n'
	952	0x3E,0x31,0xB0,0x70,0x18,0x0C,0x07,0x06,0xC6,0x3E,0x00, // 'o'
	953	0xBE,0x71,0xB0,0x70,0x18,0x0C,0x07,0x07,0xC6,0xBE,0x40,0x20,0x10,0x00, // 'p'
	954	0x3E,0xB1,0xF0,0x70,0x18,0x0C,0x07,0x06,0xC7,0x3E,0x80,0x40,0x20,0x10, // 'q'
	955	0xBA,0x49,0x24,0x80, // 'r'
	956	0x74,0x61,0x87,0x06,0x31,0x70, // 's'
	957	0x21,0x09,0xF2,0x10,0x84,0x21,0x08,0x40, // 't'
	958	0x81,0x81,0x81,0x81,0x81,0x81,0x81,0x43,0x3D, // 'u'
	959	0xC1,0xA0,0x90,0xC4,0x42,0x21,0xA0,0x50,0x38,0x08,0x00, // 'v'
	960	0x80,0x0A,0x10,0xD0,0xC4,0xCA,0x22,0x52,0x12,0xD0,0x72,0x83,0x18,0x18,0xC0, // 'w'
	961	0xC2,0x46,0x2C,0x18,0x18,0x38,0x24,0x46,0xC2, // 'x'
	962	0xC1,0x41,0x42,0x22,0x26,0x34,0x1C,0x18,0x18,0x10,0x10,0x30, // 'y'
	963	0xFC,0x08,0x20,0xC1,0x04,0x18,0x20,0xFE, // 'z'
	964	0x69,0x24,0xB6,0x49,0x24,0x40, // '{'
	965	0xFF,0xF0, // '\|'
	966	0xC9,0x24,0x8B,0x49,0x25,0x00 // '}'
	967	};
	968	const GFXglyph URW_Gothic_L_Book_16Glyphs[] PROGMEM = {
	969	// bitmapOffset, width, height, xAdvance, xOffset, yOffset
	970	{ 0, 1, 1, 5, 0, 0 }, // ' '
	971	{ 1, 1, 12, 6, 2, -12 }, // '!'
	972	{ 3, 3, 4, 6, 1, -12 }, // '"'
	973	{ 5, 9, 12, 10, 0, -12 }, // '#'
	974	{ 19, 6, 14, 10, 2, -13 }, // '$'
	975	{ 30, 12, 12, 13, 0, -12 }, // '%'
	976	{ 48, 11, 12, 13, 1, -12 }, // '&'
	977	{ 65, 1, 4, 4, 1, -12 }, // '''
	978	{ 66, 4, 14, 7, 1, -12 }, // '('
	979	{ 73, 4, 14, 7, 1, -12 }, // ')'
	980	{ 80, 5, 5, 8, 1, -12 }, // '*'
	981	{ 84, 7, 8, 11, 1, -9 }, // '+'
	982	{ 91, 3, 3, 5, 1, -2 }, // ','
	983	{ 93, 4, 1, 6, 1, -5 }, // '-'
	984	{ 94, 1, 2, 5, 2, -2 }, // '.'
	985	{ 95, 5, 14, 8, 1, -12 }, // '/'
	986	{ 104, 7, 12, 10, 1, -12 }, // '0'
	987	{ 115, 3, 12, 10, 3, -12 }, // '1'
	988	{ 120, 7, 12, 10, 1, -12 }, // '2'
	989	{ 131, 8, 12, 10, 0, -12 }, // '3'
	990	{ 143, 8, 12, 10, 0, -12 }, // '4'
	991	{ 155, 8, 12, 10, 0, -12 }, // '5'
	992	{ 167, 8, 12, 10, 0, -12 }, // '6'
	993	{ 179, 7, 12, 10, 1, -12 }, // '7'
	994	{ 190, 7, 12, 10, 1, -12 }, // '8'
	995	{ 201, 8, 12, 10, 0, -12 }, // '9'
	996	{ 213, 1, 8, 5, 2, -8 }, // ':'
	997	{ 214, 2, 9, 5, 1, -8 }, // ';'
	998	{ 217, 8, 8, 11, 1, -9 }, // '<'
	999	{ 225, 8, 4, 11, 1, -7 }, // '='
	1000	{ 229, 8, 8, 11, 1, -9 }, // '>'
	1001	{ 237, 7, 12, 10, 1, -12 }, // '?'
	1002	{ 248, 12, 12, 15, 1, -12 }, // '@'
	1003	{ 266, 12, 12, 13, 0, -12 }, // 'A'
	1004	{ 284, 8, 12, 10, 1, -12 }, // 'B'
	1005	{ 296, 11, 12, 14, 1, -12 }, // 'C'
	1006	{ 313, 10, 12, 13, 1, -12 }, // 'D'
	1007	{ 328, 6, 12, 10, 1, -12 }, // 'E'
	1008	{ 337, 6, 12, 9, 1, -12 }, // 'F'
	1009	{ 346, 12, 12, 15, 1, -12 }, // 'G'
	1010	{ 364, 9, 12, 12, 1, -12 }, // 'H'
	1011	{ 378, 1, 12, 5, 1, -12 }, // 'I'
	1012	{ 380, 6, 12, 9, 0, -12 }, // 'J'
	1013	{ 389, 8, 12, 10, 1, -12 }, // 'K'
	1014	{ 401, 6, 12, 8, 1, -12 }, // 'L'
	1015	{ 410, 12, 12, 16, 1, -12 }, // 'M'
	1016	{ 428, 10, 12, 13, 1, -12 }, // 'N'
	1017	{ 443, 12, 12, 15, 1, -12 }, // 'O'
	1018	{ 461, 8, 12, 10, 1, -12 }, // 'P'
	1019	{ 473, 12, 12, 15, 1, -12 }, // 'Q'
	1020	{ 491, 8, 12, 11, 1, -12 }, // 'R'
	1021	{ 503, 6, 12, 9, 1, -12 }, // 'S'
	1022	{ 512, 7, 12, 8, 0, -12 }, // 'T'
	1023	{ 523, 8, 12, 11, 1, -12 }, // 'U'
	1024	{ 535, 11, 12, 12, 0, -12 }, // 'V'
	1025	{ 552, 15, 12, 16, 0, -12 }, // 'W'
	1026	{ 575, 10, 12, 11, 0, -12 }, // 'X'
	1027	{ 590, 9, 12, 10, 0, -12 }, // 'Y'
	1028	{ 604, 8, 12, 9, 0, -12 }, // 'Z'
	1029	{ 616, 3, 14, 7, 2, -12 }, // '['
	1030	{ 622, 6, 12, 11, 1, -12 }, // '\'
	1031	{ 631, 3, 14, 7, 1, -12 }, // ']'
	1032	{ 637, 9, 9, 11, 0, -12 }, // '^'
	1033	{ 648, 8, 1, 9, 0, 1 }, // '_'
	1034	{ 649, 4, 2, 7, 1, -12 }, // '`'
	1035	{ 650, 9, 9, 12, 1, -9 }, // 'a'
	1036	{ 661, 9, 12, 12, 1, -12 }, // 'b'
	1037	{ 675, 9, 9, 11, 1, -9 }, // 'c'
	1038	{ 686, 9, 12, 12, 1, -12 }, // 'd'
	1039	{ 700, 9, 9, 11, 1, -9 }, // 'e'
	1040	{ 711, 4, 12, 6, 1, -12 }, // 'f'
	1041	{ 717, 9, 12, 12, 1, -9 }, // 'g'
	1042	{ 731, 8, 12, 11, 1, -12 }, // 'h'
	1043	{ 743, 1, 12, 4, 1, -12 }, // 'i'
	1044	{ 745, 3, 15, 4, -1, -12 }, // 'j'
	1045	{ 751, 7, 12, 9, 1, -12 }, // 'k'
	1046	{ 762, 1, 12, 4, 1, -12 }, // 'l'
	1047	{ 764, 13, 9, 16, 1, -9 }, // 'm'
	1048	{ 779, 8, 9, 11, 1, -9 }, // 'n'
	1049	{ 788, 9, 9, 11, 1, -9 }, // 'o'
	1050	{ 799, 9, 12, 12, 1, -9 }, // 'p'
	1051	{ 813, 9, 12, 12, 1, -9 }, // 'q'
	1052	{ 827, 3, 9, 6, 1, -9 }, // 'r'
	1053	{ 831, 5, 9, 7, 1, -9 }, // 's'
	1054	{ 837, 5, 12, 6, 0, -12 }, // 't'
	1055	{ 845, 8, 9, 11, 1, -9 }, // 'u'
	1056	{ 854, 9, 9, 10, 0, -9 }, // 'v'
	1057	{ 865, 13, 9, 14, 0, -9 }, // 'w'
	1058	{ 880, 8, 9, 9, 0, -9 }, // 'x'
	1059	{ 889, 8, 12, 10, 0, -9 }, // 'y'
	1060	{ 901, 7, 9, 8, 0, -9 }, // 'z'
	1061	{ 909, 3, 14, 7, 1, -12 }, // '{'
	1062	{ 915, 1, 12, 12, 5, -12 }, // '\|'
	1063	{ 917, 3, 14, 7, 1, -12 } // '}'
	1064	};
	1065	const GFXfont URW_Gothic_L_Book_16 PROGMEM = {
	1066	(uint8_t )URW_Gothic_L_Book_16Bitmaps,(GFXglyph )URW_Gothic_L_Book_16Glyphs,0x20, 0x7E, 20};
	1067
	1068	// Created by http://oleddisplay.squix.ch/ Consider a donation
	1069	// In case of problems make sure that you are using the font file with the correct version!
	1070	const uint8_t Open_Sans_Condensed_Light_16Bitmaps[] PROGMEM = {
	1071
	1072	// Bitmap Data:
	1073	0x00, // ' '
	1074	0xAA,0xAA,0x0A, // '!'
	1075	0xB6,0xD0, // '"'
	1076	0x24,0x48,0x91,0x27,0xE5,0x0A,0x7E,0x48,0x91,0x22,0x40, // '#'
	1077	0x22,0x7A,0xAA,0xC3,0x33,0x3E,0x22, // '$'
	1078	0xC5,0x52,0xA5,0x4B,0x16,0xF6,0x8D,0x2A,0x54,0xAA,0x30, // '%'
	1079	0x62,0x49,0x24,0x61,0x0A,0x29,0x9A,0x29,0xB9, // '&'
	1080	0xF0, // '''
	1081	0x5A,0xAA,0xAA,0x94, // '('
	1082	0xA5,0x55,0x55,0x68, // ')'
	1083	0x22,0xF6,0x90, // '*'
	1084	0x10,0x41,0x3F,0x10,0x41,0x00, // '+'
	1085	0xF0, // ','
	1086	0xF0, // '-'
	1087	0xC0, // '.'
	1088	0x04,0x20,0x84,0x10,0x42,0x08,0x21,0x04,0x20, // '/'
	1089	0x69,0x99,0x99,0x99,0x99,0x96, // '0'
	1090	0x2E,0x92,0x49,0x24,0x90, // '1'
	1091	0xE1,0x11,0x11,0x22,0x48,0x8F, // '2'
	1092	0xE1,0x11,0x16,0x11,0x11,0x1E, // '3'
	1093	0x08,0x61,0x8A,0x29,0x24,0x92,0x8B,0xF0,0x82, // '4'
	1094	0xF8,0x88,0x8E,0x11,0x11,0x1E, // '5'
	1095	0x74,0x88,0x8E,0x99,0x99,0x96, // '6'
	1096	0xF8,0x42,0x10,0x88,0x42,0x21,0x08,0x80, // '7'
	1097	0x64,0xA5,0x29,0x32,0x92,0x8C,0x64,0xC0, // '8'
	1098	0x69,0x99,0x99,0xF1,0x11,0x2C, // '9'
	1099	0xC1,0x80, // ':'
	1100	0xC1,0xE0, // ';'
	1101	0x04,0x66,0x20,0x60,0x60,0x40, // '<'
	1102	0xFC,0x00,0x3F, // '='
	1103	0x81,0x81,0x81,0x19,0x88,0x00, // '>'
	1104	0x70,0x82,0x11,0x08,0x84,0x40,0x18,0xC0, // '?'
	1105	0x3C,0x62,0x41,0x9D,0xA5,0xA5,0xA5,0xA5,0xAD,0x9E,0x80,0x40,0x38, // '@'
	1106	0x20,0xC3,0x0C,0x51,0x24,0x9E,0x4A,0x18,0x61, // 'A'
	1107	0xF4,0x63,0x18,0xFA,0x31,0x8C,0x63,0xE0, // 'B'
	1108	0x39,0x08,0x20,0x82,0x08,0x20,0x82,0x04,0x0E, // 'C'
	1109	0xF2,0x28,0x61,0x86,0x18,0x61,0x86,0x18,0xBC, // 'D'
	1110	0xF8,0x88,0x8F,0x88,0x88,0x8F, // 'E'
	1111	0xFC,0x21,0x08,0x43,0xF0,0x84,0x21,0x00, // 'F'
	1112	0x39,0x18,0x20,0x82,0x08,0xE1,0x86,0x14,0x4F, // 'G'
	1113	0x86,0x18,0x61,0x87,0xF8,0x61,0x86,0x18,0x61, // 'H'
	1114	0xFF,0xF0, // 'I'
	1115	0x24,0x92,0x49,0x24,0x92,0x70, // 'J'
	1116	0x8C,0xA5,0x4A,0x62,0x94,0x94,0xA5,0x10, // 'K'
	1117	0x84,0x21,0x08,0x42,0x10,0x84,0x21,0xF0, // 'L'
	1118	0xC1,0xE0,0xF0,0x74,0x5A,0x2D,0x16,0x8B,0x29,0x94,0xCA,0x66,0x31,0x10, // 'M'
	1119	0xC3,0x86,0x8D,0x1A,0x32,0x64,0xC5,0x8B,0x0E,0x1C,0x30, // 'N'
	1120	0x79,0x28,0x61,0x86,0x18,0x61,0x86,0x14,0x9E, // 'O'
	1121	0xF4,0x63,0x18,0xC7,0xD0,0x84,0x21,0x00, // 'P'
	1122	0x79,0x28,0x61,0x86,0x18,0x61,0x86,0x14,0x9E,0x08,0x20,0x80, // 'Q'
	1123	0xF2,0x28,0xA2,0x8A,0x2F,0x24,0x92,0x28,0xA1, // 'R'
	1124	0x78,0x88,0x84,0x31,0x11,0x1E, // 'S'
	1125	0xFC,0x82,0x08,0x20,0x82,0x08,0x20,0x82,0x08, // 'T'
	1126	0x86,0x18,0x61,0x86,0x18,0x61,0x86,0x14,0x9E, // 'U'
	1127	0x86,0x18,0x52,0x49,0x24,0x94,0x30,0xC3,0x0C, // 'V'
	1128	0x84,0x30,0x86,0x28,0xA5,0x24,0xA4,0x94,0x92,0x92,0x8C,0x31,0x86,0x30,0xC6,0x18,0xC0, // 'W'
	1129	0x45,0x24,0x8A,0x30,0x43,0x0C,0x49,0x24,0xA1, // 'X'
	1130	0x8C,0x54,0xA5,0x28,0x84,0x21,0x08,0x40, // 'Y'
	1131	0xF8,0x84,0x21,0x10,0x84,0x42,0x11,0xF0, // 'Z'
	1132	0xF2,0x49,0x24,0x92,0x49,0x38, // '['
	1133	0x81,0x04,0x08,0x20,0x81,0x04,0x10,0x20,0x81, // '\'
	1134	0xE4,0x92,0x49,0x24,0x92,0x78, // ']'
	1135	0x20,0xC4,0x92,0x84, // '^'
	1136	0xFE, // '_'
	1137	0x48,0x80, // '`'
	1138	0x61,0x11,0x79,0x99,0xF0, // 'a'
	1139	0x84,0x21,0x0F,0x66,0x31,0x8C,0x63,0x9B,0x00, // 'b'
	1140	0x78,0x88,0x88,0x88,0x70, // 'c'
	1141	0x08,0x42,0x16,0xCE,0x31,0x8C,0x63,0x36,0x80, // 'd'
	1142	0x69,0x99,0xF8,0x88,0x70, // 'e'
	1143	0x34,0x44,0xF4,0x44,0x44,0x44,0x40, // 'f'
	1144	0x3D,0x24,0x92,0x48,0xC4,0x10,0x39,0x18,0x61,0x78, // 'g'
	1145	0x84,0x21,0x0B,0x66,0x31,0x8C,0x63,0x18,0x80, // 'h'
	1146	0xDF,0xF0, // 'i'
	1147	0x51,0x55,0x55,0x56, // 'j'
	1148	0x84,0x21,0x09,0x4A,0x94,0xE4,0xA5,0x28,0x80, // 'k'
	1149	0xFF,0xF8, // 'l'
	1150	0xF6,0x99,0x89,0x89,0x89,0x89,0x89,0x89,0x89, // 'm'
	1151	0xB6,0x63,0x18,0xC6,0x31,0x88, // 'n'
	1152	0x74,0x63,0x18,0xC6,0x31,0x70, // 'o'
	1153	0xB6,0x63,0x18,0xC6,0x39,0xB4,0x21,0x08,0x00, // 'p'
	1154	0x7C,0xE3,0x18,0xC6,0x33,0x68,0x42,0x10,0x80, // 'q'
	1155	0xF2,0x49,0x24,0x80, // 'r'
	1156	0xF2,0x44,0x49,0xE0, // 's'
	1157	0x44,0xF4,0x44,0x44,0x44,0x30, // 't'
	1158	0x8C,0x63,0x18,0xC6,0x33,0x68, // 'u'
	1159	0x8C,0x62,0xA5,0x29,0x44,0x20, // 'v'
	1160	0x88,0xC4,0x55,0x4A,0xA5,0x52,0xA9,0x54,0x44,0x22,0x00, // 'w'
	1161	0x8A,0x94,0x42,0x11,0x4A,0x88, // 'x'
	1162	0x8C,0x54,0xA5,0x29,0x44,0x21,0x08,0x8C,0x00, // 'y'
	1163	0x72,0x22,0x44,0x44,0xF0, // 'z'
	1164	0x32,0x44,0x44,0x48,0x44,0x44,0x42,0x10, // '{'
	1165	0x55,0x55,0x55,0x55,0x40, // '\|'
	1166	0x84,0x22,0x22,0x21,0x22,0x22,0x24,0x80 // '}'
	1167	};
	1168	const GFXglyph Open_Sans_Condensed_Light_16Glyphs[] PROGMEM = {
	1169	// bitmapOffset, width, height, xAdvance, xOffset, yOffset
	1170	{ 0, 1, 1, 4, 0, 0 }, // ' '
	1171	{ 1, 2, 12, 5, 1, -12 }, // '!'
	1172	{ 4, 3, 4, 6, 1, -12 }, // '"'
	1173	{ 6, 7, 12, 8, 0, -12 }, // '#'
	1174	{ 17, 4, 14, 7, 1, -13 }, // '$'
	1175	{ 24, 7, 12, 10, 1, -12 }, // '%'
	1176	{ 35, 6, 12, 8, 1, -12 }, // '&'
	1177	{ 44, 1, 4, 4, 1, -12 }, // '''
	1178	{ 45, 2, 15, 5, 1, -12 }, // '('
	1179	{ 49, 2, 15, 5, 1, -12 }, // ')'
	1180	{ 53, 4, 5, 7, 1, -13 }, // '*'
	1181	{ 56, 6, 7, 7, 0, -10 }, // '+'
	1182	{ 62, 1, 4, 4, 1, -2 }, // ','
	1183	{ 63, 4, 1, 5, 0, -5 }, // '-'
	1184	{ 64, 1, 2, 4, 1, -2 }, // '.'
	1185	{ 65, 6, 12, 7, 0, -12 }, // '/'
	1186	{ 74, 4, 12, 7, 1, -12 }, // '0'
	1187	{ 80, 3, 12, 7, 1, -12 }, // '1'
	1188	{ 85, 4, 12, 7, 1, -12 }, // '2'
	1189	{ 91, 4, 12, 7, 1, -12 }, // '3'
	1190	{ 97, 6, 12, 7, 0, -12 }, // '4'
	1191	{ 106, 4, 12, 7, 1, -12 }, // '5'
	1192	{ 112, 4, 12, 7, 1, -12 }, // '6'
	1193	{ 118, 5, 12, 7, 0, -12 }, // '7'
	1194	{ 126, 5, 12, 7, 1, -12 }, // '8'
	1195	{ 134, 4, 12, 7, 1, -12 }, // '9'
	1196	{ 140, 1, 9, 4, 1, -9 }, // ':'
	1197	{ 142, 1, 11, 4, 1, -9 }, // ';'
	1198	{ 144, 6, 7, 7, 0, -10 }, // '<'
	1199	{ 150, 6, 4, 7, 0, -8 }, // '='
	1200	{ 153, 6, 7, 7, 0, -10 }, // '>'
	1201	{ 159, 5, 12, 6, 0, -12 }, // '?'
	1202	{ 167, 8, 13, 11, 1, -12 }, // '@'
	1203	{ 180, 6, 12, 7, 0, -12 }, // 'A'
	1204	{ 189, 5, 12, 8, 1, -12 }, // 'B'
	1205	{ 197, 6, 12, 8, 1, -12 }, // 'C'
	1206	{ 206, 6, 12, 9, 1, -12 }, // 'D'
	1207	{ 215, 4, 12, 7, 1, -12 }, // 'E'
	1208	{ 221, 5, 12, 7, 1, -12 }, // 'F'
	1209	{ 229, 6, 12, 9, 1, -12 }, // 'G'
	1210	{ 238, 6, 12, 9, 1, -12 }, // 'H'
	1211	{ 247, 1, 12, 4, 1, -12 }, // 'I'
	1212	{ 249, 3, 15, 4, -1, -12 }, // 'J'
	1213	{ 255, 5, 12, 7, 1, -12 }, // 'K'
	1214	{ 263, 5, 12, 7, 1, -12 }, // 'L'
	1215	{ 271, 9, 12, 12, 1, -12 }, // 'M'
	1216	{ 285, 7, 12, 10, 1, -12 }, // 'N'
	1217	{ 296, 6, 12, 9, 1, -12 }, // 'O'
	1218	{ 305, 5, 12, 8, 1, -12 }, // 'P'
	1219	{ 313, 6, 15, 9, 1, -12 }, // 'Q'
	1220	{ 325, 6, 12, 8, 1, -12 }, // 'R'
	1221	{ 334, 4, 12, 7, 1, -12 }, // 'S'
	1222	{ 340, 6, 12, 7, 0, -12 }, // 'T'
	1223	{ 349, 6, 12, 9, 1, -12 }, // 'U'
	1224	{ 358, 6, 12, 7, 0, -12 }, // 'V'
	1225	{ 367, 11, 12, 12, 0, -12 }, // 'W'
	1226	{ 384, 6, 12, 7, 0, -12 }, // 'X'
	1227	{ 393, 5, 12, 6, 0, -12 }, // 'Y'
	1228	{ 401, 5, 12, 6, 0, -12 }, // 'Z'
	1229	{ 409, 3, 15, 6, 1, -12 }, // '['
	1230	{ 415, 6, 12, 7, 0, -12 }, // '\'
	1231	{ 424, 3, 15, 6, 1, -12 }, // ']'
	1232	{ 430, 6, 5, 7, 0, -12 }, // '^'
	1233	{ 434, 7, 1, 8, 0, 1 }, // '_'
	1234	{ 435, 3, 3, 10, 3, -13 }, // '`'
	1235	{ 437, 4, 9, 7, 1, -9 }, // 'a'
	1236	{ 442, 5, 13, 8, 1, -13 }, // 'b'
	1237	{ 451, 4, 9, 6, 1, -9 }, // 'c'
	1238	{ 456, 5, 13, 8, 1, -13 }, // 'd'
	1239	{ 465, 4, 9, 7, 1, -9 }, // 'e'
	1240	{ 470, 4, 13, 5, 0, -13 }, // 'f'
	1241	{ 477, 6, 13, 7, 0, -9 }, // 'g'
	1242	{ 487, 5, 13, 8, 1, -13 }, // 'h'
	1243	{ 496, 1, 12, 4, 1, -12 }, // 'i'
	1244	{ 498, 2, 16, 4, 0, -12 }, // 'j'
	1245	{ 502, 5, 13, 7, 1, -13 }, // 'k'
	1246	{ 511, 1, 13, 4, 1, -13 }, // 'l'
	1247	{ 513, 8, 9, 11, 1, -9 }, // 'm'
	1248	{ 522, 5, 9, 8, 1, -9 }, // 'n'
	1249	{ 528, 5, 9, 8, 1, -9 }, // 'o'
	1250	{ 534, 5, 13, 8, 1, -9 }, // 'p'
	1251	{ 543, 5, 13, 8, 1, -9 }, // 'q'
	1252	{ 552, 3, 9, 5, 1, -9 }, // 'r'
	1253	{ 556, 3, 9, 6, 1, -9 }, // 's'
	1254	{ 560, 4, 11, 5, 0, -11 }, // 't'
	1255	{ 566, 5, 9, 8, 1, -9 }, // 'u'
	1256	{ 572, 5, 9, 6, 0, -9 }, // 'v'
	1257	{ 578, 9, 9, 10, 0, -9 }, // 'w'
	1258	{ 589, 5, 9, 6, 0, -9 }, // 'x'
	1259	{ 595, 5, 13, 6, 0, -9 }, // 'y'
	1260	{ 604, 4, 9, 5, 0, -9 }, // 'z'
	1261	{ 609, 4, 15, 7, 1, -12 }, // '{'
	1262	{ 617, 2, 17, 7, 2, -13 }, // '\|'
	1263	{ 622, 4, 15, 7, 1, -12 } // '}'
	1264	};
	1265	const GFXfont Open_Sans_Condensed_Light_16 PROGMEM = {
	1266	(uint8_t )Open_Sans_Condensed_Light_16Bitmaps,(GFXglyph )Open_Sans_Condensed_Light_16Glyphs,0x20, 0x7E, 23};
	1267
	1268
	1269	// Created by http://oleddisplay.squix.ch/ Consider a donation
	1270	// In case of problems make sure that you are using the font file with the correct version!
	1271	const uint8_t Open_Sans_Condensed_Light_19Bitmaps[] PROGMEM = {
	1272
	1273	// Bitmap Data:
	1274	0x00, // ' '
	1275	0xF5,0x55,0x50,0xF0, // '!'
	1276	0x99,0x99,0x90, // '"'
	1277	0x12,0x12,0x14,0x24,0x7F,0x24,0x24,0x24,0x24,0xFE,0x24,0x28,0x48,0x48, // '#'
	1278	0x20,0x87,0xF9,0xA2,0x8A,0x18,0x18,0x92,0x49,0x2F,0xE2,0x08, // '$'
	1279	0x62,0x51,0x25,0x12,0x89,0x44,0xDA,0x6B,0x59,0x6C,0x8A,0x45,0x22,0x92,0x29,0x18, // '%'
	1280	0x70,0xA1,0x42,0x85,0x0A,0x08,0x30,0x95,0x2A,0x34,0x28,0xCE,0x40, // '&'
	1281	0xAA,0x80, // '''
	1282	0x25,0x29,0x24,0x92,0x48,0x92,0x20, // '('
	1283	0x89,0x22,0x49,0x24,0x92,0x92,0x80, // ')'
	1284	0x21,0x3E,0xA5,0x00, // '*'
	1285	0x20,0x82,0x08,0xFC,0x82,0x08,0x00, // '+'
	1286	0x6A, // ','
	1287	0xE0, // '-'
	1288	0xF0, // '.'
	1289	0x08,0x20,0x84,0x10,0x42,0x08,0x21,0x04,0x20,0x82,0x00, // '/'
	1290	0x31,0x28,0x61,0x86,0x18,0x61,0x86,0x18,0x61,0x49,0xC0, // '0'
	1291	0x13,0xD1,0x11,0x11,0x11,0x11,0x11, // '1'
	1292	0x7A,0x20,0x41,0x04,0x10,0x82,0x10,0x82,0x10,0x83,0xF0, // '2'
	1293	0x7A,0x20,0x41,0x04,0x27,0x02,0x04,0x10,0x41,0x0B,0xC0, // '3'
	1294	0x04,0x0C,0x0C,0x14,0x14,0x24,0x24,0x44,0x44,0x44,0xFF,0x04,0x04,0x04, // '4'
	1295	0xFA,0x08,0x20,0x82,0x0F,0x83,0x04,0x10,0x41,0x0B,0xC0, // '5'
	1296	0x39,0x84,0x20,0x82,0xEC,0xE1,0x86,0x18,0x61,0x48,0xE0, // '6'
	1297	0xFC,0x10,0x42,0x08,0x21,0x04,0x10,0x82,0x08,0x41,0x00, // '7'
	1298	0x7B,0x38,0x61,0x85,0x23,0x16,0x86,0x18,0x61,0xC5,0xE0, // '8'
	1299	0x73,0x28,0x61,0x86,0x18,0x73,0x74,0x10,0x82,0x1B,0xC0, // '9'
	1300	0xF0,0x00,0xF0, // ':'
	1301	0xF0,0x00,0x6A, // ';'
	1302	0x04,0x23,0x30,0xC0,0xC0,0x81, // '<'
	1303	0xFC,0x00,0x00,0xFC, // '='
	1304	0x81,0x03,0x03,0x0C,0xC4,0x20, // '>'
	1305	0x70,0x82,0x11,0x08,0x84,0x22,0x00,0x06,0x30, // '?'
	1306	0x1E,0x11,0x90,0x48,0x18,0xCC,0xA6,0x53,0x29,0x94,0xCA,0x65,0x33,0x68,0x02,0x01,0x80,0x78, // '@'
	1307	0x18,0x18,0x18,0x18,0x24,0x24,0x24,0x24,0x7E,0x42,0x42,0x42,0x81,0x81, // 'A'
	1308	0xFA,0x38,0x61,0x86,0x2F,0x23,0x86,0x18,0x61,0x87,0xE0, // 'B'
	1309	0x1C,0xC1,0x04,0x08,0x10,0x20,0x40,0x81,0x02,0x02,0x06,0x03,0x80, // 'C'
	1310	0xF9,0x1A,0x14,0x18,0x30,0x60,0xC1,0x83,0x06,0x0C,0x28,0xDF,0x00, // 'D'
	1311	0xFC,0x21,0x08,0x43,0xF0,0x84,0x21,0x08,0x7C, // 'E'
	1312	0xFC,0x21,0x08,0x42,0x1E,0x84,0x21,0x08,0x40, // 'F'
	1313	0x1E,0x21,0x40,0xC0,0x80,0x80,0x80,0x87,0x81,0x81,0xC1,0x41,0x21,0x1F, // 'G'
	1314	0x86,0x18,0x61,0x86,0x1F,0xE1,0x86,0x18,0x61,0x86,0x10, // 'H'
	1315	0xAA,0xAA,0xAA,0xA0, // 'I'
	1316	0x24,0x92,0x49,0x24,0x92,0x49,0xE0, // 'J'
	1317	0x8A,0x29,0x24,0xA2,0x8C,0x28,0xA2,0x49,0x22,0x8A,0x10, // 'K'
	1318	0x84,0x21,0x08,0x42,0x10,0x84,0x21,0x08,0x7C, // 'L'
	1319	0xC0,0x78,0x0E,0x82,0xD0,0x5A,0x0B,0x42,0x64,0x4C,0x89,0x91,0x31,0x46,0x28,0xC5,0x18,0xA3,0x08,0x40, // 'M'
	1320	0xC1,0xC1,0xA1,0xA1,0x91,0x91,0x91,0x89,0x89,0x85,0x85,0x85,0x83,0x83, // 'N'
	1321	0x3C,0x66,0x42,0x81,0x81,0x81,0x81,0x81,0x81,0x81,0x81,0x42,0x66,0x3C, // 'O'
	1322	0xF4,0xE3,0x18,0xC6,0x7E,0x84,0x21,0x08,0x40, // 'P'
	1323	0x3C,0x66,0x42,0x81,0x81,0x81,0x81,0x81,0x81,0x81,0x81,0x42,0x66,0x3C,0x04,0x04,0x02, // 'Q'
	1324	0xF9,0x1A,0x14,0x28,0x50,0xA3,0x78,0x91,0x12,0x24,0x28,0x50,0x80, // 'R'
	1325	0x3F,0x18,0x20,0x83,0x06,0x06,0x04,0x10,0x41,0x0F,0xC0, // 'S'
	1326	0xFE,0x20,0x40,0x81,0x02,0x04,0x08,0x10,0x20,0x40,0x81,0x02,0x00, // 'T'
	1327	0x83,0x06,0x0C,0x18,0x30,0x60,0xC1,0x83,0x06,0x0A,0x24,0x47,0x00, // 'U'
	1328	0x83,0x06,0x12,0x24,0x48,0x91,0x14,0x28,0x50,0xA1,0x41,0x02,0x00, // 'V'
	1329	0x82,0x0C,0x10,0x51,0x44,0x8A,0x24,0x51,0x22,0x89,0x14,0x45,0x14,0x28,0xA1,0x45,0x0A,0x28,0x51,0x41,0x0C,0x08,0x20, // 'W'
	1330	0x42,0x88,0x91,0x22,0x83,0x04,0x0C,0x28,0x50,0x92,0x24,0x50,0x40, // 'X'
	1331	0x86,0x14,0x92,0x48,0xC3,0x0C,0x10,0x41,0x04,0x10,0x40, // 'Y'
	1332	0xF8,0x84,0x22,0x10,0x88,0x42,0x21,0x08,0x7C, // 'Z'
	1333	0xF2,0x49,0x24,0x92,0x49,0x24,0xE0, // '['
	1334	0x82,0x08,0x10,0x41,0x02,0x08,0x10,0x41,0x02,0x08,0x20, // '\'
	1335	0xE4,0x92,0x49,0x24,0x92,0x49,0xE0, // ']'
	1336	0x18,0x18,0x24,0x24,0x42,0x42,0x42, // '^'
	1337	0xFF, // '_'
	1338	0x88,0x80, // '`'
	1339	0x70,0xC2,0x17,0xC6,0x31,0x9B,0x40, // 'a'
	1340	0x82,0x08,0x20,0x82,0xEC,0xE1,0x86,0x18,0x61,0x87,0x3B,0x80, // 'b'
	1341	0x7A,0x21,0x08,0x42,0x10,0x43,0xC0, // 'c'
	1342	0x04,0x10,0x41,0x05,0xDC,0xE1,0x86,0x18,0x61,0x87,0x37,0x40, // 'd'
	1343	0x74,0x63,0x1F,0xC2,0x10,0x43,0xC0, // 'e'
	1344	0x39,0x10,0x84,0x79,0x08,0x42,0x10,0x84,0x21,0x00, // 'f'
	1345	0x3E,0x89,0x12,0x24,0x48,0x8E,0x10,0x40,0x79,0x0C,0x18,0x28,0x9E,0x00, // 'g'
	1346	0x82,0x08,0x20,0x82,0xEC,0xA1,0x86,0x18,0x61,0x86,0x18,0x40, // 'h'
	1347	0xA0,0xAA,0xAA,0xA0, // 'i'
	1348	0x48,0x04,0x92,0x49,0x24,0x92,0x4B,0x00, // 'j'
	1349	0x82,0x08,0x20,0x82,0x28,0xA4,0xA2,0xCD,0x24,0x8A,0x28,0x40, // 'k'
	1350	0xAA,0xAA,0xAA,0xA8, // 'l'
	1351	0xBB,0xB3,0x28,0x46,0x11,0x84,0x61,0x18,0x46,0x11,0x84,0x61,0x10, // 'm'
	1352	0xBB,0x28,0x61,0x86,0x18,0x61,0x86,0x10, // 'n'
	1353	0x79,0x28,0x61,0x86,0x18,0x61,0x49,0xE0, // 'o'
	1354	0xBB,0x38,0x61,0x86,0x18,0x61,0xCE,0xE8,0x20,0x82,0x08,0x00, // 'p'
	1355	0x77,0x38,0x61,0x86,0x18,0x61,0xCD,0xD0,0x41,0x04,0x10,0x40, // 'q'
	1356	0xBC,0xC8,0x88,0x88,0x88, // 'r'
	1357	0x78,0x88,0x43,0x11,0x1E, // 's'
	1358	0x44,0xF4,0x44,0x44,0x44,0x43, // 't'
	1359	0x86,0x18,0x61,0x86,0x18,0x61,0x4D,0xD0, // 'u'
	1360	0x86,0x14,0x92,0x49,0x23,0x0C,0x30,0xC0, // 'v'
	1361	0x8C,0x63,0x14,0xC9,0x32,0x4C,0x94,0xA5,0x28,0xCC,0x33,0x08,0x40, // 'w'
	1362	0x49,0x24,0x8C,0x30,0xC3,0x12,0x4A,0x10, // 'x'
	1363	0x86,0x14,0x92,0x49,0x23,0x0C,0x30,0xC2,0x08,0x20,0x8C,0x00, // 'y'
	1364	0xE2,0x22,0x44,0x88,0x8F, // 'z'
	1365	0x19,0x08,0x42,0x10,0x84,0xC1,0x08,0x42,0x10,0x84,0x18, // '{'
	1366	0xAA,0xAA,0xAA,0xAA,0xAA, // '\|'
	1367	0xC1,0x08,0x42,0x10,0x84,0x19,0x08,0x42,0x10,0x84,0xC0 // '}'
	1368	};
	1369	const GFXglyph Open_Sans_Condensed_Light_19Glyphs[] PROGMEM = {
	1370	// bitmapOffset, width, height, xAdvance, xOffset, yOffset
	1371	{ 0, 1, 1, 5, 0, 0 }, // ' '
	1372	{ 1, 2, 14, 5, 1, -14 }, // '!'
	1373	{ 5, 4, 5, 7, 1, -14 }, // '"'
	1374	{ 8, 8, 14, 9, 0, -14 }, // '#'
	1375	{ 22, 6, 16, 9, 1, -15 }, // '$'
	1376	{ 34, 9, 14, 12, 1, -14 }, // '%'
	1377	{ 50, 7, 14, 9, 1, -14 }, // '&'
	1378	{ 63, 2, 5, 5, 1, -14 }, // '''
	1379	{ 65, 3, 17, 6, 1, -14 }, // '('
	1380	{ 72, 3, 17, 6, 1, -14 }, // ')'
	1381	{ 79, 5, 5, 8, 1, -15 }, // '*'
	1382	{ 83, 6, 9, 9, 1, -12 }, // '+'
	1383	{ 90, 2, 4, 5, 1, -2 }, // ','
	1384	{ 91, 3, 1, 6, 1, -6 }, // '-'
	1385	{ 92, 2, 2, 5, 1, -2 }, // '.'
	1386	{ 93, 6, 14, 8, 1, -14 }, // '/'
	1387	{ 104, 6, 14, 9, 1, -14 }, // '0'
	1388	{ 115, 4, 14, 9, 1, -14 }, // '1'
	1389	{ 122, 6, 14, 9, 1, -14 }, // '2'
	1390	{ 133, 6, 14, 9, 1, -14 }, // '3'
	1391	{ 144, 8, 14, 9, 0, -14 }, // '4'
	1392	{ 158, 6, 14, 9, 1, -14 }, // '5'
	1393	{ 169, 6, 14, 9, 1, -14 }, // '6'
	1394	{ 180, 6, 14, 9, 1, -14 }, // '7'
	1395	{ 191, 6, 14, 9, 1, -14 }, // '8'
	1396	{ 202, 6, 14, 9, 1, -14 }, // '9'
	1397	{ 213, 2, 10, 5, 1, -10 }, // ':'
	1398	{ 216, 2, 12, 5, 1, -10 }, // ';'
	1399	{ 219, 6, 8, 9, 1, -11 }, // '<'
	1400	{ 225, 6, 5, 9, 1, -10 }, // '='
	1401	{ 229, 6, 8, 9, 1, -11 }, // '>'
	1402	{ 235, 5, 14, 6, 0, -14 }, // '?'
	1403	{ 244, 9, 16, 12, 1, -14 }, // '@'
	1404	{ 262, 8, 14, 9, 0, -14 }, // 'A'
	1405	{ 276, 6, 14, 9, 1, -14 }, // 'B'
	1406	{ 287, 7, 14, 9, 1, -14 }, // 'C'
	1407	{ 300, 7, 14, 10, 1, -14 }, // 'D'
	1408	{ 313, 5, 14, 8, 1, -14 }, // 'E'
	1409	{ 322, 5, 14, 8, 2, -14 }, // 'F'
	1410	{ 331, 8, 14, 11, 1, -14 }, // 'G'
	1411	{ 345, 6, 14, 11, 2, -14 }, // 'H'
	1412	{ 356, 2, 14, 5, 1, -14 }, // 'I'
	1413	{ 360, 3, 17, 5, -1, -14 }, // 'J'
	1414	{ 367, 6, 14, 9, 2, -14 }, // 'K'
	1415	{ 378, 5, 14, 8, 2, -14 }, // 'L'
	1416	{ 387, 11, 14, 14, 1, -14 }, // 'M'
	1417	{ 407, 8, 14, 11, 1, -14 }, // 'N'
	1418	{ 421, 8, 14, 11, 1, -14 }, // 'O'
	1419	{ 435, 5, 14, 9, 2, -14 }, // 'P'
	1420	{ 444, 8, 17, 11, 1, -14 }, // 'Q'
	1421	{ 461, 7, 14, 9, 1, -14 }, // 'R'
	1422	{ 474, 6, 14, 9, 1, -14 }, // 'S'
	1423	{ 485, 7, 14, 8, 0, -14 }, // 'T'
	1424	{ 498, 7, 14, 10, 1, -14 }, // 'U'
	1425	{ 511, 7, 14, 8, 0, -14 }, // 'V'
	1426	{ 524, 13, 14, 14, 0, -14 }, // 'W'
	1427	{ 547, 7, 14, 8, 0, -14 }, // 'X'
	1428	{ 560, 6, 14, 7, 0, -14 }, // 'Y'
	1429	{ 571, 5, 14, 7, 1, -14 }, // 'Z'
	1430	{ 580, 3, 17, 7, 2, -14 }, // '['
	1431	{ 587, 6, 14, 8, 1, -14 }, // '\'
	1432	{ 598, 3, 17, 7, 1, -14 }, // ']'
	1433	{ 605, 8, 7, 9, 0, -14 }, // '^'
	1434	{ 612, 8, 1, 9, 0, 2 }, // '_'
	1435	{ 613, 3, 3, 11, 4, -15 }, // '`'
	1436	{ 615, 5, 10, 8, 1, -10 }, // 'a'
	1437	{ 622, 6, 15, 9, 1, -15 }, // 'b'
	1438	{ 634, 5, 10, 7, 1, -10 }, // 'c'
	1439	{ 641, 6, 15, 9, 1, -15 }, // 'd'
	1440	{ 653, 5, 10, 8, 1, -10 }, // 'e'
	1441	{ 660, 5, 15, 5, 0, -15 }, // 'f'
	1442	{ 670, 7, 15, 8, 0, -10 }, // 'g'
	1443	{ 684, 6, 15, 9, 1, -15 }, // 'h'
	1444	{ 696, 2, 14, 5, 1, -14 }, // 'i'
	1445	{ 700, 3, 19, 5, 0, -14 }, // 'j'
	1446	{ 708, 6, 15, 8, 1, -15 }, // 'k'
	1447	{ 720, 2, 15, 5, 1, -15 }, // 'l'
	1448	{ 724, 10, 10, 13, 1, -10 }, // 'm'
	1449	{ 737, 6, 10, 9, 1, -10 }, // 'n'
	1450	{ 745, 6, 10, 9, 1, -10 }, // 'o'
	1451	{ 753, 6, 15, 9, 1, -10 }, // 'p'
	1452	{ 765, 6, 15, 9, 1, -10 }, // 'q'
	1453	{ 777, 4, 10, 6, 1, -10 }, // 'r'
	1454	{ 782, 4, 10, 7, 1, -10 }, // 's'
	1455	{ 787, 4, 12, 5, 0, -12 }, // 't'
	1456	{ 793, 6, 10, 9, 1, -10 }, // 'u'
	1457	{ 801, 6, 10, 7, 0, -10 }, // 'v'
	1458	{ 809, 10, 10, 11, 0, -10 }, // 'w'
	1459	{ 822, 6, 10, 7, 0, -10 }, // 'x'
	1460	{ 830, 6, 15, 7, 0, -10 }, // 'y'
	1461	{ 842, 4, 10, 6, 1, -10 }, // 'z'
	1462	{ 847, 5, 17, 8, 1, -14 }, // '{'
	1463	{ 858, 2, 20, 9, 3, -15 }, // '\|'
	1464	{ 863, 5, 17, 8, 1, -14 } // '}'
	1465	};
	1466	const GFXfont Open_Sans_Condensed_Light_19 PROGMEM = {
	1467	(uint8_t )Open_Sans_Condensed_Light_19Bitmaps,(GFXglyph )Open_Sans_Condensed_Light_19Glyphs,0x20, 0x7E, 27};
	1468
	1469	// Created by http://oleddisplay.squix.ch/ Consider a donation
	1470	// In case of problems make sure that you are using the font file with the correct version!
	1471	const uint8_t Open_Sans_Condensed_Light_22Bitmaps[] PROGMEM = {
	1472
	1473	// Bitmap Data:
	1474	0x00, // ' '
	1475	0xFF,0xF3, // '!'
	1476	0xDE,0xD6,0xA4,0xA4, // '"'
	1477	0x12,0x09,0x04,0x82,0x41,0x23,0xFC,0x48,0x44,0x22,0x12,0x3F,0xC4,0x82,0x41,0x20,0x90,0x48, // '#'
	1478	0x10,0x20,0xF2,0x89,0x12,0x24,0x28,0x70,0x30,0x50,0x91,0x22,0x45,0x7C,0x10,0x20,0x40, // '$'
	1479	0x61,0x12,0x22,0x44,0x49,0x09,0x21,0x24,0x25,0x34,0xA9,0x95,0x2C,0xA4,0x24,0x84,0x90,0x92,0x22,0x44,0x48,0x86, // '%'
	1480	0x30,0x48,0x48,0x48,0x48,0x48,0x30,0x20,0x50,0x92,0x8A,0x8A,0x86,0x86,0x8A,0x71, // '&'
	1481	0xF5,0x50, // '''
	1482	0x12,0x24,0x44,0xC8,0x88,0x88,0x84,0x44,0x22,0x10, // '('
	1483	0x84,0x42,0x22,0x31,0x11,0x11,0x12,0x22,0x44,0x80, // ')'
	1484	0x30,0x4D,0xCC,0x79,0x20, // '*'
	1485	0x10,0x20,0x40,0x81,0x1F,0xC4,0x08,0x10,0x20,0x40, // '+'
	1486	0x49,0x48, // ','
	1487	0xF0, // '-'
	1488	0xC0, // '.'
	1489	0x04,0x08,0x10,0x40,0x83,0x04,0x08,0x20,0x40,0x82,0x04,0x08,0x20,0x40, // '/'
	1490	0x38,0x89,0x14,0x18,0x30,0x60,0xC1,0x83,0x06,0x0C,0x18,0x28,0x91,0x1C, // '0'
	1491	0x35,0x91,0x11,0x11,0x11,0x11,0x11,0x11, // '1'
	1492	0x79,0x08,0x10,0x10,0x20,0x81,0x02,0x08,0x10,0x41,0x02,0x08,0x20,0x7F, // '2'
	1493	0x79,0x08,0x18,0x10,0x20,0x83,0x18,0x0C,0x0C,0x08,0x10,0x20,0xC1,0x7C, // '3'
	1494	0x06,0x03,0x02,0x81,0x40,0xA0,0x90,0x48,0x44,0x22,0x21,0x10,0x9F,0xF0,0x20,0x10,0x08,0x04, // '4'
	1495	0x7C,0x82,0x04,0x08,0x10,0x3E,0x02,0x02,0x04,0x08,0x10,0x20,0xA3,0x7C, // '5'
	1496	0x1C,0x41,0x02,0x04,0x10,0x2E,0x62,0x83,0x06,0x0C,0x18,0x28,0x51,0x1C, // '6'
	1497	0xFE,0x04,0x08,0x20,0x40,0x82,0x04,0x08,0x20,0x40,0x82,0x04,0x08,0x20, // '7'
	1498	0x38,0x8A,0x0C,0x18,0x28,0x99,0x1C,0x69,0x8A,0x0C,0x18,0x30,0x51,0x9C, // '8'
	1499	0x38,0x8A,0x14,0x38,0x30,0x60,0xC3,0x46,0x74,0x08,0x20,0x40,0x82,0x38, // '9'
	1500	0xC0,0x30, // ':'
	1501	0x48,0x00,0x00,0x01,0x25,0x20, // ';'
	1502	0x02,0x08,0x63,0x08,0x0C,0x06,0x03,0x02, // '<'
	1503	0xFE,0x00,0x00,0x00,0x1F,0xC0, // '='
	1504	0x80,0x80,0xC0,0x60,0x21,0x8C,0x60,0x80, // '>'
	1505	0x70,0x20,0x83,0x08,0x20,0x84,0x10,0x82,0x08,0x00,0x02,0x08, // '?'
	1506	0x0F,0x02,0x30,0x83,0x20,0x24,0x74,0x92,0x62,0x4C,0x99,0x93,0x32,0x46,0x48,0xC9,0x18,0xB4,0x9B,0x90,0x03,0x00,0x31,0x03,0xC0, // '@'
	1507	0x08,0x04,0x05,0x02,0x81,0x40,0xA0,0x88,0x44,0x22,0x1F,0x10,0x48,0x24,0x12,0x0A,0x03,0x01, // 'A'
	1508	0xF9,0x0A,0x0C,0x18,0x30,0xE1,0x7C,0x85,0x06,0x0C,0x18,0x30,0x61,0x7C, // 'B'
	1509	0x1E,0x41,0x02,0x04,0x10,0x20,0x40,0x81,0x02,0x02,0x04,0x0C,0x08,0x0F, // 'C'
	1510	0xF8,0x8C,0x86,0x82,0x82,0x81,0x81,0x81,0x81,0x81,0x81,0x82,0x82,0x86,0x8C,0xF8, // 'D'
	1511	0xFC,0x21,0x08,0x42,0x1F,0x84,0x21,0x08,0x42,0x1F, // 'E'
	1512	0xFE,0x08,0x20,0x82,0x08,0x20,0xFA,0x08,0x20,0x82,0x08,0x20, // 'F'
	1513	0x0F,0x8C,0x26,0x01,0x00,0x40,0x30,0x08,0x02,0x00,0x83,0xE0,0x1C,0x05,0x01,0x40,0x58,0x13,0x04,0x3E, // 'G'
	1514	0x83,0x06,0x0C,0x18,0x30,0x60,0xFF,0x83,0x06,0x0C,0x18,0x30,0x60,0xC1, // 'H'
	1515	0xFF,0xFF, // 'I'
	1516	0x33,0x33,0x33,0x33,0x33,0x33,0x33,0x33,0x32,0x2E, // 'J'
	1517	0x85,0x0A,0x24,0x49,0x16,0x28,0x70,0xE1,0x22,0x44,0x48,0x90,0xA1,0x41, // 'K'
	1518	0x82,0x08,0x20,0x82,0x08,0x20,0x82,0x08,0x20,0x82,0x08,0x3F, // 'L'
	1519	0x80,0x38,0x0F,0x01,0xE0,0x3A,0x0B,0x41,0x68,0x2D,0x05,0x91,0x32,0x26,0x44,0xC5,0x18,0xA3,0x14,0x62,0x8C,0x21, // 'M'
	1520	0x81,0xC1,0xC1,0xA1,0xA1,0xA1,0x91,0x91,0x89,0x89,0x85,0x85,0x87,0x83,0x83,0x81, // 'N'
	1521	0x1C,0x11,0x10,0x48,0x2C,0x1C,0x06,0x03,0x01,0x80,0xC0,0x60,0x38,0x34,0x12,0x08,0x88,0x38, // 'O'
	1522	0xF2,0x38,0x61,0x86,0x18,0x62,0xF2,0x08,0x20,0x82,0x08,0x20, // 'P'
	1523	0x1C,0x11,0x10,0x48,0x2C,0x1C,0x06,0x03,0x01,0x80,0xC0,0x60,0x38,0x34,0x12,0x08,0x88,0x38,0x04,0x01,0x00,0x80,0x20, // 'Q'
	1524	0xF1,0x12,0x14,0x28,0x50,0xA1,0x44,0xF1,0x22,0x44,0x48,0x91,0xA1,0x42, // 'R'
	1525	0x3E,0x82,0x04,0x08,0x10,0x10,0x18,0x0C,0x08,0x08,0x10,0x20,0x41,0x7C, // 'S'
	1526	0xFF,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10, // 'T'
	1527	0x83,0x06,0x0C,0x18,0x30,0x60,0xC1,0x83,0x06,0x0C,0x18,0x30,0x51,0x9E, // 'U'
	1528	0x80,0xC0,0x50,0x48,0x24,0x12,0x08,0x88,0x44,0x22,0x11,0x05,0x02,0x81,0x40,0xA0,0x20,0x10, // 'V'
	1529	0x81,0x03,0x82,0x0D,0x0A,0x12,0x14,0x24,0x28,0x48,0x50,0x98,0xA3,0x12,0x24,0x24,0x48,0x48,0x90,0x91,0x20,0xA2,0x81,0x83,0x03,0x06,0x06,0x0C,0x0C,0x18, // 'W'
	1530	0x41,0x42,0x22,0x24,0x24,0x14,0x18,0x08,0x18,0x18,0x24,0x24,0x26,0x42,0x42,0x81, // 'X'
	1531	0x83,0x8D,0x12,0x24,0x45,0x0A,0x14,0x10,0x20,0x40,0x81,0x02,0x04,0x08, // 'Y'
	1532	0xF8,0x20,0x86,0x10,0x43,0x08,0x21,0x84,0x10,0xC2,0x08,0x3F, // 'Z'
	1533	0xF8,0x88,0x88,0x88,0x88,0x88,0x88,0x88,0x88,0xF0, // '['
	1534	0x81,0x01,0x02,0x04,0x04,0x08,0x10,0x10,0x20,0x60,0x40,0x80,0x81,0x02, // '\'
	1535	0xF1,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11,0xF0, // ']'
	1536	0x08,0x0A,0x05,0x04,0x82,0x21,0x11,0x04,0x82, // '^'
	1537	0xFF,0x80, // '_'
	1538	0x99,0x10, // '`'
	1539	0x78,0x20,0x81,0x04,0xFC,0x61,0x8E,0x38,0xDD, // 'a'
	1540	0x81,0x02,0x04,0x08,0x17,0x31,0x43,0x83,0x06,0x0C,0x18,0x30,0x61,0x62,0xB8, // 'b'
	1541	0x3D,0x04,0x20,0x82,0x08,0x20,0x81,0x04,0x0E, // 'c'
	1542	0x02,0x04,0x08,0x10,0x27,0x51,0xA1,0x83,0x06,0x0C,0x18,0x30,0x70,0xA3,0x3A, // 'd'
	1543	0x38,0x89,0x1C,0x18,0x3F,0xE0,0x40,0x80,0x81,0x89,0xE0, // 'e'
	1544	0x19,0x08,0x42,0x7C,0x84,0x21,0x08,0x42,0x10,0x84,0x20, // 'f'
	1545	0x3F,0x24,0x42,0x42,0x42,0x42,0x24,0x38,0x20,0x20,0x3E,0x43,0x41,0x81,0x81,0x42,0x3C, // 'g'
	1546	0x82,0x08,0x20,0x82,0xE4,0xA2,0x86,0x18,0x61,0x86,0x18,0x61,0x84, // 'h'
	1547	0xF0,0xFF,0xFF,0xFF, // 'i'
	1548	0x6C,0x06,0xDB,0x6D,0xB6,0xDB,0x6D,0x2C, // 'j'
	1549	0x82,0x08,0x20,0x82,0x28,0xA4,0xA2,0x8E,0x24,0x92,0x48,0xA2,0x84, // 'k'
	1550	0xFF,0xFF,0x80, // 'l'
	1551	0xF3,0xA3,0x18,0xC6,0x11,0x84,0x61,0x18,0x46,0x11,0x84,0x61,0x18,0x46,0x11, // 'm'
	1552	0x39,0x28,0xA1,0x86,0x18,0x61,0x86,0x18,0x61, // 'n'
	1553	0x38,0x8B,0x1C,0x18,0x30,0x60,0xC1,0x83,0x8D,0x11,0xC0, // 'o'
	1554	0xB9,0x8A,0x1C,0x18,0x30,0x60,0xC1,0x83,0x0B,0x15,0xC8,0x10,0x20,0x40,0x80, // 'p'
	1555	0x3A,0x8D,0x0C,0x18,0x30,0x60,0xC1,0x83,0x85,0x19,0xD0,0x20,0x40,0x81,0x02, // 'q'
	1556	0xBC,0x88,0x88,0x88,0x88,0x88, // 'r'
	1557	0x7C,0x21,0x08,0x30,0x41,0x08,0x43,0xE0, // 's'
	1558	0x21,0x09,0xF2,0x10,0x84,0x21,0x08,0x42,0x10,0xE0, // 't'
	1559	0x85,0x0A,0x14,0x28,0x50,0xA1,0x43,0x86,0x8D,0x29,0x90, // 'u'
	1560	0x83,0x05,0x12,0x24,0x48,0x8A,0x14,0x28,0x50,0xC0,0x80, // 'v'
	1561	0x86,0x14,0x62,0x46,0x24,0x62,0x4A,0x24,0x92,0x29,0x42,0x94,0x29,0x42,0x94,0x30,0xC1,0x08, // 'w'
	1562	0x44,0x88,0xA1,0x42,0x82,0x04,0x14,0x28,0x89,0x12,0x20, // 'x'
	1563	0x83,0x05,0x12,0x24,0x48,0x8A,0x14,0x28,0x50,0x40,0x81,0x02,0x08,0x10,0xC0, // 'y'
	1564	0xF1,0x12,0x22,0x44,0x48,0x8F, // 'z'
	1565	0x0C,0x43,0x08,0x20,0x82,0x08,0x23,0x02,0x08,0x20,0x82,0x08,0x10,0x40,0xC0, // '{'
	1566	0xFF,0xFF,0xFC, // '\|'
	1567	0xC0,0x83,0x04,0x10,0x41,0x04,0x10,0x31,0x04,0x10,0x41,0x04,0x20,0x8C,0x00 // '}'
	1568	};
	1569	const GFXglyph Open_Sans_Condensed_Light_22Glyphs[] PROGMEM = {
	1570	// bitmapOffset, width, height, xAdvance, xOffset, yOffset
	1571	{ 0, 1, 1, 5, 0, 0 }, // ' '
	1572	{ 1, 1, 16, 6, 2, -16 }, // '!'
	1573	{ 3, 5, 6, 8, 1, -16 }, // '"'
	1574	{ 7, 9, 16, 10, 0, -16 }, // '#'
	1575	{ 25, 7, 19, 10, 1, -17 }, // '$'
	1576	{ 42, 11, 16, 14, 1, -16 }, // '%'
	1577	{ 64, 8, 16, 10, 1, -16 }, // '&'
	1578	{ 80, 2, 6, 5, 1, -16 }, // '''
	1579	{ 82, 4, 19, 7, 1, -16 }, // '('
	1580	{ 92, 4, 19, 7, 1, -16 }, // ')'
	1581	{ 102, 6, 6, 9, 1, -17 }, // '*'
	1582	{ 107, 7, 11, 10, 1, -14 }, // '+'
	1583	{ 117, 3, 5, 6, 1, -2 }, // ','
	1584	{ 119, 4, 1, 7, 1, -6 }, // '-'
	1585	{ 120, 1, 2, 6, 2, -2 }, // '.'
	1586	{ 121, 7, 16, 9, 1, -16 }, // '/'
	1587	{ 135, 7, 16, 10, 1, -16 }, // '0'
	1588	{ 149, 4, 16, 10, 2, -16 }, // '1'
	1589	{ 157, 7, 16, 10, 1, -16 }, // '2'
	1590	{ 171, 7, 16, 10, 1, -16 }, // '3'
	1591	{ 185, 9, 16, 10, 0, -16 }, // '4'
	1592	{ 203, 7, 16, 10, 1, -16 }, // '5'
	1593	{ 217, 7, 16, 10, 1, -16 }, // '6'
	1594	{ 231, 7, 16, 10, 1, -16 }, // '7'
	1595	{ 245, 7, 16, 10, 1, -16 }, // '8'
	1596	{ 259, 7, 16, 10, 1, -16 }, // '9'
	1597	{ 273, 1, 12, 6, 2, -12 }, // ':'
	1598	{ 275, 3, 15, 6, 1, -12 }, // ';'
	1599	{ 281, 7, 9, 10, 1, -13 }, // '<'
	1600	{ 289, 7, 6, 10, 1, -11 }, // '='
	1601	{ 295, 7, 9, 10, 1, -13 }, // '>'
	1602	{ 303, 6, 16, 7, 0, -16 }, // '?'
	1603	{ 315, 11, 18, 14, 1, -16 }, // '@'
	1604	{ 340, 9, 16, 10, 0, -16 }, // 'A'
	1605	{ 358, 7, 16, 11, 2, -16 }, // 'B'
	1606	{ 372, 7, 16, 10, 1, -16 }, // 'C'
	1607	{ 386, 8, 16, 12, 2, -16 }, // 'D'
	1608	{ 402, 5, 16, 9, 2, -16 }, // 'E'
	1609	{ 412, 6, 16, 9, 2, -16 }, // 'F'
	1610	{ 424, 10, 16, 13, 1, -16 }, // 'G'
	1611	{ 444, 7, 16, 12, 2, -16 }, // 'H'
	1612	{ 458, 1, 16, 5, 2, -16 }, // 'I'
	1613	{ 460, 4, 20, 5, -1, -16 }, // 'J'
	1614	{ 470, 7, 16, 10, 2, -16 }, // 'K'
	1615	{ 484, 6, 16, 9, 2, -16 }, // 'L'
	1616	{ 496, 11, 16, 16, 2, -16 }, // 'M'
	1617	{ 518, 8, 16, 13, 2, -16 }, // 'N'
	1618	{ 534, 9, 16, 12, 1, -16 }, // 'O'
	1619	{ 552, 6, 16, 10, 2, -16 }, // 'P'
	1620	{ 564, 9, 20, 12, 1, -16 }, // 'Q'
	1621	{ 587, 7, 16, 10, 2, -16 }, // 'R'
	1622	{ 601, 7, 16, 10, 1, -16 }, // 'S'
	1623	{ 615, 8, 16, 9, 0, -16 }, // 'T'
	1624	{ 631, 7, 16, 12, 2, -16 }, // 'U'
	1625	{ 645, 9, 16, 10, 0, -16 }, // 'V'
	1626	{ 663, 15, 16, 16, 0, -16 }, // 'W'
	1627	{ 693, 8, 16, 9, 0, -16 }, // 'X'
	1628	{ 709, 7, 16, 8, 0, -16 }, // 'Y'
	1629	{ 723, 6, 16, 8, 1, -16 }, // 'Z'
	1630	{ 735, 4, 19, 8, 2, -16 }, // '['
	1631	{ 745, 7, 16, 9, 1, -16 }, // '\'
	1632	{ 759, 4, 19, 8, 1, -16 }, // ']'
	1633	{ 769, 9, 8, 10, 0, -16 }, // '^'
	1634	{ 778, 9, 1, 10, 0, 2 }, // '_'
	1635	{ 780, 3, 4, 13, 5, -17 }, // '`'
	1636	{ 782, 6, 12, 9, 1, -12 }, // 'a'
	1637	{ 791, 7, 17, 11, 2, -17 }, // 'b'
	1638	{ 806, 6, 12, 8, 1, -12 }, // 'c'
	1639	{ 815, 7, 17, 11, 1, -17 }, // 'd'
	1640	{ 830, 7, 12, 10, 1, -12 }, // 'e'
	1641	{ 841, 5, 17, 6, 0, -17 }, // 'f'
	1642	{ 852, 8, 17, 9, 0, -12 }, // 'g'
	1643	{ 869, 6, 17, 10, 2, -17 }, // 'h'
	1644	{ 882, 2, 16, 5, 1, -16 }, // 'i'
	1645	{ 886, 3, 21, 5, 0, -16 }, // 'j'
	1646	{ 894, 6, 17, 9, 2, -17 }, // 'k'
	1647	{ 907, 1, 17, 5, 2, -17 }, // 'l'
	1648	{ 910, 10, 12, 15, 2, -12 }, // 'm'
	1649	{ 925, 6, 12, 10, 2, -12 }, // 'n'
	1650	{ 934, 7, 12, 10, 1, -12 }, // 'o'
	1651	{ 945, 7, 17, 11, 2, -12 }, // 'p'
	1652	{ 960, 7, 17, 11, 1, -12 }, // 'q'
	1653	{ 975, 4, 12, 7, 2, -12 }, // 'r'
	1654	{ 981, 5, 12, 8, 1, -12 }, // 's'
	1655	{ 989, 5, 15, 6, 0, -15 }, // 't'
	1656	{ 999, 7, 12, 10, 1, -12 }, // 'u'
	1657	{ 1010, 7, 12, 8, 0, -12 }, // 'v'
	1658	{ 1021, 12, 12, 13, 0, -12 }, // 'w'
	1659	{ 1039, 7, 12, 8, 0, -12 }, // 'x'
	1660	{ 1050, 7, 17, 8, 0, -12 }, // 'y'
	1661	{ 1065, 4, 12, 7, 1, -12 }, // 'z'
	1662	{ 1071, 6, 19, 9, 1, -16 }, // '{'
	1663	{ 1086, 1, 22, 10, 4, -17 }, // '\|'
	1664	{ 1089, 6, 19, 9, 1, -16 } // '}'
	1665	};
	1666	const GFXfont Open_Sans_Condensed_Light_22 PROGMEM = {
	1667	(uint8_t )Open_Sans_Condensed_Light_22Bitmaps,(GFXglyph )Open_Sans_Condensed_Light_22Glyphs,0x20, 0x7E, 31};
	1668
	1669	// Created by http://oleddisplay.squix.ch/ Consider a donation
	1670	// In case of problems make sure that you are using the font file with the correct version!
	1671	const uint8_t Roboto_Condensed_19Bitmaps[] PROGMEM = {
	1672
	1673	// Bitmap Data:
	1674	0x00, // ' '
	1675	0xFF,0xCC, // '!'
	1676	0xDD,0x99, // '"'
	1677	0x09,0x0D,0x84,0xCF,0xF1,0x20,0x90,0xC8,0x6C,0xFF,0x12,0x09,0x04,0x82,0x43,0x20, // '#'
	1678	0x10,0x20,0xF3,0x2C,0x78,0xF0,0x20,0x70,0x38,0x18,0x38,0x38,0xF1,0xBE,0x10,0x20, // '$'
	1679	0x70,0x26,0x08,0x92,0x24,0x9A,0x1D,0x80,0x40,0x30,0x0B,0x86,0x91,0x64,0xD9,0x22,0x40,0xE0, // '%'
	1680	0x38,0x32,0x11,0x08,0x86,0xC3,0xC0,0xC0,0xF0,0xD9,0x66,0xA1,0xD8,0xCC,0x71,0xCC, // '&'
	1681	0xF0, // '''
	1682	0x11,0x26,0x64,0x4C,0xCC,0xCC,0x44,0x66,0x21,0x10, // '('
	1683	0x82,0x08,0x43,0x08,0x43,0x18,0xC6,0x31,0x08,0xC6,0x22,0x20, // ')'
	1684	0x18,0x18,0x99,0xFF,0x18,0x3C,0x26,0x64, // '*'
	1685	0x18,0x18,0x18,0x18,0xFF,0x18,0x18,0x18,0x18, // '+'
	1686	0x6D,0xAC, // ','
	1687	0xF0, // '-'
	1688	0xF0, // '.'
	1689	0x04,0x10,0xC2,0x08,0x61,0x04,0x30,0x82,0x18,0x41,0x0C,0x00, // '/'
	1690	0x3C,0xCB,0x1E,0x1C,0x38,0x70,0xE1,0xC3,0x87,0x0A,0x36,0x47,0x80, // '0'
	1691	0x09,0xF6,0x31,0x8C,0x63,0x18,0xC6,0x31,0x8C, // '1'
	1692	0x3C,0x46,0xC6,0xC6,0x06,0x06,0x04,0x0C,0x18,0x18,0x30,0x60,0x40,0xFF, // '2'
	1693	0x79,0x8B,0x18,0x30,0x61,0x8E,0x02,0x06,0x0C,0x1C,0x3C,0x4F,0x00, // '3'
	1694	0x06,0x03,0x03,0x83,0xC1,0x61,0xB0,0x98,0xCC,0x46,0x7F,0xC1,0x80,0xC0,0x60,0x30, // '4'
	1695	0x7E,0x60,0x60,0x60,0x40,0x7C,0x66,0x02,0x03,0x03,0xC3,0x42,0x66,0x3C, // '5'
	1696	0x1C,0x61,0x82,0x0C,0x1F,0xB9,0xE3,0xC3,0x87,0x0E,0x36,0x47,0x00, // '6'
	1697	0xFF,0x02,0x06,0x06,0x04,0x0C,0x0C,0x18,0x18,0x10,0x30,0x30,0x20,0x60, // '7'
	1698	0x38,0x8B,0x1E,0x3C,0x68,0x8E,0x22,0xC7,0x8F,0x1E,0x34,0x47,0x00, // '8'
	1699	0x38,0x9B,0x14,0x38,0x70,0xF1,0xE7,0x7E,0x0C,0x10,0x20,0x8E,0x00, // '9'
	1700	0xF0,0x00,0xF0, // ':'
	1701	0x6C,0x00,0x00,0x6D,0xAC, // ';'
	1702	0x04,0x77,0x30,0xC1,0xC1,0xC1, // '<'
	1703	0xFE,0x00,0x00,0x0F,0xE0, // '='
	1704	0x81,0xC0,0xE0,0x70,0xE7,0x38,0x40, // '>'
	1705	0x7B,0x38,0x41,0x0C,0x31,0x8C,0x30,0xC0,0x00,0x30,0xC0, // '?'
	1706	0x07,0x80,0xC3,0x0C,0x0C,0x40,0x24,0x39,0x22,0x45,0x32,0x39,0x11,0xC8,0x8E,0x44,0x72,0x27,0x93,0x24,0xEE,0x20,0x00,0x80,0x06,0x10,0x0F,0x80, // '@'
	1707	0x04,0x01,0xC0,0x28,0x05,0x01,0xB0,0x36,0x04,0x41,0x8C,0x31,0x87,0xF0,0x83,0x30,0x66,0x0D,0x80,0xC0, // 'A'
	1708	0xFE,0xC3,0xC3,0xC3,0xC3,0xC2,0xFC,0xC3,0xC3,0xC1,0xC1,0xC3,0xC3,0xFE, // 'B'
	1709	0x1E,0x11,0x98,0x68,0x3C,0x06,0x03,0x01,0x80,0xC0,0x60,0x10,0x6C,0x32,0x30,0xF0, // 'C'
	1710	0xF8,0x84,0x86,0x82,0x83,0x83,0x83,0x83,0x83,0x83,0x82,0x86,0x84,0xF8, // 'D'
	1711	0xFF,0xC0,0xC0,0xC0,0xC0,0xC0,0xFE,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xFF, // 'E'
	1712	0xFF,0x83,0x06,0x0C,0x18,0x3F,0xE0,0xC1,0x83,0x06,0x0C,0x18,0x00, // 'F'
	1713	0x3E,0x31,0x90,0x78,0x3C,0x06,0x03,0x01,0x8F,0xC1,0xE0,0xF0,0x68,0x36,0x30,0xF0, // 'G'
	1714	0x81,0x81,0x81,0x81,0x81,0x81,0xFF,0x81,0x81,0x81,0x81,0x81,0x81,0x81, // 'H'
	1715	0xFF,0xFC, // 'I'
	1716	0x06,0x0C,0x18,0x30,0x60,0xC1,0x83,0x06,0x0E,0x1C,0x3C,0xCF,0x00, // 'J'
	1717	0xC3,0xE1,0xB1,0x99,0x8C,0xC6,0xC3,0xE1,0xF0,0xEC,0x66,0x31,0x98,0x6C,0x36,0x0C, // 'K'
	1718	0xC1,0x83,0x06,0x0C,0x18,0x30,0x60,0xC1,0x83,0x06,0x0C,0x1F,0xC0, // 'L'
	1719	0xE0,0x3E,0x07,0xE0,0x7F,0x07,0xF0,0xFD,0x0F,0xD8,0xBD,0x9B,0xC9,0xBC,0xD3,0xCF,0x3C,0x73,0xC6,0x3C,0x63, // 'M'
	1720	0xC1,0xC1,0xE1,0xE1,0xB1,0xB1,0x99,0x99,0x8D,0x8D,0x87,0x87,0x83,0x83, // 'N'
	1721	0x3E,0x31,0x90,0x58,0x3C,0x1E,0x0F,0x07,0x83,0xC1,0xE0,0xF0,0x68,0x26,0x31,0xF0, // 'O'
	1722	0xFC,0x86,0x83,0x83,0x83,0x83,0x86,0xFC,0x80,0x80,0x80,0x80,0x80,0x80, // 'P'
	1723	0x3E,0x31,0xB0,0x58,0x3C,0x1E,0x0F,0x07,0x83,0xC1,0xE0,0xF0,0x78,0x26,0x31,0xF8,0x0E,0x03, // 'Q'
	1724	0xFC,0x61,0xB0,0xD8,0x6C,0x36,0x1B,0x09,0xF8,0xC4,0x63,0x31,0x98,0x6C,0x36,0x0C, // 'R'
	1725	0x3C,0x63,0xC3,0xC3,0xC0,0x60,0x38,0x1E,0x07,0x03,0xC3,0xC3,0xC3,0x3C, // 'S'
	1726	0xFF,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, // 'T'
	1727	0xC1,0xE0,0xF0,0x78,0x3C,0x1E,0x0F,0x07,0x83,0xC1,0xE0,0xF0,0x68,0x26,0x31,0xF0, // 'U'
	1728	0xC1,0xE0,0xF0,0x68,0x26,0x33,0x18,0x8C,0x44,0x36,0x1B,0x05,0x03,0x81,0xC0,0x40, // 'V'
	1729	0x82,0x1E,0x30,0xF1,0xC5,0x8E,0x24,0x51,0x26,0x99,0x34,0xCD,0x36,0x68,0xA3,0x45,0x0E,0x28,0x61,0xC3,0x0E,0x18,0x20, // 'W'
	1730	0xC1,0xE1,0x98,0xCC,0xC3,0x60,0xE0,0x60,0x38,0x3C,0x1B,0x19,0x8C,0x6C,0x36,0x0C, // 'X'
	1731	0xC0,0xD8,0x66,0x18,0xCC,0x33,0x04,0x81,0xE0,0x30,0x0C,0x03,0x00,0xC0,0x30,0x0C,0x03,0x00, // 'Y'
	1732	0xFF,0x03,0x06,0x06,0x0C,0x0C,0x18,0x18,0x30,0x30,0x60,0x40,0xC0,0xFF, // 'Z'
	1733	0xFB,0x6D,0xB6,0xDB,0x6D,0xB6,0xDC, // '['
	1734	0xC0,0x81,0x81,0x02,0x06,0x04,0x08,0x18,0x30,0x20,0x60,0xC0,0x81,0x80, // '\'
	1735	0xE4,0x92,0x49,0x24,0x92,0x49,0x3C, // ']'
	1736	0x23,0x94,0xAD,0xEE,0x20, // '^'
	1737	0xFE, // '_'
	1738	0xCC,0x80, // '`'
	1739	0x3C,0x8B,0x18,0x33,0xF8,0xF1,0xE3,0xCE,0xEC, // 'a'
	1740	0xC1,0x83,0x06,0x0F,0xD8,0xF1,0xE1,0xC3,0x87,0x0E,0x3C,0x7F,0x80, // 'b'
	1741	0x3C,0x8F,0x0E,0x1C,0x18,0x30,0x61,0x46,0x78, // 'c'
	1742	0x06,0x0C,0x18,0x37,0xF8,0xF1,0xC3,0x87,0x0E,0x1E,0x3C,0x6F,0xC0, // 'd'
	1743	0x3C,0x8F,0x1E,0x1F,0xF8,0x30,0x60,0x66,0x78, // 'e'
	1744	0x3B,0x18,0xCF,0x31,0x8C,0x63,0x18,0xC6,0x30, // 'f'
	1745	0x7F,0x8F,0x1C,0x38,0x70,0xE1,0xE3,0xC6,0xFC,0x1C,0x3C,0x4F,0x00, // 'g'
	1746	0xC1,0x83,0x06,0x0F,0xD8,0xF1,0xE3,0xC7,0x8F,0x1E,0x3C,0x78,0xC0, // 'h'
	1747	0xF0,0xFF,0xFF,0xF0, // 'i'
	1748	0x6C,0x06,0xDB,0x6D,0xB6,0xDB,0x78, // 'j'
	1749	0xC0,0xC0,0xC0,0xC0,0xC6,0xCC,0xD8,0xD8,0xF0,0xF8,0xC8,0xCC,0xC6,0xC7, // 'k'
	1750	0xFF,0xFF,0xFF,0xF0, // 'l'
	1751	0xFD,0xEC,0x63,0xC6,0x3C,0x63,0xC6,0x3C,0x63,0xC6,0x3C,0x63,0xC6,0x3C,0x63, // 'm'
	1752	0xDD,0xCF,0x1E,0x3C,0x78,0xF1,0xE3,0xC7,0x8C, // 'n'
	1753	0x3C,0x66,0xC3,0xC3,0xC3,0xC3,0xC3,0xC3,0x66,0x3C, // 'o'
	1754	0xFD,0x8F,0x1E,0x1C,0x38,0x70,0xE3,0xC7,0xFB,0x06,0x0C,0x18,0x00, // 'p'
	1755	0x3A,0xCF,0x0E,0x1C,0x38,0x70,0xE1,0x66,0x74,0x08,0x10,0x20,0x40, // 'q'
	1756	0xFE,0xCC,0xCC,0xCC,0xCC, // 'r'
	1757	0x3C,0x8B,0x1A,0x07,0x03,0x81,0xE3,0x46,0x78, // 's'
	1758	0x31,0xBE,0x63,0x18,0xC6,0x31,0x8C,0x30, // 't'
	1759	0xC7,0x8F,0x1E,0x3C,0x78,0xF1,0xE3,0xC6,0xFC, // 'u'
	1760	0xC3,0x42,0x66,0x66,0x24,0x24,0x3C,0x18,0x18,0x18, // 'v'
	1761	0xC6,0x34,0x62,0x46,0x26,0xF6,0x6F,0x62,0x94,0x29,0x43,0x9C,0x30,0xC1,0x08, // 'w'
	1762	0x63,0x66,0x34,0x3C,0x18,0x18,0x3C,0x34,0x66,0xE3, // 'x'
	1763	0xC3,0x66,0x66,0x66,0x24,0x3C,0x3C,0x18,0x18,0x18,0x18,0x10,0x30,0x60, // 'y'
	1764	0xFC,0x18,0x20,0xC3,0x06,0x18,0x30,0xC1,0xFC, // 'z'
	1765	0x11,0xC8,0xC6,0x31,0x8C,0xC3,0x18,0xC6,0x31,0x84,0x30,0xC0, // '{'
	1766	0xFF,0xFF,0x80, // '\|'
	1767	0x47,0x08,0x63,0x18,0xC6,0x19,0x8C,0x63,0x18,0xC4,0x66,0x00 // '}'
	1768	};
	1769	const GFXglyph Roboto_Condensed_19Glyphs[] PROGMEM = {
	1770	// bitmapOffset, width, height, xAdvance, xOffset, yOffset
	1771	{ 0, 1, 1, 5, 0, 0 }, // ' '
	1772	{ 1, 1, 14, 6, 2, -14 }, // '!'
	1773	{ 3, 4, 4, 7, 1, -14 }, // '"'
	1774	{ 5, 9, 14, 11, 1, -14 }, // '#'
	1775	{ 21, 7, 18, 10, 1, -16 }, // '$'
	1776	{ 37, 10, 14, 13, 1, -14 }, // '%'
	1777	{ 55, 9, 14, 11, 1, -14 }, // '&'
	1778	{ 71, 1, 4, 4, 1, -14 }, // '''
	1779	{ 72, 4, 19, 7, 1, -15 }, // '('
	1780	{ 82, 5, 19, 7, 0, -15 }, // ')'
	1781	{ 94, 8, 8, 9, 0, -14 }, // '*'
	1782	{ 102, 8, 9, 10, 1, -11 }, // '+'
	1783	{ 111, 3, 5, 5, 0, -2 }, // ','
	1784	{ 113, 4, 1, 6, 0, -6 }, // '-'
	1785	{ 114, 2, 2, 6, 1, -2 }, // '.'
	1786	{ 115, 6, 15, 8, 0, -14 }, // '/'
	1787	{ 127, 7, 14, 10, 1, -14 }, // '0'
	1788	{ 140, 5, 14, 10, 1, -14 }, // '1'
	1789	{ 149, 8, 14, 10, 1, -14 }, // '2'
	1790	{ 163, 7, 14, 10, 1, -14 }, // '3'
	1791	{ 176, 9, 14, 10, 0, -14 }, // '4'
	1792	{ 192, 8, 14, 10, 1, -14 }, // '5'
	1793	{ 206, 7, 14, 10, 1, -14 }, // '6'
	1794	{ 219, 8, 14, 10, 1, -14 }, // '7'
	1795	{ 233, 7, 14, 10, 1, -14 }, // '8'
	1796	{ 246, 7, 14, 10, 1, -14 }, // '9'
	1797	{ 259, 2, 10, 5, 1, -10 }, // ':'
	1798	{ 262, 3, 13, 5, 0, -10 }, // ';'
	1799	{ 267, 6, 8, 9, 1, -10 }, // '<'
	1800	{ 273, 7, 5, 10, 1, -9 }, // '='
	1801	{ 278, 7, 8, 10, 1, -10 }, // '>'
	1802	{ 285, 6, 14, 9, 1, -14 }, // '?'
	1803	{ 296, 13, 17, 16, 1, -13 }, // '@'
	1804	{ 324, 11, 14, 12, 0, -14 }, // 'A'
	1805	{ 344, 8, 14, 11, 1, -14 }, // 'B'
	1806	{ 358, 9, 14, 12, 1, -14 }, // 'C'
	1807	{ 374, 8, 14, 12, 2, -14 }, // 'D'
	1808	{ 388, 8, 14, 10, 1, -14 }, // 'E'
	1809	{ 402, 7, 14, 10, 1, -14 }, // 'F'
	1810	{ 415, 9, 14, 12, 1, -14 }, // 'G'
	1811	{ 431, 8, 14, 13, 2, -14 }, // 'H'
	1812	{ 445, 1, 14, 6, 2, -14 }, // 'I'
	1813	{ 447, 7, 14, 10, 1, -14 }, // 'J'
	1814	{ 460, 9, 14, 11, 1, -14 }, // 'K'
	1815	{ 476, 7, 14, 10, 1, -14 }, // 'L'
	1816	{ 489, 12, 14, 15, 1, -14 }, // 'M'
	1817	{ 510, 8, 14, 13, 2, -14 }, // 'N'
	1818	{ 524, 9, 14, 12, 1, -14 }, // 'O'
	1819	{ 540, 8, 14, 12, 2, -14 }, // 'P'
	1820	{ 554, 9, 16, 12, 1, -14 }, // 'Q'
	1821	{ 572, 9, 14, 11, 1, -14 }, // 'R'
	1822	{ 588, 8, 14, 11, 1, -14 }, // 'S'
	1823	{ 602, 8, 14, 11, 1, -14 }, // 'T'
	1824	{ 616, 9, 14, 12, 1, -14 }, // 'U'
	1825	{ 632, 9, 14, 12, 1, -14 }, // 'V'
	1826	{ 648, 13, 14, 15, 1, -14 }, // 'W'
	1827	{ 671, 9, 14, 11, 1, -14 }, // 'X'
	1828	{ 687, 10, 14, 11, 0, -14 }, // 'Y'
	1829	{ 705, 8, 14, 11, 1, -14 }, // 'Z'
	1830	{ 719, 3, 18, 6, 1, -15 }, // '['
	1831	{ 726, 7, 15, 8, 0, -14 }, // '\'
	1832	{ 740, 3, 18, 6, 0, -15 }, // ']'
	1833	{ 747, 5, 7, 8, 1, -14 }, // '^'
	1834	{ 752, 7, 1, 9, 0, 0 }, // '_'
	1835	{ 753, 3, 3, 7, 1, -15 }, // '`'
	1836	{ 755, 7, 10, 10, 1, -10 }, // 'a'
	1837	{ 764, 7, 14, 10, 1, -14 }, // 'b'
	1838	{ 777, 7, 10, 10, 1, -10 }, // 'c'
	1839	{ 786, 7, 14, 10, 1, -14 }, // 'd'
	1840	{ 799, 7, 10, 10, 1, -10 }, // 'e'
	1841	{ 808, 5, 14, 7, 1, -14 }, // 'f'
	1842	{ 817, 7, 14, 10, 1, -10 }, // 'g'
	1843	{ 830, 7, 14, 10, 1, -14 }, // 'h'
	1844	{ 843, 2, 14, 5, 1, -14 }, // 'i'
	1845	{ 847, 3, 18, 5, 0, -14 }, // 'j'
	1846	{ 854, 8, 14, 10, 1, -14 }, // 'k'
	1847	{ 868, 2, 14, 5, 1, -14 }, // 'l'
	1848	{ 872, 12, 10, 15, 1, -10 }, // 'm'
	1849	{ 887, 7, 10, 10, 1, -10 }, // 'n'
	1850	{ 896, 8, 10, 11, 1, -10 }, // 'o'
	1851	{ 906, 7, 14, 10, 1, -10 }, // 'p'
	1852	{ 919, 7, 14, 11, 1, -10 }, // 'q'
	1853	{ 932, 4, 10, 7, 1, -10 }, // 'r'
	1854	{ 937, 7, 10, 10, 1, -10 }, // 's'
	1855	{ 946, 5, 12, 7, 0, -12 }, // 't'
	1856	{ 954, 7, 10, 10, 1, -10 }, // 'u'
	1857	{ 963, 8, 10, 9, 0, -10 }, // 'v'
	1858	{ 973, 12, 10, 13, 0, -10 }, // 'w'
	1859	{ 988, 8, 10, 9, 0, -10 }, // 'x'
	1860	{ 998, 8, 14, 9, 0, -10 }, // 'y'
	1861	{ 1012, 7, 10, 9, 1, -10 }, // 'z'
	1862	{ 1021, 5, 18, 7, 1, -15 }, // '{'
	1863	{ 1033, 1, 17, 6, 2, -14 }, // '\|'
	1864	{ 1036, 5, 18, 7, 0, -15 } // '}'
	1865	};
	1866	const GFXfont Roboto_Condensed_19 PROGMEM = {
	1867	(uint8_t )Roboto_Condensed_19Bitmaps,(GFXglyph )Roboto_Condensed_19Glyphs,0x20, 0x7E, 23};
	1868
	1869
	1870	// Created by http://oleddisplay.squix.ch/ Consider a donation
	1871	// In case of problems make sure that you are using the font file with the correct version!
	1872	const uint8_t URW_Palladio_L_Roman_18Bitmaps[] PROGMEM = {
	1873
	1874	// Bitmap Data:
	1875	0x00, // ' '
	1876	0x7F,0x55,0x0F, // '!'
	1877	0x9C,0xA5,0x20, // '"'
	1878	0x13,0x09,0x04,0x82,0x47,0xF9,0x10,0x89,0xFE,0x24,0x12,0x09,0x08,0x80, // '#'
	1879	0x10,0xFA,0x54,0x89,0x1A,0x1F,0x0F,0x12,0x26,0x4C,0xA7,0x82,0x04,0x00, // '$'
	1880	0x70,0x44,0x44,0x22,0x21,0x12,0x08,0x90,0x39,0x00,0x09,0xC0,0x99,0x04,0x88,0x44,0x42,0x22,0x21,0x31,0x07,0x00, // '%'
	1881	0x1C,0x02,0x40,0x24,0x02,0x80,0x28,0x03,0x3F,0x50,0x89,0x88,0x8C,0x88,0x70,0xC3,0x07,0xCE, // '&'
	1882	0xEA, // '''
	1883	0x12,0x44,0x88,0x88,0x88,0x88,0x44,0x42,0x10, // '('
	1884	0x84,0x22,0x21,0x11,0x11,0x11,0x22,0x44,0x80, // ')'
	1885	0x04,0xB8,0x7E,0xD0,0x40, // '*'
	1886	0x08,0x04,0x02,0x01,0x0F,0xF8,0x40,0x20,0x10,0x08,0x00, // '+'
	1887	0x32,0x64,0x80, // ','
	1888	0x78, // '-'
	1889	0xF0, // '.'
	1890	0x02,0x08,0x10,0x20,0x81,0x04,0x08,0x20,0x40,0x82,0x04,0x10,0x20,0x00, // '/'
	1891	0x38,0x8A,0x1C,0x18,0x30,0x60,0xC1,0x83,0x07,0x12,0x23,0x80, // '0'
	1892	0x13,0xC1,0x04,0x10,0x41,0x04,0x10,0x41,0x1F, // '1'
	1893	0x3C,0x46,0x82,0x02,0x02,0x04,0x04,0x08,0x10,0x20,0x43,0xFF, // '2'
	1894	0x3C,0x8D,0x08,0x10,0x43,0x81,0x81,0x03,0x05,0x13,0xC0, // '3'
	1895	0x04,0x0C,0x1C,0x14,0x24,0x24,0x44,0x44,0xFF,0x04,0x04,0x1F, // '4'
	1896	0x7E,0x81,0x02,0x0B,0xC8,0xC0,0x81,0x03,0x0A,0x13,0xC0, // '5'
	1897	0x04,0x30,0x82,0x04,0x17,0xB1,0xC1,0x83,0x05,0x11,0xC0, // '6'
	1898	0xFF,0x82,0x86,0x04,0x08,0x08,0x10,0x10,0x20,0x60,0x40,0xC0, // '7'
	1899	0x3C,0x8E,0x0C,0x1C,0x4F,0x0F,0x23,0x83,0x06,0x0E,0x27,0x80, // '8'
	1900	0x3C,0x42,0x81,0x81,0x81,0x81,0x43,0x3D,0x02,0x02,0x04,0x08,0x70, // '9'
	1901	0xF0,0x0F, // ':'
	1902	0x50,0x05,0xA8, // ';'
	1903	0x01,0x83,0x06,0x0C,0x0C,0x01,0x80,0x30,0x06,0x00,0x80, // '<'
	1904	0xFF,0x80,0x00,0x00,0x0F,0xF8, // '='
	1905	0xC0,0x18,0x03,0x00,0x60,0x18,0x30,0x60,0xC0,0x80,0x00, // '>'
	1906	0x7A,0x30,0x41,0x08,0x43,0x08,0x00,0x02,0x08, // '?'
	1907	0x0F,0xC1,0x83,0x18,0x04,0x85,0x98,0xDC,0xCC,0x46,0x46,0x32,0x32,0x53,0xB3,0x66,0xCC,0x0C,0x1F,0x80, // '@'
	1908	0x02,0x00,0x18,0x01,0x40,0x0B,0x00,0x88,0x04,0x60,0x43,0x03,0xFC,0x10,0x61,0x01,0x88,0x0D,0xE0,0xF0, // 'A'
	1909	0xFE,0x11,0x88,0x44,0x22,0x21,0xF0,0x86,0x41,0x20,0x90,0x48,0x4F,0xC0, // 'B'
	1910	0x0F,0x86,0x09,0x01,0x20,0x08,0x01,0x00,0x20,0x04,0x00,0xC0,0x08,0x00,0xC1,0x07,0xC0, // 'C'
	1911	0xFF,0x82,0x06,0x20,0x22,0x01,0x20,0x12,0x01,0x20,0x12,0x01,0x20,0x22,0x02,0x20,0xC7,0xF0, // 'D'
	1912	0xFF,0x90,0x48,0x24,0x02,0x11,0xF8,0x84,0x42,0x20,0x10,0x48,0x3F,0xF0, // 'E'
	1913	0xFF,0x90,0x88,0x04,0x02,0x11,0xF8,0x84,0x42,0x20,0x10,0x08,0x1F,0x00, // 'F'
	1914	0x0F,0xE1,0x80,0x90,0x00,0x80,0x08,0x00,0x40,0x02,0x00,0x10,0x1F,0xC0,0x13,0x00,0x8E,0x04,0x1F,0xC0, // 'G'
	1915	0x70,0x38,0x80,0x42,0x01,0x08,0x04,0x20,0x10,0xFF,0xC2,0x01,0x08,0x04,0x20,0x10,0x80,0x42,0x01,0x3E,0x1F, // 'H'
	1916	0xF9,0x08,0x42,0x10,0x84,0x21,0x09,0xF0, // 'I'
	1917	0xF9,0x08,0x42,0x10,0x84,0x21,0x08,0x42,0x11,0x10, // 'J'
	1918	0xF8,0xE2,0x08,0x21,0x02,0x20,0x24,0x03,0x80,0x2C,0x02,0x60,0x23,0x02,0x18,0x20,0xEF,0x87, // 'K'
	1919	0xF8,0x08,0x02,0x00,0x80,0x20,0x08,0x02,0x00,0x80,0x20,0x08,0x22,0x09,0xFE, // 'L'
	1920	0xF0,0x07,0x38,0x0C,0x38,0x0C,0x2C,0x14,0x2C,0x14,0x26,0x24,0x26,0x24,0x23,0x44,0x23,0x44,0x21,0x84,0x21,0x84,0xF9,0x0F, // 'M'
	1921	0xF0,0x3E,0x70,0x10,0xF0,0x21,0x70,0x42,0x60,0x84,0x61,0x08,0x62,0x10,0x64,0x20,0x68,0x40,0xF0,0x80,0xE7,0xC0,0xC0, // 'N'
	1922	0x0F,0xC1,0x83,0x10,0x05,0x00,0x38,0x00,0xC0,0x06,0x00,0x30,0x01,0xC0,0x13,0x00,0x8C,0x18,0x1F,0x00, // 'O'
	1923	0xFF,0x88,0x32,0x04,0x81,0x20,0x8B,0xC2,0x00,0x80,0x20,0x08,0x02,0x03,0xE0, // 'P'
	1924	0x0F,0xC1,0x83,0x10,0x05,0x00,0x38,0x00,0xC0,0x06,0x00,0x30,0x01,0xC0,0x12,0x00,0x8C,0x08,0x3F,0x80,0x70,0x04,0xFC,0x00,0xC0, // 'Q'
	1925	0xFF,0x04,0x30,0x82,0x10,0x42,0x10,0x4C,0x0B,0x81,0x30,0x23,0x04,0x30,0x87,0x7C,0x70, // 'R'
	1926	0x3E,0x42,0x82,0x80,0x80,0x78,0x06,0x01,0x01,0x81,0x82,0x7C, // 'S'
	1927	0xFF,0xC4,0x42,0x01,0x00,0x80,0x40,0x20,0x10,0x08,0x04,0x02,0x07,0xC0, // 'T'
	1928	0xF8,0x7C,0x80,0x42,0x01,0x08,0x04,0x20,0x10,0x80,0x42,0x01,0x08,0x04,0x20,0x10,0x80,0x41,0x06,0x03,0xF0, // 'U'
	1929	0xF8,0x76,0x02,0x30,0x23,0x04,0x18,0x41,0x84,0x08,0x80,0xC8,0x05,0x00,0x70,0x06,0x00,0x20, // 'V'
	1930	0xF8,0x43,0xB0,0x60,0x88,0x30,0x46,0x2C,0x23,0x16,0x21,0x89,0x10,0x48,0xC8,0x34,0x68,0x1C,0x14,0x0E,0x0E,0x02,0x02,0x01,0x01,0x00, // 'W'
	1931	0x70,0x66,0x08,0x62,0x0C,0x80,0xD0,0x0C,0x01,0x80,0x58,0x11,0x82,0x30,0x83,0x20,0x30, // 'X'
	1932	0xE0,0x44,0x18,0xC2,0x08,0x80,0xA0,0x14,0x01,0x00,0x20,0x04,0x00,0x80,0x10,0x0F,0x80, // 'Y'
	1933	0x7F,0xE8,0x19,0x03,0x00,0xC0,0x30,0x0C,0x03,0x00,0x60,0x18,0x06,0x05,0x80,0xFF,0xF0, // 'Z'
	1934	0xF2,0x49,0x24,0x92,0x49,0x27, // '['
	1935	0x40,0x40,0x20,0x20,0x10,0x10,0x08,0x08,0x04,0x04,0x02,0x02,0x01, // '\'
	1936	0xE4,0x92,0x49,0x24,0x92,0x4F, // ']'
	1937	0x18,0x0A,0x09,0x04,0x44,0x32,0x0A,0x06, // '^'
	1938	0xFF,0x80, // '_'
	1939	0x84,0x20, // '`'
	1940	0x39,0x98,0x10,0xE6,0x50,0xA3,0x3B, // 'a'
	1941	0x00,0xC0,0x40,0x40,0x40,0x5E,0x63,0x41,0x41,0x41,0x42,0x42,0x3C, // 'b'
	1942	0x1D,0x98,0x20,0x82,0x04,0x0F, // 'c'
	1943	0x00,0x06,0x02,0x02,0x02,0x1E,0x66,0x82,0x82,0x82,0x82,0x82,0x46,0x3B, // 'd'
	1944	0x1C,0x62,0x43,0x43,0xFF,0x40,0x40,0x61,0x3E, // 'e'
	1945	0x1B,0x10,0x84,0x79,0x08,0x42,0x10,0x8E,0x00, // 'f'
	1946	0x1C,0x33,0xD0,0x88,0x46,0x41,0xC1,0x00,0x80,0x7F,0x20,0x60,0x30,0x1C,0x31,0xE0, // 'g'
	1947	0x00,0xC0,0x40,0x40,0x40,0x5C,0x66,0x42,0x42,0x42,0x42,0x42,0xE3, // 'h'
	1948	0x48,0x2C,0x92,0x49,0x70, // 'i'
	1949	0x22,0x03,0x51,0x11,0x11,0x11,0x11,0x12,0xC0, // 'j'
	1950	0xC0,0x40,0x40,0x40,0x43,0x44,0x48,0x50,0x70,0x58,0x4C,0x46,0xE3, // 'k'
	1951	0xC9,0x24,0x92,0x49,0x2E, // 'l'
	1952	0xDC,0xE3,0x38,0x90,0x84,0x84,0x24,0x21,0x21,0x09,0x08,0x5D,0xF3, // 'm'
	1953	0xDC,0x66,0x42,0x42,0x42,0x42,0x42,0xE3, // 'n'
	1954	0x38,0x8A,0x1C,0x18,0x30,0x70,0xA2,0x38, // 'o'
	1955	0xDC,0x62,0x41,0x41,0x41,0x42,0x62,0x7C,0x40,0x40,0x40,0x40,0xE0, // 'p'
	1956	0x1C,0x62,0x82,0x82,0x82,0x82,0x82,0x46,0x3A,0x02,0x02,0x02,0x02,0x0F, // 'q'
	1957	0x5E,0xD8,0x84,0x21,0x08,0xF0, // 'r'
	1958	0x7A,0x28,0x30,0x78,0x10,0x63,0xF0, // 's'
	1959	0x44,0x47,0xC4,0x44,0x44,0x70, // 't'
	1960	0x42,0xC6,0x42,0x42,0x42,0x42,0x42,0x46,0x3B, // 'u'
	1961	0x71,0x88,0x43,0x20,0xC8,0x12,0x07,0x00,0xC0,0x20, // 'v'
	1962	0xF1,0x1D,0x84,0x22,0x38,0x88,0xE4,0x34,0x90,0x53,0x81,0x8E,0x06,0x18,0x18,0x40, // 'w'
	1963	0xE1,0x19,0x0D,0x03,0x00,0x80,0xE0,0x98,0xC6,0xC3,0x80, // 'x'
	1964	0xF3,0xD8,0x42,0x10,0xC8,0x12,0x07,0x01,0xC0,0x30,0x08,0x02,0x01,0x00,0x40,0x60,0x00, // 'y'
	1965	0x7F,0x42,0x04,0x0C,0x18,0x30,0x61,0xFF, // 'z'
	1966	0x49,0x24,0x92,0x89,0x24,0x92, // '{'
	1967	0xFF,0xF8, // '\|'
	1968	0x89,0x24,0x92,0x29,0x24,0x92 // '}'
	1969	};
	1970	const GFXglyph URW_Palladio_L_Roman_18Glyphs[] PROGMEM = {
	1971	// bitmapOffset, width, height, xAdvance, xOffset, yOffset
	1972	{ 0, 1, 1, 6, 0, 0 }, // ' '
	1973	{ 1, 2, 12, 6, 2, -12 }, // '!'
	1974	{ 4, 5, 4, 8, 1, -12 }, // '"'
	1975	{ 7, 9, 12, 10, 0, -12 }, // '#'
	1976	{ 21, 7, 15, 10, 1, -13 }, // '$'
	1977	{ 35, 13, 13, 16, 1, -13 }, // '%'
	1978	{ 57, 12, 12, 15, 1, -12 }, // '&'
	1979	{ 75, 2, 4, 5, 1, -12 }, // '''
	1980	{ 76, 4, 17, 7, 1, -13 }, // '('
	1981	{ 85, 4, 17, 7, 0, -13 }, // ')'
	1982	{ 94, 5, 7, 8, 1, -13 }, // '*'
	1983	{ 99, 9, 9, 12, 1, -9 }, // '+'
	1984	{ 110, 4, 5, 6, 0, -2 }, // ','
	1985	{ 113, 6, 1, 7, 0, -5 }, // '-'
	1986	{ 114, 2, 2, 6, 1, -2 }, // '.'
	1987	{ 115, 7, 15, 12, 2, -13 }, // '/'
	1988	{ 129, 7, 13, 10, 1, -13 }, // '0'
	1989	{ 141, 6, 12, 10, 1, -12 }, // '1'
	1990	{ 150, 8, 12, 10, 0, -12 }, // '2'
	1991	{ 162, 7, 12, 10, 0, -12 }, // '3'
	1992	{ 173, 8, 12, 10, 0, -12 }, // '4'
	1993	{ 185, 7, 12, 10, 1, -12 }, // '5'
	1994	{ 196, 7, 12, 10, 1, -12 }, // '6'
	1995	{ 207, 8, 12, 10, 1, -12 }, // '7'
	1996	{ 219, 7, 13, 10, 1, -13 }, // '8'
	1997	{ 231, 8, 13, 10, 0, -13 }, // '9'
	1998	{ 244, 2, 8, 6, 1, -8 }, // ':'
	1999	{ 246, 2, 11, 6, 1, -8 }, // ';'
	2000	{ 249, 9, 9, 12, 1, -9 }, // '<'
	2001	{ 260, 9, 5, 12, 1, -7 }, // '='
	2002	{ 266, 9, 9, 12, 1, -9 }, // '>'
	2003	{ 277, 6, 12, 9, 0, -12 }, // '?'
	2004	{ 286, 13, 12, 14, 0, -12 }, // '@'
	2005	{ 306, 13, 12, 15, 0, -12 }, // 'A'
	2006	{ 326, 9, 12, 12, 0, -12 }, // 'B'
	2007	{ 340, 11, 12, 14, 0, -12 }, // 'C'
	2008	{ 357, 12, 12, 15, 0, -12 }, // 'D'
	2009	{ 375, 9, 12, 12, 0, -12 }, // 'E'
	2010	{ 389, 9, 12, 11, 0, -12 }, // 'F'
	2011	{ 403, 13, 12, 15, 0, -12 }, // 'G'
	2012	{ 423, 14, 12, 16, 0, -12 }, // 'H'
	2013	{ 444, 5, 12, 7, 0, -12 }, // 'I'
	2014	{ 452, 5, 16, 7, 0, -12 }, // 'J'
	2015	{ 462, 12, 12, 14, 0, -12 }, // 'K'
	2016	{ 480, 10, 12, 12, 0, -12 }, // 'L'
	2017	{ 495, 16, 12, 18, 0, -12 }, // 'M'
	2018	{ 519, 15, 12, 16, 0, -12 }, // 'N'
	2019	{ 542, 13, 12, 15, 0, -12 }, // 'O'
	2020	{ 562, 10, 12, 12, 0, -12 }, // 'P'
	2021	{ 577, 13, 15, 15, 0, -12 }, // 'Q'
	2022	{ 602, 11, 12, 13, 0, -12 }, // 'R'
	2023	{ 619, 8, 12, 10, 0, -12 }, // 'S'
	2024	{ 631, 9, 12, 12, 1, -12 }, // 'T'
	2025	{ 645, 14, 12, 15, 0, -12 }, // 'U'
	2026	{ 666, 12, 12, 14, 0, -12 }, // 'V'
	2027	{ 684, 17, 12, 19, 0, -12 }, // 'W'
	2028	{ 710, 11, 12, 13, 0, -12 }, // 'X'
	2029	{ 727, 11, 12, 13, 0, -12 }, // 'Y'
	2030	{ 744, 11, 12, 13, 0, -12 }, // 'Z'
	2031	{ 761, 3, 16, 7, 2, -14 }, // '['
	2032	{ 767, 8, 13, 12, 1, -13 }, // '\'
	2033	{ 780, 3, 16, 7, 1, -14 }, // ']'
	2034	{ 786, 9, 7, 12, 1, -12 }, // '^'
	2035	{ 794, 9, 1, 10, 0, 1 }, // '_'
	2036	{ 796, 4, 3, 7, 1, -12 }, // '`'
	2037	{ 798, 7, 8, 10, 1, -8 }, // 'a'
	2038	{ 805, 8, 13, 11, 0, -13 }, // 'b'
	2039	{ 818, 6, 8, 9, 1, -8 }, // 'c'
	2040	{ 824, 8, 14, 12, 1, -14 }, // 'd'
	2041	{ 838, 8, 9, 10, 0, -9 }, // 'e'
	2042	{ 847, 5, 13, 7, 1, -13 }, // 'f'
	2043	{ 856, 9, 14, 11, 0, -9 }, // 'g'
	2044	{ 872, 8, 13, 11, 1, -13 }, // 'h'
	2045	{ 885, 3, 12, 6, 1, -12 }, // 'i'
	2046	{ 890, 4, 17, 5, -2, -12 }, // 'j'
	2047	{ 899, 8, 13, 11, 1, -13 }, // 'k'
	2048	{ 912, 3, 13, 6, 1, -13 }, // 'l'
	2049	{ 917, 13, 8, 17, 1, -8 }, // 'm'
	2050	{ 930, 8, 8, 11, 1, -8 }, // 'n'
	2051	{ 938, 7, 9, 11, 1, -9 }, // 'o'
	2052	{ 946, 8, 13, 12, 1, -8 }, // 'p'
	2053	{ 959, 8, 14, 11, 1, -9 }, // 'q'
	2054	{ 973, 5, 9, 8, 1, -9 }, // 'r'
	2055	{ 979, 6, 9, 9, 1, -9 }, // 's'
	2056	{ 986, 4, 11, 7, 1, -11 }, // 't'
	2057	{ 992, 8, 9, 12, 1, -9 }, // 'u'
	2058	{ 1001, 10, 8, 11, 0, -8 }, // 'v'
	2059	{ 1011, 14, 9, 16, 0, -9 }, // 'w'
	2060	{ 1027, 9, 9, 10, 0, -9 }, // 'x'
	2061	{ 1038, 10, 13, 11, 0, -8 }, // 'y'
	2062	{ 1055, 8, 8, 10, 0, -8 }, // 'z'
	2063	{ 1063, 3, 16, 7, 1, -13 }, // '{'
	2064	{ 1069, 1, 13, 12, 5, -13 }, // '\|'
	2065	{ 1071, 3, 16, 7, 1, -13 } // '}'
	2066	};
	2067	const GFXfont URW_Palladio_L_Roman_18 PROGMEM = {
	2068	(uint8_t )URW_Palladio_L_Roman_18Bitmaps,(GFXglyph )URW_Palladio_L_Roman_18Glyphs,0x20, 0x7E, 24};
	2069
	2070	// Created by http://oleddisplay.squix.ch/ Consider a donation
	2071	// In case of problems make sure that you are using the font file with the correct version!
	2072	const uint8_t URW_Palladio_L_Bold_18Bitmaps[] PROGMEM = {
	2073
	2074	// Bitmap Data:
	2075	0x00, // ' '
	2076	0x7F,0xB4,0x92,0x0F,0xF0, // '!'
	2077	0x67,0xDD,0x9A,0x24,0x48,0x80, // '"'
	2078	0x13,0x09,0x84,0x82,0x47,0xF9,0x90,0xD9,0xFE,0x24,0x12,0x09,0x0C,0x80, // '#'
	2079	0x10,0x7E,0xD2,0xD2,0xD0,0xF0,0xFE,0x3F,0x17,0x93,0x93,0x96,0xFC,0x10,0x10, // '$'
	2080	0x78,0x43,0x31,0x0C,0xC8,0x33,0x20,0xCD,0x01,0xE4,0x00,0x27,0x81,0x33,0x04,0xCC,0x23,0x30,0x8C,0xC4,0x1E, // '%'
	2081	0x0E,0x00,0x98,0x0C,0xC0,0x64,0x03,0xC0,0x1C,0x7D,0xF1,0x19,0xC8,0xC7,0x47,0x1C,0x1C,0x7E,0x7C,0xE0, // '&'
	2082	0xFF,0xC0, // '''
	2083	0x12,0x64,0xCC,0xCC,0xCC,0xC4,0x62,0x10, // '('
	2084	0x84,0x62,0x33,0x33,0x33,0x32,0x64,0x80, // ')'
	2085	0x1B,0x43,0xF4,0x18, // '*'
	2086	0x0C,0x03,0x00,0xC0,0x30,0xFF,0xFF,0xF0,0xC0,0x30,0x0C,0x03,0x00, // '+'
	2087	0x07,0x66,0xC8, // ','
	2088	0x7F,0xE0, // '-'
	2089	0xDF,0x00, // '.'
	2090	0x08,0xC6,0x23,0x18,0x84,0x63,0x11,0x8C,0x00, // '/'
	2091	0x38,0xDB,0x1E,0x3C,0x78,0xF1,0xE3,0xC7,0x8D,0xB1,0xC0, // '0'
	2092	0x19,0xF2,0x60,0xC1,0x83,0x06,0x0C,0x18,0x30,0x63,0xF0, // '1'
	2093	0x78,0x7E,0xCE,0x86,0x06,0x04,0x0C,0x18,0x10,0x20,0x7F,0xFF, // '2'
	2094	0x3C,0x7E,0x46,0x86,0x04,0x3C,0x3F,0x03,0x03,0x83,0xC6,0xF8, // '3'
	2095	0x02,0x07,0x03,0x82,0xC3,0x61,0x31,0x18,0x8C,0x7F,0x83,0x01,0x83,0xF0, // '4'
	2096	0x7F,0x7F,0x40,0x40,0x5E,0x7F,0x47,0x03,0x03,0x82,0x46,0x78, // '5'
	2097	0x04,0x31,0x82,0x0D,0xDF,0xF3,0xE3,0xC7,0x8D,0x91,0xC0, // '6'
	2098	0xFF,0xFE,0x82,0x84,0x04,0x08,0x08,0x10,0x30,0x30,0x60,0x60, // '7'
	2099	0x3C,0xCF,0x9F,0x3F,0x47,0x8B,0xA3,0xC7,0x8F,0x93,0xC0, // '8'
	2100	0x38,0x9B,0x1E,0x3C,0x7C,0xFF,0xBB,0x0C,0x18,0x63,0x80, // '9'
	2101	0xDF,0x01,0xBE, // ':'
	2102	0x6D,0x80,0x1B,0x5A,0x00, // ';'
	2103	0x00,0x81,0xC3,0xC7,0x8E,0x07,0x01,0xE0,0x1C,0x03,0x80,0x40, // '<'
	2104	0xFF,0xFF,0xC0,0x00,0x0F,0xFF,0xFC, // '='
	2105	0x00,0x70,0x1E,0x03,0xC0,0x38,0x1C,0x3C,0x70,0xE0,0x40,0x00, // '>'
	2106	0x7B,0xF8,0xC3,0x08,0x42,0x08,0x00,0x86,0x18, // '?'
	2107	0x0F,0x83,0x04,0x40,0x24,0x69,0x99,0x9B,0x99,0xB1,0x9B,0x32,0x75,0x65,0xDF,0x30,0x60,0xF8, // '@'
	2108	0x03,0x00,0x0C,0x00,0x78,0x01,0xE0,0x09,0xC0,0x27,0x01,0x8E,0x07,0xF8,0x10,0x60,0x81,0xC2,0x07,0x3E,0x3F, // 'A'
	2109	0xFF,0x0C,0x63,0x18,0xC6,0x33,0x0F,0xE3,0x1C,0xC3,0x30,0xCC,0x33,0x19,0xFC, // 'B'
	2110	0x0F,0xC6,0x0D,0x80,0xE0,0x1C,0x01,0x80,0x30,0x06,0x00,0x60,0x0C,0x00,0xE0,0x87,0xE0, // 'C'
	2111	0xFF,0xE0,0xC1,0xE3,0x01,0x8C,0x03,0x30,0x0C,0xC0,0x33,0x00,0xCC,0x03,0x30,0x18,0xC0,0x63,0x06,0x1F,0xE0, // 'D'
	2112	0xFF,0x8C,0x23,0x00,0xC0,0x31,0x0F,0xC3,0x10,0xC0,0x30,0x0C,0x13,0x05,0xFE, // 'E'
	2113	0xFF,0x98,0x4C,0x26,0x03,0x11,0xF8,0xC4,0x62,0x30,0x18,0x0C,0x1F,0x80, // 'F'
	2114	0x0F,0xE1,0x81,0x98,0x05,0x80,0x2C,0x00,0x60,0x03,0x00,0x18,0x1F,0x60,0x33,0x01,0x8E,0x0C,0x1F,0x80, // 'G'
	2115	0xFC,0xFC,0xC0,0xC3,0x03,0x0C,0x0C,0x30,0x30,0xFF,0xC3,0x03,0x0C,0x0C,0x30,0x30,0xC0,0xC3,0x03,0x3F,0x3F, // 'H'
	2116	0xFC,0xC3,0x0C,0x30,0xC3,0x0C,0x30,0xC3,0x3F, // 'I'
	2117	0xFC,0xC3,0x0C,0x30,0xC3,0x0C,0x30,0xC3,0x0C,0x30,0x82,0x30, // 'J'
	2118	0xFC,0x79,0x83,0x0C,0x20,0x62,0x03,0x20,0x1F,0x00,0xDC,0x06,0xF0,0x33,0xC1,0x8F,0x0C,0x3D,0xF8,0xF0, // 'K'
	2119	0xFC,0x0C,0x03,0x00,0xC0,0x30,0x0C,0x03,0x00,0xC0,0x30,0x0C,0x13,0x05,0xFE, // 'L'
	2120	0xF8,0x07,0x9C,0x07,0x0F,0x03,0x85,0x82,0xC2,0xE1,0x61,0x31,0x30,0x9C,0x98,0x46,0x8C,0x23,0xC6,0x10,0xC3,0x08,0x61,0x9F,0x33,0xF0, // 'M'
	2121	0xF8,0x3C,0xE0,0x23,0xC0,0x8B,0x82,0x27,0x08,0x9E,0x22,0x3C,0x88,0x7A,0x20,0xF8,0x81,0xE2,0x03,0xBE,0x06, // 'N'
	2122	0x0F,0xC1,0x83,0x18,0x0D,0x80,0x7C,0x01,0xE0,0x0F,0x00,0x78,0x03,0xE0,0x1B,0x01,0x8C,0x18,0x3F,0x00, // 'O'
	2123	0xFF,0x8C,0x73,0x0C,0xC3,0x31,0x8D,0xC3,0x00,0xC0,0x30,0x0C,0x03,0x03,0xF0, // 'P'
	2124	0x0F,0xC1,0x83,0x18,0x0D,0x80,0x7C,0x01,0xE0,0x0F,0x00,0x78,0x03,0xE0,0x1B,0x01,0x8C,0x18,0x3F,0x00,0xF0,0x1F,0xF4,0x01,0xC0, // 'Q'
	2125	0xFF,0x83,0x1C,0x30,0xC3,0x0C,0x30,0x83,0x30,0x37,0x03,0x38,0x33,0xC3,0x1C,0x30,0xEF,0xCF, // 'R'
	2126	0x3F,0x31,0xB0,0x58,0x0F,0x03,0xF0,0x7E,0x07,0x81,0xC0,0xF0,0xCF,0xC0, // 'S'
	2127	0xFF,0xE3,0x18,0xC4,0x30,0x0C,0x03,0x00,0xC0,0x30,0x0C,0x03,0x00,0xC0,0xFC, // 'T'
	2128	0xFC,0x7C,0xC0,0x43,0x01,0x0C,0x04,0x30,0x10,0xC0,0x43,0x01,0x0C,0x04,0x30,0x10,0xC0,0x41,0x82,0x03,0xF0, // 'U'
	2129	0xFC,0x3C,0xE0,0x43,0x81,0x07,0x0C,0x1C,0x20,0x30,0x80,0xE4,0x01,0x90,0x07,0x80,0x1E,0x00,0x30,0x00,0xC0, // 'V'
	2130	0xFC,0x43,0xDC,0x18,0x63,0x0E,0x10,0xE3,0xC4,0x39,0xF1,0x0E,0x4C,0x81,0x93,0xA0,0x78,0xE8,0x1E,0x1E,0x07,0x07,0x00,0xC0,0xC0,0x30,0x30, // 'W'
	2131	0xF0,0x73,0x84,0x1C,0x81,0xD8,0x0F,0x00,0x60,0x07,0x00,0xB8,0x1B,0x81,0x1C,0x21,0xCE,0x0F, // 'X'
	2132	0xF0,0x6E,0x08,0xE3,0x0C,0x40,0xD0,0x1A,0x01,0x80,0x30,0x06,0x00,0xC0,0x18,0x0F,0xC0, // 'Y'
	2133	0x7F,0xE8,0x39,0x07,0x01,0xC0,0x70,0x0E,0x03,0x80,0xE0,0x1C,0x07,0x05,0xC0,0xFF,0xF0, // 'Z'
	2134	0xFC,0xCC,0xCC,0xCC,0xCC,0xCC,0xCC,0xF0, // '['
	2135	0x40,0x30,0x08,0x06,0x01,0x00,0xC0,0x20,0x18,0x04,0x03,0x00,0x80,0x60,0x10, // '\'
	2136	0xF3,0x33,0x33,0x33,0x33,0x33,0x33,0xF0, // ']'
	2137	0x1C,0x0E,0x0D,0x86,0xC6,0x32,0x1B,0x06, // '^'
	2138	0xFF,0x80, // '_'
	2139	0xC3,0x0C, // '`'
	2140	0x78,0x18,0x31,0xEC,0xD9,0xBF,0x37, // 'a'
	2141	0xE0,0x30,0x18,0x0D,0xE7,0xF3,0x1D,0x86,0xC3,0x61,0xB0,0x98,0x8F,0x80, // 'b'
	2142	0x1C,0xCB,0x16,0x0C,0x18,0x18,0x1E, // 'c'
	2143	0x07,0x01,0x80,0xC0,0x61,0xF3,0x3B,0x0D,0x86,0xC3,0x71,0x9F,0xC7,0x70, // 'd'
	2144	0x3C,0x8F,0x1F,0xFC,0x18,0x38,0x1F, // 'e'
	2145	0x0C,0xF6,0x18,0x63,0xE6,0x18,0x61,0x86,0x18,0xF8, // 'f'
	2146	0x3C,0x23,0xF1,0x98,0xCC,0x63,0xC1,0x01,0xFE,0xFF,0xA0,0xF0,0x78,0x3E,0x33,0xE0, // 'g'
	2147	0xE0,0x30,0x18,0x0D,0xC7,0xF3,0x19,0x8C,0xC6,0x63,0x31,0x98,0xDE,0x70, // 'h'
	2148	0x66,0x60,0x2E,0x66,0x66,0x66,0xF0, // 'i'
	2149	0x33,0x30,0x17,0x33,0x33,0x33,0x33,0x33,0x2C, // 'j'
	2150	0xE0,0x18,0x06,0x01,0x80,0x63,0x99,0x86,0xC1,0xF0,0x6E,0x1B,0xC6,0x7B,0xCF, // 'k'
	2151	0xE6,0x66,0x66,0x66,0x66,0x6F, // 'l'
	2152	0x6E,0x73,0xFF,0xE6,0x31,0x98,0xC6,0x63,0x19,0x8C,0x66,0x31,0x98,0xC6,0xF7,0x9C, // 'm'
	2153	0x2E,0x7F,0x98,0xCC,0x66,0x33,0x19,0x8C,0xC6,0xF3,0x80, // 'n'
	2154	0x3C,0x66,0xC3,0xC3,0xC3,0xC3,0xC3,0x66,0x3C, // 'o'
	2155	0x2F,0x7F,0x98,0xEC,0x36,0x1B,0x0D,0x84,0xC4,0x7C,0x30,0x18,0x0C,0x06,0x07,0x80, // 'p'
	2156	0x1F,0x33,0xB0,0xD8,0x6C,0x37,0x19,0xFC,0xF6,0x03,0x01,0x80,0xC0,0x60,0x78, // 'q'
	2157	0x2F,0xF6,0x58,0x61,0x86,0x18,0xF8, // 'r'
	2158	0x7B,0x2C,0x3C,0x7C,0x78,0xE3,0xF8, // 's'
	2159	0x23,0x18,0xCF,0xB1,0x8C,0x63,0x1E,0x60, // 't'
	2160	0x21,0x73,0x98,0xCC,0x66,0x33,0x19,0x8C,0xFE,0x3B,0x80, // 'u'
	2161	0x71,0x8C,0x43,0x10,0xEC,0x1A,0x07,0x81,0xC0,0x30, // 'v'
	2162	0xF9,0x9E,0x63,0x18,0xC7,0x21,0x96,0x43,0xAD,0x83,0x9E,0x07,0x1C,0x0C,0x38,0x18,0x20, // 'w'
	2163	0xE1,0x99,0x0F,0x03,0x81,0xC0,0xF0,0xD8,0x4E,0xC3,0x80, // 'x'
	2164	0xF3,0xB0,0x9C,0x46,0x43,0x21,0xE0,0x70,0x30,0x08,0x04,0x04,0x12,0x0E,0x00, // 'y'
	2165	0x7F,0x46,0x0E,0x1C,0x18,0x30,0x71,0xFF, // 'z'
	2166	0x18,0xC3,0x0C,0x30,0xC3,0x10,0x30,0xC3,0x0C,0x30,0xC1,0x80, // '{'
	2167	0xFF,0xFF,0xFF,0xC0, // '\|'
	2168	0x60,0xC3,0x0C,0x30,0xC3,0x02,0x30,0xC3,0x0C,0x30,0xC6,0x00 // '}'
	2169	};
	2170	const GFXglyph URW_Palladio_L_Bold_18Glyphs[] PROGMEM = {
	2171	// bitmapOffset, width, height, xAdvance, xOffset, yOffset
	2172	{ 0, 1, 1, 6, 0, 0 }, // ' '
	2173	{ 1, 3, 12, 6, 1, -12 }, // '!'
	2174	{ 6, 7, 6, 8, 0, -12 }, // '"'
	2175	{ 12, 9, 12, 10, 0, -12 }, // '#'
	2176	{ 26, 8, 15, 10, 1, -13 }, // '$'
	2177	{ 41, 14, 12, 17, 1, -12 }, // '%'
	2178	{ 62, 13, 12, 16, 1, -12 }, // '&'
	2179	{ 82, 2, 6, 5, 1, -12 }, // '''
	2180	{ 84, 4, 15, 7, 1, -13 }, // '('
	2181	{ 92, 4, 15, 7, 1, -13 }, // ')'
	2182	{ 100, 6, 5, 9, 1, -12 }, // '*'
	2183	{ 104, 10, 10, 12, 1, -10 }, // '+'
	2184	{ 117, 4, 6, 6, 0, -3 }, // ','
	2185	{ 120, 6, 2, 7, 0, -6 }, // '-'
	2186	{ 122, 3, 3, 6, 1, -3 }, // '.'
	2187	{ 124, 5, 13, 6, 0, -13 }, // '/'
	2188	{ 133, 7, 12, 10, 1, -12 }, // '0'
	2189	{ 144, 7, 12, 10, 1, -12 }, // '1'
	2190	{ 155, 8, 12, 10, 1, -12 }, // '2'
	2191	{ 167, 8, 12, 10, 0, -12 }, // '3'
	2192	{ 179, 9, 12, 10, 0, -12 }, // '4'
	2193	{ 193, 8, 12, 10, 0, -12 }, // '5'
	2194	{ 205, 7, 12, 10, 1, -12 }, // '6'
	2195	{ 216, 8, 12, 10, 1, -12 }, // '7'
	2196	{ 228, 7, 12, 10, 1, -12 }, // '8'
	2197	{ 239, 7, 12, 10, 1, -12 }, // '9'
	2198	{ 250, 3, 8, 6, 1, -8 }, // ':'
	2199	{ 253, 3, 11, 6, 0, -8 }, // ';'
	2200	{ 258, 9, 10, 12, 1, -10 }, // '<'
	2201	{ 270, 9, 6, 12, 1, -8 }, // '='
	2202	{ 277, 9, 10, 12, 1, -10 }, // '>'
	2203	{ 289, 6, 12, 9, 1, -12 }, // '?'
	2204	{ 298, 12, 12, 14, 1, -12 }, // '@'
	2205	{ 316, 14, 12, 15, 0, -12 }, // 'A'
	2206	{ 337, 10, 12, 13, 0, -12 }, // 'B'
	2207	{ 352, 11, 12, 14, 1, -12 }, // 'C'
	2208	{ 369, 14, 12, 16, 0, -12 }, // 'D'
	2209	{ 390, 10, 12, 12, 0, -12 }, // 'E'
	2210	{ 405, 9, 12, 11, 0, -12 }, // 'F'
	2211	{ 419, 13, 12, 16, 1, -12 }, // 'G'
	2212	{ 439, 14, 12, 16, 0, -12 }, // 'H'
	2213	{ 460, 6, 12, 8, 0, -12 }, // 'I'
	2214	{ 469, 6, 16, 8, 0, -12 }, // 'J'
	2215	{ 481, 13, 12, 15, 0, -12 }, // 'K'
	2216	{ 501, 10, 12, 12, 0, -12 }, // 'L'
	2217	{ 516, 17, 12, 19, 0, -12 }, // 'M'
	2218	{ 542, 14, 12, 16, 0, -12 }, // 'N'
	2219	{ 563, 13, 12, 16, 1, -12 }, // 'O'
	2220	{ 583, 10, 12, 12, 0, -12 }, // 'P'
	2221	{ 598, 13, 15, 16, 1, -12 }, // 'Q'
	2222	{ 623, 12, 12, 14, 0, -12 }, // 'R'
	2223	{ 641, 9, 12, 12, 1, -12 }, // 'S'
	2224	{ 655, 10, 12, 13, 1, -12 }, // 'T'
	2225	{ 670, 14, 12, 15, 0, -12 }, // 'U'
	2226	{ 691, 14, 12, 15, 0, -12 }, // 'V'
	2227	{ 712, 18, 12, 19, 0, -12 }, // 'W'
	2228	{ 739, 12, 12, 13, 0, -12 }, // 'X'
	2229	{ 757, 11, 12, 13, 0, -12 }, // 'Y'
	2230	{ 774, 11, 12, 13, 0, -12 }, // 'Z'
	2231	{ 791, 4, 15, 7, 1, -13 }, // '['
	2232	{ 799, 9, 13, 12, 1, -13 }, // '\'
	2233	{ 814, 4, 15, 7, 1, -13 }, // ']'
	2234	{ 822, 9, 7, 12, 1, -12 }, // '^'
	2235	{ 830, 9, 1, 10, 0, 1 }, // '_'
	2236	{ 832, 5, 3, 7, 0, -12 }, // '`'
	2237	{ 834, 7, 8, 10, 1, -8 }, // 'a'
	2238	{ 841, 9, 12, 12, 1, -12 }, // 'b'
	2239	{ 855, 7, 8, 9, 1, -8 }, // 'c'
	2240	{ 862, 9, 12, 12, 1, -12 }, // 'd'
	2241	{ 876, 7, 8, 10, 1, -8 }, // 'e'
	2242	{ 883, 6, 13, 8, 1, -13 }, // 'f'
	2243	{ 893, 9, 14, 11, 1, -9 }, // 'g'
	2244	{ 909, 9, 12, 12, 1, -12 }, // 'h'
	2245	{ 923, 4, 13, 7, 1, -13 }, // 'i'
	2246	{ 930, 4, 18, 7, 0, -13 }, // 'j'
	2247	{ 939, 10, 12, 12, 1, -12 }, // 'k'
	2248	{ 954, 4, 12, 7, 1, -12 }, // 'l'
	2249	{ 960, 14, 9, 17, 1, -9 }, // 'm'
	2250	{ 976, 9, 9, 12, 1, -9 }, // 'n'
	2251	{ 987, 8, 9, 11, 1, -9 }, // 'o'
	2252	{ 996, 9, 14, 12, 1, -9 }, // 'p'
	2253	{ 1012, 9, 13, 12, 1, -8 }, // 'q'
	2254	{ 1027, 6, 9, 8, 1, -9 }, // 'r'
	2255	{ 1034, 6, 9, 9, 1, -9 }, // 's'
	2256	{ 1041, 5, 12, 7, 1, -12 }, // 't'
	2257	{ 1049, 9, 9, 12, 1, -9 }, // 'u'
	2258	{ 1060, 10, 8, 11, 0, -8 }, // 'v'
	2259	{ 1070, 15, 9, 16, 0, -9 }, // 'w'
	2260	{ 1087, 9, 9, 10, 0, -9 }, // 'x'
	2261	{ 1098, 9, 13, 11, 0, -8 }, // 'y'
	2262	{ 1113, 8, 8, 10, 0, -8 }, // 'z'
	2263	{ 1121, 6, 15, 7, 0, -14 }, // '{'
	2264	{ 1133, 2, 13, 12, 5, -13 }, // '\|'
	2265	{ 1137, 6, 15, 7, 0, -14 } // '}'
	2266	};
	2267	const GFXfont URW_Palladio_L_Bold_18 PROGMEM = {
	2268	(uint8_t )URW_Palladio_L_Bold_18Bitmaps,(GFXglyph )URW_Palladio_L_Bold_18Glyphs,0x20, 0x7E, 24};
	2269
	2270	// Created by http://oleddisplay.squix.ch/ Consider a donation
	2271	// In case of problems make sure that you are using the font file with the correct version!
	2272	const uint8_t Lato_Hairline_16Bitmaps[] PROGMEM = {
	2273
	2274	// Bitmap Data:
	2275	0x00, // ' '
	2276	0x55,0x55,0x07, // '!'
	2277	0xB6,0xDA, // '"'
	2278	0x12,0x12,0x12,0xFF,0x24,0x24,0x24,0x24,0xFF,0x48,0x48,0x48, // '#'
	2279	0x08,0x08,0x1C,0x6A,0x48,0x48,0x48,0x30,0x0E,0x12,0x11,0x12,0xD2,0x3C,0x10,0x10, // '$'
	2280	0x60,0x53,0x12,0x22,0x44,0x88,0xA1,0xA8,0x09,0x70,0x51,0x12,0x24,0x44,0x88,0xA0,0xE0, // '%'
	2281	0x1C,0x04,0x40,0x88,0x10,0x02,0x00,0x60,0x12,0x24,0x24,0x82,0x90,0x23,0x0A,0x1E,0x30, // '&'
	2282	0xF8, // '''
	2283	0x25,0x29,0x24,0x92,0x24,0x88, // '('
	2284	0x91,0x24,0x49,0x25,0x25,0x20, // ')'
	2285	0x27,0x4D,0xD2,0x00, // '*'
	2286	0x10,0x10,0x10,0x10,0xFF,0x10,0x10,0x10, // '+'
	2287	0x76, // ','
	2288	0xF0, // '-'
	2289	0x70, // '.'
	2290	0x04,0x20,0x82,0x10,0x42,0x08,0x41,0x04,0x20,0x80, // '/'
	2291	0x18,0x66,0x82,0x81,0x81,0x81,0x81,0x81,0x81,0x81,0x42,0x3C, // '0'
	2292	0x10,0xC5,0x24,0x10,0x41,0x04,0x10,0x41,0x3F, // '1'
	2293	0x18,0x66,0x42,0x81,0x02,0x02,0x04,0x08,0x10,0x20,0x40,0xFF, // '2'
	2294	0x18,0x66,0x42,0x82,0x02,0x06,0x1E,0x02,0x01,0x81,0x42,0x3C, // '3'
	2295	0x02,0x01,0x01,0x81,0x41,0x21,0x10,0x88,0x84,0xFF,0x81,0x00,0x80,0x40, // '4'
	2296	0x3E,0x41,0x02,0x04,0x0F,0x80,0x81,0x02,0x06,0x0B,0xE0, // '5'
	2297	0x04,0x08,0x08,0x10,0x20,0x7E,0x42,0x81,0x81,0x81,0x42,0x3C, // '6'
	2298	0xFF,0x01,0x02,0x02,0x04,0x04,0x08,0x08,0x10,0x10,0x20,0x60, // '7'
	2299	0x18,0x66,0x42,0x82,0x42,0x66,0x7E,0x82,0x81,0x81,0x42,0x3C, // '8'
	2300	0x18,0x66,0x82,0x81,0x83,0x66,0x1E,0x04,0x08,0x18,0x10,0x20, // '9'
	2301	0x70,0x01,0xC0, // ':'
	2302	0x70,0x01,0xD8, // ';'
	2303	0x06,0x30,0x86,0x03,0x01,0x80,0x80, // '<'
	2304	0xFF,0x00,0xFF, // '='
	2305	0xC0,0xC0,0x81,0x19,0x88,0x00, // '>'
	2306	0x74,0x42,0x10,0x88,0x84,0x00,0x08,0xC0, // '?'
	2307	0x1F,0x82,0x06,0x40,0x24,0x79,0x88,0x99,0x11,0x91,0x19,0x12,0x93,0x24,0xCC,0x20,0x01,0x8E,0x07,0x00, // '@'
	2308	0x04,0x00,0x80,0x28,0x05,0x01,0x20,0x22,0x04,0x41,0x04,0x3F,0x88,0x09,0x01,0x40,0x30, // 'A'
	2309	0xF9,0x0A,0x0C,0x18,0x30,0xBF,0x41,0x83,0x06,0x0F,0xE0, // 'B'
	2310	0x0E,0x0C,0x74,0x01,0x00,0x80,0x20,0x08,0x02,0x00,0x80,0x10,0x02,0x0C,0x7C, // 'C'
	2311	0xFC,0x20,0xC8,0x0A,0x02,0x80,0x60,0x18,0x06,0x01,0x80,0xA0,0x28,0x13,0xF8, // 'D'
	2312	0xFF,0x02,0x04,0x08,0x10,0x3F,0x40,0x81,0x02,0x07,0xF0, // 'E'
	2313	0xFF,0x02,0x04,0x08,0x10,0x3F,0x40,0x81,0x02,0x04,0x00, // 'F'
	2314	0x0F,0x0C,0x34,0x01,0x00,0x80,0x20,0x08,0x02,0x07,0x80,0x50,0x12,0x04,0x7E, // 'G'
	2315	0x80,0xC0,0x60,0x30,0x18,0x0C,0x07,0xFF,0x01,0x80,0xC0,0x60,0x30,0x10, // 'H'
	2316	0xFF,0xF0, // 'I'
	2317	0x08,0x42,0x10,0x84,0x21,0x08,0x43,0xE0, // 'J'
	2318	0x81,0x41,0x21,0x11,0x09,0x05,0x03,0x81,0x20,0x88,0x42,0x20,0x90,0x30, // 'K'
	2319	0x82,0x08,0x20,0x82,0x08,0x20,0x82,0x08,0x3F, // 'L'
	2320	0x80,0x30,0x07,0x01,0xD0,0x5A,0x0B,0x22,0x64,0x4C,0x51,0x8A,0x30,0x86,0x00,0xC0,0x10, // 'M'
	2321	0x80,0xC0,0x70,0x34,0x19,0x0C,0x86,0x23,0x09,0x84,0xC1,0x60,0x70,0x10, // 'N'
	2322	0x0E,0x06,0x31,0x01,0x20,0x18,0x03,0x00,0x60,0x0C,0x01,0x80,0x28,0x08,0x82,0x0F,0x80, // 'O'
	2323	0xF1,0x1A,0x0C,0x18,0x30,0xA3,0x78,0x81,0x02,0x04,0x00, // 'P'
	2324	0x0E,0x03,0x18,0x40,0x44,0x02,0x80,0x28,0x02,0x80,0x28,0x02,0x80,0x24,0x04,0x20,0xC1,0xF8,0x00,0x40,0x02,0x00,0x30, // 'Q'
	2325	0xF8,0x84,0x82,0x82,0x82,0x8C,0xF0,0x90,0x88,0x84,0x82,0x81, // 'R'
	2326	0x38,0x8E,0x04,0x04,0x06,0x03,0x01,0x02,0x06,0x1B,0xC0, // 'S'
	2327	0xFF,0xC2,0x00,0x80,0x20,0x08,0x02,0x00,0x80,0x20,0x08,0x02,0x00,0x80,0x20, // 'T'
	2328	0x81,0x81,0x81,0x81,0x81,0x81,0x81,0x81,0x81,0x81,0x42,0x3C, // 'U'
	2329	0x80,0x28,0x09,0x01,0x20,0x42,0x08,0x41,0x04,0x40,0x88,0x0A,0x01,0x40,0x30,0x02,0x00, // 'V'
	2330	0x80,0x81,0x40,0x81,0x41,0x81,0x41,0x42,0x22,0x42,0x22,0x22,0x22,0x24,0x14,0x24,0x14,0x14,0x14,0x18,0x08,0x18,0x08,0x08, // 'W'
	2331	0x80,0x50,0x22,0x10,0x44,0x12,0x03,0x00,0xC0,0x28,0x11,0x08,0x44,0x0B,0x01, // 'X'
	2332	0x80,0x50,0x24,0x10,0x84,0x12,0x05,0x00,0xC0,0x20,0x08,0x02,0x00,0x80,0x20, // 'Y'
	2333	0xFF,0x01,0x02,0x06,0x04,0x08,0x10,0x10,0x20,0x40,0x80,0xFF, // 'Z'
	2334	0xF2,0x49,0x24,0x92,0x49,0x38, // '['
	2335	0x82,0x08,0x10,0x40,0x82,0x04,0x10,0x40,0x82,0x04, // '\'
	2336	0xE4,0x92,0x49,0x24,0x92,0x78, // ']'
	2337	0x10,0x30,0x61,0x24,0x58,0x40, // '^'
	2338	0xFE, // '_'
	2339	0x89,0x80, // '`'
	2340	0x33,0x20,0x41,0x7E,0x18,0x63,0x74, // 'a'
	2341	0x81,0x02,0x04,0xCE,0x78,0x60,0xC1,0x83,0x07,0x0D,0xE0, // 'b'
	2342	0x38,0x8A,0x04,0x08,0x10,0x20,0x23,0x3C, // 'c'
	2343	0x02,0x04,0x09,0xD4,0x70,0x60,0xC1,0x83,0x05,0x19,0xD0, // 'd'
	2344	0x38,0x8A,0x0C,0x1F,0xF0,0x20,0x21,0x3C, // 'e'
	2345	0x1C,0x82,0x3F,0x20,0x82,0x08,0x20,0x82,0x08, // 'f'
	2346	0x3E,0x8A,0x14,0x24,0xCE,0x20,0x20,0xFF,0x06,0x0B,0xE0, // 'g'
	2347	0x81,0x02,0x04,0xCE,0x58,0x60,0xC1,0x83,0x06,0x0C,0x10, // 'h'
	2348	0xB2,0xAA,0xAA, // 'i'
	2349	0x23,0x02,0x22,0x22,0x22,0x22,0x22,0xE0, // 'j'
	2350	0x81,0x02,0x04,0x38,0x92,0x28,0x70,0xB1,0x32,0x34,0x30, // 'k'
	2351	0xAA,0xAA,0xAA, // 'l'
	2352	0x91,0x9D,0xCA,0x10,0xC2,0x18,0x43,0x08,0x61,0x0C,0x21,0x84,0x20, // 'm'
	2353	0x99,0xCB,0x0C,0x18,0x30,0x60,0xC1,0x82, // 'n'
	2354	0x38,0x8A,0x0C,0x18,0x30,0x60,0xA1,0x3C, // 'o'
	2355	0x99,0xCF,0x0C,0x18,0x30,0x60,0xE1,0xFD,0x02,0x04,0x00, // 'p'
	2356	0x3A,0x8E,0x0C,0x18,0x30,0x60,0xA3,0x3A,0x04,0x08,0x10, // 'q'
	2357	0x9F,0x31,0x08,0x42,0x10,0x80, // 'r'
	2358	0x36,0x61,0x07,0x04,0x31,0x70, // 's'
	2359	0x42,0x11,0xE4,0x21,0x08,0x42,0x12,0xE0, // 't'
	2360	0x83,0x06,0x0C,0x18,0x30,0x60,0xA3,0x3A, // 'u'
	2361	0x81,0x41,0x42,0x22,0x24,0x24,0x14,0x18,0x08, // 'v'
	2362	0x82,0x14,0x21,0x46,0x14,0x52,0x25,0x22,0x92,0x28,0xC1,0x0C,0x10,0x80, // 'w'
	2363	0x82,0x42,0x24,0x28,0x10,0x18,0x24,0x42,0xC3, // 'x'
	2364	0x81,0x41,0x42,0x22,0x22,0x24,0x14,0x18,0x08,0x10,0x10,0x30, // 'y'
	2365	0xFC,0x10,0x84,0x20,0x84,0x20,0xFC, // 'z'
	2366	0x74,0x44,0x44,0x4C,0x44,0x44,0x44,0x30, // '{'
	2367	0xFF,0xFF, // '\|'
	2368	0xC2,0x22,0x44,0x43,0x44,0x22,0x24,0x80 // '}'
	2369	};
	2370	const GFXglyph Lato_Hairline_16Glyphs[] PROGMEM = {
	2371	// bitmapOffset, width, height, xAdvance, xOffset, yOffset
	2372	{ 0, 1, 1, 7, 0, 0 }, // ' '
	2373	{ 1, 2, 12, 6, 1, -12 }, // '!'
	2374	{ 4, 3, 5, 7, 1, -12 }, // '"'
	2375	{ 6, 8, 12, 11, 1, -12 }, // '#'
	2376	{ 18, 8, 16, 11, 1, -14 }, // '$'
	2377	{ 34, 11, 12, 14, 1, -12 }, // '%'
	2378	{ 51, 11, 12, 13, 1, -12 }, // '&'
	2379	{ 68, 1, 5, 5, 1, -12 }, // '''
	2380	{ 69, 3, 15, 6, 1, -13 }, // '('
	2381	{ 75, 3, 15, 6, 1, -13 }, // ')'
	2382	{ 81, 5, 5, 9, 1, -12 }, // '*'
	2383	{ 85, 8, 8, 11, 1, -10 }, // '+'
	2384	{ 93, 2, 4, 5, 1, -2 }, // ','
	2385	{ 94, 4, 1, 8, 1, -5 }, // '-'
	2386	{ 95, 2, 2, 6, 1, -2 }, // '.'
	2387	{ 96, 6, 13, 9, 1, -12 }, // '/'
	2388	{ 106, 8, 12, 11, 1, -12 }, // '0'
	2389	{ 118, 6, 12, 11, 2, -12 }, // '1'
	2390	{ 127, 8, 12, 11, 1, -12 }, // '2'
	2391	{ 139, 8, 12, 11, 1, -12 }, // '3'
	2392	{ 151, 9, 12, 11, 0, -12 }, // '4'
	2393	{ 165, 7, 12, 11, 1, -12 }, // '5'
	2394	{ 176, 8, 12, 11, 1, -12 }, // '6'
	2395	{ 188, 8, 12, 11, 1, -12 }, // '7'
	2396	{ 200, 8, 12, 11, 1, -12 }, // '8'
	2397	{ 212, 8, 12, 11, 1, -12 }, // '9'
	2398	{ 224, 2, 9, 6, 1, -9 }, // ':'
	2399	{ 227, 2, 11, 6, 1, -9 }, // ';'
	2400	{ 230, 7, 7, 11, 1, -9 }, // '<'
	2401	{ 237, 8, 3, 11, 1, -7 }, // '='
	2402	{ 240, 6, 7, 11, 2, -9 }, // '>'
	2403	{ 246, 5, 12, 9, 1, -12 }, // '?'
	2404	{ 254, 12, 13, 15, 1, -11 }, // '@'
	2405	{ 274, 11, 12, 12, 0, -12 }, // 'A'
	2406	{ 291, 7, 12, 12, 2, -12 }, // 'B'
	2407	{ 302, 10, 12, 13, 1, -12 }, // 'C'
	2408	{ 317, 10, 12, 14, 2, -12 }, // 'D'
	2409	{ 332, 7, 12, 11, 2, -12 }, // 'E'
	2410	{ 343, 7, 12, 11, 2, -12 }, // 'F'
	2411	{ 354, 10, 12, 14, 1, -12 }, // 'G'
	2412	{ 369, 9, 12, 14, 2, -12 }, // 'H'
	2413	{ 383, 1, 12, 6, 2, -12 }, // 'I'
	2414	{ 385, 5, 12, 9, 0, -12 }, // 'J'
	2415	{ 393, 9, 12, 12, 2, -12 }, // 'K'
	2416	{ 407, 6, 12, 10, 2, -12 }, // 'L'
	2417	{ 416, 11, 12, 16, 2, -12 }, // 'M'
	2418	{ 433, 9, 12, 14, 2, -12 }, // 'N'
	2419	{ 447, 11, 12, 15, 1, -12 }, // 'O'
	2420	{ 464, 7, 12, 11, 2, -12 }, // 'P'
	2421	{ 475, 12, 15, 15, 1, -12 }, // 'Q'
	2422	{ 498, 8, 12, 11, 2, -12 }, // 'R'
	2423	{ 510, 7, 12, 10, 1, -12 }, // 'S'
	2424	{ 521, 10, 12, 11, 0, -12 }, // 'T'
	2425	{ 536, 8, 12, 14, 2, -12 }, // 'U'
	2426	{ 548, 11, 12, 12, 0, -12 }, // 'V'
	2427	{ 565, 16, 12, 18, 0, -12 }, // 'W'
	2428	{ 589, 10, 12, 12, 0, -12 }, // 'X'
	2429	{ 604, 10, 12, 11, 0, -12 }, // 'Y'
	2430	{ 619, 8, 12, 12, 1, -12 }, // 'Z'
	2431	{ 631, 3, 15, 7, 2, -13 }, // '['
	2432	{ 637, 6, 13, 9, 1, -12 }, // '\'
	2433	{ 647, 3, 15, 7, 1, -13 }, // ']'
	2434	{ 653, 7, 6, 11, 1, -12 }, // '^'
	2435	{ 659, 7, 1, 9, 0, 1 }, // '_'
	2436	{ 660, 3, 3, 8, 2, -12 }, // '`'
	2437	{ 662, 6, 9, 10, 1, -9 }, // 'a'
	2438	{ 669, 7, 12, 11, 1, -12 }, // 'b'
	2439	{ 680, 7, 9, 9, 1, -9 }, // 'c'
	2440	{ 688, 7, 12, 11, 1, -12 }, // 'd'
	2441	{ 699, 7, 9, 10, 1, -9 }, // 'e'
	2442	{ 707, 6, 12, 7, 0, -12 }, // 'f'
	2443	{ 716, 7, 12, 10, 1, -9 }, // 'g'
	2444	{ 727, 7, 12, 11, 1, -12 }, // 'h'
	2445	{ 738, 2, 12, 5, 1, -12 }, // 'i'
	2446	{ 741, 4, 15, 5, -1, -12 }, // 'j'
	2447	{ 749, 7, 12, 9, 1, -12 }, // 'k'
	2448	{ 760, 2, 12, 5, 1, -12 }, // 'l'
	2449	{ 763, 11, 9, 15, 1, -9 }, // 'm'
	2450	{ 776, 7, 9, 11, 1, -9 }, // 'n'
	2451	{ 784, 7, 9, 11, 1, -9 }, // 'o'
	2452	{ 792, 7, 12, 11, 1, -9 }, // 'p'
	2453	{ 803, 7, 12, 11, 1, -9 }, // 'q'
	2454	{ 814, 5, 9, 8, 1, -9 }, // 'r'
	2455	{ 820, 5, 9, 9, 1, -9 }, // 's'
	2456	{ 826, 5, 12, 7, 1, -12 }, // 't'
	2457	{ 834, 7, 9, 11, 1, -9 }, // 'u'
	2458	{ 842, 8, 9, 10, 0, -9 }, // 'v'
	2459	{ 851, 12, 9, 14, 0, -9 }, // 'w'
	2460	{ 865, 8, 9, 9, 0, -9 }, // 'x'
	2461	{ 874, 8, 12, 10, 0, -9 }, // 'y'
	2462	{ 886, 6, 9, 9, 1, -9 }, // 'z'
	2463	{ 893, 4, 15, 7, 1, -13 }, // '{'
	2464	{ 901, 1, 16, 6, 2, -13 }, // '\|'
	2465	{ 903, 4, 15, 7, 1, -13 } // '}'
	2466	};
	2467	const GFXfont Lato_Hairline_16 PROGMEM = {
	2468	(uint8_t )Lato_Hairline_16Bitmaps,(GFXglyph )Lato_Hairline_16Glyphs,0x20, 0x7E, 20};
	2469
	2470
	2471
	2472	const uint8_t sourcesans8pt7bBitmaps[] PROGMEM = {
	2473	0x00, 0xFF, 0x60, 0x99, 0x99, 0x12, 0x12, 0x3F, 0x24, 0x24, 0x24, 0xFC,
	2474	0x24, 0x48, 0x48, 0x10, 0x47, 0xB1, 0x83, 0x07, 0x06, 0x04, 0x18, 0x5E,
	2475	0x10, 0x60, 0x89, 0x10, 0x91, 0x09, 0x20, 0x92, 0xE9, 0x5B, 0x69, 0x10,
	2476	0x91, 0x11, 0x11, 0x11, 0x20, 0xE0, 0x30, 0x48, 0x48, 0x58, 0x70, 0x61,
	2477	0xF3, 0x9A, 0x8E, 0xCE, 0x79, 0xF0, 0x09, 0x29, 0x24, 0x92, 0x24, 0x88,
	2478	0x09, 0x22, 0x49, 0x24, 0xA4, 0xA0, 0x25, 0x5C, 0xE5, 0x00, 0x21, 0x09,
	2479	0xF2, 0x10, 0x80, 0xD8, 0xE0, 0xC0, 0x00, 0x44, 0x21, 0x08, 0x84, 0x22,
	2480	0x10, 0x84, 0x42, 0x00, 0x79, 0x28, 0x61, 0x86, 0x18, 0x61, 0x49, 0xE0,
	2481	0xE1, 0x08, 0x42, 0x10, 0x84, 0x27, 0xC0, 0x79, 0x98, 0x10, 0x20, 0xC1,
	2482	0x04, 0x10, 0x41, 0xFC, 0x79, 0x10, 0x43, 0x30, 0x30, 0x41, 0x8D, 0xE0,
	2483	0x18, 0x62, 0x8A, 0x4A, 0x2F, 0xC2, 0x08, 0x20, 0x7E, 0x08, 0x20, 0xF8,
	2484	0x30, 0x41, 0x8D, 0xE0, 0x39, 0x0C, 0x20, 0xBB, 0x18, 0x61, 0x4C, 0xE0,
	2485	0xFC, 0x20, 0x84, 0x10, 0x42, 0x08, 0x20, 0x80, 0x39, 0x14, 0x51, 0x39,
	2486	0x28, 0x61, 0xC5, 0xE0, 0x73, 0x28, 0x61, 0x8D, 0xD0, 0x43, 0x09, 0xC0,
	2487	0xC3, 0xC1, 0xC0, 0x00, 0x37, 0x20, 0xE0, 0x70, 0x40, 0xFC, 0x00, 0x00,
	2488	0xFC, 0x03, 0x03, 0x81, 0x1F, 0x88, 0x00, 0x74, 0x42, 0x11, 0x10, 0x84,
	2489	0x01, 0x08, 0x0F, 0x83, 0x06, 0x60, 0x24, 0x71, 0x89, 0x19, 0x11, 0x91,
	2490	0x19, 0x32, 0x8D, 0xC4, 0x00, 0x60, 0x01, 0xF0, 0x18, 0x18, 0x1C, 0x24,
	2491	0x24, 0x24, 0x66, 0x7E, 0x42, 0xC3, 0x81, 0xF9, 0x1A, 0x14, 0x28, 0xDF,
	2492	0x21, 0xC1, 0x83, 0x0F, 0xF0, 0x3C, 0xC7, 0x04, 0x08, 0x10, 0x20, 0x40,
	2493	0xC0, 0xC4, 0xF0, 0xF8, 0x86, 0x82, 0x81, 0x81, 0x81, 0x81, 0x81, 0x82,
	2494	0x86, 0xF8, 0xFE, 0x08, 0x20, 0x83, 0xE8, 0x20, 0x82, 0x0F, 0xC0, 0xFE,
	2495	0x08, 0x20, 0x83, 0xE8, 0x20, 0x82, 0x08, 0x00, 0x1E, 0x61, 0x40, 0x80,
	2496	0x80, 0x87, 0x81, 0x81, 0x41, 0x61, 0x1E, 0x81, 0x81, 0x81, 0x81, 0x81,
	2497	0xFF, 0x81, 0x81, 0x81, 0x81, 0x81, 0xFF, 0xE0, 0x08, 0x42, 0x10, 0x84,
	2498	0x21, 0x0C, 0x5C, 0x87, 0x1A, 0x64, 0x8B, 0x1E, 0x36, 0x44, 0x85, 0x0E,
	2499	0x08, 0x84, 0x21, 0x08, 0x42, 0x10, 0x84, 0x3E, 0xC1, 0xE0, 0xF0, 0x74,
	2500	0x5A, 0x2D, 0x16, 0x53, 0x29, 0x88, 0xC4, 0x60, 0x20, 0x81, 0xC1, 0xE1,
	2501	0xA1, 0x91, 0x99, 0x89, 0x85, 0x87, 0x83, 0x81, 0x3C, 0x42, 0x42, 0x81,
	2502	0x81, 0x81, 0x81, 0x81, 0x42, 0x42, 0x3C, 0xFD, 0x0E, 0x0C, 0x18, 0x7F,
	2503	0x20, 0x40, 0x81, 0x02, 0x00, 0x3C, 0x42, 0x42, 0x81, 0x81, 0x81, 0x81,
	2504	0x81, 0xC3, 0x42, 0x3C, 0x18, 0x0C, 0x07, 0xFC, 0x86, 0x82, 0x82, 0x86,
	2505	0xFC, 0x88, 0x8C, 0x84, 0x86, 0x82, 0x3E, 0x63, 0x40, 0x40, 0x30, 0x1E,
	2506	0x07, 0x01, 0x01, 0xC3, 0x3C, 0xFE, 0x20, 0x40, 0x81, 0x02, 0x04, 0x08,
	2507	0x10, 0x20, 0x40, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
	2508	0x42, 0x3C, 0x81, 0x81, 0x42, 0x42, 0x42, 0x24, 0x24, 0x24, 0x38, 0x18,
	2509	0x18, 0x86, 0x18, 0x61, 0x86, 0x14, 0xD2, 0x4D, 0x24, 0x92, 0x49, 0x25,
	2510	0x8A, 0x38, 0xC3, 0x0C, 0x30, 0xC0, 0x43, 0x62, 0x24, 0x34, 0x18, 0x18,
	2511	0x1C, 0x24, 0x26, 0x42, 0x43, 0x82, 0x89, 0x13, 0x62, 0x85, 0x04, 0x08,
	2512	0x10, 0x20, 0x40, 0xFE, 0x08, 0x30, 0x41, 0x82, 0x08, 0x30, 0x41, 0x83,
	2513	0xF8, 0xF2, 0x49, 0x24, 0x92, 0x49, 0xC0, 0x81, 0x04, 0x10, 0x20, 0x82,
	2514	0x04, 0x10, 0x20, 0x82, 0x04, 0x00, 0xE4, 0x92, 0x49, 0x24, 0x93, 0xC0,
	2515	0x30, 0xC3, 0x12, 0x4A, 0x30, 0xFF, 0xCC, 0x78, 0x10, 0x4F, 0xC6, 0x18,
	2516	0xDD, 0x81, 0x02, 0x05, 0xEC, 0x50, 0x60, 0xC1, 0x83, 0x8A, 0xE0, 0x79,
	2517	0x08, 0x20, 0x82, 0x04, 0x1E, 0x04, 0x10, 0x5F, 0x46, 0x18, 0x61, 0x87,
	2518	0x37, 0x40, 0x39, 0x38, 0x7F, 0x82, 0x04, 0x0E, 0x34, 0x44, 0xE4, 0x44,
	2519	0x44, 0x44, 0x7F, 0x9A, 0x14, 0x2C, 0xCF, 0x20, 0x3E, 0x83, 0x07, 0x13,
	2520	0xC0, 0x82, 0x08, 0x2E, 0xC6, 0x18, 0x61, 0x86, 0x18, 0x40, 0xBF, 0xC0,
	2521	0x20, 0x92, 0x49, 0x24, 0x9E, 0x82, 0x08, 0x22, 0x9A, 0xCA, 0x34, 0x9A,
	2522	0x28, 0xC0, 0xAA, 0xAA, 0xAC, 0xB9, 0xD8, 0xC6, 0x10, 0xC2, 0x18, 0x43,
	2523	0x08, 0x61, 0x0C, 0x21, 0xBB, 0x18, 0x61, 0x86, 0x18, 0x61, 0x38, 0x8A,
	2524	0x0C, 0x18, 0x30, 0x51, 0x1C, 0xBD, 0x8A, 0x0C, 0x18, 0x30, 0x71, 0x5C,
	2525	0x81, 0x02, 0x00, 0x7D, 0x18, 0x61, 0x86, 0x1C, 0xDD, 0x04, 0x10, 0x40,
	2526	0xBC, 0x88, 0x88, 0x88, 0x74, 0x20, 0xC3, 0x86, 0x3E, 0x44, 0xF4, 0x44,
	2527	0x44, 0x43, 0x86, 0x18, 0x61, 0x86, 0x18, 0xDD, 0xC2, 0x8D, 0x13, 0x22,
	2528	0x45, 0x0E, 0x0C, 0x86, 0x30, 0xC5, 0x29, 0x25, 0x24, 0x94, 0x52, 0x8A,
	2529	0x61, 0x8C, 0x44, 0xC8, 0xA0, 0xC3, 0x85, 0x11, 0x23, 0xC2, 0x89, 0x11,
	2530	0x22, 0x87, 0x06, 0x08, 0x10, 0x61, 0x80, 0x7C, 0x30, 0x84, 0x30, 0x84,
	2531	0x3F, 0x69, 0x24, 0x94, 0x49, 0x24, 0xC0, 0xFF, 0xFF, 0xC9, 0x24, 0x91,
	2532	0x49, 0x25, 0x80, 0xE0, 0x70 };
	2533
	2534	const GFXglyph sourcesans8pt7bGlyphs[] PROGMEM = {
	2535	{ 0, 1, 1, 3, 0, 0 }, // 0x20 ' '
	2536	{ 1, 1, 11, 5, 1, -10 }, // 0x21 '!'
	2537	{ 3, 4, 4, 7, 1, -10 }, // 0x22 '"'
	2538	{ 5, 8, 10, 8, 0, -9 }, // 0x23 '#'
	2539	{ 15, 6, 13, 8, 1, -11 }, // 0x24 '$'
	2540	{ 25, 12, 11, 13, 1, -10 }, // 0x25 '%'
	2541	{ 42, 8, 11, 10, 1, -10 }, // 0x26 '&'
	2542	{ 53, 1, 4, 4, 1, -10 }, // 0x27 '''
	2543	{ 54, 3, 15, 5, 1, -11 }, // 0x28 '('
	2544	{ 60, 3, 15, 5, 0, -11 }, // 0x29 ')'
	2545	{ 66, 5, 5, 7, 1, -11 }, // 0x2A '*'
	2546	{ 70, 5, 7, 8, 1, -8 }, // 0x2B '+'
	2547	{ 75, 2, 4, 4, 1, 0 }, // 0x2C ','
	2548	{ 76, 3, 1, 5, 1, -4 }, // 0x2D '-'
	2549	{ 77, 1, 2, 4, 1, -1 }, // 0x2E '.'
	2550	{ 78, 5, 15, 6, 0, -11 }, // 0x2F '/'
	2551	{ 88, 6, 10, 8, 1, -9 }, // 0x30 '0'
	2552	{ 96, 5, 10, 8, 2, -9 }, // 0x31 '1'
	2553	{ 103, 7, 10, 8, 0, -9 }, // 0x32 '2'
	2554	{ 112, 6, 10, 8, 1, -9 }, // 0x33 '3'
	2555	{ 120, 6, 10, 8, 1, -9 }, // 0x34 '4'
	2556	{ 128, 6, 10, 8, 1, -9 }, // 0x35 '5'
	2557	{ 136, 6, 10, 8, 1, -9 }, // 0x36 '6'
	2558	{ 144, 6, 10, 8, 1, -9 }, // 0x37 '7'
	2559	{ 152, 6, 10, 8, 1, -9 }, // 0x38 '8'
	2560	{ 160, 6, 10, 8, 1, -9 }, // 0x39 '9'
	2561	{ 168, 1, 8, 4, 1, -7 }, // 0x3A ':'
	2562	{ 169, 1, 11, 4, 1, -7 }, // 0x3B ';'
	2563	{ 171, 6, 7, 8, 1, -8 }, // 0x3C '<'
	2564	{ 177, 6, 5, 8, 1, -7 }, // 0x3D '='
	2565	{ 181, 6, 7, 8, 1, -8 }, // 0x3E '>'
	2566	{ 187, 5, 11, 7, 1, -10 }, // 0x3F '?'
	2567	{ 194, 12, 12, 14, 1, -9 }, // 0x40 '@'
	2568	{ 212, 8, 11, 9, 0, -10 }, // 0x41 'A'
	2569	{ 223, 7, 11, 9, 1, -10 }, // 0x42 'B'
	2570	{ 233, 7, 11, 9, 1, -10 }, // 0x43 'C'
	2571	{ 243, 8, 11, 10, 1, -10 }, // 0x44 'D'
	2572	{ 254, 6, 11, 8, 1, -10 }, // 0x45 'E'
	2573	{ 263, 6, 11, 8, 1, -10 }, // 0x46 'F'
	2574	{ 272, 8, 11, 10, 1, -10 }, // 0x47 'G'
	2575	{ 283, 8, 11, 10, 1, -10 }, // 0x48 'H'
	2576	{ 294, 1, 11, 4, 1, -10 }, // 0x49 'I'
	2577	{ 296, 5, 11, 8, 1, -10 }, // 0x4A 'J'
	2578	{ 303, 7, 11, 9, 1, -10 }, // 0x4B 'K'
	2579	{ 313, 5, 11, 8, 1, -10 }, // 0x4C 'L'
	2580	{ 320, 9, 11, 12, 1, -10 }, // 0x4D 'M'
	2581	{ 333, 8, 11, 10, 1, -10 }, // 0x4E 'N'
	2582	{ 344, 8, 11, 11, 1, -10 }, // 0x4F 'O'
	2583	{ 355, 7, 11, 9, 1, -10 }, // 0x50 'P'
	2584	{ 365, 8, 14, 11, 1, -10 }, // 0x51 'Q'
	2585	{ 379, 8, 11, 9, 1, -10 }, // 0x52 'R'
	2586	{ 390, 8, 11, 9, 0, -10 }, // 0x53 'S'
	2587	{ 401, 7, 11, 9, 1, -10 }, // 0x54 'T'
	2588	{ 411, 8, 11, 10, 1, -10 }, // 0x55 'U'
	2589	{ 422, 8, 11, 8, 0, -10 }, // 0x56 'V'
	2590	{ 433, 12, 11, 13, 0, -10 }, // 0x57 'W'
	2591	{ 450, 8, 11, 8, 0, -10 }, // 0x58 'X'
	2592	{ 461, 7, 11, 8, 0, -10 }, // 0x59 'Y'
	2593	{ 471, 7, 11, 9, 1, -10 }, // 0x5A 'Z'
	2594	{ 481, 3, 14, 5, 2, -11 }, // 0x5B '['
	2595	{ 487, 6, 14, 6, 0, -10 }, // 0x5C '\'
	2596	{ 498, 3, 14, 5, 1, -11 }, // 0x5D ']'
	2597	{ 504, 6, 6, 8, 1, -10 }, // 0x5E '^'
	2598	{ 509, 8, 1, 8, 0, 2 }, // 0x5F '_'
	2599	{ 510, 3, 2, 9, 3, -10 }, // 0x60 '`'
	2600	{ 511, 6, 8, 8, 1, -7 }, // 0x61 'a'
	2601	{ 517, 7, 11, 9, 1, -10 }, // 0x62 'b'
	2602	{ 527, 6, 8, 7, 1, -7 }, // 0x63 'c'
	2603	{ 533, 6, 11, 9, 1, -10 }, // 0x64 'd'
	2604	{ 542, 6, 8, 8, 1, -7 }, // 0x65 'e'
	2605	{ 548, 4, 12, 5, 1, -11 }, // 0x66 'f'
	2606	{ 554, 7, 12, 8, 1, -7 }, // 0x67 'g'
	2607	{ 565, 6, 11, 9, 1, -10 }, // 0x68 'h'
	2608	{ 574, 1, 10, 4, 1, -9 }, // 0x69 'i'
	2609	{ 576, 3, 13, 4, -1, -9 }, // 0x6A 'j'
	2610	{ 581, 6, 11, 8, 1, -10 }, // 0x6B 'k'
	2611	{ 590, 2, 11, 4, 1, -10 }, // 0x6C 'l'
	2612	{ 593, 11, 8, 13, 1, -7 }, // 0x6D 'm'
	2613	{ 604, 6, 8, 9, 1, -7 }, // 0x6E 'n'
	2614	{ 610, 7, 8, 9, 1, -7 }, // 0x6F 'o'
	2615	{ 617, 7, 11, 9, 1, -7 }, // 0x70 'p'
	2616	{ 627, 6, 11, 9, 1, -7 }, // 0x71 'q'
	2617	{ 636, 4, 8, 6, 1, -7 }, // 0x72 'r'
	2618	{ 640, 5, 8, 7, 1, -7 }, // 0x73 's'
	2619	{ 645, 4, 10, 5, 1, -9 }, // 0x74 't'
	2620	{ 650, 6, 8, 9, 1, -7 }, // 0x75 'u'
	2621	{ 656, 7, 8, 7, 0, -7 }, // 0x76 'v'
	2622	{ 663, 11, 8, 11, 0, -7 }, // 0x77 'w'
	2623	{ 674, 7, 8, 7, 0, -7 }, // 0x78 'x'
	2624	{ 681, 7, 11, 7, 0, -7 }, // 0x79 'y'
	2625	{ 691, 6, 8, 7, 0, -7 }, // 0x7A 'z'
	2626	{ 697, 3, 14, 5, 1, -11 }, // 0x7B '{'
	2627	{ 703, 1, 16, 4, 1, -11 }, // 0x7C '\|'
	2628	{ 705, 3, 14, 5, 1, -11 }, // 0x7D '}'
	2629	{ 711, 6, 2, 8, 1, -5 } }; // 0x7E '~'
	2630
	2631	const GFXfont sourcesans8pt7b PROGMEM = {
	2632	(uint8_t *)sourcesans8pt7bBitmaps,
	2633	(GFXglyph *)sourcesans8pt7bGlyphs,
	2634	0x20, 0x7E, 21 };
	2635
	2636
	2637	const uint8_t sourcesans10pt7bBitmaps[] PROGMEM = {
	2638	0x00, 0xFF, 0xFF, 0xCF, 0xC0, 0xDE, 0xF7, 0xBD, 0x80, 0x22, 0x22, 0xFF,
	2639	0xFF, 0x22, 0x22, 0xFF, 0xFF, 0x44, 0x44, 0x44, 0x44, 0x30, 0x61, 0xF6,
	2640	0x2C, 0x18, 0x38, 0x38, 0x1C, 0x1C, 0x18, 0x38, 0xFF, 0x9E, 0x18, 0x78,
	2641	0x10, 0xFC, 0x20, 0xCC, 0x20, 0xCC, 0x40, 0xCC, 0x9C, 0xCC, 0xBE, 0xCD,
	2642	0x77, 0x7A, 0x63, 0x32, 0x63, 0x04, 0x63, 0x08, 0x63, 0x08, 0x7F, 0x10,
	2643	0x3E, 0x1E, 0x03, 0xE0, 0xCC, 0x19, 0x83, 0x60, 0x38, 0x0E, 0x1B, 0x62,
	2644	0xC6, 0xD8, 0x73, 0x8F, 0x3F, 0xB3, 0xC2, 0xFF, 0xC0, 0x11, 0x22, 0x64,
	2645	0xCC, 0xCC, 0xCC, 0xC4, 0x62, 0x21, 0x00, 0x88, 0x44, 0x62, 0x33, 0x33,
	2646	0x33, 0x32, 0x64, 0x48, 0x00, 0x10, 0x21, 0xF1, 0xC2, 0x88, 0x80, 0x30,
	2647	0xC3, 0x3F, 0xFC, 0xC3, 0x0C, 0x33, 0x36, 0xC0, 0xFF, 0xFC, 0x00, 0x03,
	2648	0x06, 0x06, 0x06, 0x0C, 0x0C, 0x0C, 0x18, 0x18, 0x18, 0x30, 0x30, 0x30,
	2649	0x60, 0x60, 0x60, 0xC0, 0x00, 0x3C, 0x7E, 0x66, 0xC3, 0xC3, 0xC3, 0xC3,
	2650	0xC3, 0xC3, 0xC3, 0xC3, 0x66, 0x7E, 0x3C, 0x71, 0xC3, 0x0C, 0x30, 0xC3,
	2651	0x0C, 0x30, 0xC3, 0x3F, 0xFC, 0x3C, 0x3F, 0x31, 0xC0, 0x60, 0x30, 0x18,
	2652	0x0C, 0x0C, 0x06, 0x06, 0x06, 0x06, 0x03, 0x03, 0xFC, 0x1E, 0x1F, 0x98,
	2653	0xE0, 0x30, 0x18, 0x1C, 0x38, 0x1E, 0x03, 0x80, 0xC0, 0x60, 0x3C, 0x31,
	2654	0xF0, 0x06, 0x0E, 0x16, 0x16, 0x26, 0x46, 0x86, 0xFF, 0xFF, 0x06, 0x06,
	2655	0x06, 0x06, 0x3F, 0x18, 0x0C, 0x07, 0xC3, 0xF1, 0x1C, 0x06, 0x03, 0x01,
	2656	0x80, 0xF0, 0xC7, 0x80, 0x1F, 0x18, 0x98, 0x18, 0x0C, 0xE6, 0xFB, 0x8F,
	2657	0x83, 0xC1, 0xF0, 0xD8, 0xEF, 0xE1, 0xE0, 0xFE, 0x0C, 0x10, 0x60, 0x83,
	2658	0x06, 0x08, 0x30, 0x60, 0xC1, 0x80, 0x1C, 0x3E, 0x63, 0x63, 0x63, 0x32,
	2659	0x1C, 0x2E, 0xC3, 0xC3, 0xC3, 0xE3, 0x7E, 0x3C, 0x3C, 0x7E, 0xE6, 0xC3,
	2660	0xC3, 0xC3, 0xE7, 0x7F, 0x3B, 0x03, 0x02, 0x06, 0x44, 0x78, 0xFC, 0x03,
	2661	0xF0, 0xFC, 0x00, 0xFF, 0x80, 0x00, 0x07, 0x1C, 0xF0, 0xC0, 0x70, 0x1E,
	2662	0x03, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0xE0, 0x38, 0x0F, 0x03,
	2663	0x0E, 0x70, 0xC0, 0x7D, 0x0C, 0x18, 0x30, 0xC3, 0x04, 0x18, 0x00, 0x00,
	2664	0xC1, 0x83, 0x00, 0x03, 0xF0, 0x0F, 0xF8, 0x1C, 0x1C, 0x38, 0x06, 0x70,
	2665	0x06, 0x63, 0x83, 0xE7, 0xA3, 0xC6, 0x63, 0xCC, 0x63, 0xCC, 0x63, 0xCC,
	2666	0x66, 0xCF, 0xFE, 0xE7, 0x38, 0x70, 0x00, 0x38, 0x00, 0x1F, 0xE0, 0x07,
	2667	0xC0, 0x0E, 0x01, 0x40, 0x28, 0x0D, 0x81, 0xB0, 0x22, 0x0C, 0x61, 0x8C,
	2668	0x3F, 0x8F, 0xF9, 0x83, 0x30, 0x6C, 0x06, 0xFC, 0x7F, 0xB0, 0xD8, 0x6C,
	2669	0x37, 0xE3, 0xFD, 0x87, 0xC1, 0xE0, 0xF0, 0xFF, 0xEF, 0xE0, 0x0F, 0x0F,
	2670	0xE7, 0x09, 0x80, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0x18, 0x07, 0x0C,
	2671	0xFE, 0x0F, 0x00, 0xFE, 0x3F, 0xCC, 0x3B, 0x07, 0xC0, 0xF0, 0x3C, 0x0F,
	2672	0x03, 0xC0, 0xF0, 0x6C, 0x3B, 0xFC, 0xFC, 0x00, 0xFF, 0x83, 0x06, 0x0C,
	2673	0x18, 0x3F, 0x60, 0xC1, 0x83, 0x06, 0x0F, 0xE0, 0xFF, 0x83, 0x06, 0x0C,
	2674	0x18, 0x3F, 0x60, 0xC1, 0x83, 0x06, 0x0C, 0x00, 0x1F, 0x0F, 0xE7, 0x0B,
	2675	0x80, 0xC0, 0x30, 0x0C, 0x3F, 0x03, 0xC0, 0xD8, 0x37, 0x0C, 0xFF, 0x1F,
	2676	0x00, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xFF, 0xFF, 0xFF, 0x03, 0xC0,
	2677	0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xC0, 0xFF, 0xFF, 0xFF, 0xC0, 0x03, 0x03,
	2678	0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0xC7, 0x7E, 0x3C, 0xC1,
	2679	0xB0, 0xCC, 0x63, 0x18, 0xCC, 0x37, 0x0F, 0xC3, 0x98, 0xC2, 0x30, 0xCC,
	2680	0x1B, 0x06, 0xC0, 0xC0, 0xC1, 0x83, 0x06, 0x0C, 0x18, 0x30, 0x60, 0xC1,
	2681	0x83, 0x06, 0x0F, 0xE0, 0xE0, 0xFC, 0x1F, 0x83, 0xF8, 0x7D, 0x17, 0xA2,
	2682	0xF4, 0x5E, 0x53, 0xCA, 0x79, 0x4F, 0x11, 0xE2, 0x3C, 0x06, 0xC0, 0xF8,
	2683	0x3F, 0x0F, 0x43, 0xD8, 0xF2, 0x3C, 0xCF, 0x13, 0xC6, 0xF0, 0xBC, 0x3F,
	2684	0x07, 0xC0, 0xC0, 0x1F, 0x83, 0xFC, 0x70, 0xE6, 0x06, 0xC0, 0x3C, 0x03,
	2685	0xC0, 0x3C, 0x03, 0xC0, 0x36, 0x06, 0x70, 0xE3, 0xFC, 0x1F, 0x80, 0xFE,
	2686	0x7F, 0xB0, 0xF8, 0x3C, 0x1E, 0x1F, 0xF9, 0x80, 0xC0, 0x60, 0x30, 0x18,
	2687	0x0C, 0x00, 0x0F, 0x03, 0xFC, 0x70, 0xE6, 0x06, 0xC0, 0x3C, 0x03, 0xC0,
	2688	0x3C, 0x03, 0xC0, 0x3C, 0x03, 0x60, 0x67, 0x0E, 0x1F, 0x80, 0x60, 0x03,
	2689	0x00, 0x1F, 0xFE, 0x7F, 0xB0, 0xF8, 0x3C, 0x1E, 0x1B, 0xF9, 0x98, 0xC6,
	2690	0x63, 0x30, 0xD8, 0x6C, 0x18, 0x1F, 0x0F, 0xE7, 0x09, 0x80, 0x60, 0x0E,
	2691	0x00, 0xF0, 0x0E, 0x00, 0xC0, 0x36, 0x1D, 0xFE, 0x1F, 0x00, 0xFF, 0x18,
	2692	0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xC0,
	2693	0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x36,
	2694	0x19, 0xFE, 0x3F, 0x00, 0xC0, 0x68, 0x0D, 0x83, 0x30, 0x62, 0x0C, 0x63,
	2695	0x0C, 0x60, 0x8C, 0x19, 0x03, 0x60, 0x2C, 0x07, 0x00, 0xE0, 0xC1, 0x03,
	2696	0xC1, 0x83, 0x43, 0x86, 0x62, 0x86, 0x62, 0x86, 0x62, 0x46, 0x66, 0x4C,
	2697	0x24, 0x4C, 0x34, 0x4C, 0x34, 0x2C, 0x3C, 0x38, 0x38, 0x38, 0x18, 0x38,
	2698	0x60, 0x98, 0x63, 0x10, 0x4C, 0x1A, 0x03, 0x80, 0xC0, 0x78, 0x12, 0x0C,
	2699	0xC2, 0x19, 0x86, 0x40, 0xC0, 0xC0, 0xD8, 0x26, 0x18, 0x84, 0x33, 0x04,
	2700	0x81, 0xE0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0x30, 0x0C, 0x00, 0x7F, 0x81,
	2701	0x80, 0xC0, 0xC0, 0x60, 0x60, 0x60, 0x30, 0x30, 0x10, 0x18, 0x18, 0x0F,
	2702	0xF8, 0xFB, 0x6D, 0xB6, 0xDB, 0x6D, 0xB6, 0xE0, 0x80, 0x80, 0x40, 0x40,
	2703	0x20, 0x20, 0x10, 0x10, 0x10, 0x08, 0x08, 0x04, 0x04, 0x04, 0x02, 0x02,
	2704	0x01, 0xED, 0xB6, 0xDB, 0x6D, 0xB6, 0xDB, 0xE0, 0x18, 0x38, 0x24, 0x24,
	2705	0x66, 0x42, 0x42, 0xFF, 0xFF, 0xF0, 0xC8, 0x80, 0x3C, 0x7E, 0x03, 0x1F,
	2706	0x7F, 0xE3, 0xC3, 0xC7, 0xFF, 0x7B, 0xC0, 0xC0, 0xC0, 0xC0, 0xDC, 0xE6,
	2707	0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xE6, 0xFC, 0x1E, 0x3F, 0x60, 0xC0,
	2708	0xC0, 0xC0, 0xC0, 0xC0, 0x61, 0x1E, 0x01, 0x80, 0xC0, 0x60, 0x33, 0xFB,
	2709	0x1D, 0x87, 0x83, 0xC1, 0xE0, 0xF0, 0x78, 0x36, 0x39, 0xEC, 0x3E, 0x3F,
	2710	0xB0, 0x7F, 0xFF, 0xFE, 0x03, 0x00, 0xC2, 0x7F, 0x0F, 0x00, 0x3D, 0xF6,
	2711	0x18, 0x63, 0xCF, 0x18, 0x61, 0x86, 0x18, 0x61, 0x86, 0x00, 0x3F, 0x9F,
	2712	0xEE, 0x63, 0x0C, 0xC3, 0x39, 0xC7, 0xE3, 0x70, 0xFF, 0x9F, 0xFC, 0x0F,
	2713	0x07, 0xFF, 0x9F, 0x80, 0xC0, 0xC0, 0xC0, 0xC0, 0xDE, 0xE3, 0xC3, 0xC3,
	2714	0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xF0, 0xFF, 0xFF, 0xF0, 0x33, 0x00,
	2715	0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0xFE, 0xC0, 0xC0, 0xC0, 0xC0, 0xC3,
	2716	0xC6, 0xCC, 0xD8, 0xD8, 0xFC, 0xE4, 0xC6, 0xC3, 0xC3, 0xDB, 0x6D, 0xB6,
	2717	0xDB, 0x6C, 0xC0, 0xDE, 0x77, 0x3C, 0xF0, 0xC7, 0x86, 0x3C, 0x31, 0xE1,
	2718	0x8F, 0x0C, 0x78, 0x63, 0xC3, 0x1E, 0x18, 0xC0, 0xDE, 0xE3, 0xC3, 0xC3,
	2719	0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0x1C, 0x3F, 0x98, 0xD8, 0x3C, 0x1E,
	2720	0x0F, 0x07, 0x83, 0x63, 0x1F, 0x00, 0xDC, 0xE6, 0xC3, 0xC3, 0xC3, 0xC3,
	2721	0xC3, 0xC3, 0xE6, 0xFC, 0xC0, 0xC0, 0xC0, 0xC0, 0x3D, 0xB1, 0xD8, 0x78,
	2722	0x3C, 0x1E, 0x0F, 0x07, 0x83, 0x63, 0x9E, 0xC0, 0x60, 0x30, 0x18, 0x0C,
	2723	0xDF, 0xEE, 0x30, 0xC3, 0x0C, 0x30, 0xC3, 0x00, 0x79, 0xFB, 0x16, 0x07,
	2724	0x03, 0x81, 0xC3, 0xFC, 0xF0, 0x61, 0x8F, 0xBE, 0x61, 0x86, 0x18, 0x61,
	2725	0x87, 0xCF, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC7, 0x7B,
	2726	0xC1, 0xA0, 0xD8, 0x4C, 0x62, 0x31, 0x90, 0x58, 0x2C, 0x1C, 0x06, 0x00,
	2727	0xC7, 0x0F, 0x1C, 0x36, 0x78, 0x99, 0xA6, 0x66, 0x98, 0x9A, 0x43, 0x6D,
	2728	0x0F, 0x14, 0x3C, 0x60, 0x71, 0x80, 0x63, 0x31, 0x8D, 0x82, 0x81, 0xC0,
	2729	0xE0, 0xD0, 0x4C, 0x63, 0x20, 0x80, 0xC1, 0xE0, 0x90, 0xCC, 0x62, 0x21,
	2730	0x30, 0xD8, 0x28, 0x1C, 0x0E, 0x06, 0x07, 0x0F, 0x07, 0x00, 0xFF, 0xFC,
	2731	0x30, 0x41, 0x06, 0x18, 0x20, 0xFF, 0xFC, 0x19, 0x8C, 0x63, 0x18, 0xDC,
	2732	0xE1, 0x8C, 0x63, 0x18, 0xC6, 0x18, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC3,
	2733	0x18, 0xC6, 0x31, 0x87, 0x3B, 0x18, 0xC6, 0x31, 0x8C, 0xC0, 0x60, 0xF1,
	2734	0x8F, 0x06 };
	2735
	2736	const GFXglyph sourcesans10pt7bGlyphs[] PROGMEM = {
	2737	{ 0, 1, 1, 4, 0, 0 }, // 0x20 ' '
	2738	{ 1, 2, 13, 6, 2, -12 }, // 0x21 '!'
	2739	{ 5, 5, 5, 9, 2, -13 }, // 0x22 '"'
	2740	{ 9, 8, 12, 10, 1, -11 }, // 0x23 '#'
	2741	{ 21, 7, 16, 10, 2, -14 }, // 0x24 '$'
	2742	{ 35, 16, 13, 16, 1, -12 }, // 0x25 '%'
	2743	{ 61, 11, 13, 12, 1, -12 }, // 0x26 '&'
	2744	{ 79, 2, 5, 5, 2, -13 }, // 0x27 '''
	2745	{ 81, 4, 19, 6, 2, -14 }, // 0x28 '('
	2746	{ 91, 4, 19, 6, 1, -14 }, // 0x29 ')'
	2747	{ 101, 7, 6, 8, 1, -13 }, // 0x2A '*'
	2748	{ 107, 6, 8, 10, 2, -10 }, // 0x2B '+'
	2749	{ 113, 4, 5, 5, 1, -1 }, // 0x2C ','
	2750	{ 116, 4, 2, 6, 1, -5 }, // 0x2D '-'
	2751	{ 117, 2, 3, 5, 1, -2 }, // 0x2E '.'
	2752	{ 118, 8, 19, 7, 0, -14 }, // 0x2F '/'
	2753	{ 137, 8, 14, 10, 1, -13 }, // 0x30 '0'
	2754	{ 151, 6, 13, 10, 3, -12 }, // 0x31 '1'
	2755	{ 161, 9, 14, 10, 1, -13 }, // 0x32 '2'
	2756	{ 177, 9, 14, 10, 0, -13 }, // 0x33 '3'
	2757	{ 193, 8, 13, 10, 1, -12 }, // 0x34 '4'
	2758	{ 206, 9, 12, 10, 0, -11 }, // 0x35 '5'
	2759	{ 220, 9, 13, 10, 1, -12 }, // 0x36 '6'
	2760	{ 235, 7, 12, 10, 2, -11 }, // 0x37 '7'
	2761	{ 246, 8, 14, 10, 1, -13 }, // 0x38 '8'
	2762	{ 260, 8, 14, 10, 1, -13 }, // 0x39 '9'
	2763	{ 274, 2, 10, 5, 1, -9 }, // 0x3A ':'
	2764	{ 277, 2, 13, 4, 1, -9 }, // 0x3B ';'
	2765	{ 281, 8, 8, 10, 1, -10 }, // 0x3C '<'
	2766	{ 289, 8, 6, 10, 1, -9 }, // 0x3D '='
	2767	{ 295, 8, 8, 10, 1, -10 }, // 0x3E '>'
	2768	{ 303, 7, 13, 8, 1, -12 }, // 0x3F '?'
	2769	{ 315, 16, 17, 17, 1, -13 }, // 0x40 '@'
	2770	{ 349, 11, 13, 11, 0, -12 }, // 0x41 'A'
	2771	{ 367, 9, 13, 12, 2, -12 }, // 0x42 'B'
	2772	{ 382, 10, 13, 11, 1, -12 }, // 0x43 'C'
	2773	{ 399, 10, 13, 12, 2, -12 }, // 0x44 'D'
	2774	{ 416, 7, 13, 11, 2, -12 }, // 0x45 'E'
	2775	{ 428, 7, 13, 10, 2, -12 }, // 0x46 'F'
	2776	{ 440, 10, 13, 12, 1, -12 }, // 0x47 'G'
	2777	{ 457, 10, 13, 13, 2, -12 }, // 0x48 'H'
	2778	{ 474, 2, 13, 5, 2, -12 }, // 0x49 'I'
	2779	{ 478, 8, 13, 10, 0, -12 }, // 0x4A 'J'
	2780	{ 491, 10, 13, 12, 2, -12 }, // 0x4B 'K'
	2781	{ 508, 7, 13, 10, 2, -12 }, // 0x4C 'L'
	2782	{ 520, 11, 13, 15, 2, -12 }, // 0x4D 'M'
	2783	{ 538, 10, 13, 13, 2, -12 }, // 0x4E 'N'
	2784	{ 555, 12, 13, 13, 1, -12 }, // 0x4F 'O'
	2785	{ 575, 9, 13, 12, 2, -12 }, // 0x50 'P'
	2786	{ 590, 12, 16, 13, 1, -12 }, // 0x51 'Q'
	2787	{ 614, 9, 13, 12, 2, -12 }, // 0x52 'R'
	2788	{ 629, 10, 13, 11, 0, -12 }, // 0x53 'S'
	2789	{ 646, 8, 13, 11, 2, -12 }, // 0x54 'T'
	2790	{ 659, 10, 13, 13, 2, -12 }, // 0x55 'U'
	2791	{ 676, 11, 13, 10, 0, -12 }, // 0x56 'V'
	2792	{ 694, 16, 13, 16, 0, -12 }, // 0x57 'W'
	2793	{ 720, 10, 13, 10, 0, -12 }, // 0x58 'X'
	2794	{ 737, 10, 13, 10, 0, -12 }, // 0x59 'Y'
	2795	{ 754, 9, 13, 11, 1, -12 }, // 0x5A 'Z'
	2796	{ 769, 3, 17, 6, 2, -13 }, // 0x5B '['
	2797	{ 776, 8, 17, 7, 0, -13 }, // 0x5C '\'
	2798	{ 793, 3, 17, 6, 1, -13 }, // 0x5D ']'
	2799	{ 800, 8, 7, 10, 1, -12 }, // 0x5E '^'
	2800	{ 807, 10, 2, 10, 0, 2 }, // 0x5F '_'
	2801	{ 810, 3, 3, 11, 3, -13 }, // 0x60 '`'
	2802	{ 812, 8, 10, 10, 1, -9 }, // 0x61 'a'
	2803	{ 822, 8, 14, 11, 2, -13 }, // 0x62 'b'
	2804	{ 836, 8, 10, 9, 1, -9 }, // 0x63 'c'
	2805	{ 846, 9, 14, 11, 1, -13 }, // 0x64 'd'
	2806	{ 862, 9, 10, 10, 1, -9 }, // 0x65 'e'
	2807	{ 874, 6, 15, 6, 1, -14 }, // 0x66 'f'
	2808	{ 886, 10, 14, 10, 1, -9 }, // 0x67 'g'
	2809	{ 904, 8, 14, 11, 2, -13 }, // 0x68 'h'
	2810	{ 918, 2, 14, 5, 1, -13 }, // 0x69 'i'
	2811	{ 922, 4, 18, 5, 0, -13 }, // 0x6A 'j'
	2812	{ 931, 8, 14, 10, 2, -13 }, // 0x6B 'k'
	2813	{ 945, 3, 14, 5, 2, -13 }, // 0x6C 'l'
	2814	{ 951, 13, 10, 17, 2, -9 }, // 0x6D 'm'
	2815	{ 968, 8, 10, 11, 2, -9 }, // 0x6E 'n'
	2816	{ 978, 9, 10, 11, 1, -9 }, // 0x6F 'o'
	2817	{ 990, 8, 14, 11, 2, -9 }, // 0x70 'p'
	2818	{ 1004, 9, 14, 11, 1, -9 }, // 0x71 'q'
	2819	{ 1020, 6, 10, 7, 2, -9 }, // 0x72 'r'
	2820	{ 1028, 7, 10, 8, 1, -9 }, // 0x73 's'
	2821	{ 1037, 6, 12, 7, 1, -11 }, // 0x74 't'
	2822	{ 1046, 8, 10, 11, 2, -9 }, // 0x75 'u'
	2823	{ 1056, 9, 10, 9, 0, -9 }, // 0x76 'v'
	2824	{ 1068, 14, 10, 14, 0, -9 }, // 0x77 'w'
	2825	{ 1086, 9, 10, 9, 0, -9 }, // 0x78 'x'
	2826	{ 1098, 9, 14, 9, 1, -9 }, // 0x79 'y'
	2827	{ 1114, 7, 10, 8, 1, -9 }, // 0x7A 'z'
	2828	{ 1123, 5, 17, 6, 0, -13 }, // 0x7B '{'
	2829	{ 1134, 2, 20, 5, 2, -14 }, // 0x7C '\|'
	2830	{ 1139, 5, 17, 6, 2, -13 }, // 0x7D '}'
	2831	{ 1150, 8, 4, 10, 1, -8 } }; // 0x7E '~'
	2832
	2833	const GFXfont sourcesans10pt7b PROGMEM = {
	2834	(uint8_t *)sourcesans10pt7bBitmaps,
	2835	(GFXglyph *)sourcesans10pt7bGlyphs,
	2836	0x20, 0x7E, 26 };
	2837
	2838	const uint8_t sourcesans9pt7bBitmaps[] PROGMEM = {
	2839	0x00, 0xFF, 0xFF, 0x0F, 0xDE, 0xF7, 0xBD, 0x80, 0x24, 0x48, 0x97, 0xF2,
	2840	0x4D, 0xBF, 0xA4, 0x48, 0x91, 0x20, 0x18, 0x31, 0xF7, 0x2C, 0x18, 0x18,
	2841	0x0C, 0x0E, 0x0C, 0x1C, 0x37, 0xC3, 0x00, 0x78, 0x43, 0x21, 0x0C, 0xC8,
	2842	0x33, 0x20, 0xCD, 0x03, 0x35, 0xE7, 0xAC, 0xC1, 0x33, 0x04, 0xCC, 0x23,
	2843	0x30, 0x84, 0x84, 0x1E, 0x1E, 0x06, 0x60, 0xCC, 0x19, 0x81, 0x60, 0x30,
	2844	0x1E, 0x1F, 0x22, 0xC2, 0xD8, 0x71, 0x8F, 0x1F, 0x30, 0xFF, 0xC0, 0x12,
	2845	0x26, 0x4C, 0xCC, 0xCC, 0xC4, 0x62, 0x21, 0x84, 0x46, 0x23, 0x33, 0x33,
	2846	0x32, 0x64, 0x48, 0x21, 0x3E, 0xED, 0x80, 0x30, 0xC3, 0x3F, 0x30, 0xC3,
	2847	0x00, 0x33, 0x64, 0xF0, 0xF0, 0x00, 0x08, 0x10, 0x20, 0x81, 0x02, 0x08,
	2848	0x10, 0x40, 0x81, 0x04, 0x08, 0x20, 0x00, 0x3C, 0x66, 0x42, 0xC3, 0xC3,
	2849	0xC3, 0xC3, 0xC3, 0xC3, 0x42, 0x66, 0x3C, 0x71, 0x8C, 0x63, 0x18, 0xC6,
	2850	0x31, 0xBE, 0x78, 0x8C, 0x06, 0x06, 0x06, 0x06, 0x0C, 0x0C, 0x18, 0x30,
	2851	0x20, 0x7F, 0x3C, 0x66, 0x03, 0x03, 0x03, 0x06, 0x0C, 0x03, 0x03, 0x03,
	2852	0xC6, 0x7C, 0x0C, 0x18, 0xF1, 0x64, 0xD1, 0xA3, 0x7F, 0x0C, 0x18, 0x30,
	2853	0x7E, 0x60, 0x60, 0x40, 0xFC, 0x46, 0x03, 0x03, 0x03, 0xC6, 0x7C, 0x3E,
	2854	0x62, 0x60, 0xC0, 0xDC, 0xE7, 0xC3, 0xC3, 0x43, 0x66, 0x3C, 0xFC, 0x21,
	2855	0x84, 0x30, 0xC2, 0x18, 0x61, 0x86, 0x00, 0x3E, 0x63, 0x63, 0x63, 0x32,
	2856	0x1C, 0x2E, 0xC3, 0xC3, 0xC3, 0x63, 0x3C, 0x3C, 0x66, 0xC6, 0xC3, 0xC3,
	2857	0xC3, 0x67, 0x3B, 0x03, 0x06, 0x46, 0x7C, 0xF0, 0x0F, 0xF0, 0x03, 0xF8,
	2858	0x00, 0x0C, 0xE6, 0x0C, 0x07, 0x03, 0x80, 0xFE, 0x00, 0x00, 0x0F, 0xE0,
	2859	0x01, 0x80, 0xE0, 0x30, 0x67, 0x38, 0x00, 0x7B, 0x30, 0xC3, 0x08, 0x41,
	2860	0x0C, 0x00, 0x03, 0x0C, 0x07, 0xC0, 0x60, 0xC3, 0x01, 0x98, 0x07, 0x67,
	2861	0x0F, 0x32, 0x3D, 0x88, 0xF6, 0x23, 0xD8, 0x8B, 0x66, 0x6C, 0xEF, 0x18,
	2862	0x00, 0x60, 0x00, 0xE0, 0x00, 0xF8, 0x00, 0x0C, 0x03, 0x01, 0xE0, 0x48,
	2863	0x12, 0x0C, 0xC3, 0x30, 0xFC, 0x61, 0x98, 0x64, 0x0B, 0x03, 0xFC, 0xC6,
	2864	0xC6, 0xC6, 0xC4, 0xF8, 0xC6, 0xC3, 0xC3, 0xC3, 0xC6, 0xFC, 0x1F, 0x18,
	2865	0xD8, 0x08, 0x0C, 0x06, 0x03, 0x01, 0x80, 0xC0, 0x30, 0x0C, 0x63, 0xE0,
	2866	0xFC, 0x63, 0x30, 0xD8, 0x3C, 0x1E, 0x0F, 0x07, 0x83, 0xC1, 0xE1, 0xB1,
	2867	0x9F, 0x80, 0xFF, 0x0C, 0x30, 0xC3, 0xEC, 0x30, 0xC3, 0x0C, 0x3F, 0xFF,
	2868	0x0C, 0x30, 0xC3, 0x0F, 0xF0, 0xC3, 0x0C, 0x30, 0x1F, 0x8C, 0x26, 0x03,
	2869	0x00, 0xC0, 0x30, 0x0C, 0x1F, 0x03, 0xC0, 0xD8, 0x33, 0x0C, 0x7E, 0xC1,
	2870	0xE0, 0xF0, 0x78, 0x3C, 0x1F, 0xFF, 0x07, 0x83, 0xC1, 0xE0, 0xF0, 0x78,
	2871	0x30, 0xFF, 0xFF, 0xFF, 0x06, 0x0C, 0x18, 0x30, 0x60, 0xC1, 0x83, 0x06,
	2872	0x0F, 0x33, 0xC0, 0xC1, 0x61, 0x31, 0x99, 0x8D, 0x87, 0xE3, 0xB1, 0xCC,
	2873	0xC2, 0x61, 0xB0, 0x58, 0x30, 0xC3, 0x0C, 0x30, 0xC3, 0x0C, 0x30, 0xC3,
	2874	0x0C, 0x3F, 0xC0, 0xF8, 0x7E, 0x1F, 0x87, 0xD2, 0xF4, 0xBD, 0x2F, 0x33,
	2875	0xCC, 0xF3, 0x3C, 0x0F, 0x03, 0xC1, 0xF0, 0xF8, 0x7A, 0x3D, 0x1E, 0x4F,
	2876	0x27, 0x8B, 0xC5, 0xE1, 0xF0, 0xF8, 0x30, 0x1E, 0x1C, 0xE6, 0x1B, 0x03,
	2877	0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xD8, 0x63, 0x30, 0x78, 0xFC, 0xC7,
	2878	0xC3, 0xC3, 0xC3, 0xC6, 0xFC, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0x1E, 0x1C,
	2879	0xE6, 0x1B, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xD8, 0x66, 0x18,
	2880	0xFC, 0x0C, 0x01, 0x80, 0x3C, 0xFC, 0xC7, 0xC3, 0xC3, 0xC3, 0xC6, 0xFC,
	2881	0xC8, 0xCC, 0xC6, 0xC6, 0xC3, 0x3C, 0xE2, 0xC0, 0xC0, 0x60, 0x38, 0x0E,
	2882	0x07, 0x03, 0x03, 0xC6, 0x7C, 0xFF, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
	2883	0x18, 0x18, 0x18, 0x18, 0x18, 0xC1, 0xE0, 0xF0, 0x78, 0x3C, 0x1E, 0x0F,
	2884	0x07, 0x83, 0xC1, 0xE0, 0xD8, 0xC7, 0xC0, 0xC0, 0xD0, 0x36, 0x19, 0x86,
	2885	0x21, 0x8C, 0xC3, 0x30, 0x4C, 0x16, 0x07, 0x80, 0xE0, 0x30, 0xC3, 0x0F,
	2886	0x0C, 0x34, 0x30, 0x99, 0xC6, 0x64, 0x99, 0x92, 0x66, 0x49, 0x09, 0x24,
	2887	0x38, 0x70, 0xE1, 0xC3, 0x86, 0x0E, 0x18, 0x41, 0x31, 0x88, 0x86, 0xC1,
	2888	0xC0, 0x60, 0x70, 0x28, 0x36, 0x11, 0x98, 0xC8, 0x30, 0x40, 0x98, 0x62,
	2889	0x10, 0xCC, 0x12, 0x07, 0x80, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0x30,
	2890	0xFF, 0x02, 0x06, 0x04, 0x0C, 0x18, 0x10, 0x30, 0x60, 0x60, 0xC0, 0xFF,
	2891	0xFB, 0x6D, 0xB6, 0xDB, 0x6D, 0xB7, 0x01, 0x02, 0x02, 0x04, 0x04, 0x08,
	2892	0x08, 0x10, 0x20, 0x20, 0x40, 0x40, 0x81, 0x01, 0xED, 0xB6, 0xDB, 0x6D,
	2893	0xB6, 0xDF, 0x10, 0x50, 0xA3, 0x64, 0x48, 0xB1, 0x80, 0xFF, 0x80, 0xC8,
	2894	0x80, 0x7C, 0x8C, 0x18, 0xF6, 0x78, 0xF1, 0xE7, 0x76, 0xC0, 0x60, 0x30,
	2895	0x18, 0x0D, 0xE7, 0x1B, 0x07, 0x83, 0xC1, 0xE0, 0xF0, 0x7C, 0x6D, 0xE0,
	2896	0x1E, 0xC5, 0x06, 0x0C, 0x18, 0x30, 0x31, 0x1E, 0x03, 0x03, 0x03, 0x03,
	2897	0x3F, 0x63, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0x67, 0x3B, 0x3C, 0x66, 0xC3,
	2898	0xC3, 0xFF, 0xC0, 0xC0, 0x62, 0x3E, 0x39, 0x86, 0x18, 0xF1, 0x86, 0x18,
	2899	0x61, 0x86, 0x18, 0x60, 0x7F, 0x62, 0x31, 0x98, 0xCE, 0xC3, 0xC3, 0x01,
	2900	0x80, 0x7F, 0x60, 0xF0, 0x78, 0x67, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xDE,
	2901	0xE3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xFF, 0xFF, 0x30,
	2902	0x03, 0x33, 0x33, 0x33, 0x33, 0x33, 0x3E, 0xC0, 0xC0, 0xC0, 0xC0, 0xC6,
	2903	0xC4, 0xC8, 0xD8, 0xF8, 0xEC, 0xC4, 0xC6, 0xC3, 0xDB, 0x6D, 0xB6, 0xDB,
	2904	0x6E, 0xDE, 0x77, 0x1C, 0xF0, 0xC7, 0x86, 0x3C, 0x31, 0xE1, 0x8F, 0x0C,
	2905	0x78, 0x63, 0xC3, 0x18, 0xDE, 0xE3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3,
	2906	0xC3, 0x3C, 0x66, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0x66, 0x3C, 0xDE, 0x71,
	2907	0xB0, 0x78, 0x3C, 0x1E, 0x0F, 0x07, 0xC6, 0xDE, 0x60, 0x30, 0x18, 0x0C,
	2908	0x00, 0x3F, 0x63, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0x67, 0x3B, 0x03, 0x03,
	2909	0x03, 0xDF, 0x31, 0x8C, 0x63, 0x18, 0xC0, 0x7D, 0x8B, 0x07, 0x03, 0xC1,
	2910	0xC1, 0xC3, 0x7C, 0x61, 0x8F, 0x18, 0x61, 0x86, 0x18, 0x61, 0x83, 0xC0,
	2911	0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC7, 0x7B, 0xC1, 0x43, 0x62,
	2912	0x62, 0x26, 0x34, 0x34, 0x1C, 0x18, 0xC2, 0x1E, 0x38, 0xD9, 0x4C, 0xCA,
	2913	0x66, 0x53, 0x14, 0xD0, 0xE2, 0x87, 0x1C, 0x38, 0xC0, 0x42, 0x66, 0x34,
	2914	0x1C, 0x18, 0x3C, 0x24, 0x66, 0x42, 0x41, 0xA0, 0x98, 0xC4, 0x62, 0x21,
	2915	0xB0, 0x58, 0x28, 0x0C, 0x06, 0x06, 0x02, 0x06, 0x00, 0xFC, 0x31, 0x84,
	2916	0x31, 0x84, 0x30, 0xFC, 0x19, 0x8C, 0x63, 0x18, 0xD8, 0x31, 0x8C, 0x63,
	2917	0x18, 0xC3, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xC3, 0x18, 0xC6, 0x31, 0x83,
	2918	0x63, 0x18, 0xC6, 0x31, 0x98, 0xE3, 0x3C };
	2919
	2920	const GFXglyph sourcesans9pt7bGlyphs[] PROGMEM = {
	2921	{ 0, 1, 1, 4, 0, 0 }, // 0x20 ' '
	2922	{ 1, 2, 12, 5, 2, -11 }, // 0x21 '!'
	2923	{ 4, 5, 5, 8, 2, -12 }, // 0x22 '"'
	2924	{ 8, 7, 11, 9, 1, -10 }, // 0x23 '#'
	2925	{ 18, 7, 14, 9, 1, -12 }, // 0x24 '$'
	2926	{ 31, 14, 12, 15, 1, -11 }, // 0x25 '%'
	2927	{ 52, 11, 12, 11, 1, -11 }, // 0x26 '&'
	2928	{ 69, 2, 5, 4, 2, -12 }, // 0x27 '''
	2929	{ 71, 4, 16, 5, 1, -12 }, // 0x28 '('
	2930	{ 79, 4, 16, 5, 1, -12 }, // 0x29 ')'
	2931	{ 87, 5, 5, 8, 1, -12 }, // 0x2A '*'
	2932	{ 91, 6, 7, 9, 2, -8 }, // 0x2B '+'
	2933	{ 97, 4, 4, 4, 0, 0 }, // 0x2C ','
	2934	{ 99, 4, 1, 6, 1, -4 }, // 0x2D '-'
	2935	{ 100, 2, 2, 4, 1, -1 }, // 0x2E '.'
	2936	{ 101, 7, 16, 6, 0, -12 }, // 0x2F '/'
	2937	{ 115, 8, 12, 9, 1, -11 }, // 0x30 '0'
	2938	{ 127, 5, 11, 9, 2, -10 }, // 0x31 '1'
	2939	{ 134, 8, 12, 9, 1, -11 }, // 0x32 '2'
	2940	{ 146, 8, 12, 9, 1, -11 }, // 0x33 '3'
	2941	{ 158, 7, 11, 9, 1, -10 }, // 0x34 '4'
	2942	{ 168, 8, 11, 9, 1, -10 }, // 0x35 '5'
	2943	{ 179, 8, 11, 9, 1, -10 }, // 0x36 '6'
	2944	{ 190, 6, 11, 9, 2, -10 }, // 0x37 '7'
	2945	{ 199, 8, 12, 9, 1, -11 }, // 0x38 '8'
	2946	{ 211, 8, 12, 9, 1, -11 }, // 0x39 '9'
	2947	{ 223, 2, 8, 4, 1, -7 }, // 0x3A ':'
	2948	{ 225, 2, 11, 4, 1, -7 }, // 0x3B ';'
	2949	{ 228, 7, 8, 9, 1, -9 }, // 0x3C '<'
	2950	{ 235, 7, 5, 9, 1, -7 }, // 0x3D '='
	2951	{ 240, 7, 8, 9, 1, -9 }, // 0x3E '>'
	2952	{ 247, 6, 12, 8, 1, -11 }, // 0x3F '?'
	2953	{ 256, 14, 15, 15, 1, -11 }, // 0x40 '@'
	2954	{ 283, 10, 12, 10, 0, -11 }, // 0x41 'A'
	2955	{ 298, 8, 12, 11, 2, -11 }, // 0x42 'B'
	2956	{ 310, 9, 12, 10, 1, -11 }, // 0x43 'C'
	2957	{ 324, 9, 12, 11, 2, -11 }, // 0x44 'D'
	2958	{ 338, 6, 12, 9, 2, -11 }, // 0x45 'E'
	2959	{ 347, 6, 12, 9, 2, -11 }, // 0x46 'F'
	2960	{ 356, 10, 12, 11, 1, -11 }, // 0x47 'G'
	2961	{ 371, 9, 12, 12, 2, -11 }, // 0x48 'H'
	2962	{ 385, 2, 12, 5, 2, -11 }, // 0x49 'I'
	2963	{ 388, 7, 12, 9, 1, -11 }, // 0x4A 'J'
	2964	{ 399, 9, 12, 10, 2, -11 }, // 0x4B 'K'
	2965	{ 413, 6, 12, 9, 2, -11 }, // 0x4C 'L'
	2966	{ 422, 10, 12, 13, 2, -11 }, // 0x4D 'M'
	2967	{ 437, 9, 12, 12, 2, -11 }, // 0x4E 'N'
	2968	{ 451, 10, 12, 12, 1, -11 }, // 0x4F 'O'
	2969	{ 466, 8, 12, 10, 2, -11 }, // 0x50 'P'
	2970	{ 478, 10, 15, 12, 1, -11 }, // 0x51 'Q'
	2971	{ 497, 8, 12, 10, 2, -11 }, // 0x52 'R'
	2972	{ 509, 8, 12, 10, 1, -11 }, // 0x53 'S'
	2973	{ 521, 8, 12, 10, 1, -11 }, // 0x54 'T'
	2974	{ 533, 9, 12, 12, 2, -11 }, // 0x55 'U'
	2975	{ 547, 10, 12, 9, 0, -11 }, // 0x56 'V'
	2976	{ 562, 14, 12, 14, 0, -11 }, // 0x57 'W'
	2977	{ 583, 9, 12, 9, 0, -11 }, // 0x58 'X'
	2978	{ 597, 10, 12, 9, 0, -11 }, // 0x59 'Y'
	2979	{ 612, 8, 12, 10, 1, -11 }, // 0x5A 'Z'
	2980	{ 624, 3, 16, 5, 2, -12 }, // 0x5B '['
	2981	{ 630, 7, 16, 6, 0, -12 }, // 0x5C '\'
	2982	{ 644, 3, 16, 5, 1, -12 }, // 0x5D ']'
	2983	{ 650, 7, 7, 9, 1, -11 }, // 0x5E '^'
	2984	{ 657, 9, 1, 9, 0, 2 }, // 0x5F '_'
	2985	{ 659, 3, 3, 10, 3, -12 }, // 0x60 '`'
	2986	{ 661, 7, 9, 9, 1, -8 }, // 0x61 'a'
	2987	{ 669, 9, 13, 10, 1, -12 }, // 0x62 'b'
	2988	{ 684, 7, 9, 8, 1, -8 }, // 0x63 'c'
	2989	{ 692, 8, 13, 10, 1, -12 }, // 0x64 'd'
	2990	{ 705, 8, 9, 9, 1, -8 }, // 0x65 'e'
	2991	{ 714, 6, 13, 5, 1, -12 }, // 0x66 'f'
	2992	{ 724, 9, 13, 9, 1, -8 }, // 0x67 'g'
	2993	{ 739, 8, 13, 10, 1, -12 }, // 0x68 'h'
	2994	{ 752, 2, 12, 4, 1, -11 }, // 0x69 'i'
	2995	{ 755, 4, 16, 4, 0, -11 }, // 0x6A 'j'
	2996	{ 763, 8, 13, 9, 1, -12 }, // 0x6B 'k'
	2997	{ 776, 3, 13, 5, 1, -12 }, // 0x6C 'l'
	2998	{ 781, 13, 9, 15, 1, -8 }, // 0x6D 'm'
	2999	{ 796, 8, 9, 10, 1, -8 }, // 0x6E 'n'
	3000	{ 805, 8, 9, 10, 1, -8 }, // 0x6F 'o'
	3001	{ 814, 9, 13, 10, 1, -8 }, // 0x70 'p'
	3002	{ 829, 8, 12, 10, 1, -8 }, // 0x71 'q'
	3003	{ 841, 5, 9, 6, 1, -8 }, // 0x72 'r'
	3004	{ 847, 7, 9, 8, 1, -8 }, // 0x73 's'
	3005	{ 855, 6, 11, 6, 1, -10 }, // 0x74 't'
	3006	{ 864, 8, 9, 10, 1, -8 }, // 0x75 'u'
	3007	{ 873, 8, 9, 8, 0, -8 }, // 0x76 'v'
	3008	{ 882, 13, 9, 13, 0, -8 }, // 0x77 'w'
	3009	{ 897, 8, 9, 8, 0, -8 }, // 0x78 'x'
	3010	{ 906, 9, 13, 8, 0, -8 }, // 0x79 'y'
	3011	{ 921, 6, 9, 8, 1, -8 }, // 0x7A 'z'
	3012	{ 928, 5, 16, 5, 0, -12 }, // 0x7B '{'
	3013	{ 938, 2, 19, 4, 2, -13 }, // 0x7C '\|'
	3014	{ 943, 5, 16, 5, 1, -12 }, // 0x7D '}'
	3015	{ 953, 7, 2, 9, 1, -6 } }; // 0x7E '~'
	3016
	3017	const GFXfont sourcesans9pt7b PROGMEM = {
	3018	(uint8_t *)sourcesans9pt7bBitmaps,
	3019	(GFXglyph *)sourcesans9pt7bGlyphs,
	3020	0x20, 0x7E, 24 };
	3021
	3022	// Approx. 1627 bytes
	3023	const uint8_t sourcesans_semi9pt7bBitmaps[] PROGMEM = {
	3024	0x00, 0xFF, 0xD5, 0x3F, 0xCF, 0x3C, 0xF3, 0xCC, 0x24, 0x4B, 0xFF, 0xF2,
	3025	0x5F, 0xFF, 0xA4, 0x48, 0x91, 0x20, 0x18, 0x31, 0xFE, 0x2C, 0x1C, 0x1E,
	3026	0x0E, 0x0E, 0x0E, 0x1F, 0xF7, 0xC3, 0x00, 0x78, 0x43, 0xF1, 0x0C, 0xC8,
	3027	0x33, 0x20, 0xCD, 0x7B, 0x35, 0xE7, 0xAC, 0xDE, 0xB3, 0x04, 0xCC, 0x13,
	3028	0x30, 0x8F, 0xC2, 0x1E, 0x3C, 0x1F, 0x86, 0x61, 0x98, 0x6C, 0x0E, 0x07,
	3029	0x8F, 0x76, 0xCF, 0x31, 0xE7, 0xFC, 0xF3, 0xFF, 0xC0, 0x32, 0x66, 0xCC,
	3030	0xCC, 0xCC, 0xCC, 0x66, 0x23, 0xC4, 0x66, 0x33, 0x33, 0x33, 0x33, 0x66,
	3031	0x4C, 0x10, 0x21, 0xF1, 0xC2, 0x85, 0x00, 0x30, 0xCF, 0xFF, 0x30, 0xC0,
	3032	0x33, 0x36, 0xC0, 0xFF, 0xFC, 0x00, 0x10, 0x82, 0x18, 0x41, 0x0C, 0x30,
	3033	0x82, 0x18, 0x41, 0x08, 0x00, 0x3C, 0x7E, 0x66, 0xC3, 0xC3, 0xC3, 0xC3,
	3034	0xC3, 0xC3, 0x66, 0x7E, 0x3C, 0xF3, 0xC3, 0x0C, 0x30, 0xC3, 0x0C, 0x33,
	3035	0xFF, 0xC0, 0x78, 0xFC, 0xCE, 0x06, 0x06, 0x06, 0x0C, 0x18, 0x30, 0x70,
	3036	0xFF, 0xFF, 0x3E, 0x7F, 0x23, 0x03, 0x07, 0x1E, 0x1E, 0x03, 0x03, 0x43,
	3037	0xFE, 0x3C, 0x0E, 0x1E, 0x1E, 0x36, 0x66, 0x46, 0xFF, 0xFF, 0x06, 0x06,
	3038	0x06, 0x3E, 0x3E, 0x30, 0x60, 0x6C, 0x7E, 0x07, 0x03, 0x03, 0x47, 0x7E,
	3039	0x3C, 0x1E, 0x7F, 0x62, 0xC0, 0xDC, 0xFE, 0xE3, 0xC3, 0xC3, 0x67, 0x7E,
	3040	0x3C, 0xFF, 0xFC, 0x10, 0x60, 0x83, 0x06, 0x08, 0x30, 0x60, 0xC1, 0x80,
	3041	0x38, 0xFB, 0x1E, 0x3E, 0x6F, 0x9F, 0x63, 0xC7, 0x8D, 0xF1, 0xC0, 0x38,
	3042	0xFB, 0x36, 0x3C, 0x79, 0xDF, 0xBB, 0x06, 0x1B, 0xF3, 0xC0, 0xFC, 0x0F,
	3043	0xC0, 0xFC, 0x03, 0xFE, 0x01, 0x0F, 0x3C, 0xE0, 0xE0, 0x7C, 0x0F, 0x01,
	3044	0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0xE0, 0x7C, 0x0F, 0x0F, 0x7C,
	3045	0xE0, 0x80, 0x79, 0xFD, 0x18, 0x30, 0xE3, 0x86, 0x18, 0x30, 0x00, 0xC1,
	3046	0x83, 0x00, 0x07, 0xC0, 0xFF, 0x8E, 0x0C, 0xE6, 0xB6, 0x7C, 0xE7, 0x67,
	3047	0x33, 0x39, 0x91, 0xCC, 0x9E, 0x7F, 0xB9, 0x98, 0xC0, 0x07, 0x84, 0x1F,
	3048	0xE0, 0x3E, 0x00, 0x0C, 0x07, 0x81, 0xE0, 0x48, 0x33, 0x0C, 0xC3, 0x31,
	3049	0xFE, 0x7F, 0x98, 0x6C, 0x0F, 0x03, 0xFC, 0xFE, 0xC6, 0xC6, 0xFC, 0xFE,
	3050	0xC7, 0xC3, 0xC3, 0xC7, 0xFE, 0xFC, 0x1E, 0x1F, 0xDC, 0x5C, 0x0C, 0x06,
	3051	0x03, 0x01, 0x80, 0xE0, 0x30, 0x9F, 0xE3, 0xC0, 0xF8, 0xFE, 0xC6, 0xC3,
	3052	0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC6, 0xFE, 0xF8, 0xFF, 0xFF, 0x06, 0x0C,
	3053	0x1F, 0xBF, 0x60, 0xC1, 0x83, 0xFF, 0xF0, 0xFF, 0xFF, 0x06, 0x0C, 0x1F,
	3054	0xBF, 0x60, 0xC1, 0x83, 0x06, 0x00, 0x1E, 0x1F, 0xDC, 0x4C, 0x0C, 0x06,
	3055	0x03, 0x1F, 0x8F, 0xC1, 0xB0, 0xDF, 0xE3, 0xE0, 0xC3, 0xC3, 0xC3, 0xC3,
	3056	0xC3, 0xFF, 0xFF, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xFF, 0xFF, 0xFF, 0x06,
	3057	0x0C, 0x18, 0x30, 0x60, 0xC1, 0x83, 0x06, 0x8D, 0xF1, 0xE0, 0xC3, 0x63,
	3058	0x33, 0x99, 0x8D, 0x87, 0xC3, 0xF1, 0xDC, 0xC6, 0x63, 0xB0, 0xD8, 0x30,
	3059	0xC3, 0x0C, 0x30, 0xC3, 0x0C, 0x30, 0xC3, 0x0F, 0xFF, 0xE0, 0xF8, 0x7E,
	3060	0x1F, 0xC7, 0xF3, 0xF4, 0xBD, 0x2F, 0x7B, 0xCC, 0xF3, 0x3C, 0xCF, 0x03,
	3061	0xC3, 0xE3, 0xE3, 0xF3, 0xD3, 0xDB, 0xDB, 0xCB, 0xCF, 0xC7, 0xC7, 0xC3,
	3062	0x1E, 0x1F, 0xE6, 0x1B, 0x87, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xE1, 0xD8,
	3063	0x67, 0xF0, 0x78, 0xFC, 0xFE, 0xC3, 0xC3, 0xC3, 0xC7, 0xFE, 0xFC, 0xC0,
	3064	0xC0, 0xC0, 0xC0, 0x1E, 0x0F, 0xF1, 0x86, 0x70, 0xEC, 0x0D, 0x81, 0xB0,
	3065	0x36, 0x06, 0xC0, 0xCC, 0x30, 0xFC, 0x0F, 0x00, 0xE0, 0x0F, 0x80, 0xF8,
	3066	0xFC, 0x7F, 0x31, 0xD8, 0x6C, 0x36, 0x3B, 0xF9, 0xF8, 0xCC, 0x63, 0x31,
	3067	0xD8, 0x60, 0x1E, 0x1F, 0xD8, 0x4C, 0x07, 0x01, 0xF0, 0x3C, 0x07, 0x01,
	3068	0xB0, 0xDF, 0xC7, 0xC0, 0xFF, 0xFF, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
	3069	0x18, 0x18, 0x18, 0x18, 0xC1, 0xE0, 0xF0, 0x78, 0x3C, 0x1E, 0x0F, 0x07,
	3070	0x83, 0xC1, 0xF1, 0xDF, 0xC7, 0xC0, 0xC0, 0xF0, 0x36, 0x19, 0x86, 0x61,
	3071	0x8C, 0xC3, 0x30, 0xCC, 0x1E, 0x07, 0x81, 0xE0, 0x70, 0xC3, 0x8F, 0x0E,
	3072	0x3E, 0x38, 0xD8, 0xE2, 0x66, 0xD9, 0x9B, 0x66, 0x4D, 0x9D, 0x36, 0x3C,
	3073	0xD0, 0xF1, 0xC3, 0xC7, 0x0E, 0x1C, 0x61, 0x98, 0xC3, 0x30, 0xD8, 0x1E,
	3074	0x07, 0x01, 0xC0, 0x78, 0x37, 0x0C, 0xC6, 0x39, 0x86, 0x61, 0x98, 0x63,
	3075	0x30, 0xCC, 0x1A, 0x07, 0x80, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0x30,
	3076	0xFF, 0xFF, 0x06, 0x0E, 0x0C, 0x18, 0x38, 0x30, 0x60, 0xE0, 0xFF, 0xFF,
	3077	0xFB, 0x6D, 0xB6, 0xDB, 0x6D, 0xB7, 0x01, 0x01, 0x02, 0x02, 0x04, 0x0C,
	3078	0x08, 0x10, 0x30, 0x20, 0x40, 0x40, 0x81, 0x01, 0xED, 0xB6, 0xDB, 0x6D,
	3079	0xB6, 0xDF, 0x18, 0x70, 0xA3, 0x66, 0x48, 0xF1, 0x80, 0xFF, 0xFF, 0xC0,
	3080	0xC9, 0x80, 0x3D, 0xFC, 0x18, 0xF7, 0xFC, 0xF1, 0xFF, 0x76, 0xC0, 0xC0,
	3081	0xC0, 0xDC, 0xFE, 0xC7, 0xC3, 0xC3, 0xC3, 0xC7, 0xFE, 0xDC, 0x3C, 0xFF,
	3082	0x86, 0x0C, 0x18, 0x38, 0x3F, 0x3C, 0x03, 0x03, 0x03, 0x3B, 0x7F, 0xE3,
	3083	0xC3, 0xC3, 0xC3, 0xE3, 0x7F, 0x3B, 0x3C, 0xFE, 0x1F, 0xFF, 0xF0, 0x30,
	3084	0x3E, 0x3C, 0x3B, 0xD8, 0xCF, 0x79, 0x8C, 0x63, 0x18, 0xC6, 0x00, 0x7F,
	3085	0xFF, 0xC6, 0xC6, 0x7E, 0x7C, 0xC0, 0xFE, 0x7F, 0xC3, 0xC3, 0xFE, 0x7C,
	3086	0xC0, 0xC0, 0xC0, 0xDE, 0xFF, 0xE3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3,
	3087	0xF3, 0xFF, 0xFF, 0x33, 0x03, 0x33, 0x33, 0x33, 0x33, 0x33, 0xFE, 0xC0,
	3088	0xC0, 0xC0, 0xC0, 0xC6, 0xCC, 0xDC, 0xD8, 0xF8, 0xEC, 0xCC, 0xC6, 0xC7,
	3089	0xDB, 0x6D, 0xB6, 0xDB, 0xB0, 0xDE, 0x77, 0xFF, 0xF8, 0xE7, 0x86, 0x3C,
	3090	0x31, 0xE1, 0x8F, 0x0C, 0x78, 0x63, 0xC3, 0x18, 0xDE, 0xFF, 0xE3, 0xC3,
	3091	0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0x3C, 0x7E, 0xE7, 0xC3, 0xC3, 0xC3, 0xE7,
	3092	0x7E, 0x3C, 0xDC, 0xFE, 0xC7, 0xC3, 0xC3, 0xC3, 0xC7, 0xFE, 0xDC, 0xC0,
	3093	0xC0, 0xC0, 0x3B, 0x7F, 0xE3, 0xC3, 0xC3, 0xC3, 0xE3, 0x7F, 0x3B, 0x03,
	3094	0x03, 0xDF, 0xF9, 0x8C, 0x63, 0x18, 0xC0, 0x7B, 0xFC, 0x38, 0x78, 0x38,
	3095	0xFF, 0x78, 0x61, 0x8F, 0xBE, 0x61, 0x86, 0x18, 0x61, 0xE3, 0xC0, 0xC3,
	3096	0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC7, 0xFF, 0x7B, 0xC1, 0xB1, 0x98, 0xCC,
	3097	0x63, 0x61, 0xB0, 0xD8, 0x38, 0x1C, 0x00, 0xC3, 0x1E, 0x1C, 0xD9, 0xE4,
	3098	0xCB, 0x66, 0x5B, 0x3A, 0xD8, 0xF3, 0x87, 0x1C, 0x38, 0xE0, 0x63, 0x76,
	3099	0x36, 0x1C, 0x1C, 0x3C, 0x36, 0x66, 0x63, 0xC3, 0xC3, 0xC6, 0x66, 0x66,
	3100	0x2C, 0x3C, 0x3C, 0x18, 0x18, 0x30, 0xF0, 0xE0, 0xFD, 0xF8, 0x70, 0xC3,
	3101	0x0C, 0x38, 0x7F, 0xFE, 0x19, 0x8C, 0x63, 0x18, 0xDC, 0xE1, 0x8C, 0x63,
	3102	0x18, 0xC3, 0xFF, 0xFF, 0xE0, 0xC3, 0x18, 0xC6, 0x31, 0x87, 0x3B, 0x18,
	3103	0xC6, 0x31, 0x98, 0x60, 0xF2, 0x9E, 0x0C };
	3104
	3105	const GFXglyph sourcesans_semi9pt7bGlyphs[] PROGMEM = {
	3106	{ 0, 1, 1, 4, 0, 0 }, // 0x20 ' '
	3107	{ 1, 2, 12, 6, 2, -11 }, // 0x21 '!'
	3108	{ 4, 6, 5, 9, 1, -11 }, // 0x22 '"'
	3109	{ 8, 7, 11, 9, 1, -10 }, // 0x23 '#'
	3110	{ 18, 7, 14, 9, 1, -12 }, // 0x24 '$'
	3111	{ 31, 14, 12, 15, 1, -11 }, // 0x25 '%'
	3112	{ 52, 10, 12, 12, 1, -11 }, // 0x26 '&'
	3113	{ 67, 2, 5, 5, 1, -11 }, // 0x27 '''
	3114	{ 69, 4, 16, 6, 1, -12 }, // 0x28 '('
	3115	{ 77, 4, 16, 6, 1, -12 }, // 0x29 ')'
	3116	{ 85, 7, 6, 8, 0, -12 }, // 0x2A '*'
	3117	{ 91, 6, 6, 9, 2, -8 }, // 0x2B '+'
	3118	{ 96, 4, 5, 5, 1, -1 }, // 0x2C ','
	3119	{ 99, 4, 2, 6, 1, -5 }, // 0x2D '-'
	3120	{ 100, 2, 3, 5, 1, -2 }, // 0x2E '.'
	3121	{ 101, 6, 16, 6, 0, -12 }, // 0x2F '/'
	3122	{ 113, 8, 12, 9, 1, -11 }, // 0x30 '0'
	3123	{ 125, 6, 11, 9, 2, -10 }, // 0x31 '1'
	3124	{ 134, 8, 12, 9, 1, -11 }, // 0x32 '2'
	3125	{ 146, 8, 12, 9, 0, -11 }, // 0x33 '3'
	3126	{ 158, 8, 11, 9, 0, -10 }, // 0x34 '4'
	3127	{ 169, 8, 12, 9, 0, -11 }, // 0x35 '5'
	3128	{ 181, 8, 12, 9, 1, -11 }, // 0x36 '6'
	3129	{ 193, 7, 12, 9, 1, -11 }, // 0x37 '7'
	3130	{ 204, 7, 12, 9, 1, -11 }, // 0x38 '8'
	3131	{ 215, 7, 12, 9, 1, -11 }, // 0x39 '9'
	3132	{ 226, 2, 9, 5, 1, -8 }, // 0x3A ':'
	3133	{ 229, 2, 12, 4, 1, -8 }, // 0x3B ';'
	3134	{ 232, 8, 8, 9, 1, -9 }, // 0x3C '<'
	3135	{ 240, 8, 6, 9, 1, -8 }, // 0x3D '='
	3136	{ 246, 8, 8, 9, 1, -9 }, // 0x3E '>'
	3137	{ 254, 7, 13, 8, 0, -12 }, // 0x3F '?'
	3138	{ 266, 13, 15, 16, 1, -11 }, // 0x40 '@'
	3139	{ 291, 10, 12, 10, 0, -11 }, // 0x41 'A'
	3140	{ 306, 8, 12, 11, 2, -11 }, // 0x42 'B'
	3141	{ 318, 9, 12, 10, 1, -11 }, // 0x43 'C'
	3142	{ 332, 8, 12, 11, 2, -11 }, // 0x44 'D'
	3143	{ 344, 7, 12, 10, 2, -11 }, // 0x45 'E'
	3144	{ 355, 7, 12, 9, 2, -11 }, // 0x46 'F'
	3145	{ 366, 9, 12, 11, 1, -11 }, // 0x47 'G'
	3146	{ 380, 8, 12, 12, 2, -11 }, // 0x48 'H'
	3147	{ 392, 2, 12, 5, 2, -11 }, // 0x49 'I'
	3148	{ 395, 7, 12, 9, 0, -11 }, // 0x4A 'J'
	3149	{ 406, 9, 12, 11, 2, -11 }, // 0x4B 'K'
	3150	{ 420, 6, 12, 9, 2, -11 }, // 0x4C 'L'
	3151	{ 429, 10, 12, 13, 2, -11 }, // 0x4D 'M'
	3152	{ 444, 8, 12, 12, 2, -11 }, // 0x4E 'N'
	3153	{ 456, 10, 12, 12, 1, -11 }, // 0x4F 'O'
	3154	{ 471, 8, 12, 11, 2, -11 }, // 0x50 'P'
	3155	{ 483, 11, 15, 12, 1, -11 }, // 0x51 'Q'
	3156	{ 504, 9, 12, 11, 2, -11 }, // 0x52 'R'
	3157	{ 518, 9, 12, 10, 0, -11 }, // 0x53 'S'
	3158	{ 532, 8, 12, 10, 1, -11 }, // 0x54 'T'
	3159	{ 544, 9, 12, 12, 1, -11 }, // 0x55 'U'
	3160	{ 558, 10, 12, 10, 0, -11 }, // 0x56 'V'
	3161	{ 573, 14, 12, 14, 0, -11 }, // 0x57 'W'
	3162	{ 594, 10, 12, 10, 0, -11 }, // 0x58 'X'
	3163	{ 609, 10, 12, 9, -1, -11 }, // 0x59 'Y'
	3164	{ 624, 8, 12, 10, 1, -11 }, // 0x5A 'Z'
	3165	{ 636, 3, 16, 6, 2, -12 }, // 0x5B '['
	3166	{ 642, 7, 16, 6, 0, -12 }, // 0x5C '\'
	3167	{ 656, 3, 16, 6, 1, -12 }, // 0x5D ']'
	3168	{ 662, 7, 7, 9, 1, -11 }, // 0x5E '^'
	3169	{ 669, 9, 2, 9, 0, 1 }, // 0x5F '_'
	3170	{ 672, 3, 3, 10, 3, -12 }, // 0x60 '`'
	3171	{ 674, 7, 9, 9, 1, -8 }, // 0x61 'a'
	3172	{ 682, 8, 12, 10, 1, -11 }, // 0x62 'b'
	3173	{ 694, 7, 9, 8, 1, -8 }, // 0x63 'c'
	3174	{ 702, 8, 12, 10, 1, -11 }, // 0x64 'd'
	3175	{ 714, 7, 9, 9, 2, -8 }, // 0x65 'e'
	3176	{ 722, 5, 13, 6, 1, -12 }, // 0x66 'f'
	3177	{ 731, 8, 13, 9, 1, -8 }, // 0x67 'g'
	3178	{ 744, 8, 12, 10, 1, -11 }, // 0x68 'h'
	3179	{ 756, 2, 12, 5, 1, -11 }, // 0x69 'i'
	3180	{ 759, 4, 16, 5, -1, -11 }, // 0x6A 'j'
	3181	{ 767, 8, 13, 9, 1, -12 }, // 0x6B 'k'
	3182	{ 780, 3, 12, 5, 1, -11 }, // 0x6C 'l'
	3183	{ 785, 13, 9, 15, 1, -8 }, // 0x6D 'm'
	3184	{ 800, 8, 9, 10, 1, -8 }, // 0x6E 'n'
	3185	{ 809, 8, 9, 10, 1, -8 }, // 0x6F 'o'
	3186	{ 818, 8, 12, 10, 1, -8 }, // 0x70 'p'
	3187	{ 830, 8, 11, 10, 1, -8 }, // 0x71 'q'
	3188	{ 841, 5, 9, 7, 1, -8 }, // 0x72 'r'
	3189	{ 847, 6, 9, 8, 1, -8 }, // 0x73 's'
	3190	{ 854, 6, 11, 6, 1, -10 }, // 0x74 't'
	3191	{ 863, 8, 9, 10, 1, -8 }, // 0x75 'u'
	3192	{ 872, 9, 9, 9, 0, -8 }, // 0x76 'v'
	3193	{ 883, 13, 9, 13, 0, -8 }, // 0x77 'w'
	3194	{ 898, 8, 9, 9, 0, -8 }, // 0x78 'x'
	3195	{ 907, 8, 13, 9, 1, -8 }, // 0x79 'y'
	3196	{ 920, 7, 9, 8, 1, -8 }, // 0x7A 'z'
	3197	{ 928, 5, 16, 6, 0, -12 }, // 0x7B '{'
	3198	{ 938, 1, 19, 5, 2, -13 }, // 0x7C '\|'
	3199	{ 941, 5, 16, 6, 1, -12 }, // 0x7D '}'
	3200	{ 951, 8, 4, 9, 1, -7 } }; // 0x7E '~'
	3201
	3202	const GFXfont sourcesans_semi9pt7b PROGMEM = {
	3203	(uint8_t *)sourcesans_semi9pt7bBitmaps,
	3204	(GFXglyph *)sourcesans_semi9pt7bGlyphs,
	3205	0x20, 0x7E, 24 };
	3206
	3207	// Approx. 1627 bytes
	3208	const uint8_t sourcesans_bold9pt7bBitmaps[] PROGMEM = {
	3209	0x00, 0xFF, 0xFF, 0xFF, 0x1F, 0xF0, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0x42,
	3210	0x24, 0x4B, 0xFF, 0xF2, 0x4D, 0xBF, 0xFF, 0x48, 0x91, 0x20, 0x18, 0x18,
	3211	0x7E, 0xFF, 0xE2, 0xE0, 0xF0, 0x7C, 0x1E, 0x0F, 0x07, 0xC7, 0xFE, 0x7C,
	3212	0x18, 0x18, 0x78, 0x21, 0xF8, 0xC3, 0x31, 0x06, 0x66, 0x0C, 0xC9, 0x99,
	3213	0xB7, 0x9E, 0xD9, 0x99, 0x33, 0x06, 0x66, 0x08, 0xCC, 0x31, 0xF8, 0x41,
	3214	0xE0, 0x0E, 0x01, 0xF0, 0x3B, 0x03, 0xB0, 0x3E, 0x01, 0xC7, 0x7C, 0x7F,
	3215	0x6E, 0xE7, 0xCE, 0x3E, 0x7F, 0xF3, 0xE3, 0xFF, 0xFE, 0x80, 0x19, 0x9C,
	3216	0xE6, 0x73, 0x9C, 0xE7, 0x38, 0xC7, 0x38, 0xC3, 0xC3, 0x1C, 0xE3, 0x1C,
	3217	0xE7, 0x39, 0xCE, 0x67, 0x39, 0x98, 0x10, 0x23, 0xFB, 0xE3, 0x8D, 0x80,
	3218	0x00, 0x18, 0x18, 0x18, 0xFF, 0xFF, 0x18, 0x18, 0x18, 0xDF, 0x97, 0xA0,
	3219	0xFF, 0xFF, 0x80, 0x00, 0x86, 0x31, 0x8C, 0x46, 0x31, 0x88, 0x46, 0x31,
	3220	0x88, 0x46, 0x31, 0x88, 0x00, 0x3C, 0x7E, 0x66, 0xE7, 0xE7, 0xE7, 0xE7,
	3221	0xE7, 0xE7, 0x66, 0x7E, 0x3C, 0x79, 0xE3, 0x8E, 0x38, 0xE3, 0x8E, 0x3B,
	3222	0xFF, 0xC0, 0x3C, 0x7F, 0x11, 0xC0, 0xE0, 0x70, 0x38, 0x38, 0x3C, 0x1C,
	3223	0x1C, 0x1F, 0xEF, 0xF0, 0x1E, 0x3F, 0x88, 0xE0, 0x70, 0x78, 0xF0, 0x7C,
	3224	0x07, 0x03, 0xA1, 0xFF, 0xC7, 0xC0, 0x0E, 0x1E, 0x3E, 0x2E, 0x6E, 0xCE,
	3225	0xFF, 0xFF, 0x0E, 0x0E, 0x0E, 0x3F, 0x1F, 0x9C, 0x0E, 0x07, 0xE3, 0xF8,
	3226	0x0E, 0x07, 0x43, 0xFF, 0x8F, 0x80, 0x1E, 0x7F, 0x72, 0xE0, 0xE0, 0xEE,
	3227	0xFF, 0xE7, 0xE7, 0xE7, 0x7E, 0x3C, 0xFF, 0xF0, 0x86, 0x18, 0xC3, 0x1C,
	3228	0x71, 0xC7, 0x00, 0x3C, 0x7E, 0xE7, 0xE7, 0xF7, 0x7C, 0x7E, 0xE7, 0xE7,
	3229	0xE7, 0x7E, 0x3C, 0x3C, 0x7E, 0xE6, 0xE7, 0xE7, 0xE7, 0x7F, 0x37, 0x07,
	3230	0x0E, 0xFE, 0x7C, 0xFF, 0x80, 0x3F, 0xE0, 0xFF, 0x80, 0x3F, 0xE5, 0xE8,
	3231	0x03, 0x0F, 0x7E, 0xF0, 0xF0, 0x7E, 0x0F, 0x03, 0xFF, 0xFF, 0x00, 0x00,
	3232	0xFF, 0xFF, 0x80, 0xF0, 0x7C, 0x0F, 0x0F, 0x7C, 0xF0, 0x80, 0x3C, 0xFF,
	3233	0x47, 0x07, 0x0E, 0x1C, 0x38, 0x38, 0x00, 0x38, 0x38, 0x38, 0x07, 0xE0,
	3234	0x7F, 0xC3, 0xC1, 0x9C, 0x02, 0x63, 0xE7, 0x9F, 0x9C, 0xEC, 0x73, 0x31,
	3235	0xCC, 0xCF, 0x3D, 0xEE, 0x77, 0x18, 0x00, 0x78, 0x00, 0xFF, 0x00, 0xFC,
	3236	0x00, 0x0E, 0x03, 0xE0, 0x6C, 0x0D, 0x83, 0xB8, 0x77, 0x0C, 0x63, 0xFE,
	3237	0x7F, 0xCE, 0x3B, 0x83, 0xF0, 0x70, 0xFE, 0x3F, 0xEE, 0x3B, 0x8E, 0xE3,
	3238	0xBF, 0xCF, 0xFB, 0x87, 0xE1, 0xF8, 0x7F, 0xFB, 0xFC, 0x1F, 0x0F, 0xE7,
	3239	0x11, 0xC0, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0xF0, 0x1C, 0x63, 0xFC, 0x7C,
	3240	0xFE, 0x3F, 0xCE, 0x3B, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE3, 0xF8,
	3241	0xEF, 0xF3, 0xF8, 0xFF, 0xFF, 0x87, 0x0E, 0x1F, 0xBF, 0x70, 0xE1, 0xC3,
	3242	0xFF, 0xF0, 0xFF, 0xFF, 0x87, 0x0E, 0x1F, 0xBF, 0x70, 0xE1, 0xC3, 0x87,
	3243	0x00, 0x1F, 0x0F, 0xF7, 0x13, 0x80, 0xE0, 0x38, 0xFE, 0x3F, 0x87, 0xF1,
	3244	0xDC, 0x73, 0xFC, 0x7E, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xFF, 0xFF,
	3245	0xFF, 0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0,
	3246	0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x47, 0xFE, 0x3C,
	3247	0xE3, 0xB8, 0xCE, 0x73, 0xB8, 0xFC, 0x3F, 0x0F, 0xE3, 0xDC, 0xE7, 0x38,
	3248	0xEE, 0x3B, 0x87, 0xE1, 0xC3, 0x87, 0x0E, 0x1C, 0x38, 0x70, 0xE1, 0xC3,
	3249	0xFF, 0xF0, 0xF0, 0xFF, 0x0F, 0xF0, 0xFF, 0x9F, 0xF9, 0xFF, 0x9F, 0xEF,
	3250	0x7E, 0xF7, 0xE6, 0x7E, 0x67, 0xE6, 0x7E, 0x07, 0xE1, 0xFC, 0x7F, 0x1F,
	3251	0xE7, 0xF9, 0xFB, 0x7E, 0xDF, 0x9F, 0xE7, 0xF8, 0xFE, 0x3F, 0x87, 0x1F,
	3252	0x07, 0xF1, 0xC7, 0x70, 0x7E, 0x0F, 0xC1, 0xF8, 0x3F, 0x07, 0xE0, 0xEE,
	3253	0x38, 0xFE, 0x0F, 0x80, 0xFF, 0x3F, 0xEE, 0x3F, 0x87, 0xE1, 0xF8, 0xFF,
	3254	0xFB, 0xFC, 0xE0, 0x38, 0x0E, 0x03, 0x80, 0x1F, 0x07, 0xF1, 0xC7, 0x70,
	3255	0x7E, 0x0F, 0xC1, 0xF8, 0x3F, 0x07, 0xE0, 0xEE, 0x38, 0xFE, 0x0F, 0x80,
	3256	0x70, 0x0F, 0xC0, 0x78, 0xFF, 0x3F, 0xEE, 0x3F, 0x87, 0xE1, 0xF8, 0xFF,
	3257	0xFB, 0xFC, 0xE7, 0x38, 0xEE, 0x3B, 0x87, 0x3E, 0x3F, 0xB8, 0xDC, 0x0F,
	3258	0x83, 0xF0, 0xFC, 0x0F, 0x03, 0xA1, 0xFF, 0xCF, 0xC0, 0xFF, 0xFC, 0xE1,
	3259	0xC3, 0x87, 0x0E, 0x1C, 0x38, 0x70, 0xE1, 0xC0, 0xE1, 0xF8, 0x7E, 0x1F,
	3260	0x87, 0xE1, 0xF8, 0x7E, 0x1F, 0x87, 0xE1, 0xDC, 0xE7, 0xF8, 0xFC, 0xE1,
	3261	0xF8, 0x77, 0x39, 0xCE, 0x73, 0x8C, 0xC3, 0x30, 0xFC, 0x1E, 0x07, 0x81,
	3262	0xE0, 0x70, 0xE3, 0x8F, 0xC7, 0x1F, 0x8E, 0x33, 0x1C, 0xE7, 0x7D, 0xCE,
	3263	0xDB, 0x9D, 0xB7, 0x3B, 0x6C, 0x34, 0xD8, 0x79, 0xF0, 0xF1, 0xE1, 0xE3,
	3264	0xC0, 0x71, 0xDC, 0xE3, 0x38, 0xEC, 0x1F, 0x07, 0x81, 0xE0, 0x7C, 0x3F,
	3265	0x0C, 0xE7, 0x3B, 0x87, 0x60, 0xCE, 0x38, 0xC6, 0x1D, 0xC1, 0xB0, 0x3E,
	3266	0x07, 0xC0, 0x70, 0x0E, 0x01, 0xC0, 0x38, 0x07, 0x00, 0xFF, 0xFF, 0x06,
	3267	0x0E, 0x1C, 0x1C, 0x38, 0x30, 0x70, 0xE0, 0xFF, 0xFF, 0xFF, 0xCC, 0xCC,
	3268	0xCC, 0xCC, 0xCC, 0xCC, 0xFF, 0x08, 0x8C, 0xCC, 0x44, 0x46, 0x66, 0x62,
	3269	0x22, 0x33, 0x31, 0x20, 0xFF, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0xFF,
	3270	0x38, 0x38, 0x3C, 0x6C, 0x66, 0x66, 0xC6, 0xFF, 0xFF, 0xC0, 0x63, 0x3C,
	3271	0x7E, 0x47, 0x1F, 0x7F, 0xE7, 0xE7, 0xFF, 0x7F, 0xE0, 0x70, 0x38, 0x1C,
	3272	0x0E, 0xE7, 0xFB, 0x8F, 0xC7, 0xE3, 0xF1, 0xF9, 0xFF, 0xED, 0xE0, 0x1E,
	3273	0x7E, 0xF0, 0xE0, 0xE0, 0xE0, 0xF2, 0x7E, 0x3E, 0x07, 0x07, 0x07, 0x07,
	3274	0x3F, 0x7F, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0x7F, 0x3F, 0x3C, 0x7E, 0xC7,
	3275	0xFF, 0xFF, 0xC0, 0xE0, 0x7E, 0x3E, 0x1D, 0xF7, 0x1C, 0xFB, 0xE7, 0x1C,
	3276	0x71, 0xC7, 0x1C, 0x70, 0x3F, 0xFF, 0xF9, 0xDC, 0xE7, 0xF3, 0xE1, 0x80,
	3277	0xFE, 0x7F, 0xF1, 0xF8, 0xFF, 0xE7, 0xE0, 0xE0, 0x70, 0x38, 0x1C, 0x0E,
	3278	0xF7, 0xFF, 0x8F, 0xC7, 0xE3, 0xF1, 0xF8, 0xFC, 0x7E, 0x38, 0xFC, 0x7F,
	3279	0xFF, 0xFF, 0xF0, 0x39, 0xC0, 0x73, 0x9C, 0xE7, 0x39, 0xCE, 0x73, 0x9F,
	3280	0xFE, 0xE0, 0x70, 0x38, 0x1C, 0x0E, 0x77, 0x3B, 0xB9, 0xF8, 0xFC, 0x7F,
	3281	0x39, 0x9C, 0xEE, 0x38, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEF, 0x70, 0xFE,
	3282	0x7B, 0xFF, 0xFE, 0x71, 0xF9, 0xC7, 0xE7, 0x1F, 0x9C, 0x7E, 0x71, 0xF9,
	3283	0xC7, 0xE7, 0x1C, 0xEF, 0x7F, 0xF8, 0xFC, 0x7E, 0x3F, 0x1F, 0x8F, 0xC7,
	3284	0xE3, 0x80, 0x3E, 0x3F, 0xB8, 0xFC, 0x7E, 0x3F, 0x1F, 0x8E, 0xFE, 0x3E,
	3285	0x00, 0xFE, 0x7F, 0xB8, 0xFC, 0x7E, 0x3F, 0x1F, 0x9F, 0xFE, 0xFE, 0x70,
	3286	0x38, 0x1C, 0x00, 0x3B, 0x7F, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0x7F, 0x3F,
	3287	0x07, 0x07, 0x07, 0xEF, 0xFF, 0x38, 0xE3, 0x8E, 0x38, 0xE0, 0x7D, 0xFF,
	3288	0x97, 0x87, 0xC3, 0xD3, 0xFF, 0x7C, 0x71, 0xCF, 0xBE, 0x71, 0xC7, 0x1C,
	3289	0x71, 0xF3, 0xC0, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0xE7, 0xFF, 0x7F,
	3290	0xC3, 0xF1, 0xB9, 0xCC, 0xE6, 0x63, 0xB0, 0xF8, 0x78, 0x3C, 0x00, 0xE3,
	3291	0x1F, 0x8E, 0x77, 0x79, 0x9D, 0xEE, 0x77, 0xB8, 0xD3, 0xC3, 0xCF, 0x0F,
	3292	0x3C, 0x3C, 0xF0, 0x73, 0xBB, 0x8F, 0x87, 0xC1, 0xC1, 0xF0, 0xD8, 0xEE,
	3293	0x63, 0x80, 0xE3, 0xB1, 0xDC, 0xC6, 0x63, 0x71, 0xF0, 0x78, 0x38, 0x0C,
	3294	0x0E, 0x1E, 0x0E, 0x00, 0xFF, 0xFC, 0x71, 0xC3, 0x8E, 0x38, 0x7F, 0xFE,
	3295	0x3B, 0xDC, 0xE3, 0x18, 0xDE, 0xF1, 0x8C, 0xE7, 0x39, 0xE7, 0xFF, 0xFF,
	3296	0xE0, 0xE7, 0x9C, 0xE6, 0x31, 0x8F, 0x7B, 0x18, 0xC7, 0x3B, 0xDC, 0x72,
	3297	0xFF, 0x8E };
	3298
	3299	const GFXglyph sourcesans_bold9pt7bGlyphs[] PROGMEM = {
	3300	{ 0, 1, 1, 4, 0, 0 }, // 0x20 ' '
	3301	{ 1, 3, 12, 6, 1, -11 }, // 0x21 '!'
	3302	{ 6, 8, 6, 10, 1, -11 }, // 0x22 '"'
	3303	{ 12, 7, 11, 10, 1, -10 }, // 0x23 '#'
	3304	{ 22, 8, 16, 9, 1, -13 }, // 0x24 '$'
	3305	{ 38, 15, 12, 15, 0, -11 }, // 0x25 '%'
	3306	{ 61, 12, 12, 12, 0, -11 }, // 0x26 '&'
	3307	{ 79, 3, 6, 5, 1, -11 }, // 0x27 '''
	3308	{ 82, 5, 16, 6, 1, -12 }, // 0x28 '('
	3309	{ 92, 5, 16, 6, 1, -12 }, // 0x29 ')'
	3310	{ 102, 7, 7, 8, 0, -12 }, // 0x2A '*'
	3311	{ 109, 8, 8, 9, 1, -9 }, // 0x2B '+'
	3312	{ 117, 3, 7, 5, 1, -2 }, // 0x2C ','
	3313	{ 120, 4, 2, 6, 1, -5 }, // 0x2D '-'
	3314	{ 121, 3, 3, 5, 1, -2 }, // 0x2E '.'
	3315	{ 123, 5, 22, 6, 0, -15 }, // 0x2F '/'
	3316	{ 137, 8, 12, 10, 1, -11 }, // 0x30 '0'
	3317	{ 149, 6, 11, 9, 2, -10 }, // 0x31 '1'
	3318	{ 158, 9, 12, 9, 1, -11 }, // 0x32 '2'
	3319	{ 172, 9, 12, 9, 0, -11 }, // 0x33 '3'
	3320	{ 186, 8, 11, 9, 1, -10 }, // 0x34 '4'
	3321	{ 197, 9, 11, 9, 0, -10 }, // 0x35 '5'
	3322	{ 210, 8, 12, 10, 1, -11 }, // 0x36 '6'
	3323	{ 222, 6, 11, 9, 2, -10 }, // 0x37 '7'
	3324	{ 231, 8, 12, 10, 1, -11 }, // 0x38 '8'
	3325	{ 243, 8, 12, 10, 1, -11 }, // 0x39 '9'
	3326	{ 255, 3, 9, 5, 1, -8 }, // 0x3A ':'
	3327	{ 259, 3, 13, 5, 1, -8 }, // 0x3B ';'
	3328	{ 264, 8, 8, 10, 1, -9 }, // 0x3C '<'
	3329	{ 272, 8, 6, 9, 1, -8 }, // 0x3D '='
	3330	{ 278, 8, 8, 10, 1, -9 }, // 0x3E '>'
	3331	{ 286, 8, 12, 8, 0, -11 }, // 0x3F '?'
	3332	{ 298, 14, 15, 16, 1, -11 }, // 0x40 '@'
	3333	{ 325, 11, 12, 10, 0, -11 }, // 0x41 'A'
	3334	{ 342, 10, 12, 11, 1, -11 }, // 0x42 'B'
	3335	{ 357, 10, 12, 10, 1, -11 }, // 0x43 'C'
	3336	{ 372, 10, 12, 11, 1, -11 }, // 0x44 'D'
	3337	{ 387, 7, 12, 10, 1, -11 }, // 0x45 'E'
	3338	{ 398, 7, 12, 9, 1, -11 }, // 0x46 'F'
	3339	{ 409, 10, 12, 11, 1, -11 }, // 0x47 'G'
	3340	{ 424, 10, 12, 12, 1, -11 }, // 0x48 'H'
	3341	{ 439, 3, 12, 5, 1, -11 }, // 0x49 'I'
	3342	{ 444, 8, 12, 9, 0, -11 }, // 0x4A 'J'
	3343	{ 456, 10, 12, 11, 1, -11 }, // 0x4B 'K'
	3344	{ 471, 7, 12, 9, 1, -11 }, // 0x4C 'L'
	3345	{ 482, 12, 12, 14, 1, -11 }, // 0x4D 'M'
	3346	{ 500, 10, 12, 12, 1, -11 }, // 0x4E 'N'
	3347	{ 515, 11, 12, 12, 1, -11 }, // 0x4F 'O'
	3348	{ 532, 10, 12, 11, 1, -11 }, // 0x50 'P'
	3349	{ 547, 11, 15, 12, 1, -11 }, // 0x51 'Q'
	3350	{ 568, 10, 12, 11, 1, -11 }, // 0x52 'R'
	3351	{ 583, 9, 12, 10, 1, -11 }, // 0x53 'S'
	3352	{ 597, 7, 12, 10, 2, -11 }, // 0x54 'T'
	3353	{ 608, 10, 12, 12, 1, -11 }, // 0x55 'U'
	3354	{ 623, 10, 12, 10, 0, -11 }, // 0x56 'V'
	3355	{ 638, 15, 12, 15, 0, -11 }, // 0x57 'W'
	3356	{ 661, 10, 12, 10, 0, -11 }, // 0x58 'X'
	3357	{ 676, 11, 12, 9, -1, -11 }, // 0x59 'Y'
	3358	{ 693, 8, 12, 10, 1, -11 }, // 0x5A 'Z'
	3359	{ 705, 4, 16, 6, 2, -12 }, // 0x5B '['
	3360	{ 713, 4, 22, 6, 1, -15 }, // 0x5C '\'
	3361	{ 724, 4, 16, 6, 1, -12 }, // 0x5D ']'
	3362	{ 732, 8, 7, 10, 1, -11 }, // 0x5E '^'
	3363	{ 739, 9, 2, 9, 0, 2 }, // 0x5F '_'
	3364	{ 742, 4, 2, 10, 2, -11 }, // 0x60 '`'
	3365	{ 743, 8, 9, 10, 1, -8 }, // 0x61 'a'
	3366	{ 752, 9, 13, 10, 1, -12 }, // 0x62 'b'
	3367	{ 767, 8, 9, 8, 1, -8 }, // 0x63 'c'
	3368	{ 776, 8, 13, 10, 1, -12 }, // 0x64 'd'
	3369	{ 789, 8, 9, 9, 1, -8 }, // 0x65 'e'
	3370	{ 798, 6, 13, 6, 1, -12 }, // 0x66 'f'
	3371	{ 808, 9, 13, 10, 1, -8 }, // 0x67 'g'
	3372	{ 823, 9, 13, 10, 1, -12 }, // 0x68 'h'
	3373	{ 838, 3, 12, 5, 1, -11 }, // 0x69 'i'
	3374	{ 843, 5, 16, 5, -1, -11 }, // 0x6A 'j'
	3375	{ 853, 9, 13, 10, 1, -12 }, // 0x6B 'k'
	3376	{ 868, 4, 13, 5, 1, -12 }, // 0x6C 'l'
	3377	{ 875, 14, 9, 15, 1, -8 }, // 0x6D 'm'
	3378	{ 891, 9, 9, 10, 1, -8 }, // 0x6E 'n'
	3379	{ 902, 9, 9, 10, 1, -8 }, // 0x6F 'o'
	3380	{ 913, 9, 12, 10, 1, -8 }, // 0x70 'p'
	3381	{ 927, 8, 12, 10, 1, -8 }, // 0x71 'q'
	3382	{ 939, 6, 9, 7, 1, -8 }, // 0x72 'r'
	3383	{ 946, 7, 9, 8, 1, -8 }, // 0x73 's'
	3384	{ 954, 6, 11, 7, 1, -10 }, // 0x74 't'
	3385	{ 963, 8, 9, 10, 1, -8 }, // 0x75 'u'
	3386	{ 972, 9, 9, 9, 1, -8 }, // 0x76 'v'
	3387	{ 983, 14, 9, 14, 0, -8 }, // 0x77 'w'
	3388	{ 999, 9, 9, 9, 0, -8 }, // 0x78 'x'
	3389	{ 1010, 9, 12, 9, 0, -8 }, // 0x79 'y'
	3390	{ 1024, 7, 9, 8, 1, -8 }, // 0x7A 'z'
	3391	{ 1032, 5, 16, 6, 1, -12 }, // 0x7B '{'
	3392	{ 1042, 1, 19, 5, 2, -13 }, // 0x7C '\|'
	3393	{ 1045, 5, 16, 6, 1, -12 }, // 0x7D '}'
	3394	{ 1055, 8, 3, 9, 1, -6 } }; // 0x7E '~'
	3395
	3396	const GFXfont sourcesans_bold9pt7b PROGMEM = {
	3397	(uint8_t *)sourcesans_bold9pt7bBitmaps,
	3398	(GFXglyph *)sourcesans_bold9pt7bGlyphs,
	3399	0x20, 0x7E, 24 };
	3400
	3401	const uint8_t DINAlternateBold9pt7bBitmaps[] PROGMEM = {
	3402	0x00, 0xFF, 0xFF, 0xCF, 0xFF, 0xF0, 0x32, 0x32, 0x36, 0xFF, 0x26, 0x24,
	3403	0x64, 0xFF, 0x64, 0x4C, 0x4C, 0x4C, 0x08, 0x08, 0x3E, 0x7E, 0x68, 0x68,
	3404	0x68, 0x3C, 0x1E, 0x0B, 0x0B, 0x4B, 0xFE, 0x3C, 0x08, 0x08, 0xE3, 0x4A,
	3405	0x97, 0x40, 0x82, 0x04, 0x17, 0x2A, 0x95, 0x2C, 0x70, 0x3C, 0x0F, 0xC1,
	3406	0x98, 0x33, 0x03, 0xC0, 0x70, 0x13, 0x06, 0x36, 0xC3, 0x9C, 0x71, 0xFF,
	3407	0x1E, 0x60, 0xFC, 0x22, 0x64, 0xCC, 0xCC, 0xCC, 0x46, 0x22, 0x84, 0x62,
	3408	0x33, 0x33, 0x33, 0x26, 0x48, 0x27, 0xC9, 0xF2, 0x00, 0x18, 0x0C, 0x06,
	3409	0x03, 0x0F, 0xFF, 0xFC, 0x60, 0x30, 0x18, 0x00, 0xF8, 0xFF, 0xC0, 0xF0,
	3410	0x0C, 0x21, 0x86, 0x10, 0xC2, 0x08, 0x61, 0x04, 0x30, 0x39, 0xFF, 0x1E,
	3411	0x3C, 0x78, 0xF1, 0xE3, 0xC7, 0x8F, 0xF9, 0xC0, 0x7F, 0xB3, 0x33, 0x33,
	3412	0x33, 0x33, 0x38, 0xFB, 0x1E, 0x30, 0x61, 0x86, 0x18, 0x70, 0xC3, 0xFF,
	3413	0xF0, 0x79, 0xFF, 0x18, 0x33, 0xC7, 0x83, 0x83, 0x07, 0x9F, 0xF3, 0xC0,
	3414	0x0C, 0x18, 0x18, 0x30, 0x30, 0x66, 0x66, 0xC6, 0xFF, 0xFF, 0x06, 0x06,
	3415	0xFF, 0xFF, 0x07, 0xEF, 0xD8, 0xC1, 0x83, 0x07, 0x8F, 0xF1, 0xC0, 0x18,
	3416	0x30, 0xC1, 0x86, 0x0F, 0x3F, 0x63, 0xC7, 0x8F, 0x3F, 0xE3, 0x00, 0xFF,
	3417	0xFF, 0x1E, 0x60, 0xC1, 0x86, 0x0C, 0x30, 0x60, 0xC3, 0x00, 0x7D, 0xFF,
	3418	0x1E, 0x37, 0xCF, 0xBB, 0xE3, 0xC7, 0xDD, 0xF1, 0xC0, 0x7D, 0xCF, 0x1E,
	3419	0x3C, 0x7F, 0xDF, 0x06, 0x18, 0x30, 0xC1, 0x80, 0xF0, 0xF0, 0xF0, 0xF8,
	3420	0x00, 0x81, 0xC7, 0x8E, 0x0C, 0x03, 0x80, 0x70, 0x0F, 0x00, 0x80, 0xFF,
	3421	0xFF, 0xC0, 0x1F, 0xFF, 0xF8, 0x80, 0x70, 0x0F, 0x00, 0xE0, 0x18, 0x38,
	3422	0x71, 0xE0, 0x80, 0x00, 0x7B, 0xFC, 0xF3, 0x0C, 0x63, 0x8C, 0x30, 0x03,
	3423	0x0C, 0x0F, 0xC1, 0xFF, 0x1F, 0xDD, 0xF1, 0xFF, 0x89, 0xF8, 0x4F, 0xC6,
	3424	0x7E, 0x26, 0x7F, 0xC3, 0x83, 0x8F, 0xF8, 0x1F, 0x00, 0x0C, 0x01, 0xC0,
	3425	0x38, 0x0D, 0x81, 0xB0, 0x62, 0x0C, 0x61, 0xFC, 0x7F, 0x8C, 0x19, 0x83,
	3426	0x60, 0x30, 0xFE, 0x7F, 0xF0, 0x78, 0x3C, 0x3F, 0xFB, 0xFD, 0x83, 0xC1,
	3427	0xE0, 0xFF, 0xDF, 0xC0, 0x3E, 0x3F, 0xB8, 0xF8, 0x3C, 0x06, 0x03, 0x01,
	3428	0x80, 0xC1, 0xF1, 0xDF, 0xC7, 0xC0, 0xFE, 0x7F, 0xB0, 0xF8, 0x3C, 0x1E,
	3429	0x0F, 0x07, 0x83, 0xC1, 0xE1, 0xFF, 0xDF, 0xC0, 0xFF, 0xFF, 0xC0, 0xC0,
	3430	0xC0, 0xFE, 0xFE, 0xC0, 0xC0, 0xC0, 0xFF, 0xFF, 0xFF, 0xFF, 0xC0, 0xC0,
	3431	0xC0, 0xFE, 0xFE, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0x3E, 0x3F, 0xB8, 0xF8,
	3432	0x0C, 0x06, 0x3F, 0x1F, 0x83, 0xC1, 0xF1, 0xDF, 0xC7, 0xC0, 0xC1, 0xE0,
	3433	0xF0, 0x78, 0x3C, 0x1F, 0xFF, 0xFF, 0x83, 0xC1, 0xE0, 0xF0, 0x78, 0x30,
	3434	0xFF, 0xFF, 0xFF, 0x06, 0x0C, 0x18, 0x30, 0x60, 0xC1, 0x83, 0x06, 0x1F,
	3435	0xF3, 0xC0, 0xC1, 0xB0, 0xCC, 0x63, 0x30, 0xDC, 0x37, 0x0F, 0xE3, 0x98,
	3436	0xC3, 0x30, 0xCC, 0x1B, 0x07, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0,
	3437	0xC0, 0xC0, 0xC0, 0xFF, 0xFF, 0xC0, 0x7C, 0x1F, 0x83, 0xF0, 0xFF, 0x1F,
	3438	0xE3, 0xF6, 0xDE, 0xDB, 0xCE, 0x79, 0xCF, 0x01, 0xE0, 0x30, 0xC1, 0xF0,
	3439	0xF8, 0x7E, 0x3D, 0x9E, 0xCF, 0x37, 0x9B, 0xC7, 0xE1, 0xF0, 0xF8, 0x30,
	3440	0x3E, 0x3F, 0xB8, 0xF8, 0x3C, 0x1E, 0x0F, 0x07, 0x83, 0xC1, 0xF1, 0xDF,
	3441	0xC7, 0xC0, 0xFE, 0x7F, 0xB0, 0xF8, 0x3C, 0x3F, 0xFB, 0xF9, 0x80, 0xC0,
	3442	0x60, 0x30, 0x18, 0x00, 0x3E, 0x1F, 0xCE, 0x3B, 0x06, 0xC1, 0xB0, 0x6C,
	3443	0x1B, 0x16, 0xCF, 0xB8, 0xE7, 0xFC, 0xFB, 0xFE, 0x3F, 0xCC, 0x1B, 0x06,
	3444	0xC3, 0xBF, 0xCF, 0xE3, 0x18, 0xC6, 0x30, 0xCC, 0x3B, 0x06, 0x1F, 0x0F,
	3445	0xF7, 0x09, 0x80, 0x60, 0x0F, 0x80, 0xF8, 0x03, 0x00, 0xD8, 0x77, 0xF8,
	3446	0x7C, 0xFF, 0xFF, 0xC6, 0x03, 0x01, 0x80, 0xC0, 0x60, 0x30, 0x18, 0x0C,
	3447	0x06, 0x03, 0x00, 0xC1, 0xE0, 0xF0, 0x78, 0x3C, 0x1E, 0x0F, 0x07, 0x83,
	3448	0xC1, 0xF1, 0xDF, 0xC7, 0xC0, 0xC0, 0xD0, 0x66, 0x19, 0x86, 0x23, 0x0C,
	3449	0xC3, 0x30, 0x58, 0x1E, 0x07, 0x80, 0xC0, 0x30, 0xC3, 0x0D, 0x8C, 0x36,
	3450	0x38, 0xD8, 0xE3, 0x66, 0x98, 0x9B, 0x63, 0x4D, 0x8F, 0x36, 0x3C, 0x70,
	3451	0x71, 0xC1, 0x87, 0x06, 0x08, 0xE1, 0x98, 0xC3, 0x30, 0xD8, 0x1E, 0x07,
	3452	0x01, 0xC0, 0x78, 0x36, 0x1C, 0xC6, 0x1B, 0x06, 0xE1, 0xD8, 0x63, 0x30,
	3453	0xCC, 0x1E, 0x07, 0x80, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0x30, 0xFF,
	3454	0xFF, 0x06, 0x06, 0x0C, 0x18, 0x18, 0x30, 0x60, 0xE0, 0xFF, 0xFF, 0xFC,
	3455	0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCF, 0xC1, 0x04, 0x18, 0x20, 0x83, 0x04,
	3456	0x18, 0x60, 0x83, 0xF3, 0x33, 0x33, 0x33, 0x33, 0x33, 0x3F, 0x08, 0x0C,
	3457	0x05, 0x06, 0x82, 0x63, 0x11, 0x0D, 0x82, 0xFF, 0x80, 0xE6, 0x30, 0x3C,
	3458	0xFC, 0x1B, 0xFF, 0xF8, 0xF1, 0xFF, 0x7E, 0xC1, 0x83, 0x06, 0xEF, 0xF8,
	3459	0xF1, 0xC3, 0xC7, 0x8F, 0xFE, 0xE0, 0x3C, 0xFF, 0x8E, 0x0C, 0x18, 0x38,
	3460	0x3F, 0x3C, 0x06, 0x0C, 0x1B, 0xBF, 0xF8, 0xF1, 0xE3, 0xC7, 0x8F, 0xFB,
	3461	0xB0, 0x38, 0xFB, 0x1F, 0xFF, 0xF8, 0x39, 0x3F, 0x3C, 0x3B, 0xD9, 0xFF,
	3462	0xB1, 0x8C, 0x63, 0x18, 0xC0, 0x77, 0xFF, 0x1E, 0x3C, 0x78, 0xF1, 0xFF,
	3463	0x76, 0x0D, 0x3F, 0xE7, 0x80, 0xC1, 0x83, 0x06, 0xEF, 0xF8, 0xF1, 0xE3,
	3464	0xC7, 0x8F, 0x1E, 0x30, 0xF3, 0xFF, 0xFF, 0x33, 0x03, 0x33, 0x33, 0x33,
	3465	0x33, 0x33, 0xFE, 0xC0, 0xC0, 0xC0, 0xC6, 0xCC, 0xD8, 0xD8, 0xF8, 0xEC,
	3466	0xCC, 0xC6, 0xC3, 0xDB, 0x6D, 0xB6, 0xDB, 0xB0, 0xDD, 0xEF, 0xFF, 0xC6,
	3467	0x3C, 0x63, 0xC6, 0x3C, 0x63, 0xC6, 0x3C, 0x63, 0xC6, 0x30, 0xDD, 0xFF,
	3468	0x1E, 0x3C, 0x78, 0xF1, 0xE3, 0xC6, 0x38, 0xFB, 0x1E, 0x3C, 0x78, 0xF1,
	3469	0xBE, 0x38, 0xDD, 0xFF, 0x1E, 0x38, 0x78, 0xF1, 0xFF, 0xDD, 0x83, 0x06,
	3470	0x0C, 0x00, 0x77, 0xFF, 0x1E, 0x3C, 0x78, 0xF1, 0xFF, 0x76, 0x0C, 0x18,
	3471	0x30, 0x60, 0xDF, 0xFC, 0x30, 0xC3, 0x0C, 0x30, 0xC0, 0x3E, 0x7F, 0x62,
	3472	0x60, 0x3E, 0x03, 0x43, 0x7F, 0x3E, 0x66, 0x6F, 0xF6, 0x66, 0x66, 0x73,
	3473	0xC7, 0x8F, 0x1E, 0x3C, 0x78, 0xF1, 0xFF, 0x76, 0xC3, 0xC2, 0x66, 0x66,
	3474	0x24, 0x3C, 0x3C, 0x18, 0x18, 0xC2, 0x1A, 0x31, 0x99, 0xCC, 0xCA, 0x66,
	3475	0xD2, 0x16, 0xF0, 0xE7, 0x87, 0x18, 0x18, 0xC0, 0x63, 0x66, 0x3E, 0x1C,
	3476	0x18, 0x3C, 0x36, 0x66, 0xE3, 0xC3, 0xC2, 0x66, 0x66, 0x24, 0x3C, 0x3C,
	3477	0x18, 0x18, 0x18, 0x30, 0x70, 0x60, 0xFF, 0xF0, 0x86, 0x31, 0x84, 0x3F,
	3478	0xFC, 0x1C, 0xC3, 0x0C, 0x30, 0xCC, 0x1C, 0x30, 0xC3, 0x0C, 0x30, 0x70,
	3479	0xFF, 0xFF, 0xFF, 0xE1, 0x8C, 0x63, 0x18, 0x63, 0x31, 0x8C, 0x63, 0x70,
	3480	0x71, 0xFF, 0x8E };
	3481
	3482	const GFXglyph DINAlternateBold9pt7bGlyphs[] PROGMEM = {
	3483	{ 0, 1, 1, 4, 0, 0 }, // 0x20 ' '
	3484	{ 1, 2, 12, 4, 1, -11 }, // 0x21 '!'
	3485	{ 4, 4, 3, 6, 1, -11 }, // 0x22 '"'
	3486	{ 6, 8, 12, 10, 1, -11 }, // 0x23 '#'
	3487	{ 18, 8, 16, 9, 0, -13 }, // 0x24 '$'
	3488	{ 34, 7, 12, 9, 1, -11 }, // 0x25 '%'
	3489	{ 45, 11, 12, 12, 1, -11 }, // 0x26 '&'
	3490	{ 62, 2, 3, 4, 1, -11 }, // 0x27 '''
	3491	{ 63, 4, 14, 5, 1, -11 }, // 0x28 '('
	3492	{ 70, 4, 14, 5, 0, -11 }, // 0x29 ')'
	3493	{ 77, 5, 5, 7, 1, -11 }, // 0x2A '*'
	3494	{ 81, 9, 9, 11, 1, -8 }, // 0x2B '+'
	3495	{ 92, 2, 3, 4, 1, -1 }, // 0x2C ','
	3496	{ 93, 5, 2, 7, 1, -5 }, // 0x2D '-'
	3497	{ 95, 2, 2, 4, 1, -1 }, // 0x2E '.'
	3498	{ 96, 6, 12, 6, 0, -11 }, // 0x2F '/'
	3499	{ 105, 7, 12, 8, 1, -11 }, // 0x30 '0'
	3500	{ 116, 4, 12, 8, 2, -11 }, // 0x31 '1'
	3501	{ 122, 7, 12, 8, 1, -11 }, // 0x32 '2'
	3502	{ 133, 7, 12, 8, 1, -11 }, // 0x33 '3'
	3503	{ 144, 8, 12, 8, 1, -11 }, // 0x34 '4'
	3504	{ 156, 7, 12, 8, 1, -11 }, // 0x35 '5'
	3505	{ 167, 7, 13, 8, 1, -11 }, // 0x36 '6'
	3506	{ 179, 7, 12, 8, 1, -11 }, // 0x37 '7'
	3507	{ 190, 7, 12, 8, 1, -11 }, // 0x38 '8'
	3508	{ 201, 7, 12, 8, 1, -11 }, // 0x39 '9'
	3509	{ 212, 2, 6, 4, 1, -5 }, // 0x3A ':'
	3510	{ 214, 2, 7, 4, 1, -5 }, // 0x3B ';'
	3511	{ 216, 9, 9, 11, 1, -8 }, // 0x3C '<'
	3512	{ 227, 9, 5, 11, 1, -6 }, // 0x3D '='
	3513	{ 233, 9, 9, 11, 1, -8 }, // 0x3E '>'
	3514	{ 244, 6, 12, 8, 1, -11 }, // 0x3F '?'
	3515	{ 253, 13, 12, 15, 1, -11 }, // 0x40 '@'
	3516	{ 273, 11, 12, 11, 0, -11 }, // 0x41 'A'
	3517	{ 290, 9, 12, 11, 1, -11 }, // 0x42 'B'
	3518	{ 304, 9, 12, 10, 1, -11 }, // 0x43 'C'
	3519	{ 318, 9, 12, 11, 1, -11 }, // 0x44 'D'
	3520	{ 332, 8, 12, 10, 1, -11 }, // 0x45 'E'
	3521	{ 344, 8, 12, 10, 1, -11 }, // 0x46 'F'
	3522	{ 356, 9, 12, 11, 1, -11 }, // 0x47 'G'
	3523	{ 370, 9, 12, 11, 1, -11 }, // 0x48 'H'
	3524	{ 384, 2, 12, 4, 1, -11 }, // 0x49 'I'
	3525	{ 387, 7, 12, 8, 0, -11 }, // 0x4A 'J'
	3526	{ 398, 10, 12, 11, 1, -11 }, // 0x4B 'K'
	3527	{ 413, 8, 12, 10, 1, -11 }, // 0x4C 'L'
	3528	{ 425, 11, 12, 13, 1, -11 }, // 0x4D 'M'
	3529	{ 442, 9, 12, 11, 1, -11 }, // 0x4E 'N'
	3530	{ 456, 9, 12, 11, 1, -11 }, // 0x4F 'O'
	3531	{ 470, 9, 12, 11, 1, -11 }, // 0x50 'P'
	3532	{ 484, 10, 12, 11, 1, -11 }, // 0x51 'Q'
	3533	{ 499, 10, 12, 11, 1, -11 }, // 0x52 'R'
	3534	{ 514, 10, 12, 11, 0, -11 }, // 0x53 'S'
	3535	{ 529, 9, 12, 11, 1, -11 }, // 0x54 'T'
	3536	{ 543, 9, 12, 11, 1, -11 }, // 0x55 'U'
	3537	{ 557, 10, 12, 10, 0, -11 }, // 0x56 'V'
	3538	{ 572, 14, 12, 15, 0, -11 }, // 0x57 'W'
	3539	{ 593, 10, 12, 9, 0, -11 }, // 0x58 'X'
	3540	{ 608, 10, 12, 10, 0, -11 }, // 0x59 'Y'
	3541	{ 623, 8, 12, 10, 1, -11 }, // 0x5A 'Z'
	3542	{ 635, 4, 14, 5, 1, -11 }, // 0x5B '['
	3543	{ 642, 6, 12, 6, 0, -11 }, // 0x5C '\'
	3544	{ 651, 4, 14, 5, 0, -11 }, // 0x5D ']'
	3545	{ 658, 9, 8, 11, 1, -12 }, // 0x5E '^'
	3546	{ 667, 9, 1, 9, 0, 2 }, // 0x5F '_'
	3547	{ 669, 4, 3, 4, -1, -12 }, // 0x60 '`'
	3548	{ 671, 7, 9, 9, 1, -8 }, // 0x61 'a'
	3549	{ 679, 7, 12, 9, 1, -11 }, // 0x62 'b'
	3550	{ 690, 7, 9, 9, 1, -8 }, // 0x63 'c'
	3551	{ 698, 7, 12, 9, 1, -11 }, // 0x64 'd'
	3552	{ 709, 7, 9, 9, 1, -8 }, // 0x65 'e'
	3553	{ 717, 5, 12, 6, 1, -11 }, // 0x66 'f'
	3554	{ 725, 7, 13, 9, 1, -8 }, // 0x67 'g'
	3555	{ 737, 7, 12, 9, 1, -11 }, // 0x68 'h'
	3556	{ 748, 2, 12, 4, 1, -11 }, // 0x69 'i'
	3557	{ 751, 4, 16, 4, -1, -11 }, // 0x6A 'j'
	3558	{ 759, 8, 12, 9, 1, -11 }, // 0x6B 'k'
	3559	{ 771, 3, 12, 5, 1, -11 }, // 0x6C 'l'
	3560	{ 776, 12, 9, 14, 1, -8 }, // 0x6D 'm'
	3561	{ 790, 7, 9, 9, 1, -8 }, // 0x6E 'n'
	3562	{ 798, 7, 9, 9, 1, -8 }, // 0x6F 'o'
	3563	{ 806, 7, 13, 9, 1, -8 }, // 0x70 'p'
	3564	{ 818, 7, 13, 9, 1, -8 }, // 0x71 'q'
	3565	{ 830, 6, 9, 7, 1, -8 }, // 0x72 'r'
	3566	{ 837, 8, 9, 9, 0, -8 }, // 0x73 's'
	3567	{ 846, 4, 12, 6, 1, -11 }, // 0x74 't'
	3568	{ 852, 7, 9, 9, 1, -8 }, // 0x75 'u'
	3569	{ 860, 8, 9, 8, 0, -8 }, // 0x76 'v'
	3570	{ 869, 13, 9, 13, 0, -8 }, // 0x77 'w'
	3571	{ 884, 8, 9, 8, 0, -8 }, // 0x78 'x'
	3572	{ 893, 8, 13, 8, 0, -8 }, // 0x79 'y'
	3573	{ 906, 6, 9, 8, 1, -8 }, // 0x7A 'z'
	3574	{ 913, 6, 14, 6, 0, -11 }, // 0x7B '{'
	3575	{ 924, 2, 12, 4, 1, -11 }, // 0x7C '\|'
	3576	{ 927, 5, 14, 6, 0, -11 }, // 0x7D '}'
	3577	{ 936, 8, 3, 11, 1, -5 } }; // 0x7E '~'
	3578
	3579	const GFXfont DINAlternateBold9pt7b PROGMEM = {
	3580	(uint8_t *)DINAlternateBold9pt7bBitmaps,
	3581	(GFXglyph *)DINAlternateBold9pt7bGlyphs,
	3582	0x20, 0x7E, 21 };
	3583
	3584	// Approx. 1611 bytes
	3585	const uint8_t DINCondensedBold9pt7bBitmaps[] PROGMEM = {
	3586	0x00, 0xFF, 0xFF, 0xCF, 0xFF, 0xF0, 0x25, 0x96, 0xFF, 0x49, 0x24, 0xBF,
	3587	0xDB, 0x69, 0x24, 0x10, 0xE7, 0xF7, 0xDF, 0x4F, 0x0F, 0x1C, 0x7D, 0xF7,
	3588	0x7C, 0x41, 0x00, 0xEE, 0xAE, 0x86, 0x10, 0x42, 0x08, 0x7D, 0x55, 0x77,
	3589	0x78, 0xFC, 0xCC, 0xCC, 0x78, 0x30, 0x70, 0xDB, 0xCE, 0xCE, 0xFE, 0x73,
	3590	0xFC, 0x2D, 0x2D, 0xB6, 0xD9, 0x26, 0x40, 0x99, 0x26, 0xDB, 0x6D, 0x2D,
	3591	0x00, 0x25, 0x5C, 0xEA, 0x90, 0x18, 0x0C, 0x06, 0x03, 0x0F, 0xFF, 0xFC,
	3592	0x60, 0x30, 0x18, 0x00, 0xF8, 0xFF, 0xC0, 0xF0, 0x33, 0x22, 0x26, 0x64,
	3593	0x44, 0xCC, 0x77, 0xF7, 0xBD, 0xEF, 0x7B, 0xDE, 0xFE, 0xE0, 0x7F, 0xB3,
	3594	0x33, 0x33, 0x33, 0x33, 0x77, 0xF7, 0xB1, 0x98, 0xCC, 0x66, 0x3F, 0xF0,
	3595	0x77, 0xF6, 0x33, 0x98, 0x63, 0xDE, 0xFE, 0xE0, 0x30, 0xC6, 0x18, 0x61,
	3596	0x6D, 0xB6, 0xFF, 0xF1, 0x86, 0xFF, 0xF1, 0x8F, 0x7E, 0x63, 0x1E, 0xFE,
	3597	0xE0, 0x31, 0x88, 0xC6, 0x7F, 0x7B, 0xDE, 0xFE, 0xE0, 0xFF, 0xFC, 0x86,
	3598	0x18, 0x63, 0x0C, 0x31, 0x86, 0x18, 0x77, 0xF7, 0xBF, 0xFF, 0x7B, 0xDE,
	3599	0xFE, 0xE0, 0x77, 0xF7, 0xBD, 0xEF, 0xE6, 0x31, 0x18, 0xC0, 0xF0, 0xF0,
	3600	0xF0, 0xF8, 0x00, 0x81, 0xC7, 0x8E, 0x0C, 0x03, 0x80, 0x70, 0x0E, 0x00,
	3601	0x80, 0xFF, 0xFF, 0xC0, 0x1F, 0xFF, 0xF8, 0x80, 0x70, 0x0F, 0x00, 0xE0,
	3602	0x18, 0x38, 0x70, 0xE0, 0x80, 0x00, 0x77, 0xF3, 0x90, 0x8C, 0xC6, 0x30,
	3603	0x0C, 0x60, 0x0F, 0x81, 0xC3, 0x1B, 0xDC, 0xFE, 0xBD, 0x89, 0xF8, 0x4F,
	3604	0xC6, 0xFE, 0x26, 0x7F, 0xF3, 0xE7, 0x8E, 0x18, 0x1F, 0x00, 0x10, 0x70,
	3605	0xE1, 0x42, 0x85, 0x9B, 0x3E, 0x7C, 0x8F, 0x1E, 0x30, 0xFB, 0xFC, 0xF3,
	3606	0xFB, 0xEC, 0xF3, 0xCF, 0x3F, 0xFE, 0x7B, 0xFC, 0xF3, 0xC3, 0x0C, 0x30,
	3607	0xCF, 0x3F, 0xDE, 0xFB, 0xFC, 0xF3, 0xCF, 0x3C, 0xF3, 0xCF, 0x3F, 0xFE,
	3608	0xFF, 0xFC, 0x30, 0xC3, 0xEF, 0xB0, 0xC3, 0x0F, 0xFF, 0xFF, 0xFC, 0x30,
	3609	0xC3, 0xEF, 0xB0, 0xC3, 0x0C, 0x30, 0x7B, 0xFC, 0xF0, 0xC3, 0x7D, 0xF3,
	3610	0xCF, 0x3F, 0xDE, 0xCF, 0x3C, 0xF3, 0xCF, 0xFF, 0xF3, 0xCF, 0x3C, 0xF3,
	3611	0xFF, 0xFF, 0xFF, 0x0C, 0x30, 0xC3, 0x0C, 0x30, 0xC3, 0x0C, 0x37, 0xDE,
	3612	0xCD, 0x9B, 0x66, 0xCF, 0x1E, 0x3E, 0x7C, 0xCD, 0x9B, 0x36, 0x30, 0xC3,
	3613	0x0C, 0x30, 0xC3, 0x0C, 0x30, 0xC3, 0x0F, 0xFF, 0xC3, 0xC3, 0xE7, 0xE7,
	3614	0xE7, 0xFF, 0xDB, 0xDB, 0xDB, 0xDB, 0xC3, 0xC3, 0xCF, 0x3E, 0xFB, 0xEF,
	3615	0xBD, 0xF7, 0xDF, 0x7C, 0xF3, 0x7B, 0xFC, 0xF3, 0xCF, 0x3C, 0xF3, 0xCF,
	3616	0x3F, 0xDE, 0xFB, 0xFC, 0xF3, 0xCF, 0xFF, 0xB0, 0xC3, 0x0C, 0x30, 0x79,
	3617	0xFB, 0x36, 0x6C, 0xD9, 0xB3, 0x66, 0xDD, 0xBB, 0xF3, 0xA0, 0xFB, 0xFC,
	3618	0xF3, 0xCF, 0xFF, 0x36, 0xDB, 0x2C, 0xF3, 0x7B, 0xFC, 0xF3, 0xC1, 0xC1,
	3619	0xC3, 0xCF, 0x3F, 0xDE, 0xFF, 0xF3, 0x0C, 0x30, 0xC3, 0x0C, 0x30, 0xC3,
	3620	0x0C, 0xCF, 0x3C, 0xF3, 0xCF, 0x3C, 0xF3, 0xCF, 0x3F, 0xDE, 0xC6, 0x8D,
	3621	0x93, 0x66, 0xCD, 0x8B, 0x14, 0x38, 0x70, 0xE0, 0x80, 0xCC, 0xD3, 0x34,
	3622	0xCD, 0xBB, 0x6E, 0x9F, 0xA7, 0xA9, 0xEE, 0x33, 0x8C, 0xE3, 0x38, 0xC4,
	3623	0xC6, 0xD9, 0xB1, 0xC3, 0x86, 0x0E, 0x1C, 0x68, 0xD9, 0x36, 0x30, 0xCF,
	3624	0x3C, 0xDE, 0x79, 0xE3, 0x0C, 0x30, 0xC3, 0x0C, 0xFF, 0xC6, 0x23, 0x19,
	3625	0x8C, 0x46, 0x3F, 0xF0, 0xFB, 0x6D, 0xB6, 0xDB, 0x6D, 0xC0, 0xCC, 0x44,
	3626	0x46, 0x62, 0x22, 0x33, 0xED, 0xB6, 0xDB, 0x6D, 0xB7, 0xC0, 0x08, 0x0C,
	3627	0x07, 0x06, 0x82, 0x23, 0x11, 0x05, 0x82, 0xFF, 0x80, 0xC6, 0x20, 0x7B,
	3628	0xF0, 0xDF, 0xFF, 0x3C, 0xFF, 0x6C, 0xC6, 0x31, 0xFF, 0xEF, 0x7B, 0xDE,
	3629	0xFF, 0xF0, 0x73, 0xEC, 0xB0, 0xC3, 0x0C, 0xBE, 0x70, 0x18, 0xC7, 0xFF,
	3630	0xEF, 0x7B, 0xDE, 0xFF, 0xF0, 0x77, 0xF7, 0xFF, 0xE3, 0x7F, 0x70, 0x37,
	3631	0x6F, 0xF6, 0x66, 0x66, 0x66, 0xFF, 0xF7, 0xBD, 0xEF, 0x7F, 0xF8, 0xF7,
	3632	0xF7, 0x00, 0xC6, 0x31, 0xFF, 0xEF, 0x7B, 0xDE, 0xF7, 0xB0, 0xF3, 0xFF,
	3633	0xFF, 0x6C, 0x36, 0xDB, 0x6D, 0xB6, 0xFE, 0xC3, 0x0C, 0x33, 0xDB, 0x6F,
	3634	0x3C, 0xFB, 0x6C, 0xF3, 0xDB, 0x6D, 0xB6, 0xDB, 0xB0, 0xF6, 0xFF, 0xDB,
	3635	0xDB, 0xDB, 0xDB, 0xDB, 0xDB, 0xDB, 0xFF, 0xF7, 0xBD, 0xEF, 0x7B, 0xD8,
	3636	0x77, 0xF7, 0xBD, 0xEF, 0x7F, 0x70, 0xFF, 0xF7, 0xBD, 0xEF, 0x7F, 0xFE,
	3637	0x31, 0x8C, 0x00, 0xFF, 0xF7, 0xBD, 0xEF, 0x7F, 0xF8, 0xC6, 0x31, 0x80,
	3638	0xDF, 0xCC, 0xCC, 0xCC, 0xC0, 0x77, 0xF7, 0x87, 0x0F, 0x7F, 0x70, 0x66,
	3639	0x6F, 0xF6, 0x66, 0x66, 0x73, 0xDE, 0xF7, 0xBD, 0xEF, 0x7F, 0xF8, 0xCF,
	3640	0x34, 0xDA, 0x79, 0xE3, 0x8C, 0x30, 0xCD, 0xE6, 0xD3, 0x6F, 0xB7, 0xD3,
	3641	0xB8, 0xDC, 0x6E, 0x32, 0x00, 0xCD, 0x67, 0x8C, 0x31, 0xC7, 0x96, 0xCC,
	3642	0xC4, 0xD9, 0xB3, 0x62, 0x85, 0x0E, 0x1C, 0x18, 0x20, 0xC3, 0x86, 0x00,
	3643	0xFF, 0xC6, 0x62, 0x33, 0x1F, 0xF8, 0x36, 0x66, 0x66, 0x68, 0x66, 0x66,
	3644	0x63, 0xFF, 0xFF, 0xFF, 0xFF, 0xC0, 0xC6, 0x66, 0x66, 0x61, 0x66, 0x66,
	3645	0x6C, 0x71, 0xFF, 0x8E };
	3646
	3647	const GFXglyph DINCondensedBold9pt7bGlyphs[] PROGMEM = {
	3648	{ 0, 1, 1, 3, 0, 0 }, // 0x20 ' '
	3649	{ 1, 2, 12, 4, 1, -11 }, // 0x21 '!'
	3650	{ 4, 4, 3, 6, 1, -11 }, // 0x22 '"'
	3651	{ 6, 6, 12, 8, 1, -11 }, // 0x23 '#'
	3652	{ 15, 6, 15, 8, 1, -12 }, // 0x24 '$'
	3653	{ 27, 6, 12, 8, 1, -11 }, // 0x25 '%'
	3654	{ 36, 8, 12, 9, 1, -11 }, // 0x26 '&'
	3655	{ 48, 2, 3, 4, 1, -11 }, // 0x27 '''
	3656	{ 49, 3, 14, 4, 1, -11 }, // 0x28 '('
	3657	{ 55, 3, 14, 4, 0, -11 }, // 0x29 ')'
	3658	{ 61, 5, 6, 7, 1, -11 }, // 0x2A '*'
	3659	{ 65, 9, 9, 11, 1, -8 }, // 0x2B '+'
	3660	{ 76, 2, 3, 4, 1, -1 }, // 0x2C ','
	3661	{ 77, 5, 2, 7, 1, -5 }, // 0x2D '-'
	3662	{ 79, 2, 2, 4, 1, -1 }, // 0x2E '.'
	3663	{ 80, 4, 12, 4, 0, -11 }, // 0x2F '/'
	3664	{ 86, 5, 12, 7, 1, -11 }, // 0x30 '0'
	3665	{ 94, 4, 12, 7, 1, -11 }, // 0x31 '1'
	3666	{ 100, 5, 12, 7, 1, -11 }, // 0x32 '2'
	3667	{ 108, 5, 12, 7, 1, -11 }, // 0x33 '3'
	3668	{ 116, 6, 12, 7, 1, -11 }, // 0x34 '4'
	3669	{ 125, 5, 12, 7, 1, -11 }, // 0x35 '5'
	3670	{ 133, 5, 12, 7, 1, -11 }, // 0x36 '6'
	3671	{ 141, 6, 12, 7, 1, -11 }, // 0x37 '7'
	3672	{ 150, 5, 12, 7, 1, -11 }, // 0x38 '8'
	3673	{ 158, 5, 12, 7, 1, -11 }, // 0x39 '9'
	3674	{ 166, 2, 6, 4, 1, -5 }, // 0x3A ':'
	3675	{ 168, 2, 7, 4, 1, -5 }, // 0x3B ';'
	3676	{ 170, 9, 9, 11, 1, -8 }, // 0x3C '<'
	3677	{ 181, 9, 5, 11, 1, -6 }, // 0x3D '='
	3678	{ 187, 9, 9, 11, 1, -8 }, // 0x3E '>'
	3679	{ 198, 5, 12, 7, 1, -11 }, // 0x3F '?'
	3680	{ 206, 13, 12, 15, 1, -11 }, // 0x40 '@'
	3681	{ 226, 7, 12, 7, 0, -11 }, // 0x41 'A'
	3682	{ 237, 6, 12, 8, 1, -11 }, // 0x42 'B'
	3683	{ 246, 6, 12, 8, 1, -11 }, // 0x43 'C'
	3684	{ 255, 6, 12, 8, 1, -11 }, // 0x44 'D'
	3685	{ 264, 6, 12, 7, 1, -11 }, // 0x45 'E'
	3686	{ 273, 6, 12, 7, 1, -11 }, // 0x46 'F'
	3687	{ 282, 6, 12, 8, 1, -11 }, // 0x47 'G'
	3688	{ 291, 6, 12, 8, 1, -11 }, // 0x48 'H'
	3689	{ 300, 2, 12, 4, 1, -11 }, // 0x49 'I'
	3690	{ 303, 6, 12, 6, -1, -11 }, // 0x4A 'J'
	3691	{ 312, 7, 12, 8, 1, -11 }, // 0x4B 'K'
	3692	{ 323, 6, 12, 7, 1, -11 }, // 0x4C 'L'
	3693	{ 332, 8, 12, 10, 1, -11 }, // 0x4D 'M'
	3694	{ 344, 6, 12, 8, 1, -11 }, // 0x4E 'N'
	3695	{ 353, 6, 12, 8, 1, -11 }, // 0x4F 'O'
	3696	{ 362, 6, 12, 8, 1, -11 }, // 0x50 'P'
	3697	{ 371, 7, 12, 8, 1, -11 }, // 0x51 'Q'
	3698	{ 382, 6, 12, 8, 1, -11 }, // 0x52 'R'
	3699	{ 391, 6, 12, 8, 1, -11 }, // 0x53 'S'
	3700	{ 400, 6, 12, 6, 0, -11 }, // 0x54 'T'
	3701	{ 409, 6, 12, 8, 1, -11 }, // 0x55 'U'
	3702	{ 418, 7, 12, 7, 0, -11 }, // 0x56 'V'
	3703	{ 429, 10, 12, 10, 0, -11 }, // 0x57 'W'
	3704	{ 444, 7, 12, 7, 0, -11 }, // 0x58 'X'
	3705	{ 455, 6, 12, 8, 1, -11 }, // 0x59 'Y'
	3706	{ 464, 5, 12, 7, 1, -11 }, // 0x5A 'Z'
	3707	{ 472, 3, 14, 4, 1, -11 }, // 0x5B '['
	3708	{ 478, 4, 12, 4, 0, -11 }, // 0x5C '\'
	3709	{ 484, 3, 14, 4, 0, -11 }, // 0x5D ']'
	3710	{ 490, 9, 8, 11, 1, -12 }, // 0x5E '^'
	3711	{ 499, 9, 1, 9, 0, 2 }, // 0x5F '_'
	3712	{ 501, 4, 3, 3, -1, -12 }, // 0x60 '`'
	3713	{ 503, 6, 9, 8, 1, -8 }, // 0x61 'a'
	3714	{ 510, 5, 12, 7, 1, -11 }, // 0x62 'b'
	3715	{ 518, 6, 9, 7, 1, -8 }, // 0x63 'c'
	3716	{ 525, 5, 12, 7, 1, -11 }, // 0x64 'd'
	3717	{ 533, 5, 9, 7, 1, -8 }, // 0x65 'e'
	3718	{ 539, 4, 12, 5, 1, -11 }, // 0x66 'f'
	3719	{ 545, 5, 13, 7, 1, -8 }, // 0x67 'g'
	3720	{ 554, 5, 12, 7, 1, -11 }, // 0x68 'h'
	3721	{ 562, 2, 12, 4, 1, -11 }, // 0x69 'i'
	3722	{ 565, 3, 16, 4, 0, -11 }, // 0x6A 'j'
	3723	{ 571, 6, 12, 7, 1, -11 }, // 0x6B 'k'
	3724	{ 580, 3, 12, 4, 1, -11 }, // 0x6C 'l'
	3725	{ 585, 8, 9, 10, 1, -8 }, // 0x6D 'm'
	3726	{ 594, 5, 9, 7, 1, -8 }, // 0x6E 'n'
	3727	{ 600, 5, 9, 7, 1, -8 }, // 0x6F 'o'
	3728	{ 606, 5, 13, 7, 1, -8 }, // 0x70 'p'
	3729	{ 615, 5, 13, 7, 1, -8 }, // 0x71 'q'
	3730	{ 624, 4, 9, 5, 1, -8 }, // 0x72 'r'
	3731	{ 629, 5, 9, 7, 1, -8 }, // 0x73 's'
	3732	{ 635, 4, 12, 4, 0, -11 }, // 0x74 't'
	3733	{ 641, 5, 9, 7, 1, -8 }, // 0x75 'u'
	3734	{ 647, 6, 9, 6, 0, -8 }, // 0x76 'v'
	3735	{ 654, 9, 9, 9, 0, -8 }, // 0x77 'w'
	3736	{ 665, 6, 9, 6, 0, -8 }, // 0x78 'x'
	3737	{ 672, 7, 13, 6, 0, -8 }, // 0x79 'y'
	3738	{ 684, 5, 9, 7, 1, -8 }, // 0x7A 'z'
	3739	{ 690, 4, 14, 5, 1, -11 }, // 0x7B '{'
	3740	{ 697, 2, 17, 4, 1, -12 }, // 0x7C '\|'
	3741	{ 702, 4, 14, 4, 0, -11 }, // 0x7D '}'
	3742	{ 709, 8, 3, 11, 1, -5 } }; // 0x7E '~'
	3743
	3744	const GFXfont DINCondensedBold9pt7b PROGMEM = {
	3745	(uint8_t *)DINCondensedBold9pt7bBitmaps,
	3746	(GFXglyph *)DINCondensedBold9pt7bGlyphs,
	3747	0x20, 0x7E, 21 };
	3748
	3749	// Approx. 1384 bytes
	3750	const uint8_t EuphemiaCAS9pt7bBitmaps[] PROGMEM = {
	3751	0x00, 0xFF, 0xFF, 0xF0, 0x40, 0xDE, 0xD2, 0x0C, 0x20, 0x20, 0x80, 0x82,
	3752	0x1F, 0xFF, 0x08, 0x60, 0x21, 0x01, 0x84, 0x06, 0x10, 0x10, 0x40, 0x41,
	3753	0x0F, 0xFF, 0x84, 0x30, 0x10, 0x80, 0xC2, 0x03, 0x08, 0x00, 0x08, 0x1E,
	3754	0x3B, 0x4A, 0x48, 0x48, 0x68, 0x3C, 0x0E, 0x0B, 0x09, 0x09, 0x49, 0xEA,
	3755	0x3E, 0x08, 0x08, 0x70, 0x14, 0x41, 0x22, 0x19, 0x10, 0x88, 0x88, 0x44,
	3756	0x82, 0x2C, 0x0E, 0xDE, 0x05, 0x08, 0x48, 0x46, 0x42, 0x62, 0x12, 0x19,
	3757	0xA0, 0x7B, 0x00, 0x00, 0x3C, 0x0C, 0x41, 0x08, 0x21, 0x02, 0x40, 0x70,
	3758	0x1E, 0x06, 0x63, 0x84, 0x50, 0x5A, 0x06, 0x21, 0xE3, 0xE6, 0xF4, 0x12,
	3759	0x44, 0xC8, 0x88, 0x88, 0x84, 0x44, 0x21, 0x84, 0x22, 0x31, 0x11, 0x11,
	3760	0x12, 0x22, 0x48, 0x11, 0xAC, 0xE0, 0x83, 0x9A, 0xC4, 0x00, 0x08, 0x04,
	3761	0x02, 0x01, 0x0F, 0xF8, 0x40, 0x20, 0x10, 0x08, 0x00, 0xD6, 0xF8, 0xC0,
	3762	0x00, 0x80, 0x40, 0x40, 0x60, 0x20, 0x30, 0x10, 0x10, 0x08, 0x08, 0x04,
	3763	0x04, 0x02, 0x02, 0x01, 0x01, 0x00, 0x80, 0x00, 0x3C, 0x42, 0x42, 0x81,
	3764	0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x42, 0x42, 0x3C, 0x33, 0xC9, 0x04,
	3765	0x10, 0x41, 0x04, 0x10, 0x41, 0x04, 0x7C, 0x3E, 0x63, 0x01, 0x01, 0x01,
	3766	0x03, 0x06, 0x0C, 0x10, 0x60, 0x40, 0x80, 0xFE, 0x7C, 0x82, 0x01, 0x02,
	3767	0x02, 0x1C, 0x02, 0x01, 0x01, 0x01, 0x01, 0x82, 0xFC, 0x02, 0x06, 0x0A,
	3768	0x0A, 0x12, 0x22, 0x62, 0x42, 0xFF, 0x02, 0x02, 0x02, 0x02, 0xFD, 0x02,
	3769	0x04, 0x0F, 0x90, 0x80, 0x81, 0x02, 0x04, 0x0C, 0x2F, 0x80, 0x1F, 0x22,
	3770	0x40, 0xC0, 0xFC, 0xC2, 0x81, 0x81, 0x81, 0x81, 0xC1, 0x42, 0x3C, 0xFF,
	3771	0x01, 0x03, 0x02, 0x06, 0x04, 0x0C, 0x08, 0x08, 0x18, 0x10, 0x30, 0x20,
	3772	0x3C, 0xC3, 0x81, 0x81, 0xC3, 0x3C, 0x3C, 0x42, 0x81, 0x81, 0x81, 0x42,
	3773	0x3C, 0x3C, 0x42, 0x81, 0x81, 0x81, 0x81, 0x43, 0x3F, 0x03, 0x03, 0x02,
	3774	0x84, 0xF8, 0xC0, 0x03, 0xC0, 0x03, 0x58, 0x04, 0x1C, 0x61, 0x82, 0x08,
	3775	0x20, 0x20, 0x20, 0x60, 0x60, 0x60, 0x60, 0xFF, 0x80, 0x00, 0x1F, 0xF0,
	3776	0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x86, 0x18, 0x61, 0x86, 0x08, 0x00,
	3777	0xFA, 0x20, 0x41, 0x04, 0x10, 0x8C, 0x21, 0x86, 0x00, 0x40, 0x07, 0xE0,
	3778	0x18, 0x18, 0x30, 0x04, 0x60, 0x02, 0x40, 0x02, 0x87, 0xE1, 0x88, 0x21,
	3779	0x90, 0x21, 0x90, 0x21, 0x90, 0x21, 0x90, 0x22, 0x88, 0x62, 0x47, 0xBC,
	3780	0x60, 0x00, 0x30, 0x00, 0x18, 0x00, 0x07, 0xC0, 0x04, 0x01, 0x40, 0x28,
	3781	0x05, 0x81, 0x10, 0x22, 0x04, 0x61, 0xFC, 0x20, 0x84, 0x19, 0x03, 0x20,
	3782	0x2C, 0x06, 0xFD, 0x0E, 0x0C, 0x18, 0x5F, 0x21, 0x41, 0x83, 0x06, 0x0C,
	3783	0x2F, 0x80, 0x1F, 0x30, 0xD0, 0x18, 0x08, 0x04, 0x02, 0x01, 0x00, 0x80,
	3784	0x60, 0x10, 0x2C, 0x31, 0xF0, 0xFC, 0x20, 0xC8, 0x0A, 0x03, 0x80, 0x60,
	3785	0x18, 0x06, 0x01, 0x80, 0x60, 0x28, 0x1A, 0x0C, 0xFC, 0x00, 0xFF, 0x02,
	3786	0x04, 0x08, 0x1F, 0xA0, 0x40, 0x81, 0x02, 0x04, 0x0F, 0xE0, 0xFF, 0x02,
	3787	0x04, 0x08, 0x1F, 0xA0, 0x40, 0x81, 0x02, 0x04, 0x08, 0x00, 0x1F, 0x88,
	3788	0x34, 0x01, 0x00, 0x80, 0x20, 0x08, 0x02, 0x01, 0x80, 0x50, 0x14, 0x04,
	3789	0xC1, 0x1F, 0x80, 0x80, 0x60, 0x18, 0x06, 0x01, 0x80, 0x60, 0x1F, 0xFE,
	3790	0x01, 0x80, 0x60, 0x18, 0x06, 0x01, 0x80, 0x40, 0xFF, 0xF8, 0x02, 0x04,
	3791	0x08, 0x10, 0x20, 0x40, 0x81, 0x02, 0x07, 0x0E, 0x37, 0xC0, 0x83, 0x43,
	3792	0x23, 0x13, 0x0B, 0x07, 0x03, 0x01, 0xC0, 0xB0, 0x4C, 0x23, 0x10, 0xC8,
	3793	0x38, 0x81, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x81, 0x02, 0x04, 0x0F,
	3794	0xE0, 0x80, 0x1C, 0x03, 0xC0, 0x3E, 0x07, 0xA0, 0x5A, 0x05, 0xB0, 0xD9,
	3795	0x09, 0x99, 0x98, 0x91, 0x8F, 0x18, 0x61, 0x86, 0x10, 0x80, 0x70, 0x1E,
	3796	0x06, 0xC1, 0x90, 0x66, 0x18, 0xC6, 0x19, 0x86, 0x60, 0xD8, 0x1E, 0x07,
	3797	0x80, 0xC0, 0x0F, 0x83, 0x0C, 0x40, 0x24, 0x02, 0x80, 0x18, 0x01, 0x80,
	3798	0x18, 0x01, 0x80, 0x14, 0x02, 0x40, 0x23, 0x0C, 0x1F, 0x00, 0xFC, 0x82,
	3799	0x81, 0x81, 0x81, 0x86, 0xFC, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x0F,
	3800	0x83, 0x0C, 0x40, 0x24, 0x02, 0x80, 0x18, 0x01, 0x80, 0x18, 0x01, 0x80,
	3801	0x14, 0x03, 0x40, 0x23, 0x0C, 0x1F, 0x80, 0x10, 0x01, 0x80, 0x0C, 0x00,
	3802	0x60, 0xFC, 0x41, 0x20, 0x50, 0x28, 0x14, 0x33, 0xF1, 0x18, 0x84, 0x43,
	3803	0x20, 0x90, 0x68, 0x18, 0x1F, 0x10, 0xD0, 0x08, 0x06, 0x01, 0xC0, 0x38,
	3804	0x06, 0x00, 0x80, 0x50, 0x3C, 0x23, 0xE0, 0xFF, 0x84, 0x02, 0x01, 0x00,
	3805	0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, 0x00, 0x80, 0x80, 0x30,
	3806	0x06, 0x00, 0xC0, 0x18, 0x03, 0x00, 0x60, 0x0C, 0x01, 0x80, 0x30, 0x06,
	3807	0x00, 0xB0, 0x63, 0xF8, 0xC0, 0x50, 0x36, 0x0D, 0x82, 0x21, 0x8C, 0x43,
	3808	0x10, 0x4C, 0x1A, 0x06, 0x80, 0xE0, 0x30, 0x0C, 0x00, 0xC1, 0x06, 0x83,
	3809	0x0D, 0x06, 0x13, 0x14, 0x26, 0x28, 0xC4, 0x59, 0x89, 0x92, 0x1A, 0x24,
	3810	0x34, 0x68, 0x28, 0xF0, 0x70, 0xC0, 0xC1, 0x81, 0x83, 0x00, 0x60, 0xC4,
	3811	0x10, 0xC6, 0x0D, 0x80, 0xA0, 0x18, 0x03, 0x80, 0x50, 0x1B, 0x02, 0x20,
	3812	0x82, 0x30, 0x6C, 0x06, 0xC1, 0xA0, 0x98, 0xC4, 0x41, 0x40, 0xA0, 0x20,
	3813	0x10, 0x08, 0x04, 0x02, 0x01, 0x00, 0x80, 0x7F, 0x80, 0xC0, 0x40, 0x40,
	3814	0x60, 0x20, 0x20, 0x30, 0x10, 0x18, 0x18, 0x08, 0x0F, 0xF8, 0xF2, 0x49,
	3815	0x24, 0x92, 0x49, 0x24, 0xE0, 0x80, 0x40, 0x10, 0x08, 0x02, 0x01, 0x00,
	3816	0x40, 0x20, 0x08, 0x04, 0x01, 0x00, 0xC0, 0x20, 0x18, 0x04, 0x03, 0x00,
	3817	0x80, 0xE4, 0x92, 0x49, 0x24, 0x92, 0x49, 0xE0, 0x08, 0x05, 0x01, 0x20,
	3818	0x88, 0x61, 0x10, 0x68, 0x0C, 0xFF, 0x80, 0x4C, 0x21, 0x3C, 0x31, 0x00,
	3819	0x80, 0x47, 0xE6, 0x12, 0x09, 0x0C, 0x7B, 0x80, 0x80, 0x80, 0x80, 0x80,
	3820	0xBC, 0xC2, 0x81, 0x81, 0x81, 0x81, 0x83, 0x86, 0xFC, 0x3E, 0x43, 0x80,
	3821	0x80, 0x80, 0x80, 0xC0, 0x63, 0x3E, 0x01, 0x01, 0x01, 0x01, 0x3F, 0x41,
	3822	0xC1, 0x81, 0x81, 0x81, 0xC1, 0x41, 0x3F, 0x3C, 0x8E, 0x0F, 0xF8, 0x10,
	3823	0x30, 0x23, 0x3C, 0x3D, 0x04, 0x10, 0xF1, 0x04, 0x10, 0x41, 0x04, 0x10,
	3824	0x40, 0x3F, 0xE3, 0x20, 0x90, 0x4C, 0x63, 0xE2, 0x01, 0x00, 0x7C, 0x43,
	3825	0x20, 0x90, 0xC7, 0xC0, 0x80, 0x80, 0x80, 0x80, 0xBE, 0xC3, 0x81, 0x81,
	3826	0x81, 0x81, 0x81, 0x81, 0x81, 0xC0, 0x55, 0x55, 0x40, 0x30, 0x00, 0x22,
	3827	0x22, 0x22, 0x22, 0x22, 0x26, 0xC0, 0x81, 0x02, 0x04, 0x08, 0x73, 0x2C,
	3828	0x70, 0xB1, 0x32, 0x24, 0x68, 0x60, 0x92, 0x49, 0x24, 0x92, 0x4E, 0xB9,
	3829	0xD8, 0xC6, 0x10, 0xC2, 0x18, 0x43, 0x08, 0x61, 0x0C, 0x21, 0x84, 0x20,
	3830	0xBE, 0xC3, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x3E, 0x30, 0xB0,
	3831	0x70, 0x18, 0x0C, 0x07, 0x06, 0xC6, 0x3E, 0x00, 0xBC, 0xC2, 0x81, 0x81,
	3832	0x81, 0x81, 0x81, 0x82, 0xFC, 0x80, 0x80, 0x80, 0x80, 0x3F, 0x41, 0x81,
	3833	0x81, 0x81, 0x81, 0xC1, 0x41, 0x3F, 0x01, 0x01, 0x01, 0x01, 0xBE, 0x21,
	3834	0x08, 0x42, 0x10, 0x80, 0x7D, 0x0E, 0x06, 0x03, 0x80, 0xC0, 0xE1, 0x7C,
	3835	0x42, 0x11, 0xE4, 0x21, 0x08, 0x42, 0x10, 0xF0, 0x83, 0x06, 0x0C, 0x18,
	3836	0x30, 0x60, 0xC3, 0x7A, 0x81, 0x83, 0x82, 0x46, 0x46, 0x24, 0x2C, 0x2C,
	3837	0x18, 0xC4, 0x34, 0x62, 0x46, 0x66, 0xA6, 0x29, 0x42, 0x94, 0x29, 0xC1,
	3838	0x18, 0x10, 0x80, 0x43, 0x26, 0x24, 0x18, 0x18, 0x1C, 0x24, 0x66, 0xC3,
	3839	0xC1, 0xA0, 0x98, 0xC4, 0x43, 0x20, 0xA0, 0x50, 0x38, 0x08, 0x04, 0x06,
	3840	0x02, 0x0E, 0x00, 0xFE, 0x08, 0x30, 0xC3, 0x04, 0x10, 0x60, 0xFE, 0x19,
	3841	0x08, 0x42, 0x10, 0x84, 0xC1, 0x08, 0x42, 0x10, 0x84, 0x18, 0xFF, 0xFF,
	3842	0x80, 0xC1, 0x08, 0x42, 0x10, 0x84, 0x19, 0x08, 0x42, 0x10, 0x84, 0xC0,
	3843	0x70, 0xC7, 0x80 };
	3844
	3845	const GFXglyph EuphemiaCAS9pt7bGlyphs[] PROGMEM = {
	3846	{ 0, 1, 1, 9, 0, 0 }, // 0x20 ' '
	3847	{ 1, 2, 13, 4, 1, -12 }, // 0x21 '!'
	3848	{ 5, 5, 3, 7, 1, -12 }, // 0x22 '"'
	3849	{ 7, 14, 15, 16, 1, -13 }, // 0x23 '#'
	3850	{ 34, 8, 17, 10, 1, -14 }, // 0x24 '$'
	3851	{ 51, 13, 15, 17, 2, -13 }, // 0x25 '%'
	3852	{ 76, 11, 13, 13, 1, -12 }, // 0x26 '&'
	3853	{ 94, 2, 3, 4, 1, -12 }, // 0x27 '''
	3854	{ 95, 4, 16, 6, 1, -14 }, // 0x28 '('
	3855	{ 103, 4, 16, 6, 1, -14 }, // 0x29 ')'
	3856	{ 111, 7, 7, 9, 1, -14 }, // 0x2A '*'
	3857	{ 118, 9, 9, 11, 1, -9 }, // 0x2B '+'
	3858	{ 129, 2, 4, 4, 1, 0 }, // 0x2C ','
	3859	{ 130, 5, 1, 7, 1, -6 }, // 0x2D '-'
	3860	{ 131, 2, 1, 4, 1, 0 }, // 0x2E '.'
	3861	{ 132, 9, 17, 11, 1, -14 }, // 0x2F '/'
	3862	{ 152, 8, 13, 10, 1, -12 }, // 0x30 '0'
	3863	{ 165, 6, 13, 10, 2, -12 }, // 0x31 '1'
	3864	{ 175, 8, 13, 10, 1, -12 }, // 0x32 '2'
	3865	{ 188, 8, 13, 10, 1, -12 }, // 0x33 '3'
	3866	{ 201, 8, 13, 10, 1, -12 }, // 0x34 '4'
	3867	{ 214, 7, 13, 10, 2, -12 }, // 0x35 '5'
	3868	{ 226, 8, 13, 10, 1, -12 }, // 0x36 '6'
	3869	{ 239, 8, 13, 10, 1, -12 }, // 0x37 '7'
	3870	{ 252, 8, 13, 10, 1, -12 }, // 0x38 '8'
	3871	{ 265, 8, 13, 10, 1, -12 }, // 0x39 '9'
	3872	{ 278, 2, 8, 4, 1, -7 }, // 0x3A ':'
	3873	{ 280, 2, 11, 4, 1, -7 }, // 0x3B ';'
	3874	{ 283, 7, 13, 9, 1, -12 }, // 0x3C '<'
	3875	{ 295, 9, 4, 11, 1, -8 }, // 0x3D '='
	3876	{ 300, 7, 13, 9, 1, -12 }, // 0x3E '>'
	3877	{ 312, 6, 13, 9, 1, -12 }, // 0x3F '?'
	3878	{ 322, 16, 17, 18, 1, -12 }, // 0x40 '@'
	3879	{ 356, 11, 13, 11, 0, -12 }, // 0x41 'A'
	3880	{ 374, 7, 13, 11, 2, -12 }, // 0x42 'B'
	3881	{ 386, 9, 13, 12, 1, -12 }, // 0x43 'C'
	3882	{ 401, 10, 13, 12, 1, -12 }, // 0x44 'D'
	3883	{ 418, 7, 13, 10, 2, -12 }, // 0x45 'E'
	3884	{ 430, 7, 13, 9, 2, -12 }, // 0x46 'F'
	3885	{ 442, 10, 13, 12, 1, -12 }, // 0x47 'G'
	3886	{ 459, 10, 13, 12, 1, -12 }, // 0x48 'H'
	3887	{ 476, 1, 13, 4, 2, -12 }, // 0x49 'I'
	3888	{ 478, 7, 13, 9, 1, -12 }, // 0x4A 'J'
	3889	{ 490, 9, 13, 11, 2, -12 }, // 0x4B 'K'
	3890	{ 505, 7, 13, 9, 2, -12 }, // 0x4C 'L'
	3891	{ 517, 12, 13, 14, 1, -12 }, // 0x4D 'M'
	3892	{ 537, 10, 13, 12, 1, -12 }, // 0x4E 'N'
	3893	{ 554, 12, 13, 14, 1, -12 }, // 0x4F 'O'
	3894	{ 574, 8, 13, 10, 1, -12 }, // 0x50 'P'
	3895	{ 587, 12, 17, 14, 1, -12 }, // 0x51 'Q'
	3896	{ 613, 9, 13, 11, 1, -12 }, // 0x52 'R'
	3897	{ 628, 9, 13, 11, 0, -12 }, // 0x53 'S'
	3898	{ 643, 9, 13, 11, 1, -12 }, // 0x54 'T'
	3899	{ 658, 11, 13, 13, 1, -12 }, // 0x55 'U'
	3900	{ 676, 10, 13, 11, 0, -12 }, // 0x56 'V'
	3901	{ 693, 15, 13, 16, 0, -12 }, // 0x57 'W'
	3902	{ 718, 11, 13, 11, 0, -12 }, // 0x58 'X'
	3903	{ 736, 9, 13, 10, 1, -12 }, // 0x59 'Y'
	3904	{ 751, 9, 13, 10, 0, -12 }, // 0x5A 'Z'
	3905	{ 766, 3, 17, 5, 1, -14 }, // 0x5B '['
	3906	{ 773, 9, 17, 11, 1, -14 }, // 0x5C '\'
	3907	{ 793, 3, 17, 5, 1, -14 }, // 0x5D ']'
	3908	{ 800, 10, 7, 11, 1, -13 }, // 0x5E '^'
	3909	{ 809, 9, 1, 9, 0, 3 }, // 0x5F '_'
	3910	{ 811, 4, 4, 0, -2, -13 }, // 0x60 '`'
	3911	{ 813, 9, 9, 10, 1, -8 }, // 0x61 'a'
	3912	{ 824, 8, 13, 10, 1, -12 }, // 0x62 'b'
	3913	{ 837, 8, 9, 9, 1, -8 }, // 0x63 'c'
	3914	{ 846, 8, 13, 11, 1, -12 }, // 0x64 'd'
	3915	{ 859, 7, 9, 10, 1, -8 }, // 0x65 'e'
	3916	{ 867, 6, 13, 6, 1, -12 }, // 0x66 'f'
	3917	{ 877, 9, 13, 10, 1, -8 }, // 0x67 'g'
	3918	{ 892, 8, 13, 10, 1, -12 }, // 0x68 'h'
	3919	{ 905, 2, 13, 4, 1, -12 }, // 0x69 'i'
	3920	{ 909, 4, 17, 4, -1, -12 }, // 0x6A 'j'
	3921	{ 918, 7, 13, 9, 1, -12 }, // 0x6B 'k'
	3922	{ 930, 3, 13, 4, 1, -12 }, // 0x6C 'l'
	3923	{ 935, 11, 9, 13, 1, -8 }, // 0x6D 'm'
	3924	{ 948, 8, 9, 10, 1, -8 }, // 0x6E 'n'
	3925	{ 957, 9, 9, 11, 1, -8 }, // 0x6F 'o'
	3926	{ 968, 8, 13, 10, 1, -8 }, // 0x70 'p'
	3927	{ 981, 8, 13, 10, 1, -8 }, // 0x71 'q'
	3928	{ 994, 5, 9, 7, 1, -8 }, // 0x72 'r'
	3929	{ 1000, 7, 9, 9, 1, -8 }, // 0x73 's'
	3930	{ 1008, 5, 12, 6, 1, -11 }, // 0x74 't'
	3931	{ 1016, 7, 9, 10, 1, -8 }, // 0x75 'u'
	3932	{ 1024, 8, 9, 8, -1, -8 }, // 0x76 'v'
	3933	{ 1033, 12, 9, 12, 0, -8 }, // 0x77 'w'
	3934	{ 1047, 8, 9, 8, 0, -8 }, // 0x78 'x'
	3935	{ 1056, 9, 13, 9, 0, -8 }, // 0x79 'y'
	3936	{ 1071, 7, 9, 9, 1, -8 }, // 0x7A 'z'
	3937	{ 1079, 5, 17, 6, 0, -13 }, // 0x7B '{'
	3938	{ 1090, 1, 17, 9, 4, -12 }, // 0x7C '\|'
	3939	{ 1093, 5, 17, 6, 1, -13 }, // 0x7D '}'
	3940	{ 1104, 9, 2, 11, 1, -5 } }; // 0x7E '~'
	3941
	3942	const GFXfont EuphemiaCAS9pt7b PROGMEM = {
	3943	(uint8_t *)EuphemiaCAS9pt7bBitmaps,
	3944	(GFXglyph *)EuphemiaCAS9pt7bGlyphs,
	3945	0x20, 0x7E, 24 };
	3946
	3947	// Approx. 1779 bytes
	3948	const uint8_t Futura9pt7bBitmaps[] PROGMEM = {
	3949	0x00, 0xFF, 0xFF, 0xFC, 0xF0, 0xDE, 0xF7, 0xBD, 0x80, 0x11, 0x84, 0x61,
	3950	0x18, 0xC6, 0xFF, 0xFF, 0xF3, 0x30, 0xCC, 0xFF, 0xFF, 0xF2, 0x31, 0x8C,
	3951	0x62, 0x18, 0x80, 0x0C, 0x06, 0x0F, 0xCE, 0x76, 0x03, 0x01, 0xC0, 0x78,
	3952	0x1F, 0x03, 0xC0, 0x68, 0x3C, 0x1B, 0x1D, 0xFC, 0x7C, 0x0C, 0x06, 0x00,
	3953	0x38, 0x30, 0xF8, 0x43, 0x19, 0x86, 0x32, 0x0C, 0x6C, 0x0F, 0x90, 0x0E,
	3954	0x40, 0x00, 0x9C, 0x02, 0x7C, 0x05, 0x8C, 0x13, 0x18, 0x66, 0x30, 0x87,
	3955	0xC3, 0x07, 0x00, 0x1E, 0x03, 0xF0, 0x33, 0x03, 0x30, 0x3F, 0x01, 0xE0,
	3956	0x3C, 0x07, 0xE0, 0xE7, 0x6C, 0x3C, 0xC1, 0x8E, 0x3C, 0x7E, 0xE3, 0xC6,
	3957	0xFF, 0xC0, 0x76, 0x66, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xE6, 0x66, 0x20,
	3958	0xC6, 0x66, 0x33, 0x33, 0x33, 0x33, 0x33, 0x76, 0x66, 0x40, 0x18, 0x18,
	3959	0x7E, 0x7E, 0x3C, 0x66, 0x24, 0x0C, 0x06, 0x03, 0x1F, 0xFF, 0xF8, 0x60,
	3960	0x30, 0x18, 0x0C, 0x00, 0x23, 0x26, 0x6C, 0xFF, 0xF0, 0x01, 0x80, 0xC0,
	3961	0xC0, 0x60, 0x60, 0x30, 0x18, 0x18, 0x0C, 0x0C, 0x06, 0x02, 0x03, 0x01,
	3962	0x81, 0x80, 0xC0, 0xC0, 0x60, 0x10, 0x00, 0x1C, 0x1F, 0x18, 0xDC, 0x6C,
	3963	0x1E, 0x0F, 0x07, 0x83, 0xC1, 0xE0, 0xF8, 0xCC, 0x63, 0xE0, 0xE0, 0x7F,
	3964	0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x1E, 0x3F, 0x98, 0xEC, 0x30, 0x18,
	3965	0x0C, 0x0C, 0x0E, 0x0E, 0x06, 0x06, 0x06, 0x07, 0xFF, 0xFC, 0x3C, 0x7E,
	3966	0xE7, 0x03, 0x03, 0x1E, 0x1E, 0x07, 0x03, 0x03, 0xC3, 0xC7, 0x7E, 0x3C,
	3967	0x00, 0x00, 0x10, 0x06, 0x00, 0xC0, 0x38, 0x0F, 0x01, 0xE0, 0x6C, 0x1D,
	3968	0x83, 0x30, 0xC6, 0x3F, 0xF7, 0xFE, 0x03, 0x00, 0x60, 0x1F, 0x8F, 0xC6,
	3969	0x06, 0x03, 0xE1, 0xF9, 0x8C, 0x03, 0x01, 0x80, 0xD0, 0x7C, 0x67, 0xF1,
	3970	0xE0, 0x00, 0x03, 0x03, 0x81, 0x81, 0x81, 0xC0, 0xF8, 0xFE, 0xE3, 0xE0,
	3971	0xF0, 0x78, 0x3E, 0x33, 0xF8, 0x78, 0xFF, 0xFF, 0xE0, 0x30, 0x0C, 0x06,
	3972	0x01, 0x80, 0xC0, 0x70, 0x18, 0x0C, 0x03, 0x01, 0x80, 0xE0, 0x30, 0x00,
	3973	0x3C, 0x7E, 0xE7, 0xC3, 0xC3, 0xE7, 0x7E, 0x7E, 0xE7, 0xC3, 0xC3, 0xE7,
	3974	0x7E, 0x3C, 0x3C, 0x3F, 0xB8, 0xF8, 0x3C, 0x1E, 0x0F, 0x8E, 0xFE, 0x3E,
	3975	0x07, 0x03, 0x03, 0x03, 0x81, 0x80, 0x00, 0xF0, 0x03, 0xC0, 0x33, 0x00,
	3976	0x00, 0x32, 0x66, 0x44, 0x01, 0x83, 0xC7, 0x8F, 0x0E, 0x07, 0x01, 0xE0,
	3977	0x3C, 0x07, 0x80, 0xC0, 0xFF, 0xFF, 0xC0, 0x1F, 0xFF, 0xF8, 0xC0, 0x78,
	3978	0x0E, 0x01, 0xC0, 0x38, 0x3C, 0x78, 0xF0, 0xE0, 0x40, 0x00, 0x38, 0xFB,
	3979	0x1E, 0x30, 0xE7, 0xBC, 0x60, 0xCD, 0xF9, 0xE0, 0x03, 0x06, 0x00, 0x0F,
	3980	0xC0, 0x61, 0xC3, 0x01, 0x99, 0xD6, 0xCF, 0xCF, 0x73, 0x3D, 0x84, 0xF6,
	3981	0x33, 0xD8, 0xDB, 0xBD, 0xE7, 0x77, 0x0E, 0x00, 0x3F, 0xE0, 0x3F, 0x00,
	3982	0x02, 0x00, 0x10, 0x01, 0xC0, 0x0E, 0x00, 0xF8, 0x06, 0xC0, 0x73, 0x03,
	3983	0x18, 0x18, 0xE1, 0xFF, 0x0F, 0xF8, 0xC0, 0x66, 0x03, 0x60, 0x0C, 0xF8,
	3984	0xFC, 0xCE, 0xC6, 0xC6, 0xCE, 0xFC, 0xFE, 0xC7, 0xC3, 0xC3, 0xC7, 0xFE,
	3985	0xFC, 0x0F, 0x83, 0xFC, 0xE1, 0xB0, 0x0E, 0x01, 0x80, 0x30, 0x06, 0x00,
	3986	0xC0, 0x1C, 0x01, 0x80, 0x9C, 0x31, 0xFE, 0x1F, 0x00, 0xFC, 0x3F, 0xCC,
	3987	0x7B, 0x06, 0xC1, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x7C, 0x1B, 0x1E,
	3988	0xFF, 0x3F, 0x00, 0xFF, 0xFF, 0x06, 0x0C, 0x1F, 0xFF, 0xE0, 0xC1, 0x83,
	3989	0x06, 0x0F, 0xFF, 0xC0, 0xFF, 0xFF, 0x06, 0x0C, 0x1F, 0xFF, 0xE0, 0xC1,
	3990	0x83, 0x06, 0x0C, 0x18, 0x00, 0x0F, 0x80, 0xFF, 0x0E, 0x1C, 0xC0, 0x4E,
	3991	0x00, 0x60, 0x03, 0x07, 0xF8, 0x3F, 0xC0, 0x1F, 0x01, 0xD8, 0x0C, 0x71,
	3992	0xE1, 0xFE, 0x07, 0xC0, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xFF, 0xFF,
	3993	0xFF, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x30, 0xFF, 0xFF,
	3994	0xFF, 0xF0, 0x0C, 0x30, 0xC3, 0x0C, 0x30, 0xC3, 0x0C, 0x30, 0xC7, 0xFB,
	3995	0xC0, 0xC1, 0xB0, 0xCC, 0x73, 0x38, 0xDC, 0x3E, 0x0F, 0x03, 0xE0, 0xDC,
	3996	0x33, 0x0C, 0x63, 0x1C, 0xC3, 0xB0, 0x70, 0xC3, 0x0C, 0x30, 0xC3, 0x0C,
	3997	0x30, 0xC3, 0x0C, 0x30, 0xFF, 0xF0, 0x00, 0x00, 0x20, 0x20, 0xC0, 0x61,
	3998	0x80, 0xC3, 0x83, 0x87, 0x07, 0x0F, 0x1E, 0x16, 0x34, 0x6C, 0xEC, 0xCD,
	3999	0x99, 0x9B, 0x33, 0x1C, 0x66, 0x38, 0xD8, 0x21, 0xB0, 0x41, 0x80, 0x80,
	4000	0x00, 0x08, 0x03, 0xC0, 0x3E, 0x03, 0xF0, 0x3F, 0x83, 0xDC, 0x3C, 0xE3,
	4001	0xC7, 0x3C, 0x3B, 0xC1, 0xFC, 0x0F, 0xC0, 0x7C, 0x03, 0xC0, 0x10, 0x00,
	4002	0x0F, 0xC0, 0x7F, 0x83, 0x87, 0x18, 0x06, 0xE0, 0x1F, 0x00, 0x3C, 0x00,
	4003	0xF0, 0x03, 0xC0, 0x0F, 0x80, 0x76, 0x01, 0x8E, 0x1C, 0x1F, 0xE0, 0x3F,
	4004	0x00, 0xF9, 0xFB, 0x3E, 0x3C, 0x79, 0xFF, 0x7C, 0xC1, 0x83, 0x06, 0x0C,
	4005	0x18, 0x00, 0x0F, 0xC0, 0x7F, 0x83, 0x87, 0x18, 0x06, 0xE0, 0x1F, 0x00,
	4006	0x3C, 0x00, 0xF0, 0x03, 0xC3, 0x8F, 0x87, 0x76, 0x0F, 0x8E, 0x1C, 0x1F,
	4007	0xF8, 0x3E, 0x70, 0xF8, 0xFC, 0xCE, 0xC6, 0xC6, 0xCE, 0xFC, 0xF8, 0xD0,
	4008	0xD8, 0xCC, 0xCC, 0xC6, 0xC7, 0x1E, 0x1F, 0x9C, 0xCC, 0x06, 0x01, 0xC0,
	4009	0x78, 0x0E, 0x01, 0x80, 0xF8, 0x6C, 0x77, 0xF0, 0xF0, 0xFF, 0xFF, 0x18,
	4010	0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xC0,
	4011	0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x3C,
	4012	0x0D, 0x86, 0x7F, 0x87, 0x80, 0xC0, 0x76, 0x06, 0x60, 0x67, 0x0C, 0x30,
	4013	0xC3, 0x0C, 0x19, 0x81, 0x98, 0x1F, 0x00, 0xF0, 0x0F, 0x00, 0x60, 0x06,
	4014	0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x18, 0x08, 0x19, 0x81, 0x03, 0x30,
	4015	0x60, 0xE7, 0x0E, 0x18, 0x63, 0xC3, 0x0C, 0x78, 0xC0, 0xCD, 0x98, 0x1B,
	4016	0x37, 0x03, 0x63, 0xC0, 0x3C, 0x78, 0x07, 0x0E, 0x00, 0xE0, 0xC0, 0x0C,
	4017	0x18, 0x01, 0x02, 0x00, 0x00, 0x00, 0x60, 0xC6, 0x38, 0xC6, 0x0D, 0xC1,
	4018	0xB0, 0x1C, 0x03, 0x80, 0x70, 0x1F, 0x03, 0x60, 0xC6, 0x18, 0xC6, 0x0D,
	4019	0xC1, 0x80, 0xC0, 0xF8, 0x76, 0x18, 0xCC, 0x33, 0x07, 0x81, 0xE0, 0x30,
	4020	0x0C, 0x03, 0x00, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0x7F, 0x9F, 0xE0, 0x30,
	4021	0x0C, 0x06, 0x03, 0x80, 0xC0, 0x70, 0x18, 0x0E, 0x03, 0x01, 0x80, 0x7F,
	4022	0xFF, 0xF0, 0xFF, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCF, 0xF0,
	4023	0xC0, 0x20, 0x18, 0x0C, 0x03, 0x01, 0x80, 0x40, 0x30, 0x18, 0x06, 0x03,
	4024	0x00, 0xC0, 0x60, 0x30, 0x0C, 0x06, 0x01, 0x80, 0xC0, 0x00, 0xFF, 0x33,
	4025	0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x3F, 0xF0, 0x0C, 0x07, 0x81, 0xE0,
	4026	0xCC, 0x33, 0x18, 0x66, 0x18, 0xFF, 0xFF, 0xF0, 0xCE, 0x62, 0x3D, 0xBF,
	4027	0xF8, 0xF8, 0x3C, 0x1E, 0x0F, 0x8E, 0xFF, 0x3D, 0x80, 0xC0, 0x60, 0x30,
	4028	0x18, 0x0C, 0x06, 0x03, 0x79, 0xFE, 0xE3, 0xE0, 0xF0, 0x78, 0x3E, 0x3F,
	4029	0xFB, 0x78, 0x3E, 0xFF, 0x8E, 0x0C, 0x18, 0x38, 0xBF, 0x3E, 0x01, 0x80,
	4030	0xC0, 0x60, 0x30, 0x18, 0x0C, 0xF6, 0xFF, 0xE3, 0xE0, 0xF0, 0x78, 0x3E,
	4031	0x3B, 0xFC, 0xF6, 0x3C, 0x7E, 0xE3, 0xFF, 0xFF, 0xC0, 0xE3, 0x7E, 0x3C,
	4032	0x3B, 0xD8, 0xC6, 0x33, 0xFF, 0x63, 0x18, 0xC6, 0x31, 0x80, 0x3D, 0xBF,
	4033	0xF8, 0xF8, 0x3C, 0x1E, 0x0F, 0x8E, 0xFF, 0x3D, 0x80, 0xF0, 0x6C, 0x77,
	4034	0xF0, 0xF0, 0xC1, 0x83, 0x06, 0x0C, 0x18, 0x37, 0x7F, 0xE7, 0x8F, 0x1E,
	4035	0x3C, 0x78, 0xF1, 0x80, 0xF0, 0x3F, 0xFF, 0xF0, 0xF0, 0x3F, 0xFF, 0xFF,
	4036	0xFC, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xCE, 0xDC, 0xF8, 0xF0, 0xF0,
	4037	0xD8, 0xDC, 0xCC, 0xC6, 0xFF, 0xFF, 0xFF, 0xFC, 0xDD, 0xEF, 0xFF, 0xE7,
	4038	0x3C, 0x63, 0xC6, 0x3C, 0x63, 0xC6, 0x3C, 0x63, 0xC6, 0x30, 0xDD, 0xFF,
	4039	0x1E, 0x3C, 0x78, 0xF1, 0xE3, 0xC6, 0x3E, 0x3F, 0xB8, 0xF8, 0x3C, 0x1E,
	4040	0x0F, 0x8E, 0xFE, 0x3E, 0x00, 0xDE, 0x7F, 0xB8, 0xF8, 0x3C, 0x1E, 0x0F,
	4041	0x8F, 0xFE, 0xDE, 0x60, 0x30, 0x18, 0x0C, 0x06, 0x00, 0x3D, 0xBF, 0xF8,
	4042	0xF8, 0x3C, 0x1E, 0x0F, 0x8E, 0xFF, 0x3D, 0x80, 0xC0, 0x60, 0x30, 0x18,
	4043	0x0C, 0xFB, 0xEE, 0x30, 0xC3, 0x0C, 0x30, 0xC0, 0x73, 0xEC, 0x38, 0x38,
	4044	0x3C, 0xFF, 0x78, 0x66, 0x6F, 0xF6, 0x66, 0x66, 0x66, 0xC7, 0x8F, 0x1E,
	4045	0x3C, 0x78, 0xF1, 0xBE, 0x38, 0xC3, 0xB1, 0x99, 0xC6, 0xC3, 0x60, 0xE0,
	4046	0x70, 0x10, 0x08, 0x00, 0x00, 0x03, 0x08, 0x66, 0x31, 0x99, 0xCC, 0x37,
	4047	0xB0, 0xDF, 0x81, 0xCE, 0x07, 0x38, 0x08, 0xC0, 0x21, 0x00, 0x61, 0x8C,
	4048	0xC1, 0xE0, 0x78, 0x0C, 0x07, 0x83, 0x31, 0xCE, 0xE1, 0x80, 0xE1, 0xB0,
	4049	0xDC, 0xC6, 0x63, 0xE0, 0xF0, 0x70, 0x18, 0x18, 0x0C, 0x0C, 0x06, 0x07,
	4050	0x03, 0x00, 0x7F, 0xBF, 0x81, 0x81, 0x81, 0xC1, 0xC0, 0xC0, 0xFF, 0xFF,
	4051	0x80, 0x3B, 0xD8, 0xC6, 0x31, 0x8C, 0xE6, 0x38, 0xC6, 0x31, 0x8C, 0x63,
	4052	0xCE, 0xFF, 0xFF, 0xFF, 0xFF, 0xC0, 0xE7, 0x8C, 0x63, 0x18, 0xC6, 0x38,
	4053	0xCE, 0x63, 0x18, 0xC6, 0x37, 0xB8, 0x78, 0xFF, 0xE3, 0xC0 };
	4054
	4055	const GFXglyph Futura9pt7bGlyphs[] PROGMEM = {
	4056	{ 0, 1, 1, 5, 0, 0 }, // 0x20 ' '
	4057	{ 1, 2, 14, 6, 2, -13 }, // 0x21 '!'
	4058	{ 5, 5, 5, 7, 1, -13 }, // 0x22 '"'
	4059	{ 9, 10, 14, 12, 1, -13 }, // 0x23 '#'
	4060	{ 27, 9, 18, 11, 1, -15 }, // 0x24 '$'
	4061	{ 48, 15, 14, 17, 1, -13 }, // 0x25 '%'
	4062	{ 75, 12, 14, 13, 1, -13 }, // 0x26 '&'
	4063	{ 96, 2, 5, 4, 1, -13 }, // 0x27 '''
	4064	{ 98, 4, 19, 7, 2, -14 }, // 0x28 '('
	4065	{ 108, 4, 19, 7, 1, -14 }, // 0x29 ')'
	4066	{ 118, 8, 7, 12, 2, -14 }, // 0x2A '*'
	4067	{ 125, 9, 9, 11, 1, -11 }, // 0x2B '+'
	4068	{ 136, 4, 6, 5, 0, -2 }, // 0x2C ','
	4069	{ 139, 4, 2, 4, 0, -5 }, // 0x2D '-'
	4070	{ 140, 2, 2, 6, 2, -1 }, // 0x2E '.'
	4071	{ 141, 9, 19, 9, 0, -14 }, // 0x2F '/'
	4072	{ 163, 9, 14, 11, 1, -13 }, // 0x30 '0'
	4073	{ 179, 4, 14, 11, 3, -13 }, // 0x31 '1'
	4074	{ 186, 9, 14, 11, 0, -13 }, // 0x32 '2'
	4075	{ 202, 8, 14, 11, 1, -13 }, // 0x33 '3'
	4076	{ 216, 11, 15, 11, 0, -14 }, // 0x34 '4'
	4077	{ 237, 9, 14, 11, 1, -13 }, // 0x35 '5'
	4078	{ 253, 9, 15, 11, 1, -14 }, // 0x36 '6'
	4079	{ 270, 10, 14, 11, 1, -13 }, // 0x37 '7'
	4080	{ 288, 8, 14, 11, 1, -13 }, // 0x38 '8'
	4081	{ 302, 9, 15, 11, 1, -13 }, // 0x39 '9'
	4082	{ 319, 2, 9, 6, 2, -8 }, // 0x3A ':'
	4083	{ 322, 4, 12, 5, 0, -8 }, // 0x3B ';'
	4084	{ 328, 9, 10, 11, 1, -11 }, // 0x3C '<'
	4085	{ 340, 9, 5, 11, 1, -9 }, // 0x3D '='
	4086	{ 346, 9, 10, 11, 1, -11 }, // 0x3E '>'
	4087	{ 358, 7, 14, 9, 1, -13 }, // 0x3F '?'
	4088	{ 371, 14, 14, 16, 1, -13 }, // 0x40 '@'
	4089	{ 396, 13, 14, 13, 0, -13 }, // 0x41 'A'
	4090	{ 419, 8, 14, 11, 2, -13 }, // 0x42 'B'
	4091	{ 433, 11, 14, 12, 1, -13 }, // 0x43 'C'
	4092	{ 453, 10, 14, 13, 2, -13 }, // 0x44 'D'
	4093	{ 471, 7, 14, 10, 2, -13 }, // 0x45 'E'
	4094	{ 484, 7, 14, 9, 2, -13 }, // 0x46 'F'
	4095	{ 497, 13, 14, 15, 1, -13 }, // 0x47 'G'
	4096	{ 520, 10, 14, 14, 2, -13 }, // 0x48 'H'
	4097	{ 538, 2, 14, 6, 2, -13 }, // 0x49 'I'
	4098	{ 542, 6, 14, 8, 0, -13 }, // 0x4A 'J'
	4099	{ 553, 10, 14, 12, 2, -13 }, // 0x4B 'K'
	4100	{ 571, 6, 14, 9, 2, -13 }, // 0x4C 'L'
	4101	{ 582, 15, 16, 17, 1, -14 }, // 0x4D 'M'
	4102	{ 612, 12, 16, 16, 2, -14 }, // 0x4E 'N'
	4103	{ 636, 14, 14, 16, 1, -13 }, // 0x4F 'O'
	4104	{ 661, 7, 14, 10, 2, -13 }, // 0x50 'P'
	4105	{ 674, 14, 14, 16, 1, -13 }, // 0x51 'Q'
	4106	{ 699, 8, 14, 11, 2, -13 }, // 0x52 'R'
	4107	{ 713, 9, 14, 11, 1, -13 }, // 0x53 'S'
	4108	{ 729, 8, 14, 10, 1, -13 }, // 0x54 'T'
	4109	{ 743, 10, 14, 14, 2, -13 }, // 0x55 'U'
	4110	{ 761, 12, 15, 12, 0, -13 }, // 0x56 'V'
	4111	{ 784, 19, 16, 19, 0, -14 }, // 0x57 'W'
	4112	{ 822, 11, 14, 11, 0, -13 }, // 0x58 'X'
	4113	{ 842, 10, 14, 10, 0, -13 }, // 0x59 'Y'
	4114	{ 860, 10, 14, 11, 1, -13 }, // 0x5A 'Z'
	4115	{ 878, 4, 19, 6, 2, -14 }, // 0x5B '['
	4116	{ 888, 9, 19, 9, 0, -14 }, // 0x5C '\'
	4117	{ 910, 4, 19, 6, 0, -14 }, // 0x5D ']'
	4118	{ 920, 10, 7, 10, 0, -13 }, // 0x5E '^'
	4119	{ 929, 10, 2, 10, 0, 2 }, // 0x5F '_'
	4120	{ 932, 4, 4, 10, 2, -13 }, // 0x60 '`'
	4121	{ 934, 9, 9, 11, 1, -8 }, // 0x61 'a'
	4122	{ 945, 9, 15, 11, 1, -14 }, // 0x62 'b'
	4123	{ 962, 7, 9, 9, 1, -8 }, // 0x63 'c'
	4124	{ 970, 9, 15, 11, 1, -14 }, // 0x64 'd'
	4125	{ 987, 8, 9, 10, 1, -8 }, // 0x65 'e'
	4126	{ 996, 5, 15, 6, 1, -14 }, // 0x66 'f'
	4127	{ 1006, 9, 14, 11, 1, -8 }, // 0x67 'g'
	4128	{ 1022, 7, 15, 9, 1, -14 }, // 0x68 'h'
	4129	{ 1036, 2, 14, 4, 1, -13 }, // 0x69 'i'
	4130	{ 1040, 2, 19, 4, 1, -13 }, // 0x6A 'j'
	4131	{ 1045, 8, 15, 9, 1, -14 }, // 0x6B 'k'
	4132	{ 1060, 2, 15, 4, 1, -14 }, // 0x6C 'l'
	4133	{ 1064, 12, 9, 14, 1, -8 }, // 0x6D 'm'
	4134	{ 1078, 7, 9, 9, 1, -8 }, // 0x6E 'n'
	4135	{ 1086, 9, 9, 11, 1, -8 }, // 0x6F 'o'
	4136	{ 1097, 9, 14, 11, 1, -8 }, // 0x70 'p'
	4137	{ 1113, 9, 14, 11, 1, -8 }, // 0x71 'q'
	4138	{ 1129, 6, 9, 6, 1, -8 }, // 0x72 'r'
	4139	{ 1136, 6, 9, 8, 1, -8 }, // 0x73 's'
	4140	{ 1143, 4, 12, 6, 1, -11 }, // 0x74 't'
	4141	{ 1149, 7, 9, 9, 1, -8 }, // 0x75 'u'
	4142	{ 1157, 9, 9, 9, 0, -8 }, // 0x76 'v'
	4143	{ 1168, 14, 10, 14, 0, -9 }, // 0x77 'w'
	4144	{ 1186, 10, 9, 10, 0, -8 }, // 0x78 'x'
	4145	{ 1198, 9, 14, 10, 0, -8 }, // 0x79 'y'
	4146	{ 1214, 9, 9, 9, 0, -8 }, // 0x7A 'z'
	4147	{ 1225, 5, 19, 6, 1, -14 }, // 0x7B '{'
	4148	{ 1237, 2, 17, 10, 4, -13 }, // 0x7C '\|'
	4149	{ 1242, 5, 19, 6, 0, -14 }, // 0x7D '}'
	4150	{ 1254, 9, 3, 13, 2, -14 } }; // 0x7E '~'
	4151
	4152	const GFXfont Futura9pt7b PROGMEM = {
	4153	(uint8_t *)Futura9pt7bBitmaps,
	4154	(GFXglyph *)Futura9pt7bGlyphs,
	4155	0x20, 0x7E, 23 };
	4156
	4157	// Approx. 1930 bytes
	4158	const uint8_t GillSans9pt7bBitmaps[] PROGMEM = {
	4159	0x00, 0xFF, 0xFE, 0x0F, 0xDE, 0xF7, 0xBD, 0x80, 0x08, 0x82, 0x10, 0x42,
	4160	0x7F, 0xF1, 0x08, 0x42, 0x08, 0x47, 0xFF, 0x21, 0x0C, 0x21, 0x08, 0x21,
	4161	0x00, 0x18, 0x3C, 0xFE, 0xDA, 0xD8, 0xF8, 0x7C, 0x1E, 0x1B, 0x9B, 0xFF,
	4162	0x7E, 0x18, 0x18, 0x70, 0x5F, 0x13, 0x64, 0x7C, 0x87, 0x20, 0x08, 0x01,
	4163	0x00, 0x4E, 0x13, 0xE2, 0x6C, 0x8F, 0xA0, 0xE0, 0x1E, 0x07, 0xE0, 0xCC,
	4164	0x19, 0x83, 0xE0, 0x30, 0x0F, 0x3B, 0x3E, 0xC3, 0x98, 0xF3, 0xF3, 0x3C,
	4165	0x70, 0xFF, 0xC0, 0x18, 0x88, 0xC4, 0x63, 0x18, 0xC6, 0x30, 0x86, 0x10,
	4166	0xC3, 0xC3, 0x08, 0x61, 0x0C, 0x63, 0x18, 0xC6, 0x23, 0x11, 0x18, 0x10,
	4167	0x23, 0x5B, 0xE1, 0x0F, 0xB5, 0x88, 0x10, 0x08, 0x04, 0x02, 0x01, 0x0F,
	4168	0xF8, 0x40, 0x20, 0x10, 0x08, 0x00, 0xF6, 0xFF, 0xF0, 0x08, 0x44, 0x21,
	4169	0x10, 0x88, 0x42, 0x21, 0x00, 0x38, 0xF9, 0xB6, 0x3C, 0x78, 0xF1, 0xE3,
	4170	0xC6, 0xD9, 0xF1, 0xC0, 0xFF, 0xFF, 0xFF, 0x78, 0xFC, 0xCE, 0x86, 0x06,
	4171	0x04, 0x0C, 0x18, 0x10, 0x20, 0x7F, 0xFF, 0x7B, 0xF8, 0xC3, 0x0C, 0xE3,
	4172	0xC3, 0x0E, 0x3F, 0x9C, 0x06, 0x06, 0x0E, 0x1E, 0x36, 0x26, 0x66, 0xFF,
	4173	0xFF, 0x06, 0x06, 0x06, 0x7C, 0xF9, 0x83, 0x07, 0x8F, 0x83, 0x83, 0x07,
	4174	0x1F, 0xF3, 0xC0, 0x10, 0x70, 0xC3, 0x86, 0x1F, 0xBF, 0xE3, 0xC7, 0x8D,
	4175	0xF1, 0xC0, 0xFF, 0xFE, 0x06, 0x0C, 0x0C, 0x0C, 0x18, 0x18, 0x30, 0x30,
	4176	0x60, 0x60, 0x38, 0xFB, 0x1E, 0x3C, 0x67, 0x1F, 0x63, 0xC7, 0x8D, 0xF1,
	4177	0xC0, 0x38, 0xFB, 0x1E, 0x3C, 0x6F, 0xCF, 0x86, 0x1C, 0x71, 0xC1, 0x00,
	4178	0xF0, 0x0F, 0xF0, 0x0F, 0x60, 0x00, 0x83, 0xCF, 0xDF, 0x0C, 0x07, 0xC0,
	4179	0xFC, 0x0F, 0x00, 0x80, 0xFF, 0x80, 0x00, 0x1F, 0xF0, 0x80, 0x78, 0x1F,
	4180	0x81, 0xF0, 0x18, 0x7D, 0xF9, 0xE0, 0x80, 0x00, 0x6F, 0x33, 0x37, 0x66,
	4181	0x20, 0x66, 0x07, 0xF0, 0x0F, 0xF8, 0x3C, 0x1C, 0x30, 0x06, 0x63, 0x9F,
	4182	0x67, 0xF3, 0xC6, 0x73, 0xCC, 0x33, 0xCC, 0x33, 0xCC, 0x66, 0xCC, 0x6E,
	4183	0xCF, 0xFC, 0x67, 0x78, 0x70, 0x03, 0x3C, 0x0E, 0x1F, 0xFC, 0x07, 0xF0,
	4184	0x02, 0x00, 0x38, 0x01, 0xC0, 0x1B, 0x00, 0xD8, 0x0C, 0x60, 0x63, 0x07,
	4185	0xFC, 0x3F, 0xE3, 0x01, 0x98, 0x0D, 0x80, 0x30, 0xFC, 0xFE, 0xC6, 0xC6,
	4186	0xC6, 0xFC, 0xFE, 0xC3, 0xC3, 0xC3, 0xFE, 0xFC, 0x0F, 0xC7, 0xFD, 0xC0,
	4187	0xB0, 0x0C, 0x01, 0x80, 0x30, 0x06, 0x00, 0x60, 0x0E, 0x04, 0xFF, 0x87,
	4188	0xE0, 0xFF, 0x0F, 0xFC, 0xC0, 0xEC, 0x06, 0xC0, 0x3C, 0x03, 0xC0, 0x3C,
	4189	0x03, 0xC0, 0x6C, 0x0E, 0xFF, 0xCF, 0xF0, 0xFF, 0xFF, 0x06, 0x0C, 0x1F,
	4190	0xFF, 0xE0, 0xC1, 0x83, 0xFF, 0xF0, 0xFF, 0xFC, 0x30, 0xC3, 0xFF, 0xF0,
	4191	0xC3, 0x0C, 0x30, 0x0F, 0xC7, 0xFD, 0xC0, 0xB0, 0x0C, 0x01, 0x80, 0x30,
	4192	0x7E, 0x0F, 0xE0, 0x6E, 0x0C, 0xFF, 0x87, 0xC0, 0xC0, 0x78, 0x0F, 0x01,
	4193	0xE0, 0x3C, 0x07, 0xFF, 0xFF, 0xFE, 0x03, 0xC0, 0x78, 0x0F, 0x01, 0xE0,
	4194	0x30, 0xFF, 0xFF, 0xFF, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0xFE,
	4195	0xC1, 0xB0, 0xCC, 0x63, 0x30, 0xD8, 0x3C, 0x0D, 0x83, 0x30, 0xC6, 0x30,
	4196	0xCC, 0x1B, 0x03, 0xC1, 0x83, 0x06, 0x0C, 0x18, 0x30, 0x60, 0xC1, 0x83,
	4197	0xFF, 0xF0, 0xC0, 0xFC, 0x1F, 0xC7, 0xED, 0xBD, 0xF7, 0x9C, 0xF1, 0x1E,
	4198	0x03, 0xC0, 0x78, 0x0F, 0x01, 0xE0, 0x30, 0xC0, 0x3E, 0x03, 0xF0, 0x3D,
	4199	0x83, 0xCC, 0x3C, 0x63, 0xC6, 0x3C, 0x33, 0xC1, 0xBC, 0x0F, 0xC0, 0x7C,
	4200	0x03, 0x0F, 0x81, 0xFF, 0x1C, 0x1C, 0xC0, 0x6C, 0x01, 0xE0, 0x0F, 0x00,
	4201	0x78, 0x03, 0x60, 0x33, 0x83, 0x8F, 0xF8, 0x1F, 0x00, 0xFC, 0xFE, 0xC3,
	4202	0xC3, 0xC3, 0xFE, 0xFC, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0x0F, 0x81, 0xFF,
	4203	0x1C, 0x1C, 0xC0, 0x6C, 0x01, 0xE0, 0x0F, 0x00, 0x78, 0x03, 0xE0, 0x33,
	4204	0x83, 0x8F, 0xF8, 0x3F, 0x00, 0x3F, 0x80, 0x78, 0xF8, 0x7E, 0x31, 0x98,
	4205	0xCC, 0x67, 0xE3, 0xE1, 0x98, 0xC6, 0x63, 0x30, 0xD8, 0x30, 0x7B, 0xFC,
	4206	0x70, 0xC1, 0xC3, 0x83, 0x0E, 0x3F, 0xDE, 0xFF, 0xFF, 0xF0, 0xC0, 0x30,
	4207	0x0C, 0x03, 0x00, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0xC0, 0x30, 0xC0, 0x78,
	4208	0x0F, 0x01, 0xE0, 0x3C, 0x07, 0x80, 0xF0, 0x1E, 0x03, 0xC0, 0x7C, 0x1D,
	4209	0xFF, 0x0F, 0x80, 0xC0, 0x6C, 0x19, 0x83, 0x30, 0x63, 0x18, 0x63, 0x06,
	4210	0xC0, 0xD8, 0x0E, 0x01, 0xC0, 0x38, 0x02, 0x00, 0xC0, 0xE0, 0x6C, 0x1C,
	4211	0x19, 0x86, 0x83, 0x38, 0xD8, 0xE3, 0x1B, 0x18, 0x66, 0x33, 0x06, 0xC6,
	4212	0xC0, 0xD8, 0xD8, 0x0E, 0x0E, 0x01, 0xC1, 0xC0, 0x38, 0x38, 0x02, 0x02,
	4213	0x00, 0xC0, 0x1B, 0x01, 0x8C, 0x18, 0x31, 0x80, 0xD8, 0x03, 0x80, 0x1C,
	4214	0x01, 0xB0, 0x18, 0xC1, 0x83, 0x18, 0x0D, 0x80, 0x70, 0xC0, 0x6C, 0x18,
	4215	0xC6, 0x0C, 0xC0, 0xF0, 0x0C, 0x01, 0x80, 0x30, 0x06, 0x00, 0xC0, 0x18,
	4216	0x03, 0x00, 0x7F, 0xEF, 0xF8, 0x06, 0x01, 0x80, 0x70, 0x0C, 0x03, 0x00,
	4217	0xC0, 0x18, 0x06, 0x01, 0xFF, 0xFF, 0xF0, 0xFF, 0xCC, 0xCC, 0xCC, 0xCC,
	4218	0xCC, 0xCC, 0xFF, 0x84, 0x10, 0x84, 0x10, 0x82, 0x10, 0x82, 0x10, 0xFF,
	4219	0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0xFF, 0x38, 0x71, 0xB3, 0x66, 0xD8,
	4220	0xF1, 0x80, 0xFF, 0xC0, 0xCC, 0x80, 0x79, 0xFA, 0x30, 0xE6, 0xD9, 0xB3,
	4221	0x3F, 0xC1, 0x83, 0x06, 0x0D, 0xDF, 0xB3, 0xE3, 0xC7, 0x9F, 0xF7, 0xC0,
	4222	0x3D, 0xFE, 0x30, 0xC3, 0x87, 0xCF, 0x06, 0x0C, 0x18, 0x33, 0xEF, 0xF9,
	4223	0xE3, 0xC7, 0x8D, 0xF9, 0xF0, 0x38, 0xFB, 0x1F, 0xFC, 0x1C, 0x1F, 0x9F,
	4224	0x3B, 0xD8, 0xCF, 0x79, 0x8C, 0x63, 0x18, 0xC0, 0x7F, 0x9F, 0x36, 0x67,
	4225	0x98, 0x3C, 0x3E, 0xCF, 0x0F, 0x3B, 0xE0, 0xC1, 0x83, 0x06, 0x0D, 0xDF,
	4226	0xF9, 0xE3, 0xC7, 0x8F, 0x1E, 0x30, 0xF3, 0xFF, 0xFC, 0x6C, 0x36, 0xDB,
	4227	0x6D, 0xB7, 0xF0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC6, 0xCC, 0xD8, 0xF0, 0xD8,
	4228	0xCC, 0xC6, 0xC3, 0xFF, 0xFF, 0xFF, 0xDC, 0xEF, 0xFF, 0xC6, 0x3C, 0x63,
	4229	0xC6, 0x3C, 0x63, 0xC6, 0x3C, 0x63, 0xDD, 0xFF, 0x1E, 0x3C, 0x78, 0xF1,
	4230	0xE3, 0x3C, 0x7E, 0xE7, 0xC3, 0xC3, 0xE7, 0x7E, 0x3C, 0xF9, 0xFB, 0x3E,
	4231	0x3C, 0x79, 0xFF, 0x7C, 0xC1, 0x83, 0x06, 0x00, 0x3E, 0xFF, 0x9E, 0x3C,
	4232	0x7C, 0xDF, 0x9F, 0x06, 0x0C, 0x18, 0x30, 0xDB, 0xFE, 0xB0, 0xC3, 0x0C,
	4233	0x30, 0x77, 0xF2, 0xC3, 0x4F, 0xEE, 0x00, 0x87, 0xFF, 0x61, 0x86, 0x18,
	4234	0x7C, 0xF0, 0xC7, 0x8F, 0x1E, 0x3C, 0x78, 0xFF, 0xBB, 0xC7, 0x8D, 0xB3,
	4235	0x66, 0xC7, 0x8E, 0x1C, 0xC7, 0x1E, 0x38, 0xD9, 0xCC, 0xDB, 0x66, 0xDB,
	4236	0x1C, 0x70, 0xE3, 0x86, 0x0C, 0xC1, 0xB1, 0x8D, 0x83, 0x81, 0xC1, 0xB1,
	4237	0x8D, 0x83, 0xC3, 0x66, 0x66, 0x3C, 0x3C, 0x18, 0x18, 0x30, 0x30, 0x60,
	4238	0x60, 0xC0, 0xFF, 0xF8, 0x70, 0xC3, 0x0E, 0x1F, 0xFF, 0x1C, 0xF3, 0x0C,
	4239	0x30, 0xC3, 0x18, 0x83, 0x87, 0x0C, 0x30, 0xC3, 0x0F, 0x1C, 0xFF, 0xFF,
	4240	0xE3, 0xC3, 0x0C, 0x30, 0xC3, 0x06, 0x04, 0x73, 0x8C, 0x30, 0xC3, 0x3C,
	4241	0xE0, 0xF8, 0xC7, 0xC0 };
	4242
	4243	const GFXglyph GillSans9pt7bGlyphs[] PROGMEM = {
	4244	{ 0, 1, 1, 5, 0, 0 }, // 0x20 ' '
	4245	{ 1, 2, 12, 5, 1, -11 }, // 0x21 '!'
	4246	{ 4, 5, 5, 6, 1, -11 }, // 0x22 '"'
	4247	{ 8, 11, 12, 11, 0, -11 }, // 0x23 '#'
	4248	{ 25, 8, 14, 10, 1, -11 }, // 0x24 '$'
	4249	{ 39, 11, 12, 12, 0, -11 }, // 0x25 '%'
	4250	{ 56, 11, 12, 11, 1, -11 }, // 0x26 '&'
	4251	{ 73, 2, 5, 3, 1, -11 }, // 0x27 '''
	4252	{ 75, 5, 16, 6, 1, -11 }, // 0x28 '('
	4253	{ 85, 5, 16, 6, 0, -11 }, // 0x29 ')'
	4254	{ 95, 7, 9, 8, 0, -12 }, // 0x2A '*'
	4255	{ 103, 9, 9, 11, 1, -10 }, // 0x2B '+'
	4256	{ 114, 2, 4, 4, 1, -1 }, // 0x2C ','
	4257	{ 115, 4, 2, 6, 1, -4 }, // 0x2D '-'
	4258	{ 116, 2, 2, 4, 1, -1 }, // 0x2E '.'
	4259	{ 117, 5, 12, 5, 0, -11 }, // 0x2F '/'
	4260	{ 125, 7, 12, 9, 1, -11 }, // 0x30 '0'
	4261	{ 136, 2, 12, 9, 3, -11 }, // 0x31 '1'
	4262	{ 139, 8, 12, 9, 1, -11 }, // 0x32 '2'
	4263	{ 151, 6, 12, 9, 1, -11 }, // 0x33 '3'
	4264	{ 160, 8, 12, 9, 0, -11 }, // 0x34 '4'
	4265	{ 172, 7, 12, 9, 1, -11 }, // 0x35 '5'
	4266	{ 183, 7, 12, 9, 1, -11 }, // 0x36 '6'
	4267	{ 194, 8, 12, 9, 1, -11 }, // 0x37 '7'
	4268	{ 206, 7, 12, 9, 1, -11 }, // 0x38 '8'
	4269	{ 217, 7, 12, 9, 1, -11 }, // 0x39 '9'
	4270	{ 228, 2, 8, 4, 1, -7 }, // 0x3A ':'
	4271	{ 230, 2, 10, 4, 1, -7 }, // 0x3B ';'
	4272	{ 233, 9, 9, 11, 1, -10 }, // 0x3C '<'
	4273	{ 244, 9, 4, 11, 1, -8 }, // 0x3D '='
	4274	{ 249, 9, 9, 11, 1, -10 }, // 0x3E '>'
	4275	{ 260, 4, 12, 6, 1, -11 }, // 0x3F '?'
	4276	{ 266, 16, 17, 18, 1, -12 }, // 0x40 '@'
	4277	{ 300, 13, 12, 12, 0, -11 }, // 0x41 'A'
	4278	{ 320, 8, 12, 10, 1, -11 }, // 0x42 'B'
	4279	{ 332, 11, 12, 13, 1, -11 }, // 0x43 'C'
	4280	{ 349, 12, 12, 14, 1, -11 }, // 0x44 'D'
	4281	{ 367, 7, 12, 9, 1, -11 }, // 0x45 'E'
	4282	{ 378, 6, 12, 8, 1, -11 }, // 0x46 'F'
	4283	{ 387, 11, 12, 13, 1, -11 }, // 0x47 'G'
	4284	{ 404, 11, 12, 13, 1, -11 }, // 0x48 'H'
	4285	{ 421, 2, 12, 5, 1, -11 }, // 0x49 'I'
	4286	{ 424, 4, 16, 5, -1, -11 }, // 0x4A 'J'
	4287	{ 432, 10, 12, 12, 1, -11 }, // 0x4B 'K'
	4288	{ 447, 7, 12, 9, 1, -11 }, // 0x4C 'L'
	4289	{ 458, 11, 12, 14, 1, -11 }, // 0x4D 'M'
	4290	{ 475, 12, 12, 14, 1, -11 }, // 0x4E 'N'
	4291	{ 493, 13, 12, 15, 1, -11 }, // 0x4F 'O'
	4292	{ 513, 8, 12, 9, 1, -11 }, // 0x50 'P'
	4293	{ 525, 13, 14, 15, 1, -11 }, // 0x51 'Q'
	4294	{ 548, 9, 12, 11, 1, -11 }, // 0x52 'R'
	4295	{ 562, 6, 12, 8, 1, -11 }, // 0x53 'S'
	4296	{ 571, 10, 12, 11, 0, -11 }, // 0x54 'T'
	4297	{ 586, 11, 12, 13, 1, -11 }, // 0x55 'U'
	4298	{ 603, 11, 12, 11, 0, -11 }, // 0x56 'V'
	4299	{ 620, 19, 12, 19, 0, -11 }, // 0x57 'W'
	4300	{ 649, 13, 12, 13, 0, -11 }, // 0x58 'X'
	4301	{ 669, 11, 12, 11, 0, -11 }, // 0x59 'Y'
	4302	{ 686, 11, 12, 12, 0, -11 }, // 0x5A 'Z'
	4303	{ 703, 4, 16, 6, 2, -11 }, // 0x5B '['
	4304	{ 711, 5, 12, 5, 0, -11 }, // 0x5C '\'
	4305	{ 719, 4, 16, 6, 0, -11 }, // 0x5D ']'
	4306	{ 727, 7, 7, 8, 0, -11 }, // 0x5E '^'
	4307	{ 734, 10, 1, 10, 0, 4 }, // 0x5F '_'
	4308	{ 736, 3, 3, 6, 1, -12 }, // 0x60 '`'
	4309	{ 738, 7, 8, 8, 1, -7 }, // 0x61 'a'
	4310	{ 745, 7, 12, 9, 1, -11 }, // 0x62 'b'
	4311	{ 756, 6, 8, 8, 1, -7 }, // 0x63 'c'
	4312	{ 762, 7, 12, 9, 1, -11 }, // 0x64 'd'
	4313	{ 773, 7, 8, 9, 1, -7 }, // 0x65 'e'
	4314	{ 780, 5, 12, 5, 0, -11 }, // 0x66 'f'
	4315	{ 788, 7, 12, 8, 1, -7 }, // 0x67 'g'
	4316	{ 799, 7, 12, 9, 1, -11 }, // 0x68 'h'
	4317	{ 810, 2, 11, 4, 1, -10 }, // 0x69 'i'
	4318	{ 813, 3, 15, 4, 0, -10 }, // 0x6A 'j'
	4319	{ 819, 8, 12, 9, 1, -11 }, // 0x6B 'k'
	4320	{ 831, 2, 12, 4, 1, -11 }, // 0x6C 'l'
	4321	{ 834, 12, 8, 14, 1, -7 }, // 0x6D 'm'
	4322	{ 846, 7, 8, 9, 1, -7 }, // 0x6E 'n'
	4323	{ 853, 8, 8, 10, 1, -7 }, // 0x6F 'o'
	4324	{ 861, 7, 12, 9, 1, -7 }, // 0x70 'p'
	4325	{ 872, 7, 12, 9, 1, -7 }, // 0x71 'q'
	4326	{ 883, 6, 8, 7, 1, -7 }, // 0x72 'r'
	4327	{ 889, 5, 8, 7, 1, -7 }, // 0x73 's'
	4328	{ 894, 6, 10, 6, 0, -9 }, // 0x74 't'
	4329	{ 902, 7, 8, 9, 1, -7 }, // 0x75 'u'
	4330	{ 909, 7, 8, 8, 0, -7 }, // 0x76 'v'
	4331	{ 916, 13, 8, 13, 0, -7 }, // 0x77 'w'
	4332	{ 929, 9, 8, 9, 0, -7 }, // 0x78 'x'
	4333	{ 938, 8, 12, 8, 0, -7 }, // 0x79 'y'
	4334	{ 950, 7, 8, 8, 0, -7 }, // 0x7A 'z'
	4335	{ 957, 6, 17, 6, 0, -12 }, // 0x7B '{'
	4336	{ 970, 1, 16, 5, 2, -11 }, // 0x7C '\|'
	4337	{ 972, 6, 17, 6, 0, -12 }, // 0x7D '}'
	4338	{ 985, 9, 2, 11, 1, -6 } }; // 0x7E '~'
	4339
	4340	const GFXfont GillSans9pt7b PROGMEM = {
	4341	(uint8_t *)GillSans9pt7bBitmaps,
	4342	(GFXglyph *)GillSans9pt7bGlyphs,
	4343	0x20, 0x7E, 20 };
	4344
	4345	// Approx. 1660 bytes
	4346	const uint8_t ptmono9pt7bBitmaps[] PROGMEM = {
	4347	0x00, 0xFF, 0xFF, 0xCF, 0xC0, 0xCF, 0x3C, 0xF3, 0xCE, 0x20, 0x1D, 0xC6,
	4348	0x61, 0x99, 0xFF, 0x7F, 0xCC, 0xC3, 0x33, 0xFE, 0xFF, 0x8C, 0xC6, 0x61,
	4349	0x98, 0x18, 0x18, 0x3E, 0x7E, 0xCA, 0xC8, 0xE8, 0x78, 0x7E, 0x1F, 0x17,
	4350	0x13, 0x93, 0xFE, 0xFC, 0x18, 0x18, 0x70, 0x5F, 0x0F, 0x63, 0x6C, 0xCF,
	4351	0xB0, 0xEC, 0x01, 0x00, 0x6E, 0x1B, 0xE6, 0x6D, 0x8D, 0xE1, 0xF4, 0x1C,
	4352	0x3C, 0x1F, 0x86, 0x61, 0x98, 0x3C, 0x0E, 0x07, 0x8F, 0x33, 0xC6, 0xF0,
	4353	0xEE, 0x39, 0xFF, 0x3C, 0x40, 0xFF, 0xE0, 0x06, 0x3C, 0xE3, 0x86, 0x1C,
	4354	0x30, 0x60, 0xC1, 0x83, 0x07, 0x06, 0x0E, 0x0E, 0x0F, 0x06, 0xC1, 0xE0,
	4355	0xE0, 0xE0, 0xC1, 0xC1, 0x83, 0x06, 0x0C, 0x18, 0x70, 0xC3, 0x8E, 0x78,
	4356	0xC0, 0x22, 0x3B, 0x85, 0x1F, 0xFF, 0xF8, 0xA1, 0xD8, 0x46, 0x18, 0x18,
	4357	0x18, 0x18, 0xFF, 0xFF, 0x18, 0x18, 0x18, 0x18, 0x67, 0x71, 0x2C, 0xFF,
	4358	0xC0, 0xFF, 0x80, 0x02, 0x03, 0x06, 0x06, 0x0C, 0x0C, 0x0C, 0x18, 0x18,
	4359	0x30, 0x30, 0x70, 0x60, 0x60, 0xC0, 0x40, 0x3E, 0x3F, 0x98, 0xD8, 0x3C,
	4360	0x7E, 0x7F, 0x77, 0xF3, 0xE1, 0xE0, 0xD8, 0xCF, 0xE3, 0xE0, 0x18, 0x38,
	4361	0x78, 0xD8, 0x98, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xFF, 0xFF, 0x7C,
	4362	0xFE, 0x47, 0x03, 0x03, 0x03, 0x06, 0x0C, 0x18, 0x38, 0x60, 0xFF, 0xFF,
	4363	0xFE, 0xFE, 0x0C, 0x1C, 0x18, 0x3E, 0x3F, 0x07, 0x03, 0x03, 0x87, 0xFE,
	4364	0xFC, 0x03, 0x01, 0xC0, 0xF0, 0x7C, 0x3B, 0x0C, 0xC6, 0x33, 0xFF, 0xFF,
	4365	0xC0, 0xC0, 0x30, 0x0C, 0x03, 0x00, 0x7F, 0x7F, 0x60, 0x60, 0x60, 0x7C,
	4366	0x7E, 0x07, 0x03, 0x03, 0x87, 0xFE, 0xFC, 0x06, 0x0F, 0x0E, 0x0E, 0x06,
	4367	0x06, 0xF3, 0xFD, 0xC7, 0xC1, 0xE0, 0xF8, 0xEF, 0xE3, 0xE0, 0xFF, 0xFF,
	4368	0x07, 0x06, 0x0E, 0x0C, 0x0C, 0x18, 0x18, 0x30, 0x30, 0x60, 0xE0, 0x3E,
	4369	0x3F, 0xF8, 0xF8, 0x3E, 0x31, 0xF0, 0xFC, 0xCF, 0xC1, 0xE0, 0xF8, 0xEF,
	4370	0xE3, 0xE0, 0x3E, 0x3F, 0xB8, 0xF8, 0x3C, 0x1F, 0x0D, 0xFE, 0x7B, 0x03,
	4371	0x01, 0x83, 0x87, 0x83, 0x80, 0xFF, 0x80, 0x07, 0xFC, 0x77, 0x70, 0x00,
	4372	0x06, 0x77, 0x12, 0xC0, 0x01, 0x01, 0xC3, 0xC7, 0x87, 0x07, 0x01, 0xE0,
	4373	0x78, 0x0F, 0x01, 0xC0, 0x40, 0xFF, 0xFF, 0xC0, 0x00, 0x0F, 0xFF, 0xFC,
	4374	0x40, 0x70, 0x1E, 0x03, 0xC0, 0x70, 0x1C, 0x3C, 0x3C, 0x78, 0x70, 0x10,
	4375	0x00, 0x3E, 0x3F, 0xF0, 0x60, 0x30, 0x38, 0x38, 0x38, 0x30, 0x18, 0x00,
	4376	0x06, 0x03, 0x81, 0x80, 0x0F, 0x07, 0xF1, 0xC3, 0x30, 0x6E, 0x0D, 0x9F,
	4377	0xB7, 0xF6, 0xC6, 0xD8, 0xDB, 0xFF, 0xBB, 0xB0, 0x07, 0x88, 0x7F, 0x83,
	4378	0xF0, 0x0C, 0x03, 0x01, 0xE0, 0x78, 0x1E, 0x0C, 0xC3, 0x30, 0xCC, 0x7F,
	4379	0x9F, 0xE6, 0x1B, 0x03, 0xC0, 0xC0, 0xFE, 0x7F, 0xF0, 0x78, 0x3C, 0x37,
	4380	0xF3, 0xFD, 0x87, 0xC1, 0xE0, 0xF0, 0xFF, 0xEF, 0xE0, 0x1F, 0x9F, 0xDC,
	4381	0x6C, 0x3C, 0x06, 0x03, 0x01, 0x80, 0xC0, 0x70, 0xDC, 0x67, 0xF1, 0xF0,
	4382	0xFC, 0x7F, 0xB0, 0xD8, 0x7C, 0x1E, 0x0F, 0x07, 0x83, 0xC1, 0xE1, 0xF1,
	4383	0xDF, 0xCF, 0xC0, 0xFF, 0xFF, 0xC0, 0xC0, 0xC0, 0xFE, 0xFE, 0xC0, 0xC0,
	4384	0xC0, 0xC0, 0xFF, 0xFF, 0xFF, 0xFF, 0xC0, 0xC0, 0xC0, 0xFF, 0xFF, 0xC0,
	4385	0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0x1F, 0x9F, 0xDC, 0x6C, 0x3C, 0x06, 0x03,
	4386	0x1F, 0x8F, 0xC1, 0xB0, 0xDC, 0x67, 0xF1, 0xF0, 0xC1, 0xE0, 0xF0, 0x78,
	4387	0x3C, 0x1F, 0xFF, 0xFF, 0x83, 0xC1, 0xE0, 0xF0, 0x78, 0x3C, 0x18, 0xFF,
	4388	0xFF, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xFF, 0xFF,
	4389	0xFF, 0xFF, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x87, 0xFE,
	4390	0x7C, 0xC1, 0xF0, 0xEC, 0x73, 0x1C, 0xCE, 0x3F, 0x0F, 0xC3, 0x38, 0xC6,
	4391	0x31, 0xCC, 0x3B, 0x0E, 0xC1, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0,
	4392	0xC0, 0xC0, 0xC3, 0xC3, 0xC3, 0xFF, 0xFF, 0xC1, 0xF1, 0xFD, 0xFE, 0xFF,
	4393	0xFE, 0xEF, 0x27, 0x83, 0xC1, 0xE0, 0xF0, 0x78, 0x3C, 0x18, 0xC1, 0xF0,
	4394	0xF8, 0x7E, 0x3F, 0x9F, 0xCF, 0x77, 0xBF, 0xCF, 0xE3, 0xF1, 0xF8, 0x7C,
	4395	0x18, 0x1E, 0x1F, 0xE6, 0x1B, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0,
	4396	0xF0, 0x36, 0x19, 0xFE, 0x1E, 0x00, 0xFE, 0x7F, 0xB0, 0xF8, 0x3C, 0x1E,
	4397	0x0F, 0x0F, 0xFE, 0xFC, 0x60, 0x30, 0x18, 0x0C, 0x00, 0x1E, 0x1F, 0xE6,
	4398	0x1B, 0x03, 0xC0, 0xF0, 0x3C, 0x0F, 0x03, 0xC0, 0xF0, 0x36, 0x19, 0xFE,
	4399	0x1E, 0x03, 0x00, 0x7C, 0x0F, 0xFC, 0x7F, 0x31, 0xD8, 0x6C, 0x36, 0x3B,
	4400	0xF9, 0xF8, 0xCE, 0x67, 0x31, 0xD8, 0xEC, 0x38, 0x3F, 0xBF, 0xF0, 0x78,
	4401	0x3E, 0x03, 0xC0, 0xF8, 0x1F, 0x01, 0xE0, 0xF0, 0xFF, 0xE7, 0xE0, 0xFF,
	4402	0xFF, 0xFC, 0xCF, 0x33, 0x0C, 0x03, 0x00, 0xC0, 0x30, 0x0C, 0x03, 0x00,
	4403	0xC0, 0xFC, 0x3F, 0x00, 0xC1, 0xE0, 0xF0, 0x78, 0x3C, 0x1E, 0x0F, 0x07,
	4404	0x83, 0xC1, 0xE0, 0xF8, 0xEF, 0xE3, 0xE0, 0xE1, 0xF8, 0x76, 0x19, 0xC6,
	4405	0x73, 0x8C, 0xC3, 0x30, 0xEC, 0x3F, 0x07, 0x81, 0xE0, 0x78, 0x0E, 0x00,
	4406	0xC0, 0x78, 0x0F, 0x01, 0xF0, 0x3E, 0x66, 0xDD, 0x9B, 0xB3, 0x5E, 0x7B,
	4407	0xCF, 0x79, 0xC7, 0x38, 0xE7, 0x1C, 0xE0, 0xEE, 0x38, 0xE6, 0x1D, 0xC1,
	4408	0xF0, 0x3E, 0x03, 0x80, 0xF8, 0x1B, 0x07, 0x71, 0xC7, 0x38, 0xEE, 0x0E,
	4409	0xE1, 0xD8, 0x67, 0x38, 0xCC, 0x3F, 0x07, 0x81, 0xE0, 0x30, 0x0C, 0x03,
	4410	0x00, 0xC0, 0x30, 0x0C, 0x00, 0xFF, 0xFF, 0xC0, 0xE0, 0xE0, 0xE0, 0x60,
	4411	0x70, 0x70, 0x70, 0x38, 0x38, 0x1F, 0xFF, 0xF8, 0xFF, 0xFF, 0x06, 0x0C,
	4412	0x18, 0x30, 0x60, 0xC1, 0x83, 0x06, 0x0C, 0x18, 0x30, 0x7F, 0xFE, 0x40,
	4413	0xC0, 0x60, 0x60, 0x30, 0x30, 0x30, 0x18, 0x18, 0x0C, 0x0C, 0x0C, 0x06,
	4414	0x06, 0x03, 0x02, 0xFF, 0xFC, 0x18, 0x30, 0x60, 0xC1, 0x83, 0x06, 0x0C,
	4415	0x18, 0x30, 0x60, 0xC1, 0xFF, 0xFE, 0x0C, 0x03, 0x81, 0xE0, 0xCC, 0x33,
	4416	0x18, 0x6E, 0x1C, 0xFF, 0xFF, 0xE7, 0x30, 0x7E, 0x3F, 0x80, 0xC7, 0xEF,
	4417	0xF6, 0x1B, 0x0D, 0xFF, 0x7B, 0x80, 0xE0, 0x38, 0x06, 0x01, 0x80, 0x6F,
	4418	0x1F, 0xE7, 0x1D, 0x83, 0x60, 0xD8, 0x36, 0x1D, 0xFE, 0x3E, 0x00, 0x1F,
	4419	0x3F, 0xF8, 0x78, 0x3C, 0x06, 0x03, 0x84, 0xFF, 0x3F, 0x00, 0x03, 0x80,
	4420	0xE0, 0x18, 0x06, 0x1F, 0x9F, 0xEE, 0x1B, 0x06, 0xC1, 0xB0, 0x6E, 0x39,
	4421	0xFF, 0x3C, 0xC0, 0x3E, 0x3F, 0xB0, 0x7F, 0xFF, 0xFE, 0x03, 0x84, 0xFF,
	4422	0x3F, 0x00, 0x0F, 0x8F, 0xCC, 0x46, 0x0F, 0xF7, 0xF8, 0xC0, 0x60, 0x30,
	4423	0x18, 0x0C, 0x1F, 0xEF, 0xF0, 0x3F, 0xBF, 0xF8, 0x78, 0x3C, 0x1E, 0x0F,
	4424	0x8E, 0xFF, 0x3F, 0x80, 0xC8, 0xEF, 0xE3, 0xE0, 0xE0, 0x70, 0x18, 0x0C,
	4425	0x06, 0xF3, 0xFD, 0xC6, 0xC3, 0x61, 0xB0, 0xD8, 0x6C, 0x36, 0x18, 0x1C,
	4426	0x1C, 0x1C, 0x00, 0xF8, 0xF8, 0x18, 0x18, 0x18, 0x18, 0x18, 0xFF, 0xFF,
	4427	0x0E, 0x1C, 0x38, 0x07, 0xEF, 0xC1, 0x83, 0x06, 0x0C, 0x18, 0x30, 0x60,
	4428	0xE3, 0xFE, 0x78, 0xE0, 0x38, 0x06, 0x01, 0x80, 0x63, 0x99, 0xC6, 0xE1,
	4429	0xB0, 0x7C, 0x1B, 0x86, 0x71, 0x9F, 0x63, 0xC0, 0xF0, 0xF0, 0x30, 0x30,
	4430	0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x3F, 0x1E, 0xFB, 0xBF, 0xFC,
	4431	0xCF, 0x33, 0xCC, 0xF3, 0x3C, 0xCF, 0x33, 0xCC, 0xC0, 0xEF, 0x7F, 0xDC,
	4432	0xEC, 0x36, 0x1B, 0x0D, 0x86, 0xC3, 0x61, 0x80, 0x3F, 0x1F, 0xEE, 0x1F,
	4433	0x03, 0xC0, 0xF0, 0x3E, 0x1D, 0xFE, 0x3F, 0x00, 0xEF, 0x3F, 0xE7, 0x1D,
	4434	0x83, 0x60, 0xD8, 0x36, 0x1D, 0xFE, 0x7F, 0x18, 0x06, 0x01, 0x80, 0x60,
	4435	0x00, 0x1F, 0xBF, 0xF8, 0x78, 0x3C, 0x1E, 0x0F, 0x8E, 0xFF, 0x3D, 0x80,
	4436	0xC0, 0x60, 0x30, 0x18, 0xF7, 0x7F, 0xCE, 0x66, 0x03, 0x01, 0x80, 0xC1,
	4437	0xFE, 0xFF, 0x00, 0x7E, 0xFF, 0xC2, 0xF0, 0x7E, 0x07, 0x43, 0xFF, 0x3E,
	4438	0x10, 0x0C, 0x03, 0x03, 0xFE, 0xFF, 0x8C, 0x03, 0x00, 0xC0, 0x30, 0x0E,
	4439	0x21, 0xFC, 0x3C, 0xE3, 0xB8, 0xE6, 0x19, 0x86, 0x61, 0x98, 0x66, 0x39,
	4440	0xFF, 0x3C, 0xC0, 0xE1, 0xD8, 0x67, 0x18, 0xCE, 0x3B, 0x0E, 0xC1, 0xE0,
	4441	0x78, 0x0E, 0x00, 0xC0, 0x7C, 0x0D, 0x9B, 0x37, 0x66, 0xEC, 0xDF, 0x9E,
	4442	0xF1, 0xDC, 0x39, 0x80, 0xE3, 0xB9, 0x8D, 0x87, 0xC1, 0xC1, 0xF1, 0xDC,
	4443	0xC6, 0xE3, 0x80, 0xE1, 0xD8, 0x76, 0x19, 0xC6, 0x33, 0x8E, 0xC1, 0xB0,
	4444	0x7C, 0x0E, 0x01, 0x84, 0xE1, 0xF0, 0x38, 0x00, 0xFF, 0xFF, 0x06, 0x0C,
	4445	0x18, 0x30, 0x60, 0xFF, 0xFF, 0x0F, 0x1F, 0x18, 0x18, 0x18, 0x18, 0x18,
	4446	0x38, 0xF0, 0xF0, 0x38, 0x18, 0x18, 0x18, 0x18, 0x1F, 0x0F, 0xFF, 0xFF,
	4447	0xFF, 0xFC, 0xF0, 0xF8, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1C, 0x0F, 0x0F,
	4448	0x1C, 0x18, 0x18, 0x18, 0x18, 0xF8, 0xF0, 0x72, 0xFF, 0x8F };
	4449
	4450	const GFXglyph ptmono9pt7bGlyphs[] PROGMEM = {
	4451	{ 0, 1, 1, 11, 0, 0 }, // 0x20 ' '
	4452	{ 1, 2, 13, 11, 4, -12 }, // 0x21 '!'
	4453	{ 5, 6, 6, 11, 2, -12 }, // 0x22 '"'
	4454	{ 10, 10, 12, 11, 0, -11 }, // 0x23 '#'
	4455	{ 25, 8, 17, 11, 1, -14 }, // 0x24 '$'
	4456	{ 42, 11, 13, 11, 0, -12 }, // 0x25 '%'
	4457	{ 60, 10, 13, 11, 0, -12 }, // 0x26 '&'
	4458	{ 77, 2, 6, 11, 4, -12 }, // 0x27 '''
	4459	{ 79, 7, 17, 11, 2, -12 }, // 0x28 '('
	4460	{ 94, 7, 17, 11, 2, -12 }, // 0x29 ')'
	4461	{ 109, 9, 8, 11, 1, -12 }, // 0x2A '*'
	4462	{ 118, 8, 10, 11, 1, -10 }, // 0x2B '+'
	4463	{ 128, 4, 6, 11, 3, -2 }, // 0x2C ','
	4464	{ 131, 5, 2, 11, 3, -5 }, // 0x2D '-'
	4465	{ 133, 3, 3, 11, 4, -2 }, // 0x2E '.'
	4466	{ 135, 8, 16, 11, 1, -12 }, // 0x2F '/'
	4467	{ 151, 9, 13, 11, 1, -12 }, // 0x30 '0'
	4468	{ 166, 8, 13, 11, 2, -12 }, // 0x31 '1'
	4469	{ 179, 8, 13, 11, 1, -12 }, // 0x32 '2'
	4470	{ 192, 8, 13, 11, 2, -12 }, // 0x33 '3'
	4471	{ 205, 10, 13, 11, 0, -12 }, // 0x34 '4'
	4472	{ 222, 8, 13, 11, 1, -12 }, // 0x35 '5'
	4473	{ 235, 9, 13, 11, 1, -12 }, // 0x36 '6'
	4474	{ 250, 8, 13, 11, 1, -12 }, // 0x37 '7'
	4475	{ 263, 9, 13, 11, 1, -12 }, // 0x38 '8'
	4476	{ 278, 9, 13, 11, 1, -12 }, // 0x39 '9'
	4477	{ 293, 3, 10, 11, 4, -9 }, // 0x3A ':'
	4478	{ 297, 4, 13, 11, 3, -9 }, // 0x3B ';'
	4479	{ 304, 9, 11, 11, 1, -10 }, // 0x3C '<'
	4480	{ 317, 9, 6, 11, 1, -8 }, // 0x3D '='
	4481	{ 324, 9, 11, 11, 1, -10 }, // 0x3E '>'
	4482	{ 337, 9, 13, 11, 1, -12 }, // 0x3F '?'
	4483	{ 352, 11, 15, 11, 0, -10 }, // 0x40 '@'
	4484	{ 373, 10, 13, 11, 0, -12 }, // 0x41 'A'
	4485	{ 390, 9, 13, 11, 1, -12 }, // 0x42 'B'
	4486	{ 405, 9, 13, 11, 1, -12 }, // 0x43 'C'
	4487	{ 420, 9, 13, 11, 1, -12 }, // 0x44 'D'
	4488	{ 435, 8, 13, 11, 1, -12 }, // 0x45 'E'
	4489	{ 448, 8, 13, 11, 2, -12 }, // 0x46 'F'
	4490	{ 461, 9, 13, 11, 1, -12 }, // 0x47 'G'
	4491	{ 476, 9, 13, 11, 1, -12 }, // 0x48 'H'
	4492	{ 491, 8, 13, 11, 1, -12 }, // 0x49 'I'
	4493	{ 504, 8, 13, 11, 1, -12 }, // 0x4A 'J'
	4494	{ 517, 10, 13, 11, 1, -12 }, // 0x4B 'K'
	4495	{ 534, 8, 13, 11, 2, -12 }, // 0x4C 'L'
	4496	{ 547, 9, 13, 11, 1, -12 }, // 0x4D 'M'
	4497	{ 562, 9, 13, 11, 1, -12 }, // 0x4E 'N'
	4498	{ 577, 10, 13, 11, 0, -12 }, // 0x4F 'O'
	4499	{ 594, 9, 13, 11, 1, -12 }, // 0x50 'P'
	4500	{ 609, 10, 16, 11, 0, -12 }, // 0x51 'Q'
	4501	{ 629, 9, 13, 11, 1, -12 }, // 0x52 'R'
	4502	{ 644, 9, 13, 11, 1, -12 }, // 0x53 'S'
	4503	{ 659, 10, 13, 11, 0, -12 }, // 0x54 'T'
	4504	{ 676, 9, 13, 11, 1, -12 }, // 0x55 'U'
	4505	{ 691, 10, 13, 11, 0, -12 }, // 0x56 'V'
	4506	{ 708, 11, 13, 11, 0, -12 }, // 0x57 'W'
	4507	{ 726, 11, 13, 11, 0, -12 }, // 0x58 'X'
	4508	{ 744, 10, 13, 11, 0, -12 }, // 0x59 'Y'
	4509	{ 761, 9, 13, 11, 1, -12 }, // 0x5A 'Z'
	4510	{ 776, 7, 17, 11, 2, -12 }, // 0x5B '['
	4511	{ 791, 8, 16, 11, 1, -12 }, // 0x5C '\'
	4512	{ 807, 7, 17, 11, 2, -12 }, // 0x5D ']'
	4513	{ 822, 10, 7, 11, 0, -12 }, // 0x5E '^'
	4514	{ 831, 8, 2, 11, 1, 3 }, // 0x5F '_'
	4515	{ 833, 4, 3, 11, 3, -12 }, // 0x60 '`'
	4516	{ 835, 9, 9, 11, 1, -8 }, // 0x61 'a'
	4517	{ 846, 10, 13, 11, 0, -12 }, // 0x62 'b'
	4518	{ 863, 9, 9, 11, 1, -8 }, // 0x63 'c'
	4519	{ 874, 10, 13, 11, 0, -12 }, // 0x64 'd'
	4520	{ 891, 9, 9, 11, 1, -8 }, // 0x65 'e'
	4521	{ 902, 9, 13, 11, 1, -12 }, // 0x66 'f'
	4522	{ 917, 9, 13, 11, 1, -8 }, // 0x67 'g'
	4523	{ 932, 9, 13, 11, 0, -12 }, // 0x68 'h'
	4524	{ 947, 8, 13, 11, 1, -12 }, // 0x69 'i'
	4525	{ 960, 7, 17, 11, 1, -12 }, // 0x6A 'j'
	4526	{ 975, 10, 13, 11, 1, -12 }, // 0x6B 'k'
	4527	{ 992, 8, 13, 11, 1, -12 }, // 0x6C 'l'
	4528	{ 1005, 10, 9, 11, 0, -8 }, // 0x6D 'm'
	4529	{ 1017, 9, 9, 11, 1, -8 }, // 0x6E 'n'
	4530	{ 1028, 10, 9, 11, 0, -8 }, // 0x6F 'o'
	4531	{ 1040, 10, 13, 11, 0, -8 }, // 0x70 'p'
	4532	{ 1057, 9, 13, 11, 1, -8 }, // 0x71 'q'
	4533	{ 1072, 9, 9, 11, 1, -8 }, // 0x72 'r'
	4534	{ 1083, 8, 9, 11, 1, -8 }, // 0x73 's'
	4535	{ 1092, 10, 12, 11, 0, -11 }, // 0x74 't'
	4536	{ 1107, 10, 9, 11, 0, -8 }, // 0x75 'u'
	4537	{ 1119, 10, 9, 11, 0, -8 }, // 0x76 'v'
	4538	{ 1131, 11, 9, 11, 0, -8 }, // 0x77 'w'
	4539	{ 1144, 9, 9, 11, 1, -8 }, // 0x78 'x'
	4540	{ 1155, 10, 13, 11, 0, -8 }, // 0x79 'y'
	4541	{ 1172, 8, 9, 11, 1, -8 }, // 0x7A 'z'
	4542	{ 1181, 8, 17, 11, 1, -12 }, // 0x7B '{'
	4543	{ 1198, 2, 15, 11, 4, -12 }, // 0x7C '\|'
	4544	{ 1202, 8, 17, 11, 2, -12 }, // 0x7D '}'
	4545	{ 1219, 8, 3, 11, 1, -7 } }; // 0x7E '~'
	4546
	4547	const GFXfont ptmono9pt7b PROGMEM = {
	4548	(uint8_t *)ptmono9pt7bBitmaps,
	4549	(GFXglyph *)ptmono9pt7bGlyphs,
	4550	0x20, 0x7E, 20 };
	4551
	4552	// Approx. 1894 bytes
	4553	const uint8_t SourceCodePro_Regular9pt7bBitmaps[] PROGMEM = {
	4554	0x00, 0x49, 0x24, 0x90, 0x1B, 0xE0, 0xCF, 0x34, 0x51, 0x45, 0x10, 0x24,
	4555	0x48, 0x97, 0xF4, 0x48, 0xBF, 0xA4, 0x48, 0x91, 0x20, 0x10, 0x21, 0xF6,
	4556	0x38, 0x18, 0x1E, 0x0E, 0x06, 0x06, 0x1B, 0xE1, 0x02, 0x04, 0x00, 0x38,
	4557	0x13, 0x14, 0x4D, 0x16, 0x4D, 0x0E, 0x80, 0x38, 0x13, 0x14, 0x49, 0x16,
	4558	0x4F, 0x0E, 0x38, 0x32, 0x11, 0x0D, 0x83, 0x81, 0x85, 0xC3, 0xB3, 0x8D,
	4559	0x43, 0x31, 0xEF, 0x10, 0xF5, 0x50, 0x11, 0xD8, 0x8C, 0x42, 0x10, 0x84,
	4560	0x21, 0x84, 0x30, 0xC3, 0xC3, 0x08, 0x21, 0x0C, 0x21, 0x08, 0x46, 0x21,
	4561	0x11, 0x98, 0x10, 0x22, 0x4B, 0xE3, 0x8D, 0x11, 0x00, 0x10, 0x20, 0x40,
	4562	0x8F, 0xE2, 0x04, 0x08, 0x10, 0xFF, 0x97, 0xA0, 0xFC, 0xFF, 0x80, 0x02,
	4563	0x08, 0x10, 0x60, 0x81, 0x06, 0x08, 0x10, 0x60, 0x83, 0x04, 0x08, 0x30,
	4564	0x40, 0x3C, 0x31, 0x10, 0x58, 0x2D, 0x96, 0xEF, 0x05, 0x82, 0x41, 0x31,
	4565	0x0F, 0x00, 0x38, 0x78, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
	4566	0xFF, 0x3C, 0xC2, 0x03, 0x03, 0x03, 0x06, 0x04, 0x08, 0x30, 0x60, 0xFF,
	4567	0x3C, 0xC3, 0x03, 0x03, 0x06, 0x1C, 0x03, 0x01, 0x01, 0xC3, 0x7E, 0x06,
	4568	0x05, 0x06, 0x82, 0x42, 0x22, 0x13, 0x09, 0xFF, 0x02, 0x01, 0x00, 0x80,
	4569	0x7F, 0x60, 0x60, 0x40, 0x7E, 0x43, 0x01, 0x01, 0x01, 0xC3, 0x7C, 0x1F,
	4570	0x10, 0x98, 0x08, 0x0D, 0xE7, 0x1B, 0x06, 0x83, 0x41, 0x31, 0x87, 0x80,
	4571	0xFF, 0x81, 0x80, 0x80, 0x80, 0x40, 0x40, 0x20, 0x30, 0x18, 0x0C, 0x06,
	4572	0x00, 0x3E, 0x31, 0x90, 0x4C, 0x23, 0x31, 0xF1, 0x99, 0x82, 0xC1, 0xA1,
	4573	0x8F, 0x80, 0x3C, 0x42, 0xC1, 0xC1, 0x41, 0x3F, 0x01, 0x01, 0x03, 0x46,
	4574	0xFC, 0xFF, 0x80, 0x3F, 0xE0, 0xFF, 0x80, 0x3F, 0xE5, 0xE8, 0x02, 0x18,
	4575	0x63, 0x08, 0x0C, 0x06, 0x06, 0x02, 0xFE, 0x00, 0x00, 0x0F, 0xE0, 0x80,
	4576	0x80, 0xC0, 0x60, 0x61, 0x8C, 0x20, 0x80, 0x79, 0x88, 0x18, 0x20, 0x82,
	4577	0x0C, 0x00, 0x00, 0x60, 0xC1, 0x80, 0x1E, 0x10, 0x90, 0x38, 0x18, 0x7C,
	4578	0xC6, 0x43, 0x23, 0x8E, 0xC0, 0x30, 0x08, 0x02, 0x10, 0xF0, 0x18, 0x0A,
	4579	0x05, 0x06, 0x82, 0x61, 0x11, 0x88, 0xFE, 0x41, 0x60, 0xB0, 0x70, 0x10,
	4580	0xFC, 0x86, 0x82, 0x82, 0x86, 0xF8, 0x86, 0x83, 0x83, 0x83, 0x86, 0xFC,
	4581	0x1F, 0x18, 0xD8, 0x08, 0x0C, 0x06, 0x03, 0x01, 0x80, 0x40, 0x30, 0x0C,
	4582	0x63, 0xE0, 0xF8, 0x8C, 0x82, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x86,
	4583	0x8C, 0xF8, 0xFE, 0xC0, 0xC0, 0xC0, 0xC0, 0xFC, 0xC0, 0xC0, 0xC0, 0xC0,
	4584	0xC0, 0xFF, 0xFF, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xFE, 0xC0, 0xC0, 0xC0,
	4585	0xC0, 0xC0, 0x1F, 0x10, 0x90, 0x18, 0x0C, 0x06, 0x03, 0x1F, 0x83, 0xC1,
	4586	0xA0, 0xD8, 0x63, 0xC0, 0xC1, 0xC1, 0xC1, 0xC1, 0xC1, 0xFF, 0xC1, 0xC1,
	4587	0xC1, 0xC1, 0xC1, 0xC1, 0xFE, 0x20, 0x40, 0x81, 0x02, 0x04, 0x08, 0x10,
	4588	0x20, 0x47, 0xF0, 0x7F, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
	4589	0x83, 0x42, 0x3C, 0x83, 0x86, 0x8C, 0x98, 0x90, 0xB8, 0xE8, 0xCC, 0x84,
	4590	0x86, 0x83, 0x83, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0,
	4591	0xC0, 0xC0, 0xFF, 0xC1, 0xE3, 0xE3, 0xE5, 0xD5, 0xD5, 0xD9, 0xC9, 0xC1,
	4592	0xC1, 0xC1, 0xC1, 0xC1, 0xE1, 0xE1, 0xD1, 0xD1, 0xD9, 0xC9, 0xCD, 0xC5,
	4593	0xC3, 0xC3, 0xC1, 0x3C, 0x31, 0x90, 0x58, 0x3C, 0x1C, 0x0E, 0x07, 0x83,
	4594	0xC1, 0xA0, 0x98, 0xC7, 0x80, 0xFC, 0x82, 0x83, 0x83, 0x83, 0x86, 0xFC,
	4595	0x80, 0x80, 0x80, 0x80, 0x80, 0x3C, 0x31, 0x90, 0x58, 0x3C, 0x1C, 0x0E,
	4596	0x07, 0x83, 0xC1, 0xA0, 0x98, 0xC7, 0x80, 0x80, 0x60, 0x0E, 0xFC, 0x86,
	4597	0x83, 0x83, 0x82, 0x86, 0xFC, 0x88, 0x8C, 0x84, 0x86, 0x83, 0x3E, 0x30,
	4598	0x90, 0x08, 0x06, 0x01, 0xE0, 0x3C, 0x06, 0x01, 0x80, 0xF0, 0xC7, 0xC0,
	4599	0xFF, 0x84, 0x02, 0x01, 0x00, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02,
	4600	0x01, 0x00, 0xC1, 0xC1, 0xC1, 0xC1, 0xC1, 0xC1, 0xC1, 0xC1, 0xC1, 0x41,
	4601	0x63, 0x3E, 0x81, 0xE0, 0xD0, 0x48, 0x26, 0x33, 0x10, 0x88, 0x4C, 0x34,
	4602	0x0A, 0x05, 0x03, 0x00, 0xC0, 0x78, 0x09, 0x01, 0x20, 0x24, 0x44, 0x98,
	4603	0x92, 0xB3, 0x56, 0x6A, 0x86, 0x30, 0xC6, 0x18, 0xC0, 0xC1, 0xB1, 0x88,
	4604	0x86, 0xC1, 0x40, 0xE0, 0x70, 0x28, 0x26, 0x31, 0x10, 0xD8, 0x30, 0xC1,
	4605	0xE0, 0x98, 0xCC, 0x43, 0x60, 0xA0, 0x70, 0x10, 0x08, 0x04, 0x02, 0x01,
	4606	0x00, 0x7F, 0x81, 0x80, 0x80, 0xC0, 0x40, 0x60, 0x60, 0x20, 0x30, 0x30,
	4607	0x10, 0x1F, 0xF0, 0xFC, 0x21, 0x08, 0x42, 0x10, 0x84, 0x21, 0x08, 0x42,
	4608	0x1F, 0x81, 0x81, 0x02, 0x06, 0x04, 0x0C, 0x08, 0x10, 0x30, 0x20, 0x40,
	4609	0xC0, 0x81, 0x01, 0xF8, 0x42, 0x10, 0x84, 0x21, 0x08, 0x42, 0x10, 0x84,
	4610	0x3F, 0x10, 0x70, 0xA3, 0x44, 0x48, 0xA1, 0x80, 0xFF, 0x80, 0xC6, 0x30,
	4611	0x3E, 0x43, 0x01, 0x0F, 0x71, 0x41, 0xC1, 0x43, 0x3D, 0x80, 0x80, 0x80,
	4612	0x80, 0xBC, 0xC6, 0x82, 0x83, 0x83, 0x83, 0x82, 0xC6, 0xBC, 0x1F, 0x10,
	4613	0xD8, 0x08, 0x0C, 0x02, 0x01, 0x00, 0xC2, 0x1F, 0x80, 0x01, 0x01, 0x01,
	4614	0x01, 0x3D, 0x63, 0xC1, 0xC1, 0xC1, 0xC1, 0xC1, 0x63, 0x3D, 0x1E, 0x31,
	4615	0x90, 0x58, 0x3F, 0xFE, 0x01, 0x00, 0xC2, 0x1F, 0x00, 0x0F, 0x10, 0x30,
	4616	0x30, 0xFE, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x3F, 0xB1,
	4617	0x10, 0xC8, 0x66, 0x21, 0xE1, 0x00, 0x80, 0x3F, 0x20, 0x70, 0x28, 0x33,
	4618	0xE0, 0x81, 0x02, 0x04, 0x09, 0xDC, 0xE0, 0xC1, 0x83, 0x06, 0x0C, 0x18,
	4619	0x20, 0x18, 0xC0, 0x0F, 0x84, 0x21, 0x08, 0x42, 0x10, 0x80, 0x0C, 0x30,
	4620	0x00, 0x7C, 0x10, 0x41, 0x04, 0x10, 0x41, 0x04, 0x10, 0x43, 0xF8, 0x80,
	4621	0x80, 0x80, 0x80, 0x83, 0x84, 0x88, 0x98, 0xB8, 0xCC, 0x84, 0x82, 0x83,
	4622	0xF8, 0x0C, 0x06, 0x03, 0x01, 0x80, 0xC0, 0x60, 0x30, 0x18, 0x0C, 0x06,
	4623	0x01, 0x00, 0x78, 0xBB, 0x66, 0xF2, 0x39, 0x1C, 0x8E, 0x47, 0x23, 0x91,
	4624	0xC8, 0x80, 0x9D, 0xCE, 0x0C, 0x18, 0x30, 0x60, 0xC1, 0x82, 0x3C, 0x31,
	4625	0xB0, 0x58, 0x3C, 0x1E, 0x0F, 0x04, 0xC6, 0x3C, 0x00, 0xBC, 0xC6, 0x82,
	4626	0x83, 0x83, 0x83, 0x82, 0xC6, 0xBC, 0x80, 0x80, 0x80, 0x80, 0x3D, 0x63,
	4627	0xC1, 0xC1, 0xC1, 0xC1, 0xC1, 0x63, 0x3D, 0x01, 0x01, 0x01, 0x01, 0x9F,
	4628	0x43, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x3E, 0x61, 0x40, 0x70, 0x1E,
	4629	0x03, 0x01, 0x43, 0xBE, 0x10, 0x08, 0x3F, 0xC2, 0x01, 0x00, 0x80, 0x40,
	4630	0x20, 0x10, 0x0C, 0x03, 0xE0, 0xC1, 0xC1, 0xC1, 0xC1, 0xC1, 0xC1, 0xC3,
	4631	0x45, 0x39, 0xC1, 0xA0, 0x90, 0xCC, 0x42, 0x21, 0xB0, 0x50, 0x28, 0x18,
	4632	0x00, 0xC4, 0x78, 0x89, 0x29, 0x25, 0x26, 0xAC, 0xD5, 0x8C, 0xA1, 0x8C,
	4633	0x31, 0x80, 0xC3, 0x31, 0x0D, 0x82, 0x81, 0x80, 0xE0, 0x98, 0xC6, 0xC1,
	4634	0x80, 0xC1, 0xA0, 0x90, 0x4C, 0x62, 0x21, 0xB0, 0x50, 0x38, 0x0C, 0x04,
	4635	0x06, 0x02, 0x0E, 0x00, 0x7F, 0x01, 0x81, 0x81, 0x81, 0x80, 0x80, 0xC0,
	4636	0xC0, 0xFF, 0x80, 0x1E, 0x20, 0x40, 0x81, 0x02, 0x0C, 0x60, 0x30, 0x20,
	4637	0x40, 0x81, 0x02, 0x04, 0x0F, 0xFF, 0xFF, 0xC0, 0xE0, 0x20, 0x40, 0x81,
	4638	0x02, 0x04, 0x07, 0x18, 0x20, 0x40, 0x81, 0x02, 0x04, 0x70, 0x31, 0x49,
	4639	0x86 };
	4640
	4641	const GFXglyph SourceCodePro_Regular9pt7bGlyphs[] PROGMEM = {
	4642	{ 0, 1, 1, 11, 0, 0 }, // 0x20 ' '
	4643	{ 1, 3, 12, 11, 4, -11 }, // 0x21 '!'
	4644	{ 6, 6, 6, 11, 2, -11 }, // 0x22 '"'
	4645	{ 11, 7, 11, 11, 2, -10 }, // 0x23 '#'
	4646	{ 21, 7, 15, 11, 2, -12 }, // 0x24 '$'
	4647	{ 35, 10, 12, 11, 0, -11 }, // 0x25 '%'
	4648	{ 50, 9, 12, 11, 1, -11 }, // 0x26 '&'
	4649	{ 64, 2, 6, 11, 4, -11 }, // 0x27 '''
	4650	{ 66, 5, 16, 11, 4, -12 }, // 0x28 '('
	4651	{ 76, 5, 16, 11, 2, -12 }, // 0x29 ')'
	4652	{ 86, 7, 7, 11, 2, -12 }, // 0x2A '*'
	4653	{ 93, 7, 9, 11, 2, -9 }, // 0x2B '+'
	4654	{ 101, 3, 7, 11, 4, -2 }, // 0x2C ','
	4655	{ 104, 6, 1, 11, 2, -5 }, // 0x2D '-'
	4656	{ 105, 3, 3, 11, 4, -2 }, // 0x2E '.'
	4657	{ 107, 7, 16, 11, 2, -12 }, // 0x2F '/'
	4658	{ 121, 9, 11, 11, 1, -10 }, // 0x30 '0'
	4659	{ 134, 8, 11, 11, 2, -10 }, // 0x31 '1'
	4660	{ 145, 8, 11, 11, 1, -10 }, // 0x32 '2'
	4661	{ 156, 8, 11, 11, 1, -10 }, // 0x33 '3'
	4662	{ 167, 9, 11, 11, 1, -10 }, // 0x34 '4'
	4663	{ 180, 8, 11, 11, 1, -10 }, // 0x35 '5'
	4664	{ 191, 9, 11, 11, 1, -10 }, // 0x36 '6'
	4665	{ 204, 9, 11, 11, 1, -10 }, // 0x37 '7'
	4666	{ 217, 9, 11, 11, 1, -10 }, // 0x38 '8'
	4667	{ 230, 8, 11, 11, 1, -10 }, // 0x39 '9'
	4668	{ 241, 3, 9, 11, 4, -8 }, // 0x3A ':'
	4669	{ 245, 3, 13, 11, 4, -8 }, // 0x3B ';'
	4670	{ 250, 7, 9, 11, 2, -9 }, // 0x3C '<'
	4671	{ 258, 7, 5, 11, 2, -7 }, // 0x3D '='
	4672	{ 263, 7, 9, 11, 2, -9 }, // 0x3E '>'
	4673	{ 271, 7, 12, 11, 2, -11 }, // 0x3F '?'
	4674	{ 282, 9, 14, 11, 1, -10 }, // 0x40 '@'
	4675	{ 298, 9, 12, 11, 1, -11 }, // 0x41 'A'
	4676	{ 312, 8, 12, 11, 2, -11 }, // 0x42 'B'
	4677	{ 324, 9, 12, 11, 1, -11 }, // 0x43 'C'
	4678	{ 338, 8, 12, 11, 2, -11 }, // 0x44 'D'
	4679	{ 350, 8, 12, 11, 2, -11 }, // 0x45 'E'
	4680	{ 362, 8, 12, 11, 2, -11 }, // 0x46 'F'
	4681	{ 374, 9, 12, 11, 1, -11 }, // 0x47 'G'
	4682	{ 388, 8, 12, 11, 1, -11 }, // 0x48 'H'
	4683	{ 400, 7, 12, 11, 2, -11 }, // 0x49 'I'
	4684	{ 411, 8, 12, 11, 1, -11 }, // 0x4A 'J'
	4685	{ 423, 8, 12, 11, 2, -11 }, // 0x4B 'K'
	4686	{ 435, 8, 12, 11, 2, -11 }, // 0x4C 'L'
	4687	{ 447, 8, 12, 11, 1, -11 }, // 0x4D 'M'
	4688	{ 459, 8, 12, 11, 1, -11 }, // 0x4E 'N'
	4689	{ 471, 9, 12, 11, 1, -11 }, // 0x4F 'O'
	4690	{ 485, 8, 12, 11, 2, -11 }, // 0x50 'P'
	4691	{ 497, 9, 15, 11, 1, -11 }, // 0x51 'Q'
	4692	{ 514, 8, 12, 11, 2, -11 }, // 0x52 'R'
	4693	{ 526, 9, 12, 11, 1, -11 }, // 0x53 'S'
	4694	{ 540, 9, 12, 11, 1, -11 }, // 0x54 'T'
	4695	{ 554, 8, 12, 11, 1, -11 }, // 0x55 'U'
	4696	{ 566, 9, 12, 11, 1, -11 }, // 0x56 'V'
	4697	{ 580, 11, 12, 11, 0, -11 }, // 0x57 'W'
	4698	{ 597, 9, 12, 11, 1, -11 }, // 0x58 'X'
	4699	{ 611, 9, 12, 11, 1, -11 }, // 0x59 'Y'
	4700	{ 625, 9, 12, 11, 1, -11 }, // 0x5A 'Z'
	4701	{ 639, 5, 16, 11, 4, -12 }, // 0x5B '['
	4702	{ 649, 7, 16, 11, 2, -12 }, // 0x5C '\'
	4703	{ 663, 5, 16, 11, 2, -12 }, // 0x5D ']'
	4704	{ 673, 7, 7, 11, 2, -11 }, // 0x5E '^'
	4705	{ 680, 9, 1, 11, 1, 2 }, // 0x5F '_'
	4706	{ 682, 4, 3, 11, 3, -12 }, // 0x60 '`'
	4707	{ 684, 8, 9, 11, 1, -8 }, // 0x61 'a'
	4708	{ 693, 8, 13, 11, 2, -12 }, // 0x62 'b'
	4709	{ 706, 9, 9, 11, 1, -8 }, // 0x63 'c'
	4710	{ 717, 8, 13, 11, 1, -12 }, // 0x64 'd'
	4711	{ 730, 9, 9, 11, 1, -8 }, // 0x65 'e'
	4712	{ 741, 8, 13, 11, 2, -12 }, // 0x66 'f'
	4713	{ 754, 9, 13, 11, 1, -8 }, // 0x67 'g'
	4714	{ 769, 7, 13, 11, 2, -12 }, // 0x68 'h'
	4715	{ 781, 5, 13, 11, 2, -12 }, // 0x69 'i'
	4716	{ 790, 6, 17, 11, 1, -12 }, // 0x6A 'j'
	4717	{ 803, 8, 13, 11, 2, -12 }, // 0x6B 'k'
	4718	{ 816, 9, 13, 11, 1, -12 }, // 0x6C 'l'
	4719	{ 831, 9, 9, 11, 1, -8 }, // 0x6D 'm'
	4720	{ 842, 7, 9, 11, 2, -8 }, // 0x6E 'n'
	4721	{ 850, 9, 9, 11, 1, -8 }, // 0x6F 'o'
	4722	{ 861, 8, 13, 11, 2, -8 }, // 0x70 'p'
	4723	{ 874, 8, 13, 11, 1, -8 }, // 0x71 'q'
	4724	{ 887, 7, 9, 11, 3, -8 }, // 0x72 'r'
	4725	{ 895, 8, 9, 11, 1, -8 }, // 0x73 's'
	4726	{ 904, 9, 11, 11, 1, -10 }, // 0x74 't'
	4727	{ 917, 8, 9, 11, 1, -8 }, // 0x75 'u'
	4728	{ 926, 9, 9, 11, 1, -8 }, // 0x76 'v'
	4729	{ 937, 11, 9, 11, 0, -8 }, // 0x77 'w'
	4730	{ 950, 9, 9, 11, 1, -8 }, // 0x78 'x'
	4731	{ 961, 9, 13, 11, 1, -8 }, // 0x79 'y'
	4732	{ 976, 9, 9, 11, 1, -8 }, // 0x7A 'z'
	4733	{ 987, 7, 16, 11, 2, -12 }, // 0x7B '{'
	4734	{ 1001, 1, 18, 11, 5, -12 }, // 0x7C '\|'
	4735	{ 1004, 7, 16, 11, 2, -12 }, // 0x7D '}'
	4736	{ 1018, 8, 3, 11, 1, -6 } }; // 0x7E '~'
	4737
	4738	const GFXfont SourceCodePro_Regular9pt7b PROGMEM = {
	4739	(uint8_t *)SourceCodePro_Regular9pt7bBitmaps,
	4740	(GFXglyph *)SourceCodePro_Regular9pt7bGlyphs,
	4741	0x20, 0x7E, 22 };
	4742
	4743	// Approx. 1693 bytes
	4744	const uint8_t SourceCodePro_SemiBold9pt7bBitmaps[] PROGMEM = {
	4745	0x00, 0xDB, 0x64, 0x92, 0x1F, 0xF0, 0xEF, 0xDF, 0xBE, 0x64, 0x48, 0x80,
	4746	0x12, 0x12, 0x7F, 0x7F, 0x22, 0x26, 0xFF, 0xFF, 0x24, 0x24, 0x64, 0x08,
	4747	0x08, 0x3E, 0x7F, 0x62, 0x70, 0x3C, 0x0F, 0x03, 0x43, 0xFF, 0x3E, 0x08,
	4748	0x08, 0x08, 0x38, 0x1F, 0x14, 0xCD, 0x36, 0x7F, 0x0E, 0x00, 0x38, 0x1F,
	4749	0x14, 0xCD, 0x36, 0x7F, 0x0E, 0x38, 0x3E, 0x1B, 0x0D, 0x87, 0xC1, 0xCF,
	4750	0xC7, 0xB3, 0xCF, 0x63, 0xBF, 0xEF, 0x10, 0xFF, 0xE4, 0x80, 0x08, 0x73,
	4751	0x08, 0x61, 0x84, 0x30, 0xC1, 0x06, 0x18, 0x20, 0xC1, 0x83, 0x47, 0x0C,
	4752	0x61, 0x8C, 0x61, 0x08, 0xC6, 0x33, 0x19, 0x98, 0x10, 0x23, 0x5F, 0xF3,
	4753	0x87, 0x1B, 0x22, 0x08, 0x08, 0x08, 0xFF, 0xFF, 0x08, 0x08, 0x08, 0x77,
	4754	0x71, 0x36, 0xC0, 0xFF, 0xF0, 0xFF, 0xF0, 0x06, 0x0C, 0x10, 0x60, 0xC3,
	4755	0x06, 0x08, 0x30, 0x60, 0x83, 0x06, 0x18, 0x30, 0x60, 0x3C, 0x3F, 0x98,
	4756	0xDB, 0x6D, 0xDE, 0xCF, 0x07, 0x86, 0x63, 0x3F, 0x8F, 0x00, 0xF8, 0xF8,
	4757	0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xFF, 0xFF, 0x3C, 0x3F, 0x30,
	4758	0xC0, 0x60, 0x30, 0x30, 0x30, 0x30, 0x30, 0x7F, 0xFF, 0xE0, 0x3E, 0x7F,
	4759	0xC3, 0x03, 0x1E, 0x1E, 0x03, 0x03, 0xC3, 0xFF, 0x3E, 0x0E, 0x07, 0x07,
	4760	0x86, 0xC6, 0x66, 0x33, 0xFF, 0xFF, 0x06, 0x03, 0x01, 0x80, 0x7F, 0x7F,
	4761	0x60, 0x7E, 0x7F, 0x63, 0x03, 0x03, 0xC3, 0xFF, 0x3C, 0x1E, 0x1F, 0x98,
	4762	0x6C, 0x0D, 0xE7, 0xFB, 0x8F, 0x83, 0x63, 0xBF, 0x87, 0x80, 0xFF, 0xFF,
	4763	0xC0, 0xC0, 0xC0, 0x40, 0x60, 0x20, 0x30, 0x18, 0x0C, 0x06, 0x00, 0x3E,
	4764	0x3F, 0x98, 0xCC, 0x63, 0xE1, 0xF1, 0x9D, 0x83, 0xC3, 0xBF, 0x8F, 0x80,
	4765	0x3C, 0x3F, 0x30, 0xD8, 0x2C, 0x3B, 0xFC, 0xE4, 0x06, 0x47, 0x7F, 0x0F,
	4766	0x00, 0xFF, 0xF0, 0x3F, 0xFC, 0x77, 0x77, 0x00, 0x07, 0x77, 0x13, 0x6C,
	4767	0x02, 0x0C, 0x31, 0xC7, 0x18, 0x30, 0x38, 0x38, 0x18, 0x18, 0x10, 0xFF,
	4768	0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x81, 0x83, 0x81, 0xC1, 0xC1, 0xC3, 0x8E,
	4769	0x39, 0xC3, 0x04, 0x00, 0x79, 0xF9, 0x38, 0x30, 0xC3, 0x0C, 0x18, 0x00,
	4770	0x60, 0xE1, 0x80, 0x1E, 0x1F, 0x98, 0x78, 0x3C, 0x0C, 0x3E, 0x3F, 0x33,
	4771	0x99, 0xCF, 0xF3, 0xB8, 0x06, 0x11, 0xF8, 0x78, 0x0E, 0x03, 0x81, 0xA0,
	4772	0x6C, 0x1B, 0x0C, 0xC3, 0x18, 0xFE, 0x7F, 0x98, 0x76, 0x0F, 0x83, 0xFC,
	4773	0xFE, 0xC6, 0xC6, 0xFC, 0xFE, 0xC7, 0xC3, 0xC3, 0xC7, 0xFE, 0xFC, 0x1E,
	4774	0x1F, 0xDC, 0x5C, 0x0C, 0x06, 0x03, 0x01, 0x80, 0xE0, 0x38, 0xCF, 0xE3,
	4775	0xE0, 0xFC, 0x7F, 0x31, 0xD8, 0x7C, 0x1E, 0x0F, 0x07, 0x83, 0xC3, 0xE3,
	4776	0xBF, 0x9F, 0x80, 0xFE, 0xFE, 0xC0, 0xC0, 0xC0, 0xFE, 0xFE, 0xC0, 0xC0,
	4777	0xC0, 0xFF, 0xFF, 0xFF, 0xFF, 0xC0, 0xC0, 0xC0, 0xFE, 0xFE, 0xC0, 0xC0,
	4778	0xC0, 0xC0, 0xC0, 0x1E, 0x3F, 0x9C, 0x7C, 0x0C, 0x06, 0x3F, 0x1F, 0x83,
	4779	0xE1, 0xB0, 0xDF, 0xE3, 0xC0, 0xC3, 0xE1, 0xF0, 0xF8, 0x7C, 0x3F, 0xFF,
	4780	0xFF, 0x87, 0xC3, 0xE1, 0xF0, 0xF8, 0x70, 0xFF, 0xFC, 0xC1, 0x83, 0x06,
	4781	0x0C, 0x18, 0x30, 0x63, 0xFF, 0xF0, 0x7F, 0x7F, 0x03, 0x03, 0x03, 0x03,
	4782	0x03, 0x03, 0x03, 0x47, 0xFE, 0x3C, 0xE3, 0xB8, 0xCE, 0x63, 0xB0, 0xFC,
	4783	0x3F, 0x0F, 0xE3, 0x98, 0xE7, 0x38, 0xCE, 0x3B, 0x87, 0xC0, 0xC0, 0xC0,
	4784	0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xFF, 0xFF, 0xE3, 0xE3, 0xE3,
	4785	0xE7, 0xF5, 0xD5, 0xD5, 0xD9, 0xC9, 0xC1, 0xC1, 0xC1, 0xE3, 0xE3, 0xF3,
	4786	0xD3, 0xDB, 0xDB, 0xCB, 0xCD, 0xC5, 0xC7, 0xC3, 0xC3, 0x3C, 0x3F, 0xB8,
	4787	0xD8, 0x7C, 0x1E, 0x0F, 0x07, 0x83, 0xC3, 0xB1, 0x9F, 0xC7, 0x80, 0xFC,
	4788	0xFE, 0xC7, 0xC3, 0xC3, 0xC7, 0xFE, 0xFC, 0xC0, 0xC0, 0xC0, 0xC0, 0x3C,
	4789	0x3F, 0xB8, 0xD8, 0x7C, 0x1E, 0x0F, 0x07, 0x83, 0xC3, 0xF1, 0x9F, 0xC7,
	4790	0xC0, 0xC0, 0x7C, 0x1E, 0xFC, 0xFE, 0xC7, 0xC3, 0xC7, 0xFE, 0xFC, 0xCC,
	4791	0xCC, 0xC6, 0xC6, 0xC3, 0x3E, 0x3F, 0x98, 0x4C, 0x07, 0x01, 0xE0, 0x7C,
	4792	0x07, 0x01, 0xA1, 0xFF, 0xC7, 0xC0, 0xFF, 0xFF, 0xC6, 0x03, 0x01, 0x80,
	4793	0xC0, 0x60, 0x30, 0x18, 0x0C, 0x06, 0x03, 0x00, 0xC3, 0xE1, 0xF0, 0xF8,
	4794	0x7C, 0x3E, 0x1F, 0x0F, 0x86, 0xE3, 0x31, 0x9F, 0xC7, 0xC0, 0xE0, 0xD8,
	4795	0x36, 0x1C, 0xC6, 0x31, 0x8C, 0x63, 0x30, 0x6C, 0x1B, 0x06, 0x80, 0xE0,
	4796	0x38, 0xC0, 0x78, 0x0B, 0x03, 0x32, 0x66, 0xEC, 0xD5, 0x9A, 0xB3, 0x56,
	4797	0x7B, 0xCF, 0x70, 0xC6, 0x18, 0xC0, 0xC3, 0xB1, 0x99, 0xC6, 0xC3, 0x40,
	4798	0xE0, 0x70, 0x7C, 0x36, 0x33, 0xB8, 0xD8, 0x30, 0xE0, 0xD8, 0x73, 0x18,
	4799	0xC6, 0x1B, 0x06, 0xC0, 0xE0, 0x38, 0x0C, 0x03, 0x00, 0xC0, 0x30, 0x7F,
	4800	0xBF, 0xC0, 0xC0, 0xC0, 0xE0, 0x60, 0x60, 0x60, 0x30, 0x30, 0x3F, 0xFF,
	4801	0xF0, 0xFF, 0xE1, 0x08, 0x42, 0x10, 0x84, 0x21, 0x08, 0x43, 0xFF, 0xC1,
	4802	0x83, 0x03, 0x06, 0x04, 0x0C, 0x18, 0x10, 0x30, 0x60, 0x60, 0xC0, 0x81,
	4803	0x83, 0xFF, 0xC6, 0x31, 0x8C, 0x63, 0x18, 0xC6, 0x31, 0x8F, 0xFF, 0x30,
	4804	0x70, 0xA3, 0x64, 0xD8, 0xB1, 0x80, 0xFF, 0xFF, 0xC0, 0xC6, 0x30, 0x3E,
	4805	0x7F, 0x43, 0x1F, 0x7F, 0xE3, 0xC3, 0x7F, 0x79, 0xE0, 0x70, 0x38, 0x1C,
	4806	0x0F, 0xE7, 0xFB, 0x8F, 0xC3, 0xE1, 0xF0, 0xF8, 0xDF, 0xED, 0xE0, 0x1E,
	4807	0x3F, 0xDC, 0x5C, 0x0C, 0x07, 0x01, 0xC4, 0xFF, 0x1E, 0x00, 0x03, 0x03,
	4808	0x03, 0x03, 0x3F, 0x7F, 0xE3, 0xC3, 0xC3, 0xC3, 0xE3, 0x7F, 0x39, 0x1E,
	4809	0x3F, 0x98, 0x7F, 0xFF, 0xFE, 0x01, 0x84, 0xFE, 0x1E, 0x00, 0x0F, 0x1F,
	4810	0x38, 0x30, 0xFF, 0xFF, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x3F,
	4811	0xBF, 0xD8, 0x8C, 0x67, 0xE3, 0xE1, 0x00, 0xFE, 0x7F, 0xE0, 0xFF, 0xEF,
	4812	0xC0, 0xE0, 0x70, 0x38, 0x1C, 0x0C, 0xE7, 0xFB, 0xCD, 0xC7, 0xE3, 0xF1,
	4813	0xF8, 0xFC, 0x7E, 0x38, 0x18, 0x71, 0x80, 0x03, 0xEF, 0x86, 0x18, 0x61,
	4814	0x86, 0x18, 0x60, 0x0C, 0x1C, 0x30, 0x00, 0x0F, 0x9F, 0x06, 0x0C, 0x18,
	4815	0x30, 0x60, 0xC1, 0x83, 0x7E, 0xF8, 0xC0, 0xC0, 0xC0, 0xC0, 0xC7, 0xCE,
	4816	0xDC, 0xF8, 0xF8, 0xEC, 0xCE, 0xC6, 0xC3, 0xF8, 0x7C, 0x06, 0x03, 0x01,
	4817	0x80, 0xC0, 0x60, 0x30, 0x18, 0x0C, 0x06, 0x03, 0xE0, 0xF8, 0xFB, 0x7F,
	4818	0xF3, 0x79, 0x3C, 0x9E, 0x4F, 0x27, 0x93, 0xC9, 0x80, 0xCE, 0x7F, 0xBC,
	4819	0xDC, 0x7E, 0x3F, 0x1F, 0x8F, 0xC7, 0xE3, 0x80, 0x3E, 0x3F, 0xB8, 0xD8,
	4820	0x3C, 0x1E, 0x0F, 0x8C, 0xFE, 0x3E, 0x00, 0xDE, 0x7F, 0xB8, 0xFC, 0x3E,
	4821	0x1F, 0x0F, 0x8D, 0xFE, 0xFE, 0x70, 0x38, 0x1C, 0x00, 0x3D, 0x7F, 0xE3,
	4822	0xC3, 0xC3, 0xC3, 0xE3, 0x7F, 0x3B, 0x03, 0x03, 0x03, 0xCF, 0xDF, 0xF0,
	4823	0xE0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0x3E, 0x3F, 0x98, 0x4E, 0x03, 0xE0,
	4824	0x39, 0x07, 0xFE, 0x3E, 0x00, 0x10, 0x08, 0x3F, 0xFF, 0xF3, 0x01, 0x80,
	4825	0xC0, 0x70, 0x18, 0x0F, 0xC3, 0xE0, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3,
	4826	0xE7, 0x7F, 0x79, 0xC1, 0xE0, 0x98, 0xCC, 0x67, 0x61, 0xB0, 0xD8, 0x38,
	4827	0x1C, 0x00, 0xC4, 0x79, 0xC9, 0xBB, 0x35, 0x66, 0xAC, 0xD5, 0x9E, 0xB1,
	4828	0xDC, 0x31, 0x80, 0xE3, 0xB1, 0x8D, 0x83, 0x81, 0xC1, 0xE0, 0xD8, 0xC6,
	4829	0xC3, 0x80, 0xC1, 0xE0, 0x98, 0xCC, 0x63, 0x21, 0xB0, 0x50, 0x38, 0x1C,
	4830	0x0C, 0x3E, 0x1C, 0x00, 0x7F, 0xBF, 0x81, 0x81, 0xC1, 0xC1, 0xC1, 0xC1,
	4831	0xFF, 0xFF, 0x80, 0x1E, 0x3C, 0xC1, 0x81, 0x02, 0x0C, 0x78, 0xF0, 0x60,
	4832	0x40, 0x83, 0x06, 0x07, 0x8F, 0xFF, 0xFF, 0xC0, 0xF1, 0xE0, 0x40, 0x81,
	4833	0x02, 0x06, 0x0F, 0x1E, 0x30, 0x40, 0x81, 0x02, 0x3C, 0x78, 0x79, 0xBF,
	4834	0xB3, 0x80 };
	4835
	4836	const GFXglyph SourceCodePro_SemiBold9pt7bGlyphs[] PROGMEM = {
	4837	{ 0, 1, 1, 11, 0, 0 }, // 0x20 ' '
	4838	{ 1, 3, 12, 11, 4, -11 }, // 0x21 '!'
	4839	{ 6, 7, 6, 11, 2, -11 }, // 0x22 '"'
	4840	{ 12, 8, 11, 11, 1, -10 }, // 0x23 '#'
	4841	{ 23, 8, 15, 11, 1, -12 }, // 0x24 '$'
	4842	{ 38, 10, 12, 11, 0, -11 }, // 0x25 '%'
	4843	{ 53, 9, 12, 11, 1, -11 }, // 0x26 '&'
	4844	{ 67, 3, 6, 11, 4, -11 }, // 0x27 '''
	4845	{ 70, 6, 16, 11, 3, -12 }, // 0x28 '('
	4846	{ 82, 5, 16, 11, 2, -12 }, // 0x29 ')'
	4847	{ 92, 7, 8, 11, 2, -12 }, // 0x2A '*'
	4848	{ 99, 8, 8, 11, 1, -9 }, // 0x2B '+'
	4849	{ 107, 4, 7, 11, 3, -2 }, // 0x2C ','
	4850	{ 111, 6, 2, 11, 2, -5 }, // 0x2D '-'
	4851	{ 113, 3, 4, 11, 4, -3 }, // 0x2E '.'
	4852	{ 115, 7, 16, 11, 2, -12 }, // 0x2F '/'
	4853	{ 129, 9, 11, 11, 1, -10 }, // 0x30 '0'
	4854	{ 142, 8, 11, 11, 2, -10 }, // 0x31 '1'
	4855	{ 153, 9, 11, 11, 1, -10 }, // 0x32 '2'
	4856	{ 166, 8, 11, 11, 1, -10 }, // 0x33 '3'
	4857	{ 177, 9, 11, 11, 1, -10 }, // 0x34 '4'
	4858	{ 190, 8, 11, 11, 1, -10 }, // 0x35 '5'
	4859	{ 201, 9, 11, 11, 1, -10 }, // 0x36 '6'
	4860	{ 214, 9, 11, 11, 1, -10 }, // 0x37 '7'
	4861	{ 227, 9, 11, 11, 1, -10 }, // 0x38 '8'
	4862	{ 240, 9, 11, 11, 1, -10 }, // 0x39 '9'
	4863	{ 253, 3, 10, 11, 4, -9 }, // 0x3A ':'
	4864	{ 257, 4, 14, 11, 3, -9 }, // 0x3B ';'
	4865	{ 264, 7, 12, 11, 2, -11 }, // 0x3C '<'
	4866	{ 275, 8, 6, 11, 1, -8 }, // 0x3D '='
	4867	{ 281, 7, 12, 11, 2, -11 }, // 0x3E '>'
	4868	{ 292, 7, 12, 11, 2, -11 }, // 0x3F '?'
	4869	{ 303, 9, 15, 11, 1, -11 }, // 0x40 '@'
	4870	{ 320, 10, 12, 11, 0, -11 }, // 0x41 'A'
	4871	{ 335, 8, 12, 11, 2, -11 }, // 0x42 'B'
	4872	{ 347, 9, 12, 11, 1, -11 }, // 0x43 'C'
	4873	{ 361, 9, 12, 11, 1, -11 }, // 0x44 'D'
	4874	{ 375, 8, 12, 11, 2, -11 }, // 0x45 'E'
	4875	{ 387, 8, 12, 11, 2, -11 }, // 0x46 'F'
	4876	{ 399, 9, 12, 11, 1, -11 }, // 0x47 'G'
	4877	{ 413, 9, 12, 11, 1, -11 }, // 0x48 'H'
	4878	{ 427, 7, 12, 11, 2, -11 }, // 0x49 'I'
	4879	{ 438, 8, 12, 11, 1, -11 }, // 0x4A 'J'
	4880	{ 450, 10, 12, 11, 1, -11 }, // 0x4B 'K'
	4881	{ 465, 8, 12, 11, 2, -11 }, // 0x4C 'L'
	4882	{ 477, 8, 12, 11, 1, -11 }, // 0x4D 'M'
	4883	{ 489, 8, 12, 11, 1, -11 }, // 0x4E 'N'
	4884	{ 501, 9, 12, 11, 1, -11 }, // 0x4F 'O'
	4885	{ 515, 8, 12, 11, 2, -11 }, // 0x50 'P'
	4886	{ 527, 9, 15, 11, 1, -11 }, // 0x51 'Q'
	4887	{ 544, 8, 12, 11, 2, -11 }, // 0x52 'R'
	4888	{ 556, 9, 12, 11, 1, -11 }, // 0x53 'S'
	4889	{ 570, 9, 12, 11, 1, -11 }, // 0x54 'T'
	4890	{ 584, 9, 12, 11, 1, -11 }, // 0x55 'U'
	4891	{ 598, 10, 12, 11, 0, -11 }, // 0x56 'V'
	4892	{ 613, 11, 12, 11, 0, -11 }, // 0x57 'W'
	4893	{ 630, 9, 12, 11, 1, -11 }, // 0x58 'X'
	4894	{ 644, 10, 12, 11, 0, -11 }, // 0x59 'Y'
	4895	{ 659, 9, 12, 11, 1, -11 }, // 0x5A 'Z'
	4896	{ 673, 5, 16, 11, 4, -12 }, // 0x5B '['
	4897	{ 683, 7, 16, 11, 2, -12 }, // 0x5C '\'
	4898	{ 697, 5, 16, 11, 2, -12 }, // 0x5D ']'
	4899	{ 707, 7, 7, 11, 2, -11 }, // 0x5E '^'
	4900	{ 714, 9, 2, 11, 1, 2 }, // 0x5F '_'
	4901	{ 717, 4, 3, 11, 3, -12 }, // 0x60 '`'
	4902	{ 719, 8, 9, 11, 1, -8 }, // 0x61 'a'
	4903	{ 728, 9, 13, 11, 1, -12 }, // 0x62 'b'
	4904	{ 743, 9, 9, 11, 1, -8 }, // 0x63 'c'
	4905	{ 754, 8, 13, 11, 1, -12 }, // 0x64 'd'
	4906	{ 767, 9, 9, 11, 1, -8 }, // 0x65 'e'
	4907	{ 778, 8, 13, 11, 2, -12 }, // 0x66 'f'
	4908	{ 791, 9, 12, 11, 1, -8 }, // 0x67 'g'
	4909	{ 805, 9, 13, 11, 1, -12 }, // 0x68 'h'
	4910	{ 820, 6, 14, 11, 2, -13 }, // 0x69 'i'
	4911	{ 831, 7, 17, 11, 1, -13 }, // 0x6A 'j'
	4912	{ 846, 8, 13, 11, 2, -12 }, // 0x6B 'k'
	4913	{ 859, 9, 13, 11, 1, -12 }, // 0x6C 'l'
	4914	{ 874, 9, 9, 11, 1, -8 }, // 0x6D 'm'
	4915	{ 885, 9, 9, 11, 1, -8 }, // 0x6E 'n'
	4916	{ 896, 9, 9, 11, 1, -8 }, // 0x6F 'o'
	4917	{ 907, 9, 12, 11, 1, -8 }, // 0x70 'p'
	4918	{ 921, 8, 12, 11, 1, -8 }, // 0x71 'q'
	4919	{ 933, 8, 9, 11, 2, -8 }, // 0x72 'r'
	4920	{ 942, 9, 9, 11, 1, -8 }, // 0x73 's'
	4921	{ 953, 9, 11, 11, 1, -10 }, // 0x74 't'
	4922	{ 966, 8, 9, 11, 1, -8 }, // 0x75 'u'
	4923	{ 975, 9, 9, 11, 1, -8 }, // 0x76 'v'
	4924	{ 986, 11, 9, 11, 0, -8 }, // 0x77 'w'
	4925	{ 999, 9, 9, 11, 1, -8 }, // 0x78 'x'
	4926	{ 1010, 9, 12, 11, 1, -8 }, // 0x79 'y'
	4927	{ 1024, 9, 9, 11, 1, -8 }, // 0x7A 'z'
	4928	{ 1035, 7, 16, 11, 2, -12 }, // 0x7B '{'
	4929	{ 1049, 1, 18, 11, 5, -12 }, // 0x7C '\|'
	4930	{ 1052, 7, 16, 11, 2, -12 }, // 0x7D '}'
	4931	{ 1066, 9, 3, 11, 1, -6 } }; // 0x7E '~'
	4932
	4933	const GFXfont SourceCodePro_SemiBold9pt7b PROGMEM = {
	4934	(uint8_t *)SourceCodePro_SemiBold9pt7bBitmaps,
	4935	(GFXglyph *)SourceCodePro_SemiBold9pt7bGlyphs,
	4936	0x20, 0x7E, 22 };
	4937
	4938	// Approx. 1742 bytes
	4939	const uint8_t Shree7149pt7bBitmaps[] PROGMEM = {
	4940	0x00, 0xFF, 0xEA, 0x80, 0xC0, 0x99, 0x99, 0x04, 0x20, 0x21, 0x01, 0x10,
	4941	0x77, 0xE0, 0x84, 0x04, 0x40, 0x42, 0x1F, 0xFE, 0x11, 0x01, 0x08, 0x08,
	4942	0x40, 0x04, 0x07, 0x82, 0x59, 0x13, 0x44, 0x51, 0x06, 0x40, 0xF0, 0x07,
	4943	0x01, 0x30, 0x45, 0x11, 0x44, 0x59, 0x21, 0xF0, 0x10, 0x04, 0x00, 0x00,
	4944	0x09, 0xE0, 0x44, 0x42, 0x20, 0x90, 0x82, 0x41, 0x12, 0x03, 0x90, 0x00,
	4945	0x80, 0x02, 0xF0, 0x12, 0x20, 0x90, 0x44, 0x42, 0x10, 0x88, 0x81, 0xC0,
	4946	0x00, 0x03, 0xC0, 0x84, 0x11, 0x01, 0x20, 0x28, 0x06, 0x01, 0x20, 0x42,
	4947	0x50, 0x2A, 0x05, 0x20, 0x44, 0x14, 0x7C, 0x40, 0xEA, 0x12, 0x44, 0x44,
	4948	0x88, 0x88, 0x84, 0x44, 0x21, 0x04, 0x22, 0x21, 0x11, 0x11, 0x12, 0x22,
	4949	0x40, 0x18, 0x18, 0xF3, 0x24, 0x24, 0x53, 0x18, 0x18, 0x08, 0x04, 0x02,
	4950	0x01, 0x0F, 0xF8, 0x40, 0x20, 0x10, 0x08, 0x00, 0xD4, 0x7E, 0xC0, 0x01,
	4951	0x01, 0x02, 0x02, 0x04, 0x04, 0x08, 0x08, 0x10, 0x10, 0x20, 0x20, 0x40,
	4952	0x40, 0x3E, 0x20, 0x90, 0x50, 0x28, 0x14, 0x06, 0x03, 0x01, 0x81, 0x40,
	4953	0x90, 0x48, 0x43, 0xC0, 0x11, 0xF1, 0x11, 0x11, 0x11, 0x11, 0x10, 0x3E,
	4954	0x41, 0x41, 0x01, 0x01, 0x01, 0x02, 0x0C, 0x30, 0x40, 0x40, 0x80, 0xFF,
	4955	0x7E, 0x20, 0xA0, 0x40, 0x20, 0x10, 0x10, 0x78, 0x02, 0x01, 0x40, 0x60,
	4956	0x48, 0x23, 0xE0, 0x06, 0x03, 0x02, 0x82, 0x41, 0x21, 0x11, 0x08, 0x84,
	4957	0x82, 0x7F, 0xC0, 0x80, 0x40, 0x20, 0x7E, 0x20, 0x10, 0x08, 0x04, 0x03,
	4958	0xF1, 0x04, 0x02, 0x00, 0x80, 0x60, 0x48, 0x23, 0xE0, 0x3E, 0x30, 0x90,
	4959	0x30, 0x08, 0x05, 0xF3, 0x05, 0x82, 0x80, 0xC0, 0x50, 0x48, 0x23, 0xE0,
	4960	0x7F, 0x02, 0x02, 0x04, 0x08, 0x08, 0x10, 0x10, 0x10, 0x10, 0x20, 0x20,
	4961	0x20, 0x3E, 0x20, 0x90, 0x48, 0x24, 0x11, 0xB0, 0xB8, 0x82, 0x81, 0x40,
	4962	0x60, 0x48, 0x23, 0xE0, 0x7E, 0x21, 0xA0, 0x50, 0x28, 0x14, 0x0D, 0x0A,
	4963	0x79, 0x01, 0x00, 0xA0, 0x48, 0x43, 0xC0, 0xF0, 0x00, 0x30, 0xF0, 0x00,
	4964	0x35, 0x00, 0x02, 0x18, 0xC2, 0x0C, 0x04, 0x06, 0x03, 0x00, 0xFF, 0x00,
	4965	0x00, 0x00, 0xFF, 0x00, 0x80, 0xC0, 0x60, 0x20, 0x43, 0x18, 0x41, 0x00,
	4966	0x18, 0x66, 0x41, 0x81, 0x01, 0x01, 0x02, 0x04, 0x08, 0x08, 0x00, 0x00,
	4967	0x00, 0x08, 0x07, 0xF8, 0x06, 0x01, 0x82, 0x00, 0x11, 0x00, 0x02, 0x40,
	4968	0x00, 0xA0, 0xFA, 0x18, 0x41, 0x86, 0x10, 0x21, 0x84, 0x08, 0x61, 0x02,
	4969	0x18, 0x40, 0x86, 0x08, 0x62, 0x41, 0x6C, 0x90, 0x20, 0xC2, 0x00, 0x00,
	4970	0x60, 0x08, 0x07, 0xFC, 0x00, 0x06, 0x00, 0x60, 0x09, 0x00, 0x90, 0x09,
	4971	0x01, 0x08, 0x10, 0x82, 0x04, 0x3F, 0xC2, 0x04, 0x40, 0x24, 0x02, 0x80,
	4972	0x10, 0xFF, 0xA0, 0x28, 0x06, 0x02, 0x80, 0xA0, 0x6F, 0xFA, 0x01, 0x80,
	4973	0x60, 0x18, 0x06, 0x02, 0xFF, 0x00, 0x06, 0x07, 0x31, 0x81, 0x20, 0x18,
	4974	0x01, 0x00, 0x20, 0x04, 0x00, 0x80, 0x10, 0x02, 0x00, 0xA0, 0x12, 0x04,
	4975	0x3F, 0x00, 0xFF, 0x10, 0x12, 0x01, 0x40, 0x28, 0x03, 0x00, 0x60, 0x0C,
	4976	0x01, 0x80, 0x50, 0x0A, 0x01, 0x40, 0x4F, 0xF0, 0xFF, 0xC0, 0x20, 0x10,
	4977	0x08, 0x04, 0x03, 0xFD, 0x00, 0x80, 0x40, 0x20, 0x10, 0x0F, 0xF8, 0xFF,
	4978	0xC0, 0x20, 0x10, 0x08, 0x04, 0x03, 0xFD, 0x00, 0x80, 0x40, 0x20, 0x10,
	4979	0x08, 0x00, 0x06, 0x03, 0x31, 0x81, 0x20, 0x18, 0x01, 0x00, 0x20, 0x04,
	4980	0x1F, 0x80, 0x30, 0x06, 0x00, 0xA0, 0x32, 0x06, 0x3F, 0x40, 0x80, 0x60,
	4981	0x18, 0x06, 0x01, 0x80, 0x60, 0x1F, 0xFE, 0x01, 0x80, 0x60, 0x18, 0x06,
	4982	0x01, 0x80, 0x40, 0xFF, 0xF8, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x81,
	4983	0x03, 0x06, 0x0A, 0x13, 0xC0, 0x80, 0xE0, 0x48, 0x22, 0x10, 0x88, 0x26,
	4984	0x0A, 0x83, 0x10, 0x82, 0x20, 0x48, 0x1A, 0x02, 0x80, 0x40, 0x80, 0x80,
	4985	0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xFF, 0xC0,
	4986	0x1D, 0x00, 0xE8, 0x0B, 0x40, 0x59, 0x02, 0xC8, 0x26, 0x21, 0x31, 0x11,
	4987	0x88, 0x8C, 0x24, 0x61, 0x43, 0x06, 0x18, 0x20, 0x80, 0xC0, 0x34, 0x06,
	4988	0x80, 0xC8, 0x18, 0x83, 0x10, 0x61, 0x0C, 0x11, 0x82, 0x30, 0x26, 0x02,
	4989	0xC0, 0x58, 0x06, 0x0E, 0x03, 0x18, 0x40, 0x44, 0x02, 0x80, 0x28, 0x02,
	4990	0x80, 0x28, 0x01, 0x80, 0x28, 0x02, 0x80, 0x24, 0x04, 0x20, 0xC1, 0xF0,
	4991	0xFF, 0x20, 0x28, 0x0A, 0x01, 0x80, 0xA0, 0x2F, 0xF2, 0x00, 0x80, 0x20,
	4992	0x08, 0x02, 0x00, 0x80, 0x00, 0x06, 0x07, 0x31, 0x81, 0x20, 0x28, 0x03,
	4993	0x00, 0x60, 0x0C, 0x01, 0x80, 0x30, 0x06, 0x00, 0xA0, 0xB2, 0x0C, 0x37,
	4994	0xC1, 0x08, 0xFF, 0xA0, 0x18, 0x06, 0x01, 0x80, 0x60, 0x2F, 0xF2, 0x02,
	4995	0x80, 0x60, 0x18, 0x06, 0x01, 0x80, 0x40, 0x18, 0x33, 0xA0, 0x50, 0x18,
	4996	0x04, 0x01, 0x80, 0x3C, 0x01, 0x00, 0x60, 0x30, 0x1C, 0x13, 0xF0, 0xFF,
	4997	0xC1, 0x00, 0x40, 0x10, 0x04, 0x01, 0x00, 0x40, 0x10, 0x04, 0x01, 0x00,
	4998	0x40, 0x10, 0x04, 0x00, 0x80, 0x60, 0x18, 0x06, 0x01, 0x80, 0x60, 0x18,
	4999	0x06, 0x01, 0x80, 0x60, 0x14, 0x05, 0x02, 0x3F, 0x00, 0xC0, 0x48, 0x09,

1895 more lines aren’t shown here.

LEAF/Inc/debug.h+56−0

@@ -0,0 +1,56 @@
	1	/**
	2	******************************************************************************
	3	* File Name : DEBUG.h
	4	* Description : This file provides code for the configuration
	5	* of the DEBUG instances.
	6	******************************************************************************
	7	* @attention
	8	*
	9	* <h2><center>© Copyright (c) 2020 STMicroelectronics.
	10	* All rights reserved.</center></h2>
	11	*
	12	* This software component is licensed by ST under Ultimate Liberty license
	13	* SLA0044, the "License"; You may not use this file except in compliance with
	14	* the License. You may obtain a copy of the License at:
	15	* www.st.com/SLA0044
	16	*
	17	******************************************************************************
	18	*/
	19	/* Define to prevent recursive inclusion -------------------------------------*/
	20	#ifndef __debug_H
	21	#define __debug_H
	22	#ifdef __cplusplus
	23	extern "C" {
	24	#endif
	25
	26	/* Includes ------------------------------------------------------------------*/
	27	#include "main.h"
	28
	29	/* USER CODE BEGIN Includes */
	30
	31	/* USER CODE END Includes */
	32
	33	/* USER CODE BEGIN Private defines */
	34
	35	/* USER CODE END Private defines */
	36
	37	void MX_DEBUG_Init(void);
	38
	39	/* USER CODE BEGIN Prototypes */
	40
	41	/* USER CODE END Prototypes */
	42
	43	#ifdef __cplusplus
	44	}
	45	#endif
	46	#endif /__ debug_H /
	47
	48	/**
	49	* @}
	50	*/
	51
	52	/**
	53	* @}
	54	*/
	55
	56	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

LEAF/Inc/dma.h+56−0

@@ -0,0 +1,56 @@
	1	/**
	2	******************************************************************************
	3	* File Name : dma.h
	4	* Description : This file contains all the function prototypes for
	5	* the dma.c file
	6	******************************************************************************
	7	* @attention
	8	*
	9	* <h2><center>© Copyright (c) 2020 STMicroelectronics.
	10	* All rights reserved.</center></h2>
	11	*
	12	* This software component is licensed by ST under Ultimate Liberty license
	13	* SLA0044, the "License"; You may not use this file except in compliance with
	14	* the License. You may obtain a copy of the License at:
	15	* www.st.com/SLA0044
	16	*
	17	******************************************************************************
	18	*/
	19	/* Define to prevent recursive inclusion -------------------------------------*/
	20	#ifndef __dma_H
	21	#define __dma_H
	22
	23	#ifdef __cplusplus
	24	extern "C" {
	25	#endif
	26
	27	/* Includes ------------------------------------------------------------------*/
	28	#include "main.h"
	29
	30	/* DMA memory to memory transfer handles -------------------------------------*/
	31
	32	/* USER CODE BEGIN Includes */
	33
	34	/* USER CODE END Includes */
	35
	36	/* USER CODE BEGIN Private defines */
	37
	38	/* USER CODE END Private defines */
	39
	40	void MX_DMA_Init(void);
	41
	42	/* USER CODE BEGIN Prototypes */
	43
	44	/* USER CODE END Prototypes */
	45
	46	#ifdef __cplusplus
	47	}
	48	#endif
	49
	50	#endif /* __dma_H */
	51
	52	/**
	53	* @}
	54	*/
	55
	56	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

LEAF/Inc/eeprom.h+125−0

@@ -0,0 +1,125 @@
	1
	2
	3	/**
	4	******************************************************************************
	5	* @file EEPROM_Emulation/inc/eeprom.h
	6	* @author MCD Application Team
	7	* @brief This file contains all the functions prototypes for the EEPROM
	8	* emulation firmware library.
	9	******************************************************************************
	10	* @attention
	11	*
	12	* <h2><center>© Copyright (c) 2017 STMicroelectronics.
	13	* All rights reserved.</center></h2>
	14	*
	15	* This software component is licensed by ST under Ultimate Liberty license
	16	* SLA0044, the "License"; You may not use this file except in compliance with
	17	* the License. You may obtain a copy of the License at:
	18	* www.st.com/SLA0044
	19	*
	20	******************************************************************************
	21	*/
	22
	23	/* Define to prevent recursive inclusion -------------------------------------*/
	24	#ifndef __EEPROM_H
	25	#define __EEPROM_H
	26
	27	/* Includes ------------------------------------------------------------------*/
	28	#include "stm32h7xx_hal.h"
	29	#include "main.h"
	30
	31	/* Exported constants --------------------------------------------------------*/
	32	/* EEPROM emulation firmware error codes */
	33	#define EE_OK (uint32_t)HAL_OK
	34	#define EE_ERROR (uint32_t)HAL_ERROR
	35	#define EE_BUSY (uint32_t)HAL_BUSY
	36	#define EE_TIMEOUT (uint32_t)HAL_TIMEOUT
	37
	38
	39	#define FLASH_BASE_ADDR (uint32_t)(FLASH_BASE)
	40	#define FLASH_END_ADDR (uint32_t)(0x081FFFFF)
	41
	42	/* Base address of the Flash sectors Bank 1 */
	43	#define ADDR_FLASH_SECTOR_0_BANK1 ((uint32_t)0x08000000) /* Base @ of Sector 0, 128 Kbytes */
	44	#define ADDR_FLASH_SECTOR_1_BANK1 ((uint32_t)0x08020000) /* Base @ of Sector 1, 128 Kbytes */
	45	#define ADDR_FLASH_SECTOR_2_BANK1 ((uint32_t)0x08040000) /* Base @ of Sector 2, 128 Kbytes */
	46	#define ADDR_FLASH_SECTOR_3_BANK1 ((uint32_t)0x08060000) /* Base @ of Sector 3, 128 Kbytes */
	47	#define ADDR_FLASH_SECTOR_4_BANK1 ((uint32_t)0x08080000) /* Base @ of Sector 4, 128 Kbytes */
	48	#define ADDR_FLASH_SECTOR_5_BANK1 ((uint32_t)0x080A0000) /* Base @ of Sector 5, 128 Kbytes */
	49	#define ADDR_FLASH_SECTOR_6_BANK1 ((uint32_t)0x080C0000) /* Base @ of Sector 6, 128 Kbytes */
	50	#define ADDR_FLASH_SECTOR_7_BANK1 ((uint32_t)0x080E0000) /* Base @ of Sector 7, 128 Kbytes */
	51
	52	/* Base address of the Flash sectors Bank 2 */
	53	#define ADDR_FLASH_SECTOR_0_BANK2 ((uint32_t)0x08100000) /* Base @ of Sector 0, 128 Kbytes */
	54	#define ADDR_FLASH_SECTOR_1_BANK2 ((uint32_t)0x08120000) /* Base @ of Sector 1, 128 Kbytes */
	55	#define ADDR_FLASH_SECTOR_2_BANK2 ((uint32_t)0x08140000) /* Base @ of Sector 2, 128 Kbytes */
	56	#define ADDR_FLASH_SECTOR_3_BANK2 ((uint32_t)0x08160000) /* Base @ of Sector 3, 128 Kbytes */
	57	#define ADDR_FLASH_SECTOR_4_BANK2 ((uint32_t)0x08180000) /* Base @ of Sector 4, 128 Kbytes */
	58	#define ADDR_FLASH_SECTOR_5_BANK2 ((uint32_t)0x081A0000) /* Base @ of Sector 5, 128 Kbytes */
	59	#define ADDR_FLASH_SECTOR_6_BANK2 ((uint32_t)0x081C0000) /* Base @ of Sector 6, 128 Kbytes */
	60	#define ADDR_FLASH_SECTOR_7_BANK2 ((uint32_t)0x081E0000) /* Base @ of Sector 7, 128 Kbytes */
	61
	62
	63	/* Define the size of the sectors to be used */
	64
	65	#define PAGE_SIZE (uint32_t)0x20000 /* Page size = 128KByte */
	66
	67
	68	/* Device voltage range supposed to be [2.7V to 3.6V], the operation will
	69	be done by word */
	70	#define VOLTAGE_RANGE (uint8_t)VOLTAGE_RANGE_3
	71
	72	/* EEPROM emulation start address in Flash */
	73
	74	#define EEPROM_START_ADDRESS ADDR_FLASH_SECTOR_6_BANK2 /* sector6 of bank 2 */
	75
	76
	77	/* Pages 0 and 1 base and end addresses */
	78	#define PAGE0_BASE_ADDRESS ((uint32_t)(EEPROM_START_ADDRESS + 0x0000))
	79	#define PAGE0_END_ADDRESS ((uint32_t)(EEPROM_START_ADDRESS + (PAGE_SIZE - 1)))
	80
	81	#define PAGE0_ID FLASH_SECTOR_6
	82
	83
	84	#define PAGE1_BASE_ADDRESS ((uint32_t)(EEPROM_START_ADDRESS + PAGE_SIZE))
	85	#define PAGE1_END_ADDRESS ((uint32_t)(EEPROM_START_ADDRESS + (2 * PAGE_SIZE - 1)))
	86
	87	#define PAGE1_ID FLASH_SECTOR_7
	88
	89
	90	/* Used Flash pages for EEPROM emulation */
	91	#define PAGE0 ((uint16_t)0x0000)
	92	#define PAGE1 ((uint16_t)0x0001) /* Page nb between PAGE0_BASE_ADDRESS & PAGE1_BASE_ADDRESS*/
	93
	94	/* No valid page define */
	95	#define NO_VALID_PAGE ((uint16_t)0x00AB)
	96
	97	/* Page status definitions */
	98	#define ERASED ((uint16_t)0xFFFF) /* Page is empty */
	99	#define RECEIVE_DATA ((uint16_t)0xEEEE) /* Page is marked to receive data */
	100	#define VALID_PAGE ((uint16_t)0x0000) /* Page containing valid data */
	101
	102	/* Valid pages in read and write defines */
	103	#define READ_FROM_VALID_PAGE ((uint8_t)0x00)
	104	#define WRITE_IN_VALID_PAGE ((uint8_t)0x01)
	105
	106	/* Page full define */
	107	#define PAGE_FULL ((uint8_t)0x80)
	108
	109	/* Variables' number */
	110	#define NB_OF_VAR ((uint8_t)0x03)
	111
	112	/* Exported types ------------------------------------------------------------*/
	113	/* Exported macro ------------------------------------------------------------*/
	114	/* Exported functions ------------------------------------------------------- */
	115
	116	/* Virtual address defined by the user: 0xFFFF value is prohibited */
	117	extern uint16_t VirtAddVarTab[NB_OF_VAR];
	118	uint16_t EE_Init(void);
	119	uint16_t EE_ReadVariable(uint16_t VirtAddress, uint16_t* Data);
	120	uint16_t EE_WriteVariable(uint16_t VirtAddress, uint16_t Data);
	121
	122	#endif /* __EEPROM_H */
	123
	124	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/
	125

LEAF/Inc/fatfs.h+49−0

@@ -0,0 +1,49 @@
	1	/**
	2	******************************************************************************
	3	* @file fatfs.h
	4	* @brief Header for fatfs applications
	5	******************************************************************************
	6	* @attention
	7	*
	8	* <h2><center>© Copyright (c) 2020 STMicroelectronics.
	9	* All rights reserved.</center></h2>
	10	*
	11	* This software component is licensed by ST under Ultimate Liberty license
	12	* SLA0044, the "License"; You may not use this file except in compliance with
	13	* the License. You may obtain a copy of the License at:
	14	* www.st.com/SLA0044
	15	*
	16	******************************************************************************
	17	*/
	18
	19	/* Define to prevent recursive inclusion -------------------------------------*/
	20	#ifndef __fatfs_H
	21	#define __fatfs_H
	22	#ifdef __cplusplus
	23	extern "C" {
	24	#endif
	25
	26	#include "ff.h"
	27	#include "ff_gen_drv.h"
	28	#include "sd_diskio.h" /* defines SD_Driver as external */
	29
	30	/* USER CODE BEGIN Includes */
	31
	32	/* USER CODE END Includes */
	33
	34	extern uint8_t retSD; /* Return value for SD */
	35	extern char SDPath[4]; /* SD logical drive path */
	36	extern FATFS SDFatFS; /* File system object for SD logical drive */
	37	extern FIL SDFile; /* File object for SD */
	38
	39	void MX_FATFS_Init(void);
	40
	41	/* USER CODE BEGIN Prototypes */
	42
	43	/* USER CODE END Prototypes */
	44	#ifdef __cplusplus
	45	}
	46	#endif
	47	#endif /__fatfs_H /
	48
	49	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

LEAF/Inc/fatfs_platform.h+26−0

@@ -0,0 +1,26 @@
	1	/**
	2	******************************************************************************
	3	* @file : fatfs_platform.h
	4	* @brief : fatfs_platform header file
	5	******************************************************************************
	6	* @attention
	7	*
	8	* <h2><center>© Copyright (c) 2020 STMicroelectronics.
	9	* All rights reserved.</center></h2>
	10	*
	11	* This software component is licensed by ST under Ultimate Liberty license
	12	* SLA0044, the "License"; You may not use this file except in compliance with
	13	* the License. You may obtain a copy of the License at:
	14	* www.st.com/SLA0044
	15	*
	16	******************************************************************************
	17	*/
	18	/* Includes ------------------------------------------------------------------*/
	19	#include "stm32h7xx_hal.h"
	20	/* Defines ------------------------------------------------------------------*/
	21	#define SD_PRESENT ((uint8_t)0x01) /* also in bsp_driver_sd.h */
	22	#define SD_NOT_PRESENT ((uint8_t)0x00) /* also in bsp_driver_sd.h */
	23	#define SD_DETECT_PIN GPIO_PIN_13
	24	#define SD_DETECT_GPIO_PORT GPIOC
	25	/* Prototypes ---------------------------------------------------------------*/
	26	uint8_t BSP_PlatformIsDetected(void);

LEAF/Inc/ffconf.h+269−0

@@ -0,0 +1,269 @@
	1	/* USER CODE BEGIN Header */
	2	/**
	3	******************************************************************************
	4	* FatFs - Generic FAT file system module R0.12c (C)ChaN, 2017
	5	******************************************************************************
	6	* @attention
	7	*
	8	* <h2><center>© Copyright (c) 2019 STMicroelectronics.
	9	* All rights reserved.</center></h2>
	10	*
	11	* This software component is licensed by ST under Ultimate Liberty license
	12	* SLA0044, the "License"; You may not use this file except in compliance with
	13	* the License. You may obtain a copy of the License at:
	14	* www.st.com/SLA0044
	15	*
	16	******************************************************************************
	17	*/
	18	/* USER CODE END Header */
	19
	20	#ifndef _FFCONF
	21	#define _FFCONF 68300 /* Revision ID */
	22
	23	/*-----------------------------------------------------------------------------/
	24	/ Additional user header to be used
	25	/-----------------------------------------------------------------------------*/
	26	#include "main.h"
	27	#include "stm32h7xx_hal.h"
	28	#include "bsp_driver_sd.h"
	29
	30	/*-----------------------------------------------------------------------------/
	31	/ Function Configurations
	32	/-----------------------------------------------------------------------------*/
	33
	34	#define _FS_READONLY 0 /* 0:Read/Write or 1:Read only */
	35	/* This option switches read-only configuration. (0:Read/Write or 1:Read-only)
	36	/ Read-only configuration removes writing API functions, f_write(), f_sync(),
	37	/ f_unlink(), f_mkdir(), f_chmod(), f_rename(), f_truncate(), f_getfree()
	38	/ and optional writing functions as well. */
	39
	40	#define _FS_MINIMIZE 0 /* 0 to 3 */
	41	/* This option defines minimization level to remove some basic API functions.
	42	/
	43	/ 0: All basic functions are enabled.
	44	/ 1: f_stat(), f_getfree(), f_unlink(), f_mkdir(), f_truncate() and f_rename()
	45	/ are removed.
	46	/ 2: f_opendir(), f_readdir() and f_closedir() are removed in addition to 1.
	47	/ 3: f_lseek() function is removed in addition to 2. */
	48
	49	#define _USE_STRFUNC 2 /* 0:Disable or 1-2:Enable */
	50	/* This option switches string functions, f_gets(), f_putc(), f_puts() and
	51	/ f_printf().
	52	/
	53	/ 0: Disable string functions.
	54	/ 1: Enable without LF-CRLF conversion.
	55	/ 2: Enable with LF-CRLF conversion. */
	56
	57	#define _USE_FIND 0
	58	/* This option switches filtered directory read functions, f_findfirst() and
	59	/ f_findnext(). (0:Disable, 1:Enable 2:Enable with matching altname[] too) */
	60
	61	#define _USE_MKFS 1
	62	/* This option switches f_mkfs() function. (0:Disable or 1:Enable) */
	63
	64	#define _USE_FASTSEEK 1
	65	/* This option switches fast seek feature. (0:Disable or 1:Enable) */
	66
	67	#define _USE_EXPAND 0
	68	/* This option switches f_expand function. (0:Disable or 1:Enable) */
	69
	70	#define _USE_CHMOD 0
	71	/* This option switches attribute manipulation functions, f_chmod() and f_utime().
	72	/ (0:Disable or 1:Enable) Also _FS_READONLY needs to be 0 to enable this option. */
	73
	74	#define _USE_LABEL 0
	75	/* This option switches volume label functions, f_getlabel() and f_setlabel().
	76	/ (0:Disable or 1:Enable) */
	77
	78	#define _USE_FORWARD 0
	79	/* This option switches f_forward() function. (0:Disable or 1:Enable) */
	80
	81	/*-----------------------------------------------------------------------------/
	82	/ Locale and Namespace Configurations
	83	/-----------------------------------------------------------------------------*/
	84
	85	#define _CODE_PAGE 850
	86	/* This option specifies the OEM code page to be used on the target system.
	87	/ Incorrect setting of the code page can cause a file open failure.
	88	/
	89	/ 1 - ASCII (No extended character. Non-LFN cfg. only)
	90	/ 437 - U.S.
	91	/ 720 - Arabic
	92	/ 737 - Greek
	93	/ 771 - KBL
	94	/ 775 - Baltic
	95	/ 850 - Latin 1
	96	/ 852 - Latin 2
	97	/ 855 - Cyrillic
	98	/ 857 - Turkish
	99	/ 860 - Portuguese
	100	/ 861 - Icelandic
	101	/ 862 - Hebrew
	102	/ 863 - Canadian French
	103	/ 864 - Arabic
	104	/ 865 - Nordic
	105	/ 866 - Russian
	106	/ 869 - Greek 2
	107	/ 932 - Japanese (DBCS)
	108	/ 936 - Simplified Chinese (DBCS)
	109	/ 949 - Korean (DBCS)
	110	/ 950 - Traditional Chinese (DBCS)
	111	*/
	112
	113	#define _USE_LFN 0 /* 0 to 3 */
	114	#define _MAX_LFN 255 /* Maximum LFN length to handle (12 to 255) */
	115	/* The _USE_LFN switches the support of long file name (LFN).
	116	/
	117	/ 0: Disable support of LFN. _MAX_LFN has no effect.
	118	/ 1: Enable LFN with static working buffer on the BSS. Always NOT thread-safe.
	119	/ 2: Enable LFN with dynamic working buffer on the STACK.
	120	/ 3: Enable LFN with dynamic working buffer on the HEAP.
	121	/
	122	/ To enable the LFN, Unicode handling functions (option/unicode.c) must be added
	123	/ to the project. The working buffer occupies (_MAX_LFN + 1) * 2 bytes and
	124	/ additional 608 bytes at exFAT enabled. _MAX_LFN can be in range from 12 to 255.
	125	/ It should be set 255 to support full featured LFN operations.
	126	/ When use stack for the working buffer, take care on stack overflow. When use heap
	127	/ memory for the working buffer, memory management functions, ff_memalloc() and
	128	/ ff_memfree(), must be added to the project. */
	129
	130	#define _LFN_UNICODE 0 /* 0:ANSI/OEM or 1:Unicode */
	131	/* This option switches character encoding on the API. (0:ANSI/OEM or 1:UTF-16)
	132	/ To use Unicode string for the path name, enable LFN and set _LFN_UNICODE = 1.
	133	/ This option also affects behavior of string I/O functions. */
	134
	135	#define _STRF_ENCODE 3
	136	/* When _LFN_UNICODE == 1, this option selects the character encoding ON THE FILE to
	137	/ be read/written via string I/O functions, f_gets(), f_putc(), f_puts and f_printf().
	138	/
	139	/ 0: ANSI/OEM
	140	/ 1: UTF-16LE
	141	/ 2: UTF-16BE
	142	/ 3: UTF-8
	143	/
	144	/ This option has no effect when _LFN_UNICODE == 0. */
	145
	146	#define _FS_RPATH 0 /* 0 to 2 */
	147	/* This option configures support of relative path.
	148	/
	149	/ 0: Disable relative path and remove related functions.
	150	/ 1: Enable relative path. f_chdir() and f_chdrive() are available.
	151	/ 2: f_getcwd() function is available in addition to 1.
	152	*/
	153
	154	/*---------------------------------------------------------------------------/
	155	/ Drive/Volume Configurations
	156	/----------------------------------------------------------------------------*/
	157
	158	#define _VOLUMES 1
	159	/* Number of volumes (logical drives) to be used. */
	160
	161	/* USER CODE BEGIN Volumes */
	162	#define _STR_VOLUME_ID 0 /* 0:Use only 0-9 for drive ID, 1:Use strings for drive ID */
	163	#define _VOLUME_STRS "RAM","NAND","CF","SD1","SD2","USB1","USB2","USB3"
	164	/* _STR_VOLUME_ID switches string support of volume ID.
	165	/ When _STR_VOLUME_ID is set to 1, also pre-defined strings can be used as drive
	166	/ number in the path name. _VOLUME_STRS defines the drive ID strings for each
	167	/ logical drives. Number of items must be equal to _VOLUMES. Valid characters for
	168	/ the drive ID strings are: A-Z and 0-9. */
	169	/* USER CODE END Volumes */
	170
	171	#define _MULTI_PARTITION 0 /* 0:Single partition, 1:Multiple partition */
	172	/* This option switches support of multi-partition on a physical drive.
	173	/ By default (0), each logical drive number is bound to the same physical drive
	174	/ number and only an FAT volume found on the physical drive will be mounted.
	175	/ When multi-partition is enabled (1), each logical drive number can be bound to
	176	/ arbitrary physical drive and partition listed in the VolToPart[]. Also f_fdisk()
	177	/ funciton will be available. */
	178	#define _MIN_SS 512 /* 512, 1024, 2048 or 4096 */
	179	#define _MAX_SS 512 /* 512, 1024, 2048 or 4096 */
	180	/* These options configure the range of sector size to be supported. (512, 1024,
	181	/ 2048 or 4096) Always set both 512 for most systems, all type of memory cards and
	182	/ harddisk. But a larger value may be required for on-board flash memory and some
	183	/ type of optical media. When _MAX_SS is larger than _MIN_SS, FatFs is configured
	184	/ to variable sector size and GET_SECTOR_SIZE command must be implemented to the
	185	/ disk_ioctl() function. */
	186
	187	#define _USE_TRIM 0
	188	/* This option switches support of ATA-TRIM. (0:Disable or 1:Enable)
	189	/ To enable Trim function, also CTRL_TRIM command should be implemented to the
	190	/ disk_ioctl() function. */
	191
	192	#define _FS_NOFSINFO 0 /* 0,1,2 or 3 */
	193	/* If you need to know correct free space on the FAT32 volume, set bit 0 of this
	194	/ option, and f_getfree() function at first time after volume mount will force
	195	/ a full FAT scan. Bit 1 controls the use of last allocated cluster number.
	196	/
	197	/ bit0=0: Use free cluster count in the FSINFO if available.
	198	/ bit0=1: Do not trust free cluster count in the FSINFO.
	199	/ bit1=0: Use last allocated cluster number in the FSINFO if available.
	200	/ bit1=1: Do not trust last allocated cluster number in the FSINFO.
	201	*/
	202
	203	/*---------------------------------------------------------------------------/
	204	/ System Configurations
	205	/----------------------------------------------------------------------------*/
	206
	207	#define _FS_TINY 0 /* 0:Normal or 1:Tiny */
	208	/* This option switches tiny buffer configuration. (0:Normal or 1:Tiny)
	209	/ At the tiny configuration, size of file object (FIL) is reduced _MAX_SS bytes.
	210	/ Instead of private sector buffer eliminated from the file object, common sector
	211	/ buffer in the file system object (FATFS) is used for the file data transfer. */
	212
	213	#define _FS_EXFAT 0
	214	/* This option switches support of exFAT file system. (0:Disable or 1:Enable)
	215	/ When enable exFAT, also LFN needs to be enabled. (_USE_LFN >= 1)
	216	/ Note that enabling exFAT discards C89 compatibility. */
	217
	218	#define _FS_NORTC 0
	219	#define _NORTC_MON 6
	220	#define _NORTC_MDAY 4
	221	#define _NORTC_YEAR 2015
	222	/* The option _FS_NORTC switches timestamp functiton. If the system does not have
	223	/ any RTC function or valid timestamp is not needed, set _FS_NORTC = 1 to disable
	224	/ the timestamp function. All objects modified by FatFs will have a fixed timestamp
	225	/ defined by _NORTC_MON, _NORTC_MDAY and _NORTC_YEAR in local time.
	226	/ To enable timestamp function (_FS_NORTC = 0), get_fattime() function need to be
	227	/ added to the project to get current time form real-time clock. _NORTC_MON,
	228	/ _NORTC_MDAY and _NORTC_YEAR have no effect.
	229	/ These options have no effect at read-only configuration (_FS_READONLY = 1). */
	230
	231	#define _FS_LOCK 2 /* 0:Disable or >=1:Enable */
	232	/* The option _FS_LOCK switches file lock function to control duplicated file open
	233	/ and illegal operation to open objects. This option must be 0 when _FS_READONLY
	234	/ is 1.
	235	/
	236	/ 0: Disable file lock function. To avoid volume corruption, application program
	237	/ should avoid illegal open, remove and rename to the open objects.
	238	/ >0: Enable file lock function. The value defines how many files/sub-directories
	239	/ can be opened simultaneously under file lock control. Note that the file
	240	/ lock control is independent of re-entrancy. */
	241
	242	#define _FS_REENTRANT 0 /* 0:Disable or 1:Enable */
	243	#define _FS_TIMEOUT 1000 /* Timeout period in unit of time ticks */
	244	#define _SYNC_t NULL
	245	/* The option _FS_REENTRANT switches the re-entrancy (thread safe) of the FatFs
	246	/ module itself. Note that regardless of this option, file access to different
	247	/ volume is always re-entrant and volume control functions, f_mount(), f_mkfs()
	248	/ and f_fdisk() function, are always not re-entrant. Only file/directory access
	249	/ to the same volume is under control of this function.
	250	/
	251	/ 0: Disable re-entrancy. _FS_TIMEOUT and _SYNC_t have no effect.
	252	/ 1: Enable re-entrancy. Also user provided synchronization handlers,
	253	/ ff_req_grant(), ff_rel_grant(), ff_del_syncobj() and ff_cre_syncobj()
	254	/ function, must be added to the project. Samples are available in
	255	/ option/syscall.c.
	256	/
	257	/ The _FS_TIMEOUT defines timeout period in unit of time tick.
	258	/ The _SYNC_t defines O/S dependent sync object type. e.g. HANDLE, ID, OS_EVENT*,
	259	/ SemaphoreHandle_t and etc.. A header file for O/S definitions needs to be
	260	/ included somewhere in the scope of ff.h. */
	261
	262	/* define the ff_malloc ff_free macros as standard malloc free */
	263	#if !defined(ff_malloc) && !defined(ff_free)
	264	#include <stdlib.h>
	265	#define ff_malloc malloc
	266	#define ff_free free
	267	#endif
	268
	269	#endif /* _FFCONF */

LEAF/Inc/fmc.h+60−0

@@ -0,0 +1,60 @@
	1	/**
	2	******************************************************************************
	3	* File Name : FMC.h
	4	* Description : This file provides code for the configuration
	5	* of the FMC peripheral.
	6	******************************************************************************
	7	* @attention
	8	*
	9	* <h2><center>© Copyright (c) 2020 STMicroelectronics.
	10	* All rights reserved.</center></h2>
	11	*
	12	* This software component is licensed by ST under Ultimate Liberty license
	13	* SLA0044, the "License"; You may not use this file except in compliance with
	14	* the License. You may obtain a copy of the License at:
	15	* www.st.com/SLA0044
	16	*
	17	******************************************************************************
	18	*/
	19	/* Define to prevent recursive inclusion -------------------------------------*/
	20	#ifndef __FMC_H
	21	#define __FMC_H
	22	#ifdef __cplusplus
	23	extern "C" {
	24	#endif
	25
	26	/* Includes ------------------------------------------------------------------*/
	27	#include "main.h"
	28
	29	/* USER CODE BEGIN Includes */
	30
	31	/* USER CODE END Includes */
	32
	33	extern SDRAM_HandleTypeDef hsdram1;
	34
	35	/* USER CODE BEGIN Private defines */
	36
	37	/* USER CODE END Private defines */
	38
	39	void MX_FMC_Init(void);
	40	void HAL_SDRAM_MspInit(SDRAM_HandleTypeDef* hsdram);
	41	void HAL_SDRAM_MspDeInit(SDRAM_HandleTypeDef* hsdram);
	42
	43	/* USER CODE BEGIN Prototypes */
	44
	45	/* USER CODE END Prototypes */
	46
	47	#ifdef __cplusplus
	48	}
	49	#endif
	50	#endif /__FMC_H /
	51
	52	/**
	53	* @}
	54	*/
	55
	56	/**
	57	* @}
	58	*/
	59
	60	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

LEAF/Inc/gfx.h+120−0

@@ -0,0 +1,120 @@
	1	/*
	2	* gfx.h
	3	*
	4	* Created on: Jul 8, 2018
	5	* Author: jeffsnyder
	6	*/
	7
	8	#ifndef GFX_H_
	9	#define GFX_H_
	10
	11
	12	#include "gfx_font.h"
	13	#include "ssd1306.h"
	14
	15	typedef struct _GFX
	16	{
	17	int16_t WIDTH;
	18	int16_t HEIGHT;
	19	uint16_t _width;
	20	uint16_t _height;
	21	uint16_t rotation;
	22	uint16_t cursor_y;
	23	uint16_t cursor_x;
	24	uint16_t textsize;
	25	uint16_t textcolor;
	26	uint16_t textbgcolor;
	27	uint16_t wrap;
	28	uint16_t _cp437;
	29	GFXfont *gfxFont;
	30	} GFX;
	31
	32	void GFXinit(GFX* myGfx, int16_t w, int16_t h); // Constructor
	33
	34	// This MUST be defined by the subclass:
	35	void GFXdrawPixel(GFX* myGfx, int16_t x, int16_t y, uint16_t color);
	36
	37	// TRANSACTION API / CORE DRAW API
	38	// These MAY be overridden by the subclass to provide device-specific
	39	// optimized code. Otherwise 'generic' versions are used.
	40	void GFXstartWrite(GFX* myGfx);
	41	void GFXwritePixel(GFX* myGfx, int16_t x, int16_t y, uint16_t color);
	42	void GFXwriteFillRect(GFX* myGfx, int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color);
	43	void GFXwriteFastVLine(GFX* myGfx, int16_t x, int16_t y, int16_t h, uint16_t color);
	44	void GFXwriteFastHLine(GFX* myGfx, int16_t x, int16_t y, int16_t w, uint16_t color);
	45	void GFXwriteLine(GFX* myGfx, int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color);
	46	void GFXendWrite(GFX* myGfx);
	47
	48	// CONTROL API
	49	// These MAY be overridden by the subclass to provide device-specific
	50	// optimized code. Otherwise 'generic' versions are used.
	51	void GFXsetRotation(GFX* myGfx, uint8_t r);
	52	void GFXinvertDisplay(GFX* myGfx, uint8_t i);
	53
	54	// BASIC DRAW API
	55	// These MAY be overridden by the subclass to provide device-specific
	56	// optimized code. Otherwise 'generic' versions are used.
	57
	58	// It's good to implement those, even if using transaction API
	59	void GFXdrawFastVLine(GFX* myGfx, int16_t x, int16_t y, int16_t h, uint16_t color);
	60	void GFXdrawFastHLine(GFX* myGfx, int16_t x, int16_t y, int16_t w, uint16_t color);
	61	void GFXfillRect(GFX* myGfx, int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color);
	62	void GFXfillScreen(GFX* myGfx, uint16_t color);
	63	// Optional and probably not necessary to change
	64	void GFXdrawLine(GFX* myGfx, int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color);
	65	void GFXdrawRect(GFX* myGfx, int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color);
	66
	67	// These exist only with Adafruit_GFX (no subclass overrides)
	68
	69	void GFXdrawCircle(GFX* myGfx, int16_t x0, int16_t y0, int16_t r, uint16_t color);
	70	void GFXdrawCircleHelper(GFX* myGfx, int16_t x0, int16_t y0, int16_t r, uint8_t cornername,
	71	uint16_t color);
	72	void GFXfillCircle(GFX* myGfx, int16_t x0, int16_t y0, int16_t r, uint16_t color);
	73	void GFXfillCircleHelper(GFX* myGfx, int16_t x0, int16_t y0, int16_t r, uint8_t cornername,
	74	int16_t delta, uint16_t color);
	75	void GFXdrawTriangle(GFX* myGfx, int16_t x0, int16_t y0, int16_t x1, int16_t y1,
	76	int16_t x2, int16_t y2, uint16_t color);
	77	void GFXfillTriangle(GFX* myGfx, int16_t x0, int16_t y0, int16_t x1, int16_t y1,
	78	int16_t x2, int16_t y2, uint16_t color);
	79	void GFXdrawRoundRect(GFX* myGfx, int16_t x0, int16_t y0, int16_t w, int16_t h,
	80	int16_t radius, uint16_t color);
	81	void GFXfillRoundRect(GFX* myGfx, int16_t x0, int16_t y0, int16_t w, int16_t h,
	82	int16_t radius, uint16_t color);
	83	void GFXdrawBitmap(GFX* myGfx, int16_t x, int16_t y, uint8_t *bitmap,
	84	int16_t w, int16_t h, uint16_t color, uint16_t bg);
	85	void GFXdrawChar(GFX* myGfx, int16_t x, int16_t y, unsigned char c, uint16_t color,
	86	uint16_t bg, uint8_t size);
	87	void GFXsetCursor(GFX* myGfx, int16_t x, int16_t y);
	88	void GFXsetTextColor(GFX* myGfx, uint16_t c, uint16_t bg);
	89	void GFXsetTextSize(GFX* myGfx, uint8_t s);
	90	void GFXsetTextWrap(GFX* myGfx, uint8_t w);
	91	void GFXcp437(GFX* myGfx, uint8_t x);
	92	void GFXsetFont(GFX* myGfx, const GFXfont *f);
	93	void GFXgetTextBounds(GFX* myGfx, char *string, int16_t x, int16_t y,
	94	int16_t x1, int16_t y1, uint16_t w, uint16_t h);
	95
	96
	97	void GFXwrite(GFX* myGfx, uint8_t);
	98
	99
	100	int16_t GFXheight(GFX* myGfx );
	101	int16_t GFXwidth(GFX* myGfx );
	102
	103	uint8_t GFXgetRotation(GFX* myGfx );
	104
	105	// get current cursor position (get rotation safe maximum values, using: width() for x, height() for y)
	106	int16_t GFXgetCursorX(GFX* myGfx);
	107	int16_t GFXgetCursorY(GFX* myGfx );
	108
	109	void GFXcharBounds(GFX* myGfx, char c, int16_t x, int16_t y,
	110	int16_t minx, int16_t miny, int16_t maxx, int16_t maxy);
	111
	112	int OLEDparseInt(char* buffer, uint32_t myNumber, uint8_t numDigits);
	113
	114	int OLEDparsePitch(char* buffer, float midi);
	115
	116	int OLEDparsePitchClass(char* buffer, float midi);
	117
	118	int OLEDparseFixedFloat(char* buffer, float input, uint8_t numDigits, uint8_t numDecimal);
	119
	120	#endif /* GFX_H_ */

LEAF/Inc/gfx_font.h+24−0

@@ -0,0 +1,24 @@
	1	// Font structures for newer Adafruit_GFX (1.1 and later).
	2	// Example fonts are included in 'Fonts' directory.
	3	// To use a font in your Arduino sketch, #include the corresponding .h
	4	// file and pass address of GFXfont struct to setFont(). Pass NULL to
	5	// revert to 'classic' fixed-space bitmap font.
	6
	7	#ifndef _GFXFONT_H_
	8	#define _GFXFONT_H_
	9
	10	typedef struct { // Data stored PER GLYPH
	11	uint16_t bitmapOffset; // Pointer into GFXfont->bitmap
	12	uint8_t width, height; // Bitmap dimensions in pixels
	13	uint8_t xAdvance; // Distance to advance cursor (x axis)
	14	int8_t xOffset, yOffset; // Dist from cursor pos to UL corner
	15	} GFXglyph;
	16
	17	typedef struct { // Data stored for FONT AS A WHOLE:
	18	uint8_t *bitmap; // Glyph bitmaps, concatenated
	19	GFXglyph *glyph; // Glyph array
	20	uint8_t first, last; // ASCII extents
	21	uint8_t yAdvance; // Newline distance (y axis)
	22	} GFXfont;
	23
	24	#endif // _GFXFONT_H_

LEAF/Inc/gpio.h+57−0

@@ -0,0 +1,57 @@
	1	/**
	2	******************************************************************************
	3	* File Name : gpio.h
	4	* Description : This file contains all the functions prototypes for
	5	* the gpio
	6	******************************************************************************
	7	* @attention
	8	*
	9	* <h2><center>© Copyright (c) 2020 STMicroelectronics.
	10	* All rights reserved.</center></h2>
	11	*
	12	* This software component is licensed by ST under Ultimate Liberty license
	13	* SLA0044, the "License"; You may not use this file except in compliance with
	14	* the License. You may obtain a copy of the License at:
	15	* www.st.com/SLA0044
	16	*
	17	******************************************************************************
	18	*/
	19
	20	/* Define to prevent recursive inclusion -------------------------------------*/
	21	#ifndef __gpio_H
	22	#define __gpio_H
	23	#ifdef __cplusplus
	24	extern "C" {
	25	#endif
	26
	27	/* Includes ------------------------------------------------------------------*/
	28	#include "main.h"
	29
	30	/* USER CODE BEGIN Includes */
	31
	32	/* USER CODE END Includes */
	33
	34	/* USER CODE BEGIN Private defines */
	35
	36	/* USER CODE END Private defines */
	37
	38	void MX_GPIO_Init(void);
	39
	40	/* USER CODE BEGIN Prototypes */
	41
	42	/* USER CODE END Prototypes */
	43
	44	#ifdef __cplusplus
	45	}
	46	#endif
	47	#endif /__ pinoutConfig_H /
	48
	49	/**
	50	* @}
	51	*/
	52
	53	/**
	54	* @}
	55	*/
	56
	57	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

LEAF/Inc/i2c.h+60−0

@@ -0,0 +1,60 @@
	1	/**
	2	******************************************************************************
	3	* File Name : I2C.h
	4	* Description : This file provides code for the configuration
	5	* of the I2C instances.
	6	******************************************************************************
	7	* @attention
	8	*
	9	* <h2><center>© Copyright (c) 2020 STMicroelectronics.
	10	* All rights reserved.</center></h2>
	11	*
	12	* This software component is licensed by ST under Ultimate Liberty license
	13	* SLA0044, the "License"; You may not use this file except in compliance with
	14	* the License. You may obtain a copy of the License at:
	15	* www.st.com/SLA0044
	16	*
	17	******************************************************************************
	18	*/
	19	/* Define to prevent recursive inclusion -------------------------------------*/
	20	#ifndef __i2c_H
	21	#define __i2c_H
	22	#ifdef __cplusplus
	23	extern "C" {
	24	#endif
	25
	26	/* Includes ------------------------------------------------------------------*/
	27	#include "main.h"
	28
	29	/* USER CODE BEGIN Includes */
	30
	31	/* USER CODE END Includes */
	32
	33	extern I2C_HandleTypeDef hi2c2;
	34	extern I2C_HandleTypeDef hi2c4;
	35
	36	/* USER CODE BEGIN Private defines */
	37
	38	/* USER CODE END Private defines */
	39
	40	void MX_I2C2_Init(void);
	41	void MX_I2C4_Init(void);
	42
	43	/* USER CODE BEGIN Prototypes */
	44
	45	/* USER CODE END Prototypes */
	46
	47	#ifdef __cplusplus
	48	}
	49	#endif
	50	#endif /__ i2c_H /
	51
	52	/**
	53	* @}
	54	*/
	55
	56	/**
	57	* @}
	58	*/
	59
	60	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

LEAF/Inc/leaf-analysis.h+0−258

@@ -1,258 +0,0 @@
1	/*==============================================================================
2
3	leaf-analysis.h
4	Created: 25 Oct 2019 10:30:52am
5	Author: Matthew Wang
6
7	==============================================================================*/
8
9	#ifndef LEAF_ANALYSIS_H_INCLUDED
10	#define LEAF_ANALYSIS_H_INCLUDED
11
12	#ifdef __cplusplus
13	extern "C" {
14	#endif
15
16	//==============================================================================
17
18	#include "leaf-global.h"
19	#include "leaf-mempool.h"
20	#include "leaf-math.h"
21	#include "leaf-filters.h"
22	#include "leaf-envelopes.h"
23
24	//==============================================================================
25
26	/* Envelope Follower */
27	typedef struct _tEnvelopeFollower
28	{
29	float y;
30	float a_thresh;
31	float d_coeff;
32
33	} _tEnvelopeFollower;
34
35	typedef _tEnvelopeFollower* tEnvelopeFollower;
36
37	void tEnvelopeFollower_init (tEnvelopeFollower* const, float attackThreshold, float decayCoeff);
38	void tEnvelopeFollower_free (tEnvelopeFollower* const);
39	void tEnvelopeFollower_initToPool (tEnvelopeFollower* const, float attackThreshold, float decayCoeff, tMempool* const);
40	void tEnvelopeFollower_freeFromPool (tEnvelopeFollower* const, tMempool* const);
41
42	float tEnvelopeFollower_tick (tEnvelopeFollower* const, float x);
43	int tEnvelopeFollower_decayCoeff (tEnvelopeFollower* const, float decayCoeff);
44	int tEnvelopeFollower_attackThresh (tEnvelopeFollower* const, float attackThresh);
45
46	// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
47
48	/* PowerEnvelopeFollower */
49	typedef struct _tPowerFollower {
50	float factor, oneminusfactor;
51	float curr;
52
53	} _tPowerFollower;
54
55	typedef _tPowerFollower* tPowerFollower;
56
57	void tPowerFollower_init (tPowerFollower* const, float factor);
58	void tPowerFollower_free (tPowerFollower* const);
59	void tPowerFollower_initToPool (tPowerFollower* const, float factor, tMempool* const);
60	void tPowerFollower_freeFromPool (tPowerFollower* const, tMempool* const);
61
62	float tPowerFollower_tick (tPowerFollower* const, float input);
63	float tPowerFollower_sample (tPowerFollower* const);
64	int tPowerFollower_setFactor (tPowerFollower* const, float factor);
65
66	// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
67
68	// ENV~ from PD, modified for LEAF
69	#define MAXOVERLAP 32
70	#define INITVSTAKEN 64
71	#define ENV_WINDOW_SIZE 1024
72	#define ENV_HOP_SIZE 256
73
74	typedef struct _tEnvPD
75	{
76	float buf[ENV_WINDOW_SIZE + INITVSTAKEN];
77	uint16_t x_phase; /* number of points since last output */
78	uint16_t x_period; /* requested period of output */
79	uint16_t x_realperiod; /* period rounded up to vecsize multiple */
80	uint16_t x_npoints; /* analysis window size in samples */
81	float x_result; /* result to output */
82	float x_sumbuf[MAXOVERLAP]; /* summing buffer */
83	float x_f;
84	uint16_t windowSize, hopSize, blockSize;
85	uint16_t x_allocforvs; /* extra buffer for DSP vector size */
86	} _tEnvPD;
87
88	typedef _tEnvPD* tEnvPD;
89
90	void tEnvPD_init (tEnvPD* const, int windowSize, int hopSize, int blockSize);
91	void tEnvPD_free (tEnvPD* const);
92	void tEnvPD_initToPool (tEnvPD* const, int windowSize, int hopSize, int blockSize, tMempool* const);
93	void tEnvPD_freeFromPool (tEnvPD* const, tMempool* const);
94
95	float tEnvPD_tick (tEnvPD* const);
96	void tEnvPD_processBlock (tEnvPD* const, float* in);
97
98	// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
99
100	/* tAttackDetection */
101	#define DEFBLOCKSIZE 1024
102	#define DEFTHRESHOLD 6
103	#define DEFATTACK 10
104	#define DEFRELEASE 10
105
106	typedef struct _tAttackDetection
107	{
108	float env;
109
110	//Attack & Release times in msec
111	int atk;
112	int rel;
113
114	//Attack & Release coefficients based on times
115	float atk_coeff;
116	float rel_coeff;
117
118	int blocksize;
119	int samplerate;
120
121	//RMS amplitude of previous block - used to decide if attack is present
122	float prevAmp;
123
124	float threshold;
125	} _tAttackDetection;
126
127	typedef _tAttackDetection* tAttackDetection;
128
129	void tAttackDetection_init (tAttackDetection* const, int blocksize, int atk, int rel);
130	void tAttackDetection_free (tAttackDetection* const);
131	void tAttackDetection_initToPool (tAttackDetection* const, int blocksize, int atk, int rel, tMempool* const);
132	void tAttackDetection_freeFromPool (tAttackDetection* const, tMempool* const);
133
134	// set expected input blocksize
135	void tAttackDetection_setBlocksize (tAttackDetection* const, int size);
136
137	// change atkDetector sample rate
138	void tAttackDetection_setSamplerate (tAttackDetection* const, int inRate);
139
140	// set attack time and coeff
141	void tAttackDetection_setAttack (tAttackDetection* const, int inAtk);
142
143	// set release time and coeff
144	void tAttackDetection_setRelease (tAttackDetection* const, int inRel);
145
146	// set level above which values are identified as attacks
147	void tAttackDetection_setThreshold (tAttackDetection* const, float thres);
148
149	// find largest transient in input block, return index of attack
150	int tAttackDetection_detect (tAttackDetection* const, float *in);
151
152	//==============================================================================
153
154	// tSNAC: period detector
155	// from Katja Vetters http://www.katjaas.nl/helmholtz/helmholtz.html
156	#define SNAC_FRAME_SIZE 1024 // default analysis framesize // should be the same as (or smaller than?) PS_FRAME_SIZE
157	#define DEFOVERLAP 1 // default overlap
158	#define DEFBIAS 0.2f // default bias
159	#define DEFMINRMS 0.003f // default minimum RMS
160	#define SEEK 0.85f // seek-length as ratio of framesize
161
162	typedef struct _tSNAC
163	{
164	float* inputbuf;
165	float* processbuf;
166	float* spectrumbuf;
167	float* biasbuf;
168	uint16_t timeindex;
169	uint16_t framesize;
170	uint16_t overlap;
171	uint16_t periodindex;
172
173	float periodlength;
174	float fidelity;
175	float biasfactor;
176	float minrms;
177
178	} _tSNAC;
179
180	typedef _tSNAC* tSNAC;
181
182	void tSNAC_init (tSNAC* const, int overlaparg);
183	void tSNAC_free (tSNAC* const);
184	void tSNAC_initToPool (tSNAC* const, int overlaparg, tMempool* const);
185	void tSNAC_freeFromPool (tSNAC* const, tMempool* const);
186
187	void tSNAC_ioSamples (tSNAC s, float in, float *out, int size);
188	void tSNAC_setOverlap (tSNAC *s, int lap);
189	void tSNAC_setBias (tSNAC *s, float bias);
190	void tSNAC_setMinRMS (tSNAC *s, float rms);
191
192	/To get freq, perform SAMPLE_RATE/snac_getperiod() /
193	float tSNAC_getPeriod (tSNAC *s);
194	float tSNAC_getFidelity (tSNAC *s);
195
196	#define DEFPITCHRATIO 2.0f
197	#define DEFTIMECONSTANT 100.0f
198	#define DEFHOPSIZE 64
199	#define DEFWINDOWSIZE 64
200	#define FBA 20
201	#define HPFREQ 40.0f
202
203	// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
204	// Period detection
205	typedef struct _tPeriodDetection
206	{
207	tEnvPD env;
208	tSNAC snac;
209	float* inBuffer;
210	float* outBuffer;
211	int frameSize;
212	int bufSize;
213	int framesPerBuffer;
214	int curBlock;
215	int lastBlock;
216	int i;
217	int indexstore;
218	int iLast;
219	int index;
220	float period;
221
222	uint16_t hopSize;
223	uint16_t windowSize;
224	uint8_t fba;
225
226	float timeConstant;
227	float radius;
228	float max;
229	float lastmax;
230	float deltamax;
231
232	float fidelityThreshold;
233
234	} _tPeriodDetection;
235
236	typedef _tPeriodDetection* tPeriodDetection;
237
238	void tPeriodDetection_init (tPeriodDetection* const, float* in, float* out, int bufSize, int frameSize);
239	void tPeriodDetection_free (tPeriodDetection* const);
240	void tPeriodDetection_initToPool (tPeriodDetection* const, float* in, float* out, int bufSize, int frameSize, tMempool* const);
241	void tPeriodDetection_freeFromPool (tPeriodDetection* const, tMempool* const);
242
243	float tPeriodDetection_tick (tPeriodDetection* const, float sample);
244	float tPeriodDetection_getPeriod (tPeriodDetection* const);
245	void tPeriodDetection_setHopSize (tPeriodDetection* const, int hs);
246	void tPeriodDetection_setWindowSize (tPeriodDetection* const, int ws);
247	void tPeriodDetection_setFidelityThreshold(tPeriodDetection* const, float threshold);
248
249	//==============================================================================
250
251	#ifdef __cplusplus
252	}
253	#endif
254
255	#endif // LEAF_ANALYSIS_H_INCLUDED
256
257	//==============================================================================
258

LEAF/Inc/leaf-delay.h+0−221

@@ -1,221 +0,0 @@
1	/*==============================================================================
2
3	leaf-delay.h
4	Created: 20 Jan 2017 12:01:24pm
5	Author: Michael R Mulshine
6
7	==============================================================================*/
8
9	#ifndef LEAF_DELAY_H_INCLUDED
10	#define LEAF_DELAY_H_INCLUDED
11
12	#ifdef __cplusplus
13	extern "C" {
14	#endif
15
16	//==============================================================================
17
18	#include "leaf-math.h"
19	#include "leaf-mempool.h"
20
21	//==============================================================================
22
23	/* Non-interpolating delay, reimplemented from STK (Cook and Scavone). */
24	typedef struct _tDelay
25	{
26	float gain;
27	float* buff;
28
29	float lastOut, lastIn;
30
31	uint32_t inPoint, outPoint;
32
33	uint32_t delay, maxDelay;
34
35	} _tDelay;
36
37	typedef _tDelay* tDelay;
38
39	void tDelay_init (tDelay* const, uint32_t delay, uint32_t maxDelay);
40	void tDelay_free (tDelay* const);
41	void tDelay_initToPool (tDelay* const, uint32_t delay, uint32_t maxDelay, tMempool* const);
42	void tDelay_freeFromPool (tDelay* const, tMempool* const);
43
44	void tDelay_clear (tDelay* const);
45	int tDelay_setDelay (tDelay* const, uint32_t delay);
46	uint32_t tDelay_getDelay (tDelay* const);
47	void tDelay_tapIn (tDelay* const, float in, uint32_t tapDelay);
48	float tDelay_tapOut (tDelay* const, uint32_t tapDelay);
49	float tDelay_addTo (tDelay* const, float value, uint32_t tapDelay);
50	float tDelay_tick (tDelay* const, float sample);
51	float tDelay_getLastOut (tDelay* const);
52	float tDelay_getLastIn (tDelay* const);
53
54	//==============================================================================
55
56	/* Linearly-interpolating delay, reimplemented from STK (Cook and Scavone). */
57	typedef struct _tLinearDelay
58	{
59	float gain;
60	float* buff;
61
62	float lastOut, lastIn;
63
64	uint32_t inPoint, outPoint;
65
66	uint32_t maxDelay;
67
68	float delay;
69
70	float alpha, omAlpha;
71
72	} _tLinearDelay;
73
74	typedef _tLinearDelay* tLinearDelay;
75
76	void tLinearDelay_init (tLinearDelay* const, float delay, uint32_t maxDelay);
77	void tLinearDelay_free (tLinearDelay* const);
78	void tLinearDelay_initToPool (tLinearDelay* const, float delay, uint32_t maxDelay, tMempool* const);
79	void tLinearDelay_freeFromPool(tLinearDelay* const, tMempool* const);
80	void tLinearDelay_clear (tLinearDelay* const dl);
81	int tLinearDelay_setDelay (tLinearDelay* const, float delay);
82	float tLinearDelay_getDelay (tLinearDelay* const);
83	void tLinearDelay_tapIn (tLinearDelay* const, float in, uint32_t tapDelay);
84	float tLinearDelay_tapOut (tLinearDelay* const, uint32_t tapDelay);
85	float tLinearDelay_addTo (tLinearDelay* const, float value, uint32_t tapDelay);
86	float tLinearDelay_tick (tLinearDelay* const, float sample);
87	void tLinearDelay_tickIn (tLinearDelay* const, float input);
88	float tLinearDelay_tickOut (tLinearDelay* const);
89	float tLinearDelay_getLastOut (tLinearDelay* const);
90	float tLinearDelay_getLastIn (tLinearDelay* const);
91
92
93
94	//==============================================================================
95
96	/* Hermite-interpolating delay, created by adapting STK linear delay with Hermite interpolation */
97	typedef struct _tHermiteDelay
98	{
99	float gain;
100	float* buff;
101
102	float lastOut, lastIn;
103
104	uint32_t inPoint, outPoint;
105
106	uint32_t maxDelay;
107
108	float delay;
109
110	float alpha, omAlpha;
111
112	} _tHermiteDelay;
113
114	typedef _tHermiteDelay* tHermiteDelay;
115
116	void tHermiteDelay_init (tHermiteDelay* const dl, float delay, uint32_t maxDelay);
117	void tHermiteDelay_free (tHermiteDelay* const dl);
118	void tHermiteDelay_initToPool (tHermiteDelay* const dl, float delay, uint32_t maxDelay, tMempool* const mp);
119	void tHermiteDelay_freeFromPool (tHermiteDelay* const dl, tMempool* const mp);
120	void tHermiteDelay_clear (tHermiteDelay* const dl);
121	float tHermiteDelay_tick (tHermiteDelay* const dl, float input);
122	void tHermiteDelay_tickIn (tHermiteDelay* const dl, float input);
123	float tHermiteDelay_tickOut (tHermiteDelay* const dl);
124	int tHermiteDelay_setDelay (tHermiteDelay* const dl, float delay);
125	float tHermiteDelay_tapOut (tHermiteDelay* const dl, uint32_t tapDelay);
126	void tHermiteDelay_tapIn (tHermiteDelay* const dl, float value, uint32_t tapDelay);
127	float tHermiteDelay_addTo (tHermiteDelay* const dl, float value, uint32_t tapDelay);
128	float tHermiteDelay_getDelay (tHermiteDelay* const dl);
129	float tHermiteDelay_getLastOut (tHermiteDelay* const dl);
130	float tHermiteDelay_getLastIn (tHermiteDelay* const dl);
131	void tHermiteDelay_setGain (tHermiteDelay* const dl, float gain);
132	float tHermiteDelay_getGain (tHermiteDelay* const dl);
133
134
135	//==============================================================================
136
137	/* Allpass-interpolating delay, reimplemented from STK (Cook and Scavone). */
138	typedef struct _tAllpassDelay
139	{
140	float gain;
141	float* buff;
142
143	float lastOut, lastIn;
144
145	uint32_t inPoint, outPoint;
146
147	uint32_t maxDelay;
148
149	float delay;
150
151	float alpha, omAlpha, coeff;
152
153	float apInput;
154
155	} _tAllpassDelay;
156
157	typedef _tAllpassDelay* tAllpassDelay;
158
159	void tAllpassDelay_init (tAllpassDelay* const, float delay, uint32_t maxDelay);
160	void tAllpassDelay_free (tAllpassDelay* const);
161	void tAllpassDelay_initToPool (tAllpassDelay* const, float delay, uint32_t maxDelay, tMempool* const);
162	void tAllpassDelay_freeFromPool(tAllpassDelay* const, tMempool* const);
163
164	void tAllpassDelay_clear (tAllpassDelay* const);
165	int tAllpassDelay_setDelay (tAllpassDelay* const, float delay);
166	float tAllpassDelay_getDelay (tAllpassDelay* const);
167	void tAllpassDelay_tapIn (tAllpassDelay* const, float in, uint32_t tapDelay);
168	float tAllpassDelay_tapOut (tAllpassDelay* const, uint32_t tapDelay);
169	float tAllpassDelay_addTo (tAllpassDelay* const, float value, uint32_t tapDelay);
170	float tAllpassDelay_tick (tAllpassDelay* const, float sample);
171	float tAllpassDelay_getLastOut (tAllpassDelay* const);
172	float tAllpassDelay_getLastIn (tAllpassDelay* const);
173
174	//==============================================================================
175
176	/* Linear interpolating delay with fixed read and write pointers, variable rate. */
177	typedef struct _tTapeDelay
178	{
179	float gain;
180	float* buff;
181
182	float lastOut, lastIn;
183
184	uint32_t inPoint;
185
186	uint32_t maxDelay;
187
188	float delay, inc, idx;
189
190	float apInput;
191
192	} _tTapeDelay;
193
194	typedef _tTapeDelay* tTapeDelay;
195
196	void tTapeDelay_init (tTapeDelay* const, float delay, uint32_t maxDelay);
197	void tTapeDelay_free (tTapeDelay* const);
198	void tTapeDelay_initToPool (tTapeDelay* const, float delay, uint32_t maxDelay, tMempool* const);
199	void tTapeDelay_freeFromPool(tTapeDelay* const, tMempool* const);
200
201	void tTapeDelay_clear (tTapeDelay* const);
202	void tTapeDelay_setDelay (tTapeDelay* const, float delay);
203	float tTapeDelay_getDelay (tTapeDelay* const);
204	void tTapeDelay_tapIn (tTapeDelay* const, float in, uint32_t tapDelay);
205	float tTapeDelay_tapOut (tTapeDelay* const d, float tapDelay);
206	float tTapeDelay_addTo (tTapeDelay* const, float value, uint32_t tapDelay);
207	float tTapeDelay_tick (tTapeDelay* const, float sample);
208	void tTapeDelay_incrementInPoint(tTapeDelay* const dl);
209	float tTapeDelay_getLastOut (tTapeDelay* const);
210	float tTapeDelay_getLastIn (tTapeDelay* const);
211
212	//==============================================================================
213
214	#ifdef __cplusplus
215	}
216	#endif
217
218	#endif // LEAF_DELAY_H_INCLUDED
219
220	//==============================================================================
221

LEAF/Inc/leaf-distortion.h+0−148

@@ -1,148 +0,0 @@
1	/*==============================================================================
2
3	leaf-distortion.h
4	Created: 25 Oct 2019 10:23:28am
5	Author: Matthew Wang
6
7	==============================================================================*/
8
9	#ifndef LEAF_DISTORTION_H_INCLUDED
10	#define LEAF_DISTORTION_H_INCLUDED
11
12	#ifdef __cplusplus
13	extern "C" {
14	#endif
15
16	//==============================================================================
17
18	#include "leaf-global.h"
19	#include "leaf-mempool.h"
20	#include "leaf-math.h"
21
22	//==============================================================================
23
24	typedef struct _tSampleReducer
25	{
26	float invRatio;
27	float hold;
28	uint32_t count;
29	} _tSampleReducer;
30
31	typedef _tSampleReducer* tSampleReducer;
32
33	void tSampleReducer_init (tSampleReducer* const);
34	void tSampleReducer_free (tSampleReducer* const);
35	void tSampleReducer_initToPool (tSampleReducer* const, tMempool* const);
36	void tSampleReducer_freeFromPool (tSampleReducer* const, tMempool* const);
37
38	float tSampleReducer_tick (tSampleReducer* const, float input);
39
40	// sampling ratio
41	void tSampleReducer_setRatio (tSampleReducer* const, float ratio);
42
43	//==============================================================================
44
45	typedef struct _tOversampler
46	{
47	int ratio;
48	float* pCoeffs;
49	float* upState;
50	float* downState;
51	int numTaps;
52	int phaseLength;
53	} _tOversampler;
54
55	typedef _tOversampler* tOversampler;
56
57	void tOversampler_init (tOversampler* const, int order, oBool extraQuality);
58	void tOversampler_free (tOversampler* const);
59	void tOversampler_initToPool (tOversampler* const, int order, oBool extraQuality, tMempool* const);
60	void tOversampler_freeFromPool (tOversampler* const, tMempool* const);
61
62	void tOversampler_upsample (tOversampler* const, float input, float* output);
63	float tOversampler_downsample (tOversampler* const os, float* input);
64	float tOversampler_tick (tOversampler* const, float input, float (*effectTick)(float));
65	int tOversampler_getLatency (tOversampler* const os);
66
67	//==============================================================================
68
69	/* tLockhartWavefolder */
70
71	typedef struct _tLockhartWavefolder
72	{
73	double Ln1;
74	double Fn1;
75	float xn1;
76
77	double RL;
78	double R;
79	double VT;
80	double Is;
81
82	double a;
83	double b;
84	double d;
85
86	// Antialiasing error threshold
87	double thresh;
88	double half_a;
89	double longthing;
90
91	} _tLockhartWavefolder;
92
93	typedef _tLockhartWavefolder* tLockhartWavefolder;
94
95	void tLockhartWavefolder_init (tLockhartWavefolder* const);
96	void tLockhartWavefolder_free (tLockhartWavefolder* const);
97	void tLockhartWavefolder_initToPool (tLockhartWavefolder* const, tMempool* const);
98	void tLockhartWavefolder_freeFromPool (tLockhartWavefolder* const, tMempool* const);
99
100	float tLockhartWavefolder_tick (tLockhartWavefolder* const, float samp);
101
102	//==============================================================================
103
104	typedef struct _tCrusher
105	{
106	float srr;
107	float mult, div;
108	float rnd;
109
110	uint32_t op; //which bitwise operation (0-7)
111
112	float gain;
113	tSampleReducer sReducer;
114
115	} _tCrusher;
116
117	typedef _tCrusher* tCrusher;
118
119	void tCrusher_init (tCrusher* const);
120	void tCrusher_free (tCrusher* const);
121	void tCrusher_initToPool (tCrusher* const, tMempool* const);
122	void tCrusher_freeFromPool (tCrusher* const, tMempool* const);
123
124	float tCrusher_tick (tCrusher* const, float input);
125
126	// 0.0 - 1.0
127	void tCrusher_setOperation (tCrusher* const, float op);
128
129	// 0.0 - 1.0
130	void tCrusher_setQuality (tCrusher* const, float val);
131
132	// what division to round to
133	void tCrusher_setRound (tCrusher* const, float rnd);
134
135	// sampling ratio
136	void tCrusher_setSamplingRatio (tCrusher* const, float ratio);
137
138	//==============================================================================
139
140	#ifdef __cplusplus
141	}
142	#endif
143
144	#endif // LEAF_DISTORTION_H_INCLUDED
145
146	//==============================================================================
147
148

LEAF/Inc/leaf-dynamics.h+0−90

@@ -1,90 +0,0 @@
1	/*==============================================================================
2
3	leaf-dynamics.h
4	Created: 30 Nov 2018 11:57:05am
5	Author: airship
6
7	==============================================================================*/
8
9	#ifndef LEAF_DYNAMICS_H_INCLUDED
10	#define LEAF_DYNAMICS_H_INCLUDED
11
12
13	#ifdef __cplusplus
14	extern "C" {
15	#endif
16
17	//==============================================================================
18
19	#include "leaf-global.h"
20	#include "leaf-math.h"
21	#include "leaf-mempool.h"
22	#include "leaf-analysis.h"
23
24	//==============================================================================
25
26	// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
27
28	/* Compressor */
29	typedef struct _tCompressor
30	{
31	float tauAttack, tauRelease;
32	float T, R, W, M; // Threshold, compression Ratio, decibel Width of knee transition, decibel Make-up gain
33
34	float x_G[2], y_G[2], x_T[2], y_T[2];
35
36	oBool isActive;
37
38	} _tCompressor;
39
40	typedef _tCompressor* tCompressor;
41
42	void tCompressor_init (tCompressor* const);
43	void tCompressor_free (tCompressor* const);
44	void tCompressor_initToPool (tCompressor* const, tMempool* const);
45	void tCompressor_freeFromPool(tCompressor* const, tMempool* const);
46
47	float tCompressor_tick (tCompressor* const, float input);
48
49	///
50	/* Feedback leveller */
51	// An auto VCA that you put into a feedback circuit to make it stay at the same level.
52	// It can enforce level bidirectionally (amplifying and attenuating as needed) or
53	// just attenutating. The former option allows for infinite sustain strings, for example, while
54	// The latter option allows for decaying strings, which can never exceed
55	// a specific level.
56
57	typedef struct _tFeedbackLeveler {
58	float targetLevel; // target power level
59	float strength; // how strongly level difference affects the VCA
60	int mode; // 0 for upwards limiting only, 1 for biderctional limiting
61	float curr;
62	tPowerFollower pwrFlw; // internal power follower needed for level tracking
63
64	} _tFeedbackLeveler;
65
66	typedef _tFeedbackLeveler* tFeedbackLeveler;
67
68	void tFeedbackLeveler_init (tFeedbackLeveler* const, float targetLevel, float factor, float strength, int mode);
69	void tFeedbackLeveler_free (tFeedbackLeveler* const);
70	void tFeedbackLeveler_initToPool (tFeedbackLeveler* const, float targetLevel, float factor, float strength, int mode, tMempool* const);
71	void tFeedbackLeveler_freeFromPool (tFeedbackLeveler* const, tMempool* const);
72
73	float tFeedbackLeveler_tick (tFeedbackLeveler* const, float input);
74	float tFeedbackLeveler_sample (tFeedbackLeveler* const);
75	void tFeedbackLeveler_setTargetLevel (tFeedbackLeveler* const, float TargetLevel);
76	void tFeedbackLeveler_setFactor (tFeedbackLeveler* const, float factor);
77	void tFeedbackLeveler_setMode (tFeedbackLeveler* const, int mode); // 0 for upwards limiting only, 1 for biderctional limiting
78	void tFeedbackLeveler_setStrength (tFeedbackLeveler* const, float strength);
79
80
81	//==============================================================================
82
83	#ifdef __cplusplus
84	}
85	#endif
86
87	#endif // LEAF_DYNAMICS_H_INCLUDED
88
89	//==============================================================================
90

LEAF/Inc/leaf-effects.h+0−316

@@ -1,316 +0,0 @@
1	/*==============================================================================
2
3	leaf-effects.h
4	Created: 20 Jan 2017 12:01:54pm
5	Author: Michael R Mulshine
6
7	==============================================================================*/
8
9	#ifndef LEAF_EFFECTS_H_INCLUDED
10	#define LEAF_EFFECTS_H_INCLUDED
11
12	#ifdef __cplusplus
13	extern "C" {
14	#endif
15
16	//==============================================================================
17	#include "leaf-global.h"
18	#include "leaf-math.h"
19	#include "leaf-mempool.h"
20	#include "leaf-dynamics.h"
21	#include "leaf-analysis.h"
22	#include "leaf-envelopes.h"
23
24	//==============================================================================
25
26	/* tTalkbox */
27	#define NUM_TALKBOX_PARAM 4
28
29	typedef struct _tTalkbox
30	{
31	float param[NUM_TALKBOX_PARAM];
32
33	int bufsize;
34	float* car0;
35	float* car1;
36	float* window;
37	float* buf0;
38	float* buf1;
39
40	float emphasis;
41	int32_t K, N, O, pos;
42	float wet, dry, FX;
43	float d0, d1, d2, d3, d4;
44	float u0, u1, u2, u3, u4;
45
46	} _tTalkbox;
47
48	typedef _tTalkbox* tTalkbox;
49
50	void tTalkbox_init (tTalkbox* const, int bufsize);
51	void tTalkbox_free (tTalkbox* const);
52	void tTalkbox_initToPool (tTalkbox* const, int bufsize, tMempool* const);
53	void tTalkbox_freeFromPool (tTalkbox* const, tMempool* const);
54
55	float tTalkbox_tick (tTalkbox* const, float synth, float voice);
56	void tTalkbox_update (tTalkbox* const);
57	void tTalkbox_suspend (tTalkbox* const);
58	void tTalkbox_lpcDurbin (float r, int p, float k, float *g);
59	void tTalkbox_lpc (float buf, float car, int32_t n, int32_t o);
60	void tTalkbox_setQuality (tTalkbox* const, float quality);
61
62	//==============================================================================
63
64	/* tVocoder */
65	#define NUM_VOCODER_PARAM 8
66	#define NBANDS 16
67
68	typedef struct _tVocoder
69	{
70	float param[NUM_VOCODER_PARAM];
71
72	float gain; //output level
73	float thru, high; //hf thru
74	float kout; //downsampled output
75	int32_t kval; //downsample counter
76	int32_t nbnd; //number of bands
77
78	//filter coeffs and buffers - seems it's faster to leave this global than make local copy
79	float f[NBANDS][13]; //[0-8][0 1 2 \| 0 1 2 3 \| 0 1 2 3 \| val rate]
80
81	} _tVocoder;
82
83	typedef _tVocoder* tVocoder;
84
85	void tVocoder_init (tVocoder* const);
86	void tVocoder_free (tVocoder* const);
87	void tVocoder_initToPool (tVocoder* const, tMempool* const);
88	void tVocoder_freeFromPool (tVocoder* const, tMempool* const);
89
90	float tVocoder_tick (tVocoder* const, float synth, float voice);
91	void tVocoder_update (tVocoder* const);
92	void tVocoder_suspend (tVocoder* const);
93
94	//==============================================================================
95
96
97	//==============================================================================
98
99	// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
100
101	/* tSOLAD : pitch shifting algorithm that underlies tRetune etc */
102	// from Katja Vetters http://www.katjaas.nl/pitchshiftlowlatency/pitchshiftlowlatency.html
103	#define LOOPSIZE (20482) // (40962) // loop size must be power of two
104	#define LOOPMASK (LOOPSIZE - 1)
105	#define PITCHFACTORDEFAULT 1.0f
106	#define INITPERIOD 64.0f
107	#define MAXPERIOD (float)((LOOPSIZE - w->blocksize) * 0.8f)
108	#define MINPERIOD 8.0f
109
110	typedef struct _tSOLAD
111	{
112	uint16_t timeindex; // current reference time, write index
113	uint16_t blocksize; // signal input / output block size
114	float pitchfactor; // pitch factor between 0.25 and 4
115	float readlag; // read pointer's lag behind write pointer
116	float period; // period length in input signal
117	float jump; // read pointer jump length and direction
118	float xfadelength; // crossfade length expressed at input sample rate
119	float xfadevalue; // crossfade phase and value
120
121	float* delaybuf;
122
123	} _tSOLAD;
124
125	typedef _tSOLAD* tSOLAD;
126
127	void tSOLAD_init (tSOLAD* const);
128	void tSOLAD_free (tSOLAD* const);
129	void tSOLAD_initToPool (tSOLAD* const, tMempool* const);
130	void tSOLAD_freeFromPool (tSOLAD* const, tMempool* const);
131
132	// send one block of input samples, receive one block of output samples
133	void tSOLAD_ioSamples (tSOLAD w, float in, float* out, int blocksize);
134	// set periodicity analysis data
135	void tSOLAD_setPeriod (tSOLAD *w, float period);
136	// set pitch factor between 0.25 and 4
137	void tSOLAD_setPitchFactor (tSOLAD *w, float pitchfactor);
138	// force readpointer lag
139	void tSOLAD_setReadLag (tSOLAD *w, float readlag);
140	// reset state variables
141	void tSOLAD_resetState (tSOLAD *w);
142
143	// Pitch shift
144	typedef struct _tPitchShift
145	{
146	tSOLAD sola;
147	tHighpass hp;
148	tPeriodDetection* p;
149
150	float* outBuffer;
151	int frameSize;
152	int bufSize;
153
154	int framesPerBuffer;
155	int curBlock;
156	int lastBlock;
157	int index;
158
159	float pitchFactor;
160	float timeConstant;
161	float radius;
162	} _tPitchShift;
163
164	typedef _tPitchShift* tPitchShift;
165
166	void tPitchShift_init (tPitchShift* const, tPeriodDetection* const, float* out, int bufSize);
167	void tPitchShift_free (tPitchShift* const);
168	void tPitchShift_initToPool (tPitchShift* const, tPeriodDetection* const, float* out, int bufSize, tMempool* const);
169	void tPitchShift_freeFromPool (tPitchShift* const, tMempool* const);
170
171	float tPitchShift_shift (tPitchShift* const);
172	float tPitchShift_shiftToFunc (tPitchShift* const, float (*fun)(float));
173	float tPitchShift_shiftToFreq (tPitchShift* const, float freq);
174	void tPitchShift_setPitchFactor (tPitchShift* const, float pf);
175
176	// Retune
177	typedef struct _tRetune
178	{
179	tPeriodDetection pd;
180	tPitchShift* ps;
181
182	float* inBuffer;
183	float** outBuffers;
184	float* tickOutput;
185	int frameSize;
186	int bufSize;
187
188	uint16_t hopSize;
189	uint16_t windowSize;
190	uint8_t fba;
191
192	float* pitchFactor;
193	float timeConstant;
194	float radius;
195
196	float inputPeriod;
197
198	int numVoices;
199	} _tRetune;
200
201	typedef _tRetune* tRetune;
202
203	void tRetune_init (tRetune* const, int numVoices, int bufSize, int frameSize);
204	void tRetune_free (tRetune* const);
205	void tRetune_initToPool (tRetune* const, int numVoices, int bufSize, int frameSize, tMempool* const);
206	void tRetune_freeFromPool (tRetune* const, tMempool* const);
207
208	float* tRetune_tick (tRetune* const, float sample);
209	void tRetune_setNumVoices (tRetune* const, int numVoices);
210	void tRetune_setPitchFactors (tRetune* const, float pf);
211	void tRetune_setPitchFactor (tRetune* const, float pf, int voice);
212	void tRetune_setTimeConstant (tRetune* const, float tc);
213	void tRetune_setHopSize (tRetune* const, int hs);
214	void tRetune_setWindowSize (tRetune* const, int ws);
215	void tRetune_setFidelityThreshold(tRetune* const, float threshold);
216	float tRetune_getInputPeriod (tRetune* const);
217	float tRetune_getInputFreq (tRetune* const);
218
219	// Autotune
220	typedef struct _tAutotune
221	{
222	tPeriodDetection pd;
223	tPitchShift* ps;
224
225	float* inBuffer;
226	float** outBuffers;
227	float* tickOutput;
228	int frameSize;
229	int bufSize;
230
231	uint16_t hopSize;
232	uint16_t windowSize;
233	uint8_t fba;
234
235	float* freq;
236	float timeConstant;
237	float radius;
238
239	float inputPeriod;
240
241	int numVoices;
242	} _tAutotune;
243
244	typedef _tAutotune* tAutotune;
245
246	void tAutotune_init (tAutotune* const, int numVoices, int bufSize, int frameSize);
247	void tAutotune_free (tAutotune* const);
248	void tAutotune_initToPool (tAutotune* const, int numVoices, int bufSize, int frameSize, tMempool* const);
249	void tAutotune_freeFromPool (tAutotune* const, tMempool* const);
250
251	float* tAutotune_tick (tAutotune* const, float sample);
252	void tAutotune_setNumVoices (tAutotune* const, int numVoices);
253	void tAutotune_setFreqs (tAutotune* const, float f);
254	void tAutotune_setFreq (tAutotune* const, float f, int voice);
255	void tAutotune_setTimeConstant (tAutotune* const, float tc);
256	void tAutotune_setHopSize (tAutotune* const, int hs);
257	void tAutotune_setWindowSize (tAutotune* const, int ws);
258	void tAutotune_setFidelityThreshold (tAutotune* const, float threshold);
259	float tAutotune_getInputPeriod (tAutotune* const);
260	float tAutotune_getInputFreq (tAutotune* const);
261
262	//==============================================================================
263
264
265	typedef struct _tFormantShifter
266	{
267	int ford;
268	float falph;
269	float flamb;
270	float* fk;
271	float* fb;
272	float* fc;
273	float* frb;
274	float* frc;
275	float* fsig;
276	float* fsmooth;
277	float fhp;
278	float flp;
279	float flpa;
280	float* fbuff;
281	float* ftvec;
282	float fmute;
283	float fmutealph;
284	unsigned int cbi;
285	float shiftFactor;
286	float intensity, invIntensity;
287	tHighpass hp;
288	tHighpass hp2;
289	tFeedbackLeveler fbl1;
290	tFeedbackLeveler fbl2;
291
292	} _tFormantShifter;
293
294	typedef _tFormantShifter* tFormantShifter;
295
296	void tFormantShifter_init (tFormantShifter* const, int order);
297	void tFormantShifter_free (tFormantShifter* const);
298	void tFormantShifter_initToPool (tFormantShifter* const, int order, tMempool* const);
299	void tFormantShifter_freeFromPool (tFormantShifter* const, tMempool* const);
300
301	float tFormantShifter_tick (tFormantShifter* const, float input);
302	float tFormantShifter_remove (tFormantShifter* const, float input);
303	float tFormantShifter_add (tFormantShifter* const, float input);
304	void tFormantShifter_ioSamples (tFormantShifter* const, float* in, float* out, int size, float fwarp);
305	void tFormantShifter_setShiftFactor (tFormantShifter* const, float shiftFactor);
306	void tFormantShifter_setIntensity (tFormantShifter* const, float intensity);
307
308	//==============================================================================
309
310	#ifdef __cplusplus
311	}
312	#endif
313
314	#endif // LEAF_EFFECTS_H_INCLUDED
315
316	//==============================================================================

LEAF/Inc/leaf-electrical.h+0−95

@@ -1,95 +0,0 @@
1	/*
2	* leaf-electrical.h
3	*
4	* Created on: Sep 25, 2019
5	* Author: jeffsnyder
6	*/
7
8	#ifndef LEAF_INC_LEAF_ELECTRICAL_H_
9	#define LEAF_INC_LEAF_ELECTRICAL_H_
10
11	#ifdef __cplusplus
12	extern "C" {
13	#endif
14
15	//==============================================================================
16
17	#include "leaf-global.h"
18	#include "leaf-math.h"
19	#include "leaf-mempool.h"
20
21	//==============================================================================
22
23	typedef enum WDFComponentType
24	{
25	SeriesAdaptor = 0,
26	ParallelAdaptor,
27	Resistor,
28	Capacitor,
29	Inductor,
30	Inverter,
31	ResistiveSource,
32	IdealSource,
33	Diode,
34	DiodePair,
35	RootNil,
36	WDFComponentNil
37	} WDFComponentType;
38
39	typedef struct _tWDF _tWDF; // needed to allow tWDF pointers in struct
40	typedef _tWDF* tWDF;
41	struct _tWDF
42	{
43	WDFComponentType type;
44	float port_resistance_up;
45	float port_resistance_left;
46	float port_resistance_right;
47	float port_conductance_up;
48	float port_conductance_left;
49	float port_conductance_right;
50	float incident_wave_up;
51	float incident_wave_left;
52	float incident_wave_right;
53	float reflected_wave_up;
54	float reflected_wave_left;
55	float reflected_wave_right;
56	float gamma_zero;
57	float sample_rate;
58	float value;
59	tWDF* child_left;
60	tWDF* child_right;
61	float (get_port_resistance)(tWDF const);
62	float (get_reflected_wave_up)(tWDF const, float);
63	float (get_reflected_wave_down)(tWDF const, float, float);
64	void (set_incident_wave)(tWDF const, float, float);
65	};
66
67	//WDF Linear Components
68	void tWDF_init (tWDF* const, WDFComponentType type, float value, tWDF* const rL, tWDF* const rR);
69	void tWDF_free (tWDF* const);
70	void tWDF_initToPool (tWDF* const, WDFComponentType type, float value, tWDF* const rL, tWDF* const rR, tMempool* const);
71	void tWDF_freeFromPool (tWDF* const, tMempool* const);
72
73	float tWDF_tick (tWDF* const, float sample, tWDF* const outputPoint, uint8_t paramsChanged);
74
75	void tWDF_setValue (tWDF* const, float value);
76	void tWDF_setSampleRate (tWDF* const, float sample_rate);
77	uint8_t tWDF_isLeaf (tWDF* const);
78
79	float tWDF_getPortResistance (tWDF* const);
80	float tWDF_getReflectedWaveUp (tWDF* const, float input); //for tree, only uses input for resistive source
81	float tWDF_getReflectedWaveDown (tWDF* const, float input, float incident_wave); //for roots
82	void tWDF_setIncidentWave (tWDF* const, float incident_wave, float input);
83
84	float tWDF_getVoltage (tWDF* const);
85	float tWDF_getCurrent (tWDF* const);
86
87
88	//==============================================================================
89
90	#ifdef __cplusplus
91	}
92	#endif
93
94	#endif /* LEAF_INC_LEAF_ELECTRICAL_H_ */
95

LEAF/Inc/leaf-envelopes.h+0−154

@@ -1,154 +0,0 @@
1	/*
2	==============================================================================
3
4	leaf-envelopes.h
5	Created: 20 Jan 2017 12:02:17pm
6	Author: Michael R Mulshine
7
8	==============================================================================
9	*/
10
11	#ifndef LEAF_ENVELOPES_H_INCLUDED
12	#define LEAF_ENVELOPES_H_INCLUDED
13
14	#ifdef __cplusplus
15	extern "C" {
16	#endif
17
18	// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
19
20	#include "leaf-math.h"
21	#include "leaf-mempool.h"
22	#include "leaf-filters.h"
23	#include "leaf-delay.h"
24
25	// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
26
27	/* Attack-Decay envelope */
28	typedef struct _tEnvelope {
29
30	const float *exp_buff;
31	const float *inc_buff;
32	uint32_t buff_size;
33
34	float next;
35
36	float attackInc, decayInc, rampInc;
37
38	oBool inAttack, inDecay, inRamp;
39
40	oBool loop;
41
42	float gain, rampPeak;
43
44	float attackPhase, decayPhase, rampPhase;
45
46	} _tEnvelope;
47
48	typedef _tEnvelope* tEnvelope;
49
50	void tEnvelope_init (tEnvelope* const, float attack, float decay, oBool loop);
51	void tEnvelope_free (tEnvelope* const);
52	void tEnvelope_initToPool (tEnvelope* const, float attack, float decay, oBool loop, tMempool* const);
53	void tEnvelope_freeFromPool (tEnvelope* const, tMempool* const);
54
55	float tEnvelope_tick (tEnvelope* const);
56	void tEnvelope_setAttack (tEnvelope* const, float attack);
57	void tEnvelope_setDecay (tEnvelope* const, float decay);
58	void tEnvelope_loop (tEnvelope* const, oBool loop);
59	void tEnvelope_on (tEnvelope* const, float velocity);
60
61	// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
62
63	/* ADSR */
64	typedef struct _tADSR
65	{
66	const float *exp_buff;
67	const float *inc_buff;
68	uint32_t buff_size;
69
70	float next;
71
72	float attackInc, decayInc, releaseInc, rampInc;
73
74	oBool inAttack, inDecay, inSustain, inRelease, inRamp;
75
76	float sustain, gain, rampPeak, releasePeak;
77
78	float attackPhase, decayPhase, releasePhase, rampPhase;
79
80	} _tADSR;
81
82	typedef _tADSR* tADSR;
83
84	void tADSR_init (tADSR* const, float attack, float decay, float sustain, float release);
85	void tADSR_free (tADSR* const);
86	void tADSR_initToPool (tADSR* const, float attack, float decay, float sustain, float release, tMempool* const);
87	void tADSR_freeFromPool (tADSR* const, tMempool* const);
88
89	float tADSR_tick (tADSR* const);
90	void tADSR_setAttack (tADSR* const, float attack);
91	void tADSR_setDecay (tADSR* const, float decay);
92	void tADSR_setSustain (tADSR* const, float sustain);
93	void tADSR_setRelease (tADSR* const, float release);
94	void tADSR_on (tADSR* const, float velocity);
95	void tADSR_off (tADSR* const);
96
97	// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
98
99	// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
100
101	/* Ramp */
102	typedef struct _tRamp {
103	float inc;
104	float inv_sr_ms;
105	float minimum_time;
106	float curr,dest;
107	float time;
108	int samples_per_tick;
109
110	} _tRamp;
111
112	typedef _tRamp* tRamp;
113
114	void tRamp_init (tRamp* const, float time, int samplesPerTick);
115	void tRamp_free (tRamp* const);
116	void tRamp_initToPool (tRamp* const, float time, int samplesPerTick, tMempool* const);
117	void tRamp_freeFromPool (tRamp* const, tMempool* const);
118
119	float tRamp_tick (tRamp* const);
120	float tRamp_sample (tRamp* const);
121	void tRamp_setTime (tRamp* const, float time);
122	void tRamp_setDest (tRamp* const, float dest);
123	void tRamp_setVal (tRamp* const, float val);
124
125	// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
126
127	/* Exponential Smoother */
128	typedef struct _tExpSmooth {
129	float factor, oneminusfactor;
130	float curr,dest;
131
132	} _tExpSmooth;
133
134	typedef _tExpSmooth* tExpSmooth;
135
136	void tExpSmooth_init (tExpSmooth* const, float val, float factor);
137	void tExpSmooth_free (tExpSmooth* const);
138	void tExpSmooth_initToPool (tExpSmooth* const, float val, float factor, tMempool* const);
139	void tExpSmooth_freeFromPool (tExpSmooth* const, tMempool* const);
140
141	float tExpSmooth_tick (tExpSmooth* const);
142	float tExpSmooth_sample (tExpSmooth* const);
143	void tExpSmooth_setFactor (tExpSmooth* const, float factor);
144	void tExpSmooth_setDest (tExpSmooth* const, float dest);
145	void tExpSmooth_setVal (tExpSmooth* const, float val);
146
147	#ifdef __cplusplus
148	}
149	#endif
150
151	#endif // LEAF_ENVELOPES_H_INCLUDED
152
153
154

LEAF/Inc/leaf-filters.h+0−358

@@ -1,358 +0,0 @@
1	/*==============================================================================
2
3	leaf-filters.h
4	Created: 20 Jan 2017 12:01:10pm
5	Author: Michael R Mulshine
6
7	==============================================================================*/
8
9	#ifndef LEAF_FILTERS_H_INCLUDED
10	#define LEAF_FILTERS_H_INCLUDED
11
12	#ifdef __cplusplus
13	extern "C" {
14	#endif
15
16	//==============================================================================
17
18	#include "leaf-math.h"
19	#include "leaf-mempool.h"
20	#include "leaf-delay.h"
21	#include "leaf-tables.h"
22
23	//==============================================================================
24
25	/* tAllpass: Schroeder allpass. Comb-filter with feedforward and feedback. */
26	typedef struct _tAllpass
27	{
28	float gain;
29
30	tLinearDelay delay;
31
32	float lastOut;
33
34	} _tAllpass;
35
36	typedef _tAllpass* tAllpass;
37
38	void tAllpass_init (tAllpass* const, float initDelay, uint32_t maxDelay);
39	void tAllpass_free (tAllpass* const);
40	void tAllpass_initToPool (tAllpass* const, float initDelay, uint32_t maxDelay, tMempool* const);
41	void tAllpass_freeFromPool (tAllpass* const, tMempool* const);
42
43	float tAllpass_tick (tAllpass* const, float input);
44	void tAllpass_setGain (tAllpass* const, float gain);
45	void tAllpass_setDelay (tAllpass* const, float delay);
46
47
48	//==============================================================================
49
50	/* tOnePole: OnePole filter, reimplemented from STK (Cook and Scavone). */
51	typedef struct _tOnePole
52	{
53	float gain;
54	float a0,a1;
55	float b0,b1;
56	float lastIn, lastOut;
57
58
59	} _tOnePole;
60
61	typedef _tOnePole* tOnePole;
62
63	void tOnePole_init (tOnePole* const, float thePole);
64	void tOnePole_free (tOnePole* const);
65	void tOnePole_initToPool (tOnePole* const, float thePole, tMempool* const);
66	void tOnePole_freeFromPool (tOnePole* const, tMempool* const);
67
68	float tOnePole_tick (tOnePole* const, float input);
69	void tOnePole_setB0 (tOnePole* const, float b0);
70	void tOnePole_setA1 (tOnePole* const, float a1);
71	void tOnePole_setPole (tOnePole* const, float thePole);
72	void tOnePole_setFreq (tOnePole* const, float freq);
73	void tOnePole_setCoefficients(tOnePole* const, float b0, float a1);
74	void tOnePole_setGain (tOnePole* const, float gain);
75
76	//==============================================================================
77
78	/* TwoPole filter, reimplemented from STK (Cook and Scavone). */
79	typedef struct _tTwoPole
80	{
81	float gain;
82	float a0, a1, a2;
83	float b0;
84
85	float radius, frequency;
86	oBool normalize;
87
88	float lastOut[2];
89
90	} _tTwoPole;
91
92	typedef _tTwoPole* tTwoPole;
93
94	void tTwoPole_init (tTwoPole* const);
95	void tTwoPole_free (tTwoPole* const);
96	void tTwoPole_initToPool (tTwoPole* const, tMempool* const);
97	void tTwoPole_freeFromPool (tTwoPole* const, tMempool* const);
98
99	float tTwoPole_tick (tTwoPole* const, float input);
100	void tTwoPole_setB0 (tTwoPole* const, float b0);
101	void tTwoPole_setA1 (tTwoPole* const, float a1);
102	void tTwoPole_setA2 (tTwoPole* const, float a2);
103	void tTwoPole_setResonance (tTwoPole* const, float freq, float radius, oBool normalize);
104	void tTwoPole_setCoefficients(tTwoPole* const, float b0, float a1, float a2);
105	void tTwoPole_setGain (tTwoPole* const, float gain);
106
107	//==============================================================================
108
109	/* OneZero filter, reimplemented from STK (Cook and Scavone). */
110	typedef struct _tOneZero
111	{
112	float gain;
113	float b0,b1;
114	float lastIn, lastOut, frequency;
115
116	} _tOneZero;
117
118	typedef _tOneZero* tOneZero;
119
120	void tOneZero_init (tOneZero* const, float theZero);
121	void tOneZero_free (tOneZero* const);
122	void tOneZero_initToPool (tOneZero* const, float theZero, tMempool* const);
123	void tOneZero_freeFromPool (tOneZero* const, tMempool* const);
124
125	float tOneZero_tick (tOneZero* const, float input);
126	void tOneZero_setB0 (tOneZero* const, float b0);
127	void tOneZero_setB1 (tOneZero* const, float b1);
128	void tOneZero_setZero (tOneZero* const, float theZero);
129	void tOneZero_setCoefficients(tOneZero* const, float b0, float b1);
130	void tOneZero_setGain (tOneZero* const, float gain);
131	float tOneZero_getPhaseDelay (tOneZero *f, float frequency );
132
133	//==============================================================================
134
135	/* TwoZero filter, reimplemented from STK (Cook and Scavone). */
136	typedef struct _tTwoZero
137	{
138	float gain;
139	float b0, b1, b2;
140
141	float frequency, radius;
142
143	float lastIn[2];
144
145	} _tTwoZero;
146
147	typedef _tTwoZero* tTwoZero;
148
149	void tTwoZero_init (tTwoZero* const);
150	void tTwoZero_free (tTwoZero* const);
151	void tTwoZero_initToPool (tTwoZero* const, tMempool* const);
152	void tTwoZero_freeFromPool (tTwoZero* const, tMempool* const);
153
154	float tTwoZero_tick (tTwoZero* const, float input);
155	void tTwoZero_setB0 (tTwoZero* const, float b0);
156	void tTwoZero_setB1 (tTwoZero* const, float b1);
157	void tTwoZero_setB2 (tTwoZero* const, float b2);
158	void tTwoZero_setNotch (tTwoZero* const, float frequency, float radius);
159	void tTwoZero_setCoefficients(tTwoZero* const, float b0, float b1, float b2);
160	void tTwoZero_setGain (tTwoZero* const, float gain);
161
162	//==============================================================================
163
164	/* PoleZero filter, reimplemented from STK (Cook and Scavone). */
165	typedef struct _tPoleZero
166	{
167	float gain;
168	float a0,a1;
169	float b0,b1;
170
171	float lastIn, lastOut;
172
173	} _tPoleZero;
174
175	typedef _tPoleZero* tPoleZero;
176
177	void tPoleZero_init (tPoleZero* const);
178	void tPoleZero_free (tPoleZero* const);
179	void tPoleZero_initToPool (tPoleZero* const, tMempool* const);
180	void tPoleZero_freeFromPool (tPoleZero* const, tMempool* const);
181
182	float tPoleZero_tick (tPoleZero* const, float input);
183	void tPoleZero_setB0 (tPoleZero* const, float b0);
184	void tPoleZero_setB1 (tPoleZero* const, float b1);
185	void tPoleZero_setA1 (tPoleZero* const, float a1);
186	void tPoleZero_setCoefficients (tPoleZero* const, float b0, float b1, float a1);
187	void tPoleZero_setAllpass (tPoleZero* const, float coeff);
188	void tPoleZero_setBlockZero (tPoleZero* const, float thePole);
189	void tPoleZero_setGain (tPoleZero* const, float gain);
190
191	//==============================================================================
192
193	/* BiQuad filter, reimplemented from STK (Cook and Scavone). */
194	typedef struct _tBiQuad
195	{
196	float gain;
197	float a0, a1, a2;
198	float b0, b1, b2;
199
200	float lastIn[2];
201	float lastOut[2];
202
203	float frequency, radius;
204	oBool normalize;
205	} _tBiQuad;
206
207	typedef _tBiQuad* tBiQuad;
208
209	void tBiQuad_init (tBiQuad* const);
210	void tBiQuad_free (tBiQuad* const);
211	void tBiQuad_initToPool (tBiQuad* const, tMempool* const);
212	void tBiQuad_freeFromPool (tBiQuad* const, tMempool* const);
213
214	float tBiQuad_tick (tBiQuad* const, float input);
215	void tBiQuad_setB0 (tBiQuad* const, float b0);
216	void tBiQuad_setB1 (tBiQuad* const, float b1);
217	void tBiQuad_setB2 (tBiQuad* const, float b2);
218	void tBiQuad_setA1 (tBiQuad* const, float a1);
219	void tBiQuad_setA2 (tBiQuad* const, float a2);
220	void tBiQuad_setNotch (tBiQuad* const, float freq, float radius);
221	void tBiQuad_setResonance (tBiQuad* const, float freq, float radius, oBool normalize);
222	void tBiQuad_setCoefficients(tBiQuad* const, float b0, float b1, float b2, float a1, float a2);
223	void tBiQuad_setGain (tBiQuad* const, float gain);
224
225	//==============================================================================
226
227	/* State Variable Filter, algorithm from Andy Simper. */
228	typedef enum SVFType
229	{
230	SVFTypeHighpass = 0,
231	SVFTypeLowpass,
232	SVFTypeBandpass,
233	SVFTypeNotch,
234	SVFTypePeak,
235	} SVFType;
236
237	typedef struct _tSVF
238	{
239	SVFType type;
240	float cutoff, Q;
241	float ic1eq,ic2eq;
242	float g,k,a1,a2,a3;
243
244	} _tSVF;
245
246	typedef _tSVF* tSVF;
247
248	void tSVF_init (tSVF* const, SVFType type, float freq, float Q);
249	void tSVF_free (tSVF* const);
250	void tSVF_initToPool (tSVF* const, SVFType type, float freq, float Q, tMempool* const);
251	void tSVF_freeFromPool (tSVF* const, tMempool* const);
252
253	float tSVF_tick (tSVF* const, float v0);
254	void tSVF_setFreq (tSVF* const, float freq);
255	void tSVF_setQ (tSVF* const, float Q);
256
257	//==============================================================================
258
259	/* Efficient State Variable Filter for 14-bit control input, [0, 4096). */
260	typedef struct _tEfficientSVF
261	{
262	SVFType type;
263	float cutoff, Q;
264	float ic1eq,ic2eq;
265	float g,k,a1,a2,a3;
266
267	} _tEfficientSVF;
268
269	typedef _tEfficientSVF* tEfficientSVF;
270
271	void tEfficientSVF_init (tEfficientSVF* const, SVFType type, uint16_t input, float Q);
272	void tEfficientSVF_free (tEfficientSVF* const);
273	void tEfficientSVF_initToPool (tEfficientSVF* const, SVFType type, uint16_t input, float Q, tMempool* const);
274	void tEfficientSVF_freeFromPool (tEfficientSVF* const, tMempool* const);
275
276	float tEfficientSVF_tick (tEfficientSVF* const, float v0);
277	void tEfficientSVF_setFreq (tEfficientSVF* const, uint16_t controlFreq);
278	void tEfficientSVF_setQ (tEfficientSVF* const, float Q);
279
280	//==============================================================================
281
282	/* Simple Highpass filter. */
283	typedef struct _tHighpass
284	{
285	float xs, ys, R;
286	float frequency;
287
288	} _tHighpass;
289
290	typedef _tHighpass* tHighpass;
291
292	void tHighpass_init (tHighpass* const, float freq);
293	void tHighpass_free (tHighpass* const);
294	void tHighpass_initToPool (tHighpass* const, float freq, tMempool* const);
295	void tHighpass_freeFromPool (tHighpass* const, tMempool* const);
296
297	float tHighpass_tick (tHighpass* const, float x);
298	void tHighpass_setFreq (tHighpass* const, float freq);
299	float tHighpass_getFreq (tHighpass* const);
300
301	//==============================================================================
302
303	// Butterworth Filter
304	#define NUM_SVF_BW 16
305	typedef struct _tButterworth
306	{
307	float gain;
308
309	int N;
310
311	tSVF low[NUM_SVF_BW];
312	tSVF high[NUM_SVF_BW];
313
314	float f1,f2;
315
316	} _tButterworth;
317
318	typedef _tButterworth* tButterworth;
319
320	void tButterworth_init (tButterworth* const, int N, float f1, float f2);
321	void tButterworth_free (tButterworth* const);
322	void tButterworth_initToPool (tButterworth* const, int N, float f1, float f2, tMempool* const);
323	void tButterworth_freeFromPool (tButterworth* const, tMempool* const);
324
325	float tButterworth_tick (tButterworth* const, float input);
326	void tButterworth_setF1 (tButterworth* const, float in);
327	void tButterworth_setF2 (tButterworth* const, float in);
328	void tButterworth_setFreqs (tButterworth* const, float f1, float f2);
329
330	//==============================================================================
331
332	typedef struct _tFIR
333	{
334	float* past;
335	float* coeff;
336	int numTaps;
337	} _tFIR;
338
339	typedef _tFIR* tFIR;
340
341	void tFIR_init (tFIR* const, float* coeffs, int numTaps);
342	void tFIR_free (tFIR* const);
343	void tFIR_initToPool (tFIR* const, float* coeffs, int numTaps, tMempool* const);
344	void tFIR_freeFromPool (tFIR* const, tMempool* const);
345
346	float tFIR_tick (tFIR* const, float input);
347	void tFIR_coeffs (tFIR* const, float in);
348
349	//==============================================================================
350
351	#ifdef __cplusplus
352	}
353	#endif
354
355	#endif // LEAF_FILTERS_H_INCLUDED
356
357	//==============================================================================
358

LEAF/Inc/leaf-global.h+0−39

@@ -1,39 +0,0 @@
1	/*
2	==============================================================================
3
4	leaf-global.h
5	Created: 24 Oct 2019 2:24:38pm
6	Author: Matthew Wang
7
8	==============================================================================
9	*/
10
11	#ifndef LEAF_GLOBAL_H_INCLUDED
12	#define LEAF_GLOBAL_H_INCLUDED
13
14	#ifdef __cplusplus
15	extern "C" {
16	#endif
17
18	typedef struct _LEAF
19	{
20	float sampleRate;
21	float invSampleRate;
22	int blockSize;
23	float twoPiTimesInvSampleRate;
24	float (*random)(void);
25	int clearOnAllocation;
26	} LEAF;
27
28	extern LEAF leaf; // The global instance of LEAF.
29
30	//==============================================================================
31
32	#ifdef __cplusplus
33	}
34	#endif
35
36	#endif // LEAF_GLOBAL_H_INCLUDED
37
38	//==============================================================================
39

LEAF/Inc/leaf-instruments.h+0−201

@@ -1,201 +0,0 @@
1	/*==============================================================================
2
3	leaf-instruments.h
4	Created: 30 Nov 2018 10:24:44am
5	Author: airship
6
7	==============================================================================*/
8
9	#ifndef LEAF_INSTRUMENTS_H_INCLUDED
10	#define LEAF_INSTRUMENTS_H_INCLUDED
11
12	#ifdef __cplusplus
13	extern "C" {
14	#endif
15
16	//==============================================================================
17
18	#include "leaf-math.h"
19	#include "leaf-mempool.h"
20	#include "leaf-oscillators.h"
21	#include "leaf-filters.h"
22	#include "leaf-envelopes.h"
23
24	//==============================================================================
25
26	// 808 Cowbell
27	typedef struct _t808Cowbell {
28
29	tSquare p[2];
30	tNoise stick;
31	tSVF bandpassOsc;
32	tSVF bandpassStick;
33	tEnvelope envGain;
34	tEnvelope envStick;
35	tEnvelope envFilter;
36	tHighpass highpass;
37	float oscMix;
38	float filterCutoff;
39	oBool useStick;
40
41	} _t808Cowbell;
42
43	typedef _t808Cowbell* t808Cowbell;
44
45	void t808Cowbell_init (t808Cowbell* const, int useStick);
46	void t808Cowbell_free (t808Cowbell* const);
47	void t808Cowbell_initToPool (t808Cowbell* const, int useStick, tMempool* const);
48	void t808Cowbell_freeFromPool (t808Cowbell* const, tMempool* const);
49
50	float t808Cowbell_tick (t808Cowbell* const);
51	void t808Cowbell_on (t808Cowbell* const, float vel);
52	void t808Cowbell_setDecay (t808Cowbell* const, float decay);
53	void t808Cowbell_setHighpassFreq (t808Cowbell* const, float freq);
54	void t808Cowbell_setBandpassFreq (t808Cowbell* const, float freq);
55	void t808Cowbell_setFreq (t808Cowbell* const, float freq);
56	void t808Cowbell_setOscMix (t808Cowbell* const, float oscMix);
57	void t808Cowbell_setStick (t808Cowbell* const, int useStick);
58
59	//==============================================================================
60
61	// 808 Hihat
62	typedef struct _t808Hihat {
63
64	// 6 Square waves
65	tSquare p[6];
66	tNoise n;
67	tSVF bandpassOsc;
68	tSVF bandpassStick;
69	tEnvelope envGain;
70	tEnvelope envStick;
71	tEnvelope noiseFMGain;
72	tHighpass highpass;
73	tNoise stick;
74
75	float freq;
76	float stretch;
77	float FM_amount;
78	float oscNoiseMix;
79
80	} _t808Hihat;
81
82	typedef _t808Hihat* t808Hihat;
83
84	void t808Hihat_init (t808Hihat* const);
85	void t808Hihat_free (t808Hihat* const);
86	void t808Hihat_initToPool (t808Hihat* const, tMempool* const);
87	void t808Hihat_freeFromPool (t808Hihat* const, tMempool* const);
88
89	float t808Hihat_tick (t808Hihat* const);
90	void t808Hihat_on (t808Hihat* const, float vel);
91	void t808Hihat_setOscNoiseMix (t808Hihat* const, float oscNoiseMix);
92	void t808Hihat_setDecay (t808Hihat* const, float decay);
93	void t808Hihat_setHighpassFreq (t808Hihat* const, float freq);
94	void t808Hihat_setOscBandpassFreq (t808Hihat* const, float freq);
95	void t808Hihat_setOscBandpassQ (t808Hihat* const hihat, float Q);
96	void t808Hihat_setStickBandPassFreq (t808Hihat* const, float freq);
97	void t808Hihat_setStickBandPassQ (t808Hihat* const hihat, float Q);
98	void t808Hihat_setOscFreq (t808Hihat* const, float freq);
99	void t808Hihat_setStretch (t808Hihat* const hihat, float stretch);
100	void t808Hihat_setFM (t808Hihat* const hihat, float FM_amount);
101
102	//==============================================================================
103
104	// 808 Snare
105	typedef struct _t808Snare {
106
107	// Tone 1, Tone 2, Noise
108	tTriangle tone[2]; // Tri (not yet antialiased or wavetabled)
109	tNoise noiseOsc;
110	tSVF toneLowpass[2];
111	tSVF noiseLowpass; // Lowpass from SVF filter
112	tEnvelope toneEnvOsc[2];
113	tEnvelope toneEnvGain[2];
114	tEnvelope noiseEnvGain;
115	tEnvelope toneEnvFilter[2];
116	tEnvelope noiseEnvFilter;
117
118	float toneGain[2];
119	float noiseGain;
120
121	float toneNoiseMix;
122
123	float tone1Freq, tone2Freq;
124
125	float noiseFilterFreq;
126
127	} _t808Snare;
128
129	typedef _t808Snare* t808Snare;
130
131	void t808Snare_init (t808Snare* const);
132	void t808Snare_free (t808Snare* const);
133	void t808Snare_initToPool (t808Snare* const, tMempool* const);
134	void t808Snare_freeFromPool (t808Snare* const, tMempool* const);
135
136	float t808Snare_tick (t808Snare* const);
137	void t808Snare_on (t808Snare* const, float vel);
138	void t808Snare_setTone1Freq (t808Snare* const, float freq);
139	void t808Snare_setTone2Freq (t808Snare* const, float freq);
140	void t808Snare_setTone1Decay (t808Snare* const, float decay);
141	void t808Snare_setTone2Decay (t808Snare* const, float decay);
142	void t808Snare_setNoiseDecay (t808Snare* const, float decay);
143	void t808Snare_setToneNoiseMix (t808Snare* const, float toneNoiseMix);
144	void t808Snare_setNoiseFilterFreq (t808Snare* const, float noiseFilterFreq);
145	void t808Snare_setNoiseFilterQ (t808Snare* const, float noiseFilterQ);
146
147	//==============================================================================
148
149	// 808 Kick
150	typedef struct _t808Kick {
151
152
153	tCycle tone; // Tri
154	tNoise noiseOsc;
155	tSVF toneLowpass;
156	tEnvelope toneEnvOscChirp;
157	tEnvelope toneEnvOscSigh;
158	tEnvelope toneEnvGain;
159	tEnvelope noiseEnvGain;
160	tEnvelope toneEnvFilter;
161
162	float toneGain;
163	float noiseGain;
164
165	float toneInitialFreq;
166	float sighAmountInHz;
167	float chirpRatioMinusOne;
168	float noiseFilterFreq;
169
170	} _t808Kick;
171
172	typedef _t808Kick* t808Kick;
173
174	void t808Kick_init (t808Kick* const);
175	void t808Kick_free (t808Kick* const);
176	void t808Kick_initToPool (t808Kick* const, tMempool* const);
177	void t808Kick_freeFromPool (t808Kick* const, tMempool* const);
178
179	float t808Kick_tick (t808Kick* const);
180	void t808Kick_on (t808Kick* const, float vel);
181	void t808Kick_setToneFreq (t808Kick* const, float freq);
182	void t808Kick_setToneDecay (t808Kick* const, float decay);
183	void t808Kick_setNoiseDecay (t808Kick* const, float decay);
184	void t808Kick_setSighAmount (t808Kick* const, float sigh);
185	void t808Kick_setChirpAmount (t808Kick* const, float chirp);
186	void t808Kick_setToneNoiseMix (t808Kick* const, float toneNoiseMix);
187	void t808Kick_setNoiseFilterFreq (t808Kick* const, float noiseFilterFreq);
188	void t808Kick_setNoiseFilterQ (t808Kick* const, float noiseFilterQ);
189
190	//==============================================================================
191
192	#ifdef __cplusplus
193	}
194	#endif
195
196	#endif // LEAF_INSTRUMENTS_H_INCLUDED
197
198	//==============================================================================
199
200
201

LEAF/Inc/leaf-math.h+0−179

@@ -1,179 +0,0 @@
1	/*==============================================================================
2
3	leaf-math.h
4	Created: 22 Jan 2017 7:02:56pm
5	Author: Michael R Mulshine
6
7	==============================================================================*/
8
9	#ifndef LEAF_MATH_H_INCLUDED
10	#define LEAF_MATH_H_INCLUDED
11
12	#ifdef __cplusplus
13	extern "C" {
14	#endif
15
16	#include "leaf-global.h"
17	#include "math.h"
18	#include "stdint.h"
19	#include "stdlib.h"
20
21	//==============================================================================
22
23	//==============================================================================
24
25	typedef enum oBool
26	{
27	OTRUE = 1,
28	OFALSE = 0
29	}oBool;
30
31	// Allows for bitwise operations on floats
32	union unholy_t { /* a union between a float and an integer */
33	float f;
34	int i;
35	};
36
37	#define SQRT8 2.82842712475f
38	#define WSCALE 1.30612244898f
39	#define PI (3.14159265358979f)
40	#define TWO_PI (2 * PI)
41
42	#define VSF 1.0e-38f
43
44	#define MAX_DELAY 8192
45	#define INV_128 0.0078125f
46
47	#define INV_20 0.05f
48	#define INV_40 0.025f
49	#define INV_80 0.0125f
50	#define INV_160 0.00625f
51	#define INV_320 0.003125f
52	#define INV_640 0.0015625f
53	#define INV_1280 0.00078125f
54	#define INV_2560 0.000390625f
55	#define INV_5120 0.0001953125f
56	#define INV_10240 0.00009765625f
57	#define INV_20480 0.000048828125f
58
59
60	#define INV_TWELVE 0.0833333333f
61	#define INV_440 0.0022727273f
62
63	#define LOG2 0.3010299957f
64	#define INV_LOG2 3.321928095f
65
66	#define SOS_M 343.0f
67	#define TWO_TO_5 32.0f
68	#define INV_TWO_TO_5 0.03125f
69	#define TWO_TO_7 128.f
70	#define INV_TWO_TO_7 0.0078125f
71	#define TWO_TO_8 256.f
72	#define INV_TWO_TO_8 0.00390625f
73	#define TWO_TO_9 512.f
74	#define INV_TWO_TO_9 0.001953125f
75	#define TWO_TO_10 1024.f
76	#define INV_TWO_TO_10 0.0009765625f
77	#define TWO_TO_11 2048.f
78	#define INV_TWO_TO_11 0.00048828125f
79	#define TWO_TO_12 4096.f
80	#define INV_TWO_TO_12 0.00024414062f
81	#define TWO_TO_15 32768.f
82	#define TWO_TO_16 65536.f
83	#define INV_TWO_TO_15 0.00003051757f
84	#define INV_TWO_TO_16 0.00001525878f
85	#define TWO_TO_16_MINUS_ONE 65535.0f
86	#define TWO_TO_23 8388608.0f
87	#define INV_TWO_TO_23 0.00000011920929f
88	#define TWO_TO_31 2147483648.0f
89	#define INV_TWO_TO_31 0.000000000465661f
90	#define TWO_TO_32 4294967296.0f
91	#define INV_TWO_TO_32 0.000000000232831f
92
93
94	#define LOGTEN 2.302585092994
95
96	// Jones shaper
97	float LEAF_shaper (float input, float m_drive);
98	float LEAF_reedTable (float input, float offset, float slope);
99
100	float LEAF_reduct (float input, float ratio);
101	float LEAF_round (float input, float rnd);
102	float LEAF_bitwise_xor(float input, uint32_t op);
103
104	float LEAF_reduct (float input, float ratio);
105	float LEAF_round (float input, float rnd);
106	float LEAF_bitwise_xor(float input, uint32_t op);
107
108	float LEAF_clip (float min, float val, float max);
109	int LEAF_clipInt (int min, int val, int max);
110	float LEAF_softClip (float val, float thresh);
111	oBool LEAF_isPrime (uint64_t number );
112
113	float LEAF_midiToFrequency (float f);
114	float LEAF_frequencyToMidi(float f);
115
116	void LEAF_generate_sine (float* buffer, int size);
117	void LEAF_generate_sawtooth (float* buffer, float basefreq, int size);
118	void LEAF_generate_triangle (float* buffer, float basefreq, int size);
119	void LEAF_generate_square (float* buffer, float basefreq, int size);
120
121	// dope af
122	float LEAF_chebyshevT(float in, int n);
123	float LEAF_CompoundChebyshevT(float in, int n, float* amps);
124
125	// Hermite interpolation
126	float LEAF_interpolate_hermite (float A, float B, float C, float D, float t);
127	float LEAF_interpolate_hermite_x(float yy0, float yy1, float yy2, float yy3, float xx);
128	float LEAF_interpolation_linear (float A, float B, float t);
129
130	float interpolate3max(float *buf, const int peakindex);
131	float interpolate3phase(float *buf, const int peakindex);
132
133	// alternative implementation for abs()
134	// REQUIRES: 32 bit integers
135	int fastabs_int(int in);
136
137	// alternative implementation for abs()
138	// REQUIRES: 32 bit floats
139	float fastabsf(float f);
140
141	float fastexp2f(float f);
142
143
144	void LEAF_crossfade(float fade, float* volumes);
145
146
147
148	float fast_mtof(float f);
149
150	float fastexpf(float x);
151
152	float fasterexpf(float x);
153
154	float mtof(float f);
155
156	float fast_mtof(float f);
157
158	float faster_mtof(float f);
159
160	float ftom(float f);
161
162	float powtodb(float f);
163
164	float rmstodb(float f);
165
166	float dbtopow(float f);
167
168	float dbtorms(float f);
169
170	//==============================================================================
171
172	#ifdef __cplusplus
173	}
174	#endif
175
176	#endif // LEAF_MATH_H_INCLUDED
177
178	//==============================================================================
179

LEAF/Inc/leaf-mempool.h+0−127

@@ -1,127 +0,0 @@
1	/*==============================================================================
2
3	In short, mpool is distributed under so called "BSD license",
4
5	Copyright (c) 2009-2010 Tatsuhiko Kubo <cubicdaiya@gmail.com>
6	All rights reserved.
7
8	Redistribution and use in source and binary forms, with or without modification,
9	are permitted provided that the following conditions are met:
10
11	* Redistributions of source code must retain the above copyright notice,
12	this list of conditions and the following disclaimer.
13
14	* Redistributions in binary form must reproduce the above copyright notice,
15	this list of conditions and the following disclaimer in the documentation
16	and/or other materials provided with the distribution.
17
18	* Neither the name of the authors nor the names of its contributors
19	may be used to endorse or promote products derived from this software
20	without specific prior written permission.
21
22	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23	"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24	LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
25	A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
26	OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
27	SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
28	TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
29	PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
30	LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
31	NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
32	SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33
34	written by C99 style
35	==============================================================================*/
36
37	#ifndef LEAF_MPOOL_H_INCLUDED
38	#define LEAF_MPOOL_H_INCLUDED
39
40	#ifdef __cplusplus
41	extern "C" {
42	#endif
43
44	//==============================================================================
45
46	#include <stdio.h>
47	#include <stdlib.h>
48	#include <string.h>
49	#include <stdbool.h>
50
51	//==============================================================================
52
53	#define MPOOL_ALIGN_SIZE (8)
54
55	//#define size_t unsigned long
56
57	/**
58	* memory pool structure
59	*/
60
61	// node of free list
62	typedef struct mpool_node_t {
63	void *pool; // memory pool field
64	struct mpool_node_t *next; // next node pointer
65	struct mpool_node_t *prev; // prev node pointer
66	size_t size;
67	} mpool_node_t;
68
69	typedef struct mpool_t {
70	void* mpool; // start of the mpool
71	size_t usize; // used size of the pool
72	size_t msize; // max size of the pool
73	mpool_node_t* head; // first node of memory pool free list
74	} mpool_t;
75
76	void mpool_create (char* memory, size_t size, mpool_t* pool);
77
78	void* mpool_alloc(size_t size, mpool_t* pool);
79	void* mpool_calloc(size_t asize, mpool_t* pool);
80
81	void mpool_free(void* ptr, mpool_t* pool);
82
83	size_t mpool_get_size(mpool_t* pool);
84	size_t mpool_get_used(mpool_t* pool);
85
86	void leaf_pool_init(char* memory, size_t size);
87
88	void* leaf_alloc(size_t size);
89	void* leaf_calloc(size_t size);
90
91	void leaf_free(void* ptr);
92
93	size_t leaf_pool_get_size(void);
94	size_t leaf_pool_get_used(void);
95
96	void* leaf_pool_get_pool(void);
97
98	void leaf_mempool_overrun(void);
99
100	// User object for creating additional mempools
101
102	typedef struct _tMempool
103	{
104	mpool_t pool;
105	} _tMempool;
106
107	typedef _tMempool* tMempool;
108
109	void tMempool_init (tMempool* const, char* memory, size_t size);
110	void tMempool_free (tMempool* const);
111	void tMempool_initToPool (tMempool* const, char* memory, size_t size, tMempool* const);
112	void tMempool_freeFromPool (tMempool* const, tMempool* const);
113
114	//==============================================================================
115
116	extern tMempool leaf_mempool;
117
118	#ifdef __cplusplus
119	}
120	#endif
121
122	#endif // LEAF_MPOOL_H
123
124	//==============================================================================
125
126
127

LEAF/Inc/leaf-midi.h+0−133

@@ -1,133 +0,0 @@
1	/*==============================================================================
2
3	leaf-midi.h
4	Created: 30 Nov 2018 11:29:26am
5	Author: airship
6
7	==============================================================================*/
8
9	#ifndef LEAF_MIDI_H_INCLUDED
10	#define LEAF_MIDI_H_INCLUDED
11
12	#ifdef __cplusplus
13	extern "C" {
14	#endif
15
16	//==============================================================================
17
18	#include "leaf-global.h"
19	#include "leaf-mempool.h"
20	#include "leaf-math.h"
21	#include "leaf-envelopes.h"
22
23	//==============================================================================
24
25	// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
26
27	// STACK implementation (fixed size)
28	#define STACK_SIZE 128
29	typedef struct _tStack
30	{
31	int data[STACK_SIZE];
32	uint16_t pos;
33	uint16_t size;
34	uint16_t capacity;
35	oBool ordered;
36
37	} _tStack;
38
39	typedef _tStack* tStack;
40
41	void tStack_init (tStack* const);
42	void tStack_free (tStack* const);
43	void tStack_initToPool (tStack* const, tMempool* const);
44	void tStack_freeFromPool (tStack* const, tMempool* const);
45
46	void tStack_setCapacity (tStack* const, uint16_t cap);
47	int tStack_addIfNotAlreadyThere (tStack* const, uint16_t item);
48	void tStack_add (tStack* const, uint16_t item);
49	int tStack_remove (tStack* const, uint16_t item);
50	void tStack_clear (tStack* const);
51	int tStack_first (tStack* const);
52	int tStack_getSize (tStack* const);
53	int tStack_contains (tStack* const, uint16_t item);
54	int tStack_next (tStack* const);
55	int tStack_get (tStack* const, int which);
56
57	/* tPoly */
58	typedef struct _tPoly
59	{
60	tStack stack;
61	tStack orderStack;
62
63	tRamp* ramps;
64	float* rampVals;
65	oBool* firstReceived;
66	float glideTime;
67	oBool pitchGlideIsActive;
68
69	int numVoices;
70	int maxNumVoices;
71
72	//int voices[POLY_NUM_MAX_VOICES][2];
73	int** voices;
74
75	int notes[128][2];
76
77	int CCs[128];
78
79	uint8_t CCsRaw[128];
80
81	int lastVoiceToChange;
82
83	float pitchBend;
84	tRamp pitchBendRamp;
85
86	int currentNote;
87	int currentVoice;
88	int currentVelocity;
89	int maxLength;
90
91	} _tPoly;
92
93	typedef _tPoly* tPoly;
94
95	/* MPoly*/
96	void tPoly_init (tPoly* const, int maxNumVoices);
97	void tPoly_free (tPoly* const);
98	void tPoly_initToPool (tPoly* const, int maxNumVoices, tMempool* const);
99	void tPoly_freeFromPool (tPoly* const, tMempool* const);
100
101	//ADDING A NOTE
102	int tPoly_noteOn (tPoly* const, int note, uint8_t vel);
103	int tPoly_noteOff (tPoly* const, uint8_t note);
104	void tPoly_orderedAddToStack (tPoly* const, uint8_t noteVal);
105	void tPoly_setNumVoices (tPoly* const, uint8_t numVoices);
106
107	void tPoly_setPitchBend (tPoly* const, float pitchBend);
108	void tPoly_setPitchGlideActive (tPoly* const, oBool isActive);
109	void tPoly_setPitchGlideTime (tPoly* const, float t);
110	void tPoly_setBendGlideTime (tPoly* const polyh, float t);
111	void tPoly_setBendSamplesPerTick (tPoly* const polyh, float t);
112	void tPoly_tickPitch (tPoly* const);
113	void tPoly_tickPitchGlide (tPoly* const);
114	void tPoly_tickPitchBend (tPoly* const);
115
116	int tPoly_getNumVoices (tPoly* const);
117	int tPoly_getNumActiveVoices (tPoly* const);
118	float tPoly_getPitch (tPoly* const, uint8_t voice);
119	int tPoly_getKey (tPoly* const, uint8_t voice);
120	int tPoly_getVelocity (tPoly* const, uint8_t voice);
121	int tPoly_isOn (tPoly* const, uint8_t voice);
122
123	//==============================================================================
124
125	#ifdef __cplusplus
126	}
127	#endif
128
129	#endif // LEAF_MIDI_H_INCLUDED
130
131	//==============================================================================
132
133

LEAF/Inc/leaf-oscillators.h+0−208

@@ -1,208 +0,0 @@
1	/*==============================================================================
2	leaf-oscillators.h
3	Created: 20 Jan 2017 12:00:58pm
4	Author: Michael R Mulshine
5	==============================================================================*/
6
7	#ifndef LEAF_OSCILLATORS_H_INCLUDED
8	#define LEAF_OSCILLATORS_H_INCLUDED
9
10	#ifdef __cplusplus
11	extern "C" {
12	#endif
13
14	//==============================================================================
15
16	#include "leaf-math.h"
17	#include "leaf-mempool.h"
18	#include "leaf-filters.h"
19
20	//==============================================================================
21
22	/* tCycle: Cycle/Sine waveform. Wavetable synthesis.*/
23	typedef struct _tCycle
24	{
25	// Underlying phasor
26	float phase;
27	float inc,freq;
28
29	} _tCycle;
30
31	typedef _tCycle* tCycle;
32
33	void tCycle_init (tCycle* const);
34	void tCycle_free (tCycle* const);
35	void tCycle_initToPool (tCycle* const, tMempool* const);
36	void tCycle_freeFromPool (tCycle* const, tMempool* const);
37
38	float tCycle_tick (tCycle* const);
39	int tCycle_setFreq (tCycle* const, float freq);
40
41	//==============================================================================
42
43	/* tTriangle: Anti-aliased Triangle waveform using wavetable interpolation. Wavetables constructed from sine components. */
44	typedef struct _tTriangle
45	{
46	// Underlying phasor
47	float phase;
48	float inc,freq;
49
50	} _tTriangle;
51
52	typedef _tTriangle* tTriangle;
53
54	void tTriangle_init (tTriangle* const);
55	void tTriangle_free (tTriangle* const);
56	void tTriangle_initToPool (tTriangle* const, tMempool* const);
57	void tTriangle_freeFromPool (tTriangle* const, tMempool* const);
58
59	float tTriangle_tick (tTriangle* const);
60	int tTriangle_setFreq (tTriangle* const, float freq);
61
62	//==============================================================================
63
64	/* tSquare: Anti-aliased Square waveform using wavetable interpolation. Wavetables constructed from sine components. */
65	typedef struct _tSquare
66	{
67	// Underlying phasor
68	float phase;
69	float inc,freq;
70
71	} _tSquare;
72
73	typedef _tSquare* tSquare;
74
75	void tSquare_init (tSquare* const);
76	void tSquare_free (tSquare* const);
77	void tSquare_initToPool (tSquare* const, tMempool* const);
78	void tSquare_freeFromPool(tSquare* const, tMempool* const);
79
80	float tSquare_tick (tSquare* const);
81	int tSquare_setFreq (tSquare* const, float freq);
82
83	//==============================================================================
84
85	/* tSawtooth: Anti-aliased Sawtooth waveform using wavetable interpolation. Wavetables constructed from sine components. */
86	typedef struct _tSawtooth
87	{
88	// Underlying phasor
89	float phase;
90	float inc,freq;
91
92	} _tSawtooth;
93
94	typedef _tSawtooth* tSawtooth;
95
96	void tSawtooth_init (tSawtooth* const);
97	void tSawtooth_free (tSawtooth* const);
98	void tSawtooth_initToPool (tSawtooth* const, tMempool* const);
99	void tSawtooth_freeFromPool (tSawtooth* const, tMempool* const);
100
101	float tSawtooth_tick (tSawtooth* const);
102	int tSawtooth_setFreq (tSawtooth* const, float freq);
103
104	//==============================================================================
105
106	/* tPhasor: Aliasing phasor [0.0, 1.0) */
107	typedef struct _tPhasor
108	{
109	float phase;
110	float inc,freq;
111
112	} _tPhasor;
113
114	typedef _tPhasor* tPhasor;
115
116	void tPhasor_init (tPhasor* const);
117	void tPhasor_free (tPhasor* const);
118	void tPhasor_initToPool (tPhasor* const, tMempool* const);
119	void tPhasor_freeFromPool(tPhasor* const, tMempool* const);
120
121	float tPhasor_tick (tPhasor* const);
122	int tPhasor_setFreq (tPhasor* const, float freq);
123
124	//==============================================================================
125
126	/* tNoise. WhiteNoise, PinkNoise. */
127	typedef enum NoiseType
128	{
129	WhiteNoise=0,
130	PinkNoise,
131	NoiseTypeNil,
132	} NoiseType;
133
134	typedef struct _tNoise
135	{
136	NoiseType type;
137	float pinkb0, pinkb1, pinkb2;
138	float(*rand)(void);
139
140	} _tNoise;
141
142	typedef _tNoise* tNoise;
143
144	void tNoise_init (tNoise* const, NoiseType type);
145	void tNoise_free (tNoise* const);
146	void tNoise_initToPool (tNoise* const, NoiseType type, tMempool* const);
147	void tNoise_freeFromPool (tNoise* const, tMempool* const);
148
149	float tNoise_tick (tNoise* const);
150
151	//==============================================================================
152
153	/* tNeuron */
154	typedef enum NeuronMode
155	{
156	NeuronNormal = 0,
157	NeuronTanh,
158	NeuronAaltoShaper,
159	NeuronModeNil
160	} NeuronMode;
161
162	typedef struct _tNeuron
163	{
164	tPoleZero f;
165
166	NeuronMode mode;
167
168	float voltage, current;
169	float timeStep;
170
171	float alpha[3];
172	float beta[3];
173	float rate[3];
174	float V[3];
175	float P[3];
176	float gK, gN, gL, C;
177	} _tNeuron;
178
179	typedef _tNeuron* tNeuron;
180
181	void tNeuron_init (tNeuron* const);
182	void tNeuron_free (tNeuron* const);
183	void tNeuron_initToPool (tNeuron* const, tMempool* const);
184	void tNeuron_freeFromPool(tNeuron* const, tMempool* const);
185
186	void tNeuron_reset (tNeuron* const);
187	float tNeuron_tick (tNeuron* const);
188	void tNeuron_setMode (tNeuron* const, NeuronMode mode);
189	void tNeuron_setCurrent (tNeuron* const, float current);
190	void tNeuron_setK (tNeuron* const, float K);
191	void tNeuron_setL (tNeuron* const, float L);
192	void tNeuron_setN (tNeuron* const, float N);
193	void tNeuron_setC (tNeuron* const, float C);
194	void tNeuron_setV1 (tNeuron* const, float V1);
195	void tNeuron_setV2 (tNeuron* const, float V2);
196	void tNeuron_setV3 (tNeuron* const, float V3);
197	void tNeuron_setTimeStep (tNeuron* const, float timestep);
198
199	//==============================================================================
200
201	#ifdef __cplusplus
202	}
203	#endif
204
205	#endif // LEAF_OSCILLATORS_H_INCLUDED
206
207	//==============================================================================
208

LEAF/Inc/leaf-physical.h+0−251

@@ -1,251 +0,0 @@
1	/*
2	==============================================================================
3
4	leaf-physical.h
5	Created: 30 Nov 2018 10:41:55am
6	Author: airship
7
8	==============================================================================
9	*/
10
11	#ifndef LEAF_PHYSICAL_H_INCLUDED
12	#define LEAF_PHYSICAL_H_INCLUDED
13
14	#ifdef __cplusplus
15	extern "C" {
16	#endif
17
18	//==============================================================================
19
20	#include "leaf-global.h"
21	#include "leaf-math.h"
22	#include "leaf-mempool.h"
23	#include "leaf-delay.h"
24	#include "leaf-filters.h"
25	#include "leaf-oscillators.h"
26	#include "leaf-envelopes.h"
27	#include "leaf-dynamics.h"
28
29	//==============================================================================
30
31	/* Karplus Strong model */
32	typedef struct _tPluck
33	{
34	tAllpassDelay delayLine; // Allpass or Linear?? big difference...
35	tOneZero loopFilter;
36	tOnePole pickFilter;
37	tNoise noise;
38
39	float lastOut;
40	float loopGain;
41	float lastFreq;
42
43	float sr;
44
45	} _tPluck;
46
47	typedef _tPluck* tPluck;
48
49	void tPluck_init (tPluck* const, float lowestFrequency); //float delayBuff[DELAY_LENGTH]);
50	void tPluck_free (tPluck* const);
51	void tPluck_initToPool (tPluck* const, float lowestFrequency, tMempool* const);
52	void tPluck_freeFromPool (tPluck* const, tMempool* const);
53
54	float tPluck_tick (tPluck* const);
55
56	// Pluck the string.
57	void tPluck_pluck (tPluck* const, float amplitude);
58
59	// Start a note with the given frequency and amplitude.;
60	void tPluck_noteOn (tPluck* const, float frequency, float amplitude );
61
62	// Stop a note with the given amplitude (speed of decay).
63	void tPluck_noteOff (tPluck* const, float amplitude );
64
65	// Set instrument parameters for a particular frequency.
66	void tPluck_setFrequency (tPluck* const, float frequency );
67
68	// Perform the control change specified by \e number and \e value (0.0 - 128.0).
69	void tPluck_controlChange (tPluck* const, int number, float value);
70
71	// tPluck Utilities.
72	float tPluck_getLastOut (tPluck* const);
73
74	//==============================================================================
75
76	typedef enum SKControlType
77	{
78	SKPickPosition = 0,
79	SKStringDamping,
80	SKDetune,
81	SKControlTypeNil
82	} SKControlType;
83
84	/* Stif Karplus Strong model */
85	typedef struct _tKarplusStrong
86	{
87	tAllpassDelay delayLine;
88	tLinearDelay combDelay;
89	tOneZero filter;
90	tNoise noise;
91	tBiQuad biquad[4];
92
93	uint32_t length;
94	float loopGain;
95	float baseLoopGain;
96	float lastFrequency;
97	float lastLength;
98	float stretching;
99	float pluckAmplitude;
100	float pickupPosition;
101
102	float lastOut;
103
104	} _tKarplusStrong;
105
106	typedef _tKarplusStrong* tKarplusStrong;
107
108	void tKarplusStrong_init (tKarplusStrong* const, float lowestFrequency); // float delayBuff[2][DELAY_LENGTH]);
109	void tKarplusStrong_free (tKarplusStrong* const);
110	void tKarplusStrong_initToPool (tKarplusStrong* const, float lowestFrequency, tMempool* const);
111	void tKarplusStrong_freeFromPool (tKarplusStrong* const, tMempool* const);
112
113	float tKarplusStrong_tick (tKarplusStrong* const);
114
115	// Pluck the string.
116	void tKarplusStrong_pluck (tKarplusStrong* const, float amplitude);
117
118	// Start a note with the given frequency and amplitude.;
119	void tKarplusStrong_noteOn (tKarplusStrong* const, float frequency, float amplitude );
120
121	// Stop a note with the given amplitude (speed of decay).
122	void tKarplusStrong_noteOff (tKarplusStrong* const, float amplitude );
123
124	// Set instrument parameters for a particular frequency.
125	void tKarplusStrong_setFrequency (tKarplusStrong* const, float frequency );
126
127	// Perform the control change specified by \e number and \e value (0.0 - 128.0).
128	// Use SKPickPosition, SKStringDamping, or SKDetune for type.
129	void tKarplusStrong_controlChange (tKarplusStrong* const, SKControlType type, float value);
130
131	// Set the stretch "factor" of the string (0.0 - 1.0).
132	void tKarplusStrong_setStretch (tKarplusStrong* const, float stretch );
133
134	// Set the pluck or "excitation" position along the string (0.0 - 1.0).
135	void tKarplusStrong_setPickupPosition (tKarplusStrong* const, float position );
136
137	// Set the base loop gain.
138	void tKarplusStrong_setBaseLoopGain (tKarplusStrong* const, float aGain );
139
140	// tKarplusStrong utilities.
141	float tKarplusStrong_getLastOut (tKarplusStrong* const);
142
143	// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
144
145	/* Simple Living String */
146	typedef struct _tSimpleLivingString {
147	float freq, waveLengthInSamples; // the frequency of the string, determining delay length
148	float dampFreq; // frequency for the bridge LP filter, in Hz
149	float decay; // amplitude damping factor for the string (only active in mode 0)
150	float levMode;
151	float curr;
152	tLinearDelay delayLine;
153	tOnePole bridgeFilter;
154	tHighpass DCblocker;
155	tFeedbackLeveler fbLev;
156	tExpSmooth wlSmooth;
157	} _tSimpleLivingString;
158
159	typedef _tSimpleLivingString* tSimpleLivingString;
160
161	void tSimpleLivingString_init (tSimpleLivingString* const, float freq, float dampFreq,
162	float decay, float targetLev, float levSmoothFactor,
163	float levStrength, int levMode);
164	void tSimpleLivingString_free (tSimpleLivingString* const);
165	void tSimpleLivingString_initToPool (tSimpleLivingString* const, float freq, float dampFreq,
166	float decay, float targetLev, float levSmoothFactor,
167	float levStrength, int levMode, tMempool* const);
168	void tSimpleLivingString_freeFromPool (tSimpleLivingString* const, tMempool* const);
169
170	float tSimpleLivingString_tick (tSimpleLivingString* const, float input);
171	float tSimpleLivingString_sample (tSimpleLivingString* const);
172	void tSimpleLivingString_setFreq (tSimpleLivingString* const, float freq);
173	void tSimpleLivingString_setWaveLength (tSimpleLivingString* const, float waveLength); // in samples
174	void tSimpleLivingString_setDampFreq (tSimpleLivingString* const, float dampFreq);
175	void tSimpleLivingString_setDecay (tSimpleLivingString* const, float decay); // should be near 1.0
176	void tSimpleLivingString_setTargetLev (tSimpleLivingString* const, float targetLev);
177	void tSimpleLivingString_setLevSmoothFactor (tSimpleLivingString* const, float levSmoothFactor);
178	void tSimpleLivingString_setLevStrength (tSimpleLivingString* const, float levStrength);
179	void tSimpleLivingString_setLevMode (tSimpleLivingString* const, int levMode);
180
181	// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
182
183	/* Living String */
184	typedef struct _tLivingString {
185	float freq, waveLengthInSamples; // the frequency of the whole string, determining delay length
186	float pickPos; // the pick position, dividing the string in two, in ratio
187	float prepIndex; // the amount of pressure on the pickpoint of the string (near 0=soft obj, near 1=hard obj)
188	float dampFreq; // frequency for the bridge LP filter, in Hz
189	float decay; // amplitude damping factor for the string (only active in mode 0)
190	float levMode;
191	float curr;
192	tLinearDelay delLF,delUF,delUB,delLB; // delay for lower/upper/forward/backward part of the waveguide model
193	tOnePole bridgeFilter, nutFilter, prepFilterU, prepFilterL;
194	tHighpass DCblockerL, DCblockerU;
195	tFeedbackLeveler fbLevU, fbLevL;
196	tExpSmooth wlSmooth, ppSmooth;
197	} _tLivingString;
198
199	typedef _tLivingString* tLivingString;
200
201	void tLivingString_init (tLivingString* const, float freq, float pickPos, float prepIndex,
202	float dampFreq, float decay, float targetLev, float levSmoothFactor,
203	float levStrength, int levMode);
204	void tLivingString_free (tLivingString* const);
205	void tLivingString_initToPool (tLivingString* const, float freq, float pickPos, float prepIndex,
206	float dampFreq, float decay, float targetLev, float levSmoothFactor,
207	float levStrength, int levMode, tMempool* const);
208	void tLivingString_freeFromPool (tLivingString* const, tMempool* const);
209
210	float tLivingString_tick (tLivingString* const, float input);
211	float tLivingString_sample (tLivingString* const);
212	void tLivingString_setFreq (tLivingString* const, float freq);
213	void tLivingString_setWaveLength (tLivingString* const, float waveLength); // in samples
214	void tLivingString_setPickPos (tLivingString* const, float pickPos);
215	void tLivingString_setPrepIndex (tLivingString* const, float prepIndex);
216	void tLivingString_setDampFreq (tLivingString* const, float dampFreq);
217	void tLivingString_setDecay (tLivingString* const, float decay); // should be near 1.0
218	void tLivingString_setTargetLev (tLivingString* const, float targetLev);
219	void tLivingString_setLevSmoothFactor (tLivingString* const, float levSmoothFactor);
220	void tLivingString_setLevStrength (tLivingString* const, float levStrength);
221	void tLivingString_setLevMode (tLivingString* const, int levMode);
222
223	// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
224
225	//Reed Table - borrowed from STK
226	typedef struct _tReedTable {
227	float offset, slope;
228	} _tReedTable;
229
230	typedef _tReedTable* tReedTable;
231
232	void tReedTable_init (tReedTable* const, float offset, float slope);
233	void tReedTable_free (tReedTable* const);
234	void tReedTable_initToPool (tReedTable* const, float offset, float slope, tMempool* const);
235	void tReedTable_freeFromPool (tReedTable* const, tMempool* const);
236
237	float tReedTable_tick (tReedTable* const, float input);
238	float tReedTable_tanh_tick (tReedTable* const, float input); //tanh softclip version of reed table - replacing the hard clip in original stk code
239	void tReedTable_setOffset (tReedTable* const, float offset);
240	void tReedTable_setSlope (tReedTable* const, float slope);
241
242	//==============================================================================
243
244	#ifdef __cplusplus
245	}
246	#endif
247
248	#endif // LEAF_PHYSICAL_H_INCLUDED
249
250	//==============================================================================
251

LEAF/Inc/leaf-reverb.h+0−167

@@ -1,167 +0,0 @@
1	/*==============================================================================
2
3	leaf-reverb.h
4	Created: 20 Jan 2017 12:02:04pm
5	Author: Michael R Mulshine
6
7	==============================================================================*/
8
9	#ifndef LEAF_REVERB_H_INCLUDED
10	#define LEAF_REVERB_H_INCLUDED
11
12	#ifdef __cplusplus
13	extern "C" {
14	#endif
15
16	//==============================================================================
17
18	#include "leaf-global.h"
19	#include "leaf-math.h"
20	#include "leaf-mempool.h"
21	#include "leaf-delay.h"
22	#include "leaf-filters.h"
23	#include "leaf-oscillators.h"
24
25	//==============================================================================
26
27	/* PRCReverb: Reverb, reimplemented from STK (Cook and Scavone). */
28	typedef struct _tPRCReverb
29	{
30	float mix, t60;
31
32	float inv_441;
33
34	tDelay allpassDelays[2];
35	tDelay combDelay;
36	float allpassCoeff;
37	float combCoeff;
38
39	float lastIn, lastOut;
40
41	} _tPRCReverb;
42
43	typedef _tPRCReverb* tPRCReverb;
44
45	void tPRCReverb_init (tPRCReverb* const, float t60);
46	void tPRCReverb_free (tPRCReverb* const);
47	void tPRCReverb_initToPool (tPRCReverb* const, float t60, tMempool* const);
48	void tPRCReverb_freeFromPool (tPRCReverb* const, tMempool* const);
49
50	void tPRCReverb_clear (tPRCReverb* const);
51	float tPRCReverb_tick (tPRCReverb* const, float input);
52
53	// Set reverb time in seconds.
54	void tPRCReverb_setT60 (tPRCReverb* const, float t60);
55
56	// Set mix between dry input and wet output signal.
57	void tPRCReverb_setMix (tPRCReverb* const, float mix);
58
59	//==============================================================================
60
61	/* NReverb: Reverb, reimplemented from STK (Cook and Scavone). */
62	typedef struct _tNReverb
63	{
64	float mix, t60;
65
66	float inv_sr, inv_441;
67
68	tLinearDelay allpassDelays[8];
69	tLinearDelay combDelays[6];
70	float allpassCoeff;
71	float combCoeffs[6];
72	float lowpassState;
73
74	float lastIn, lastOut;
75
76	} _tNReverb;
77
78	typedef _tNReverb* tNReverb;
79
80	void tNReverb_init (tNReverb* const, float t60);
81	void tNReverb_free (tNReverb* const);
82	void tNReverb_initToPool (tNReverb* const, float t60, tMempool* const);
83	void tNReverb_freeFromPool (tNReverb* const, tMempool* const);
84
85	void tNReverb_clear (tNReverb* const);
86	float tNReverb_tick (tNReverb* const, float input);
87	void tNReverb_tickStereo (tNReverb* const rev, float input, float* output);
88
89	// Set reverb time in seconds.
90	void tNReverb_setT60 (tNReverb* const, float t60);
91
92	// Set mix between dry input and wet output signal.
93	void tNReverb_setMix (tNReverb* const, float mix);
94
95	//==============================================================================
96
97	typedef struct _tDattorroReverb
98	{
99	float predelay;
100	float input_filter;
101	float feedback_filter;
102	float feedback_gain;
103	float mix;
104	uint32_t frozen;
105
106	float size, size_max, t;
107
108	float f1_delay_2_last,
109	f2_delay_2_last;
110
111	float f1_last,
112	f2_last;
113
114	// INPUT
115	tTapeDelay in_delay;
116	tOnePole in_filter;
117	tAllpass in_allpass[4];
118
119	// FEEDBACK 1
120	tAllpass f1_allpass;
121	tTapeDelay f1_delay_1;
122	tOnePole f1_filter;
123	tTapeDelay f1_delay_2;
124	tTapeDelay f1_delay_3;
125	tHighpass f1_hp;
126
127	tCycle f1_lfo;
128
129	// FEEDBACK 2
130	tAllpass f2_allpass;
131	tTapeDelay f2_delay_1;
132	tOnePole f2_filter;
133	tTapeDelay f2_delay_2;
134	tTapeDelay f2_delay_3;
135	tHighpass f2_hp;
136
137	tCycle f2_lfo;
138
139	} _tDattorroReverb;
140
141	typedef _tDattorroReverb* tDattorroReverb;
142
143	void tDattorroReverb_init (tDattorroReverb* const);
144	void tDattorroReverb_free (tDattorroReverb* const);
145	void tDattorroReverb_initToPool (tDattorroReverb* const, tMempool* const);
146	void tDattorroReverb_freeFromPool (tDattorroReverb* const, tMempool* const);
147
148	void tDattorroReverb_clear (tDattorroReverb* const);
149	float tDattorroReverb_tick (tDattorroReverb* const, float input);
150	void tDattorroReverb_tickStereo (tDattorroReverb* const rev, float input, float* output);
151	void tDattorroReverb_setMix (tDattorroReverb* const, float mix);
152	void tDattorroReverb_setFreeze (tDattorroReverb* const rev, uint32_t freeze);
153	void tDattorroReverb_setHP (tDattorroReverb* const, float freq);
154	void tDattorroReverb_setSize (tDattorroReverb* const, float size);
155	void tDattorroReverb_setInputDelay (tDattorroReverb* const, float preDelay);
156	void tDattorroReverb_setInputFilter (tDattorroReverb* const, float freq);
157	void tDattorroReverb_setFeedbackFilter (tDattorroReverb* const, float freq);
158	void tDattorroReverb_setFeedbackGain (tDattorroReverb* const, float gain);
159
160	#ifdef __cplusplus
161	}
162	#endif
163
164	#endif // LEAF_REVERB_H_INCLUDED
165
166	//==============================================================================
167

LEAF/Inc/leaf-sampling.h+0−176

@@ -1,176 +0,0 @@
1	/*==============================================================================
2
3	leaf-sampling.h
4	Created: 23 Jan 2019 11:22:09am
5	Author: Mike Mulshine
6
7	==============================================================================*/
8
9
10	#ifndef LEAF_SAMPLING_H_INCLUDED
11	#define LEAF_SAMPLING_H_INCLUDED
12
13	#ifdef __cplusplus
14	extern "C" {
15	#endif
16
17	//==============================================================================
18
19	#include "leaf-global.h"
20	#include "leaf-math.h"
21	#include "leaf-mempool.h"
22	#include "leaf-envelopes.h"
23	#include "leaf-mempool.h"
24	#include "leaf-analysis.h"
25
26	//==============================================================================
27
28	typedef enum RecordMode
29	{
30	RecordOneShot = 0,
31	RecordLoop,
32	RecordModeNil
33	} RecordMode;
34
35	typedef struct _tBuffer
36	{
37	float* buff;
38
39	uint32_t idx;
40	uint32_t bufferLength;
41	uint32_t recordedLength;
42	RecordMode mode;
43
44	int active;
45
46	} _tBuffer;
47
48	typedef _tBuffer* tBuffer;
49
50	void tBuffer_init (tBuffer* const, uint32_t length);
51	void tBuffer_free (tBuffer* const);
52	void tBuffer_initToPool (tBuffer* const, uint32_t length, tMempool* const);
53	void tBuffer_freeFromPool (tBuffer* const, tMempool* const);
54
55	void tBuffer_tick (tBuffer* const, float sample);
56
57	void tBuffer_read (tBuffer* const, float* buff, uint32_t len);
58
59	float tBuffer_get (tBuffer* const, int idx);
60
61	void tBuffer_record (tBuffer* const);
62	void tBuffer_stop (tBuffer* const);
63	int tBuffer_getRecordPosition (tBuffer* const);
64
65	void tBuffer_setRecordMode (tBuffer* const, RecordMode mode);
66
67	void tBuffer_clear (tBuffer* const);
68
69	uint32_t tBuffer_getBufferLength (tBuffer* const);
70	uint32_t tBuffer_getRecordedLength (tBuffer* const sb);
71
72	//==============================================================================
73
74	typedef enum PlayMode
75	{
76	PlayNormal,
77	PlayLoop,
78	PlayBackAndForth,
79	PlayModeNil
80	} PlayMode;
81
82	typedef struct _tSampler
83	{
84	tBuffer samp;
85
86	tRamp gain;
87
88	float idx;
89	float inc;
90	float last;
91	float iinc;
92	int8_t dir;
93	int8_t flip;
94	int8_t bnf;
95
96	int32_t start, targetstart;
97	int32_t end, targetend;
98
99	uint32_t len;
100	uint32_t cfxlen;
101	float numticks;
102	PlayMode mode;
103	int retrigger;
104
105	int active;
106
107	} _tSampler;
108
109	typedef _tSampler* tSampler;
110
111	void tSampler_init (tSampler* const, tBuffer* const);
112	void tSampler_free (tSampler* const);
113	void tSampler_initToPool (tSampler* const, tBuffer* const, tMempool* const);
114	void tSampler_freeFromPool (tSampler* const, tMempool* const);
115
116	float tSampler_tick (tSampler* const);
117
118	void tSampler_setSample (tSampler* const, tBuffer* const);
119
120	void tSampler_setMode (tSampler* const, PlayMode mode);
121
122	void tSampler_play (tSampler* const);
123	void tSampler_stop (tSampler* const);
124
125	void tSampler_setStart (tSampler* const, int32_t start);
126	void tSampler_setEnd (tSampler* const, int32_t end);
127
128	static void handleStartEndChange (tSampler* const sp);
129
130	void tSampler_setCrossfadeLength (tSampler* const sp, uint32_t length);
131
132	void tSampler_setRate (tSampler* const, float rate);
133
134	//==============================================================================
135
136	typedef struct _tAutoSampler
137	{
138	tSampler sampler;
139	tEnvelopeFollower ef;
140	uint32_t windowSize;
141	float threshold;
142	float previousPower;
143	uint32_t sampleCounter;
144	uint32_t powerCounter;
145	uint8_t sampleTriggered;
146	} _tAutoSampler;
147
148	typedef _tAutoSampler* tAutoSampler;
149
150	void tAutoSampler_init (tAutoSampler* const, tBuffer* const);
151	void tAutoSampler_free (tAutoSampler* const);
152	void tAutoSampler_initToPool (tAutoSampler* const, tBuffer* const, tMempool* const);
153	void tAutoSampler_freeFromPool (tAutoSampler* const, tMempool* const);
154
155	float tAutoSampler_tick (tAutoSampler* const, float input);
156
157	void tAutoSampler_setBuffer (tAutoSampler* const, tBuffer* const);
158
159	void tAutoSampler_setMode (tAutoSampler* const, PlayMode mode);
160
161	void tAutoSampler_play (tAutoSampler* const);
162	void tAutoSampler_stop (tAutoSampler* const);
163
164	void tAutoSampler_setThreshold (tAutoSampler* const, float thresh);
165	void tAutoSampler_setWindowSize (tAutoSampler* const, uint32_t size);
166	void tAutoSampler_setCrossfadeLength (tAutoSampler* const, uint32_t length);
167
168	void tAutoSampler_setRate (tAutoSampler* const, float rate);
169
170	#ifdef __cplusplus
171	}
172	#endif
173
174	#endif // LEAF_SAMPLING_H_INCLUDED
175
176	//==============================================================================

LEAF/Inc/leaf-tables.h+0−100

@@ -1,100 +0,0 @@
1	/*==============================================================================
2
3	leaf-tables.h
4	Created: 4 Dec 2016 9:42:41pm
5	Author: Michael R Mulshine
6
7	==============================================================================*/
8
9	#ifndef LEAF_TABLES_H_INCLUDED
10	#define LEAF_TABLES_H_INCLUDED
11
12	#ifdef __cplusplus
13	extern "C" {
14	#endif
15
16	//==============================================================================
17
18	#include "leaf-math.h"
19
20	//==============================================================================
21
22
23	#define SINE_TABLE_SIZE 2048
24	#define SAW_TABLE_SIZE 2048
25	#define SQR_TABLE_SIZE 2048
26	#define TRI_TABLE_SIZE 2048
27	#define EXP_DECAY_TABLE_SIZE 65536
28	#define ATTACK_DECAY_INC_TABLE_SIZE 65536
29	#define TANH1_TABLE_SIZE 65536
30	#define DECAY_COEFF_TABLE_SIZE 4096
31	#define MTOF1_TABLE_SIZE 4096
32	#define FILTERTAN_TABLE_SIZE 4096
33
34	#define SHAPER1_TABLE_SIZE 65536
35	extern const float shaper1[SHAPER1_TABLE_SIZE];
36
37	#define COEFFS_SIZE 32
38	extern const float* firCoeffs[COEFFS_SIZE];
39	extern const float firNumTaps[COEFFS_SIZE];
40	extern const float fir2XLow[32];
41	extern const float fir4XLow[64];
42	extern const float fir8XLow[64];
43	extern const float fir16XLow[128];
44	extern const float fir32XLow[256];
45	extern const float fir64XLow[256];
46	extern const float fir2XHigh[128];
47	extern const float fir4XHigh[256];
48	extern const float fir8XHigh[256];
49	extern const float fir16XHigh[512];
50	extern const float fir32XHigh[512];
51	extern const float fir64XHigh[1024];
52
53	typedef enum TableName
54	{
55	T20 = 0,
56	T40,
57	T80,
58	T160,
59	T320,
60	T640,
61	T1280,
62	T2560,
63	T5120,
64	T10240,
65	T20480,
66	TableNameNil
67	} TableName;
68
69	// mtof lookup table based on input range [0.0,1.0) in 4096 increments - midi frequency values scaled between m25 and m134 (from the Snyderphonics DrumBox code)
70
71	extern const float exp_decay[EXP_DECAY_TABLE_SIZE];
72	extern const float attack_decay_inc[ATTACK_DECAY_INC_TABLE_SIZE];
73
74	extern const float filtertan[FILTERTAN_TABLE_SIZE];
75
76	extern const float mtof1[MTOF1_TABLE_SIZE];
77	extern const float decayCoeffTable[DECAY_COEFF_TABLE_SIZE];
78
79	extern const float tanh1[TANH1_TABLE_SIZE];
80
81	//==============================================================================
82
83	/* Sine wave table ripped from http://aquaticus.info/pwm-sine-wave. */
84	extern const float sinewave[SINE_TABLE_SIZE];
85
86	extern const float sawtooth[11][SAW_TABLE_SIZE];
87
88	extern const float triangle[11][TRI_TABLE_SIZE];
89
90	extern const float squarewave[11][SQR_TABLE_SIZE];
91
92	//==============================================================================
93
94	#ifdef __cplusplus
95	}
96	#endif
97
98	#endif // LEAF_TABLES_H_INCLUDED
99
100	//==============================================================================

LEAF/Inc/main.h+81−0

@@ -0,0 +1,81 @@
	1	/* USER CODE BEGIN Header */
	2	/**
	3	******************************************************************************
	4	* @file : main.h
	5	* @brief : Header for main.c file.
	6	* This file contains the common defines of the application.
	7	******************************************************************************
	8	* @attention
	9	*
	10	* <h2><center>© Copyright (c) 2019 STMicroelectronics.
	11	* All rights reserved.</center></h2>
	12	*
	13	* This software component is licensed by ST under Ultimate Liberty license
	14	* SLA0044, the "License"; You may not use this file except in compliance with
	15	* the License. You may obtain a copy of the License at:
	16	* www.st.com/SLA0044
	17	*
	18	******************************************************************************
	19	*/
	20	/* USER CODE END Header */
	21
	22	/* Define to prevent recursive inclusion -------------------------------------*/
	23	#ifndef __MAIN_H
	24	#define __MAIN_H
	25
	26	#ifdef __cplusplus
	27	extern "C" {
	28	#endif
	29
	30	/* Includes ------------------------------------------------------------------*/
	31	#include "stm32h7xx_hal.h"
	32	#include "stm32h7xx_hal.h"
	33
	34	/* Private includes ----------------------------------------------------------*/
	35	/* USER CODE BEGIN Includes */
	36
	37	/* USER CODE END Includes */
	38
	39	/* Exported types ------------------------------------------------------------*/
	40	/* USER CODE BEGIN ET */
	41
	42	/* USER CODE END ET */
	43
	44	/* Exported constants --------------------------------------------------------*/
	45	/* USER CODE BEGIN EC */
	46
	47	/* USER CODE END EC */
	48
	49	/* Exported macro ------------------------------------------------------------*/
	50	/* USER CODE BEGIN EM */
	51	#define __ATTR_RAM_D1 __attribute__ ((section(".RAM_D1"))) __attribute__ ((aligned (32)))
	52	#define __ATTR_RAM_D2 __attribute__ ((section(".RAM_D2"))) __attribute__ ((aligned (32)))
	53	#define __ATTR_RAM_D3 __attribute__ ((section(".RAM_D3"))) __attribute__ ((aligned (32)))
	54	#define __ATTR_SDRAM __attribute__ ((section(".SDRAM"))) __attribute__ ((aligned (32)))
	55
	56	#define STM32 // define this so that LEAF knows you are building for STM32
	57	/* USER CODE END EM */
	58
	59	/* Exported functions prototypes ---------------------------------------------*/
	60	void Error_Handler(void);
	61
	62	/* USER CODE BEGIN EFP */
	63	float randomNumber(void);
	64	static void HardFault_Handler(void) __attribute__ ((naked));
	65	void prvGetRegistersFromStack( uint32_t *pulFaultStackAddress );
	66	void writeIntToFlash(uint32_t data, uint32_t location);
	67	uint32_t readIntFromFlash (uint32_t location);
	68	/* USER CODE END EFP */
	69
	70	/* Private defines -----------------------------------------------------------*/
	71	/* USER CODE BEGIN Private defines */
	72
	73	/* USER CODE END Private defines */
	74
	75	#ifdef __cplusplus
	76	}
	77	#endif
	78
	79	#endif /* __MAIN_H */
	80
	81	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

LEAF/Inc/oled.h+90−0

@@ -0,0 +1,90 @@
	1	/*
	2	* oled.h
	3	*
	4	* Created on: Feb 05, 2020
	5	* Author: Matthew Wang
	6	*/
	7
	8	#ifndef OLED_H_
	9	#define OLED_H_
	10
	11	extern char oled_buffer[32];
	12
	13	typedef enum _OLEDLine
	14	{
	15	FirstLine = 0,
	16	SecondLine,
	17	BothLines,
	18	NilLine
	19	} OLEDLine;
	20
	21	void OLED_init(I2C_HandleTypeDef* hi2c);
	22
	23	void initUIFunctionPointers(void);
	24
	25	void setLED_Edit(uint8_t onOff);
	26
	27	void setLED_USB(uint8_t onOff);
	28
	29	void setLED_1(uint8_t onOff);
	30
	31	void setLED_2(uint8_t onOff);
	32
	33	void setLED_A(uint8_t onOff);
	34
	35	void setLED_B(uint8_t onOff);
	36
	37	void setLED_C(uint8_t onOff);
	38
	39	void setLED_leftout_clip(uint8_t onOff);
	40
	41	void setLED_rightout_clip(uint8_t onOff);
	42
	43	void setLED_leftin_clip(uint8_t onOff);
	44
	45	void setLED_rightin_clip(uint8_t onOff);
	46
	47	int getCursorX(void);
	48
	49	void OLED_process(void);
	50
	51	void OLED_writePreset(void);
	52
	53	void OLED_writeEditScreen(void);
	54
	55	void OLED_writeKnobParameter(uint8_t whichParam);
	56
	57	void OLED_writeButtonAction(uint8_t whichButton, uint8_t whichAction);
	58
	59	void OLED_writeTuning(void);
	60
	61	void OLED_draw(void);
	62
	63	void OLEDclear(void);
	64
	65	void OLEDclearLine(OLEDLine line);
	66
	67	void OLEDwriteString(char* myCharArray, uint8_t arrayLength, uint8_t startCursor, OLEDLine line);
	68
	69	void OLEDwriteLine(char* myCharArray, uint8_t arrayLength, OLEDLine line);
	70
	71	void OLEDwriteInt(uint32_t myNumber, uint8_t numDigits, uint8_t startCursor, OLEDLine line);
	72
	73	void OLEDwriteIntLine(uint32_t myNumber, uint8_t numDigits, OLEDLine line);
	74
	75	void OLEDwritePitch(float midi, uint8_t startCursor, OLEDLine line);
	76
	77	void OLEDwritePitchClass(float midi, uint8_t startCursor, OLEDLine line);
	78
	79	void OLEDwritePitchLine(float midi, OLEDLine line);
	80
	81	void OLEDwriteFixedFloat(float input, uint8_t numDigits, uint8_t numDecimal, uint8_t startCursor, OLEDLine line);
	82
	83	void OLEDwriteFixedFloatLine(float input, uint8_t numDigits, uint8_t numDecimal, OLEDLine line);
	84
	85	void OLEDwriteFloat(float input, uint8_t startCursor, OLEDLine line);
	86
	87	void OLEDdrawFloatArray(float* input, float min, float max, uint8_t size, uint8_t offset, uint8_t startCursor, OLEDLine line);
	88
	89	#endif /* OLED_H_ */
	90

LEAF/Inc/rng.h+58−0

@@ -0,0 +1,58 @@
	1	/**
	2	******************************************************************************
	3	* File Name : RNG.h
	4	* Description : This file provides code for the configuration
	5	* of the RNG instances.
	6	******************************************************************************
	7	* @attention
	8	*
	9	* <h2><center>© Copyright (c) 2020 STMicroelectronics.
	10	* All rights reserved.</center></h2>
	11	*
	12	* This software component is licensed by ST under Ultimate Liberty license
	13	* SLA0044, the "License"; You may not use this file except in compliance with
	14	* the License. You may obtain a copy of the License at:
	15	* www.st.com/SLA0044
	16	*
	17	******************************************************************************
	18	*/
	19	/* Define to prevent recursive inclusion -------------------------------------*/
	20	#ifndef __rng_H
	21	#define __rng_H
	22	#ifdef __cplusplus
	23	extern "C" {
	24	#endif
	25
	26	/* Includes ------------------------------------------------------------------*/
	27	#include "main.h"
	28
	29	/* USER CODE BEGIN Includes */
	30
	31	/* USER CODE END Includes */
	32
	33	extern RNG_HandleTypeDef hrng;
	34
	35	/* USER CODE BEGIN Private defines */
	36
	37	/* USER CODE END Private defines */
	38
	39	void MX_RNG_Init(void);
	40
	41	/* USER CODE BEGIN Prototypes */
	42
	43	/* USER CODE END Prototypes */
	44
	45	#ifdef __cplusplus
	46	}
	47	#endif
	48	#endif /__ rng_H /
	49
	50	/**
	51	* @}
	52	*/
	53
	54	/**
	55	* @}
	56	*/
	57
	58	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

LEAF/Inc/sai.h+59−0

@@ -0,0 +1,59 @@
	1	/**
	2	******************************************************************************
	3	* File Name : SAI.h
	4	* Description : This file provides code for the configuration
	5	* of the SAI instances.
	6	******************************************************************************
	7	* @attention
	8	*
	9	* <h2><center>© Copyright (c) 2020 STMicroelectronics.
	10	* All rights reserved.</center></h2>
	11	*
	12	* This software component is licensed by ST under Ultimate Liberty license
	13	* SLA0044, the "License"; You may not use this file except in compliance with
	14	* the License. You may obtain a copy of the License at:
	15	* www.st.com/SLA0044
	16	*
	17	******************************************************************************
	18	*/
	19	/* Define to prevent recursive inclusion -------------------------------------*/
	20	#ifndef __sai_H
	21	#define __sai_H
	22	#ifdef __cplusplus
	23	extern "C" {
	24	#endif
	25
	26	/* Includes ------------------------------------------------------------------*/
	27	#include "main.h"
	28
	29	/* USER CODE BEGIN Includes */
	30
	31	/* USER CODE END Includes */
	32
	33	extern SAI_HandleTypeDef hsai_BlockA1;
	34	extern SAI_HandleTypeDef hsai_BlockB1;
	35
	36	/* USER CODE BEGIN Private defines */
	37
	38	/* USER CODE END Private defines */
	39
	40	void MX_SAI1_Init(void);
	41
	42	/* USER CODE BEGIN Prototypes */
	43
	44	/* USER CODE END Prototypes */
	45
	46	#ifdef __cplusplus
	47	}
	48	#endif
	49	#endif /__ sai_H /
	50
	51	/**
	52	* @}
	53	*/
	54
	55	/**
	56	* @}
	57	*/
	58
	59	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

LEAF/Inc/sd_diskio.h+45−0

@@ -0,0 +1,45 @@
	1	/* USER CODE BEGIN Header */
	2	/**
	3	******************************************************************************
	4	* @file sd_diskio.h
	5	* @brief Header for sd_diskio.c module
	6	******************************************************************************
	7	* @attention
	8	*
	9	* <h2><center>© Copyright (c) 2019 STMicroelectronics.
	10	* All rights reserved.</center></h2>
	11	*
	12	* This software component is licensed by ST under Ultimate Liberty license
	13	* SLA0044, the "License"; You may not use this file except in compliance with
	14	* the License. You may obtain a copy of the License at:
	15	* www.st.com/SLA0044
	16	*
	17	******************************************************************************
	18	*/
	19	/* USER CODE END Header */
	20
	21	/* Note: code generation based on sd_diskio_template.h */
	22
	23	/* Define to prevent recursive inclusion -------------------------------------*/
	24	#ifndef __SD_DISKIO_H
	25	#define __SD_DISKIO_H
	26
	27	/* USER CODE BEGIN firstSection */
	28	/* can be used to modify / undefine following code or add new definitions */
	29	/* USER CODE END firstSection */
	30
	31	/* Includes ------------------------------------------------------------------*/
	32	#include "bsp_driver_sd.h"
	33	/* Exported types ------------------------------------------------------------*/
	34	/* Exported constants --------------------------------------------------------*/
	35	/* Exported functions ------------------------------------------------------- */
	36	extern const Diskio_drvTypeDef SD_Driver;
	37
	38	/* USER CODE BEGIN lastSection */
	39	/* can be used to modify / undefine previous code or add new definitions */
	40	/* USER CODE END lastSection */
	41
	42	#endif /* __SD_DISKIO_H */
	43
	44	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/
	45

LEAF/Inc/sdmmc.h+58−0

@@ -0,0 +1,58 @@
	1	/**
	2	******************************************************************************
	3	* File Name : SDMMC.h
	4	* Description : This file provides code for the configuration
	5	* of the SDMMC instances.
	6	******************************************************************************
	7	* @attention
	8	*
	9	* <h2><center>© Copyright (c) 2020 STMicroelectronics.
	10	* All rights reserved.</center></h2>
	11	*
	12	* This software component is licensed by ST under Ultimate Liberty license
	13	* SLA0044, the "License"; You may not use this file except in compliance with
	14	* the License. You may obtain a copy of the License at:
	15	* www.st.com/SLA0044
	16	*
	17	******************************************************************************
	18	*/
	19	/* Define to prevent recursive inclusion -------------------------------------*/
	20	#ifndef __sdmmc_H
	21	#define __sdmmc_H
	22	#ifdef __cplusplus
	23	extern "C" {
	24	#endif
	25
	26	/* Includes ------------------------------------------------------------------*/
	27	#include "main.h"
	28
	29	/* USER CODE BEGIN Includes */
	30
	31	/* USER CODE END Includes */
	32
	33	extern SD_HandleTypeDef hsd1;
	34
	35	/* USER CODE BEGIN Private defines */
	36
	37	/* USER CODE END Private defines */
	38
	39	void MX_SDMMC1_SD_Init(void);
	40
	41	/* USER CODE BEGIN Prototypes */
	42
	43	/* USER CODE END Prototypes */
	44
	45	#ifdef __cplusplus
	46	}
	47	#endif
	48	#endif /__ sdmmc_H /
	49
	50	/**
	51	* @}
	52	*/
	53
	54	/**
	55	* @}
	56	*/
	57
	58	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

LEAF/Inc/sfx.h+177−0

@@ -0,0 +1,177 @@
	1	/*
	2	* sfx.h
	3	*
	4	* Created on: Dec 23, 2019
	5	* Author: josnyder
	6	*/
	7	#ifndef SFX_H_
	8	#define SFX_H_
	9
	10	#include "audiostream.h"
	11	#include "ui.h"
	12
	13	#define NUM_VOC_VOICES 8
	14	#define NUM_OSC_PER_VOICE 3
	15	#define NUM_VOC_OSC 1
	16	#define INV_NUM_VOC_VOICES 0.125
	17	#define INV_NUM_VOC_OSC 1
	18	#define NUM_AUTOTUNE 2
	19	#define NUM_RETUNE 1
	20	#define OVERSAMPLER_RATIO 8
	21	#define OVERSAMPLER_HQ FALSE
	22
	23	extern float presetKnobValues[PresetNil][NUM_ADC_CHANNELS];
	24	extern uint8_t knobActive[NUM_ADC_CHANNELS];
	25
	26	extern tPoly poly;
	27	extern tRamp polyRamp[NUM_VOC_VOICES];
	28	extern tSawtooth osc[NUM_VOC_VOICES * NUM_OSC_PER_VOICE];
	29
	30	extern PlayMode samplerMode;
	31	extern float sampleLength;
	32
	33	extern uint32_t freeze;
	34
	35	void initGlobalSFXObjects();
	36
	37	//1 vocoder internal poly
	38	extern uint8_t numVoices;
	39	extern uint8_t internalExternal;
	40
	41	void SFXVocoderAlloc();
	42	void SFXVocoderFrame();
	43	void SFXVocoderTick(float audioIn);
	44	void SFXVocoderFree(void);
	45
	46	//4 pitch shift
	47	void SFXPitchShiftAlloc();
	48	void SFXPitchShiftFrame();
	49	void SFXPitchShiftTick(float audioIn);
	50	void SFXPitchShiftFree(void);
	51
	52	//5 neartune
	53	extern uint8_t autotuneChromatic;
	54
	55	void SFXNeartuneAlloc();
	56	void SFXNeartuneFrame();
	57	void SFXNeartuneTick(float audioIn);
	58	void SFXNeartuneFree(void);
	59
	60	//6 autotune
	61	void SFXAutotuneAlloc();
	62	void SFXAutotuneFrame();
	63	void SFXAutotuneTick(float audioIn);
	64	void SFXAutotuneFree(void);
	65
	66	//7 sampler - button press
	67	extern uint8_t samplePlaying;
	68
	69	void SFXSamplerBPAlloc();
	70	void SFXSamplerBPFrame();
	71	void SFXSamplerBPTick(float audioIn);
	72	void SFXSamplerBPFree(void);
	73
	74
	75	//8 sampler - auto ch1
	76	extern uint8_t triggerChannel;
	77
	78	void SFXSamplerAutoAlloc();
	79	void SFXSamplerAutoFrame();
	80	void SFXSamplerAutoTick(float audioIn);
	81	void SFXSamplerAutoFree(void);
	82
	83	//10 distortion tanh
	84	extern uint8_t distortionMode;
	85
	86	void SFXDistortionAlloc();
	87	void SFXDistortionFrame();
	88	void SFXDistortionTick(float audioIn);
	89	void SFXDistortionFree(void);
	90
	91	//12 distortion wave folder
	92	void SFXWaveFolderAlloc();
	93	void SFXWaveFolderFrame();
	94	void SFXWaveFolderTick(float audioIn);
	95	void SFXWaveFolderFree(void);
	96
	97
	98	//13 bitcrusher
	99	void SFXBitcrusherAlloc();
	100	void SFXBitcrusherFrame();
	101	void SFXBitcrusherTick(float audioIn);
	102	void SFXBitcrusherFree(void);
	103
	104
	105	//14 delay
	106	extern int delayShaper;
	107
	108	void SFXDelayAlloc();
	109	void SFXDelayFrame();
	110	void SFXDelayTick(float audioIn);
	111	void SFXDelayFree(void);
	112
	113
	114	//15 reverb
	115	void SFXReverbAlloc();
	116	void SFXReverbFrame();
	117	void SFXReverbTick(float audioIn);
	118	void SFXReverbFree(void);
	119
	120	//16 reverb2
	121	void SFXReverb2Alloc();
	122	void SFXReverb2Frame();
	123	void SFXReverb2Tick(float audioIn);
	124	void SFXReverb2Free(void);
	125
	126	//17 living string
	127	void SFXLivingStringAlloc();
	128	void SFXLivingStringFrame();
	129	void SFXLivingStringTick(float audioIn);
	130	void SFXLivingStringFree(void);
	131
	132	//17 living string
	133	void SFXLivingStringSynthAlloc();
	134	void SFXLivingStringSynthFrame();
	135	void SFXLivingStringSynthTick(float audioIn);
	136	void SFXLivingStringSynthFree(void);
	137
	138
	139	//17 living string
	140	void SFXClassicSynthAlloc();
	141	void SFXClassicSynthFrame();
	142	void SFXClassicSynthTick(float audioIn);
	143	void SFXClassicSynthFree(void);
	144
	145
	146	//17 living string
	147	void SFXRhodesAlloc();
	148	void SFXRhodesFrame();
	149	void SFXRhodesTick(float audioIn);
	150	void SFXRhodesFree(void);
	151
	152
	153	// MIDI FUNCTIONS
	154	void noteOn(int key, int velocity);
	155	void noteOff(int key, int velocity);
	156	void pitchBend(int data);
	157	void sustainOn(void);
	158	void sustainOff(void);
	159	void toggleBypass(void);
	160	void toggleSustain(void);
	161
	162	void calculateFreq(int voice);
	163
	164	float calculateTunedMidiNote(float tempNote);
	165
	166
	167	void calculateNoteArray(void);
	168	//void calculatePeriodArray(void);
	169	float nearestNote(float period);
	170	//float nearestPeriod(float period);
	171
	172	void clearNotes(void);
	173
	174	void ctrlInput(int ctrl, int value);
	175
	176
	177	#endif /* SFX_H_ */

LEAF/Inc/ssd1306.h+127−0

@@ -0,0 +1,127 @@
	1
	2	/*
	3	* ssd1306.h
	4	*
	5	* Created on: Jul 6, 2018
	6	* Author: jeffsnyder
	7	*/
	8	#include "stm32h7xx_hal.h"
	9	#include "main.h"
	10
	11	#ifndef SSD1306_H_
	12	#define SSD1306_H_
	13
	14	#define pgm_read_byte(addr) ((const unsigned char )(addr))
	15
	16	#define BLACK 0
	17	#define WHITE 1
	18	#define INVERSE 2
	19
	20	#define SSD1306_I2C_ADDRESS (0x3C<<1) // 011110+SA0+RW - 0x3C or 0x3D
	21	// Address for 128x32 is 0x3C
	22	// Address for 128x64 is 0x3D (default) or 0x3C (if SA0 is grounded)
	23
	24	/*=========================================================================
	25	SSD1306 Displays
	26	-----------------------------------------------------------------------
	27	The driver is used in multiple displays (128x64, 128x32, etc.).
	28	Select the appropriate display below to create an appropriately
	29	sized framebuffer, etc.
	30
	31	SSD1306_128_64 128x64 pixel display
	32
	33	SSD1306_128_32 128x32 pixel display
	34
	35	SSD1306_96_16
	36
	37	-----------------------------------------------------------------------*/
	38	// #define SSD1306_128_64
	39	#define SSD1306_128_32
	40	// #define SSD1306_96_16
	41	/=========================================================================/
	42
	43	#if defined SSD1306_128_64 && defined SSD1306_128_32
	44	#error "Only one SSD1306 display can be specified at once in SSD1306.h"
	45	#endif
	46	#if !defined SSD1306_128_64 && !defined SSD1306_128_32 && !defined SSD1306_96_16
	47	#error "At least one SSD1306 display must be specified in SSD1306.h"
	48	#endif
	49
	50	#if defined SSD1306_128_64
	51	#define SSD1306_LCDWIDTH 128
	52	#define SSD1306_LCDHEIGHT 64
	53	#endif
	54	#if defined SSD1306_128_32
	55	#define SSD1306_LCDWIDTH 128
	56	#define SSD1306_LCDHEIGHT 32
	57	#endif
	58	#if defined SSD1306_96_16
	59	#define SSD1306_LCDWIDTH 96
	60	#define SSD1306_LCDHEIGHT 16
	61	#endif
	62
	63	#define SSD1306_SETCONTRAST 0x81
	64	#define SSD1306_DISPLAYALLON_RESUME 0xA4
	65	#define SSD1306_DISPLAYALLON 0xA5
	66	#define SSD1306_NORMALDISPLAY 0xA6
	67	#define SSD1306_INVERTDISPLAY 0xA7
	68	#define SSD1306_DISPLAYOFF 0xAE
	69	#define SSD1306_DISPLAYON 0xAF
	70
	71	#define SSD1306_SETDISPLAYOFFSET 0xD3
	72	#define SSD1306_SETCOMPINS 0xDA
	73
	74	#define SSD1306_SETVCOMDETECT 0xDB
	75
	76	#define SSD1306_SETDISPLAYCLOCKDIV 0xD5
	77	#define SSD1306_SETPRECHARGE 0xD9
	78
	79	#define SSD1306_SETMULTIPLEX 0xA8
	80
	81	#define SSD1306_SETLOWCOLUMN 0x00
	82	#define SSD1306_SETHIGHCOLUMN 0x10
	83
	84	#define SSD1306_SETSTARTLINE 0x40
	85
	86	#define SSD1306_MEMORYMODE 0x20
	87	#define SSD1306_COLUMNADDR 0x21
	88	#define SSD1306_PAGEADDR 0x22
	89
	90	#define SSD1306_COMSCANINC 0xC0
	91	#define SSD1306_COMSCANDEC 0xC8
	92
	93	#define SSD1306_SEGREMAP 0xA0
	94
	95	#define SSD1306_CHARGEPUMP 0x8D
	96
	97	#define SSD1306_EXTERNALVCC 0x1
	98	#define SSD1306_SWITCHCAPVCC 0x2
	99
	100	// Scrolling #defines
	101	#define SSD1306_ACTIVATE_SCROLL 0x2F
	102	#define SSD1306_DEACTIVATE_SCROLL 0x2E
	103	#define SSD1306_SET_VERTICAL_SCROLL_AREA 0xA3
	104	#define SSD1306_RIGHT_HORIZONTAL_SCROLL 0x26
	105	#define SSD1306_LEFT_HORIZONTAL_SCROLL 0x27
	106	#define SSD1306_VERTICAL_AND_RIGHT_HORIZONTAL_SCROLL 0x29
	107	#define SSD1306_VERTICAL_AND_LEFT_HORIZONTAL_SCROLL 0x2A
	108
	109	extern unsigned char buffer [];
	110
	111	void ssd1306_begin(I2C_HandleTypeDef* hi2c, uint8_t vccstate, uint8_t i2caddr);
	112	void ssd1306_drawPixel(int16_t x, int16_t y, uint16_t color);
	113	void sdd1306_invertDisplay(uint8_t i);
	114	void ssd1306_command(uint8_t c);
	115	void ssd1306_dim(uint8_t dim);
	116	void ssd1306_display_full_buffer(void);
	117	void ssd1306_display(void);
	118	void ssd1306_write(uint8_t* data, uint16_t numBytes);
	119	void ssd1306_move(uint8_t row, uint8_t column);
	120	void ssd1306_move_raw(uint8_t row, uint8_t column);
	121	void ssd1306_home(void);
	122
	123
	124
	125
	126
	127	#endif /* SSD1306_H_ */

LEAF/Inc/stm32h7xx_hal_conf.h+493−0

@@ -0,0 +1,493 @@
	1	/**
	2	******************************************************************************
	3	* @file stm32h7xx_hal_conf.h
	4	* @author MCD Application Team
	5	* @brief HAL configuration file.
	6	******************************************************************************
	7	* @attention
	8	*
	9	* <h2><center>© Copyright (c) 2017 STMicroelectronics.
	10	* All rights reserved.</center></h2>
	11	*
	12	* This software component is licensed by ST under BSD 3-Clause license,
	13	* the "License"; You may not use this file except in compliance with the
	14	* License. You may obtain a copy of the License at:
	15	* opensource.org/licenses/BSD-3-Clause
	16	*
	17	******************************************************************************
	18	*/
	19
	20	/* Define to prevent recursive inclusion -------------------------------------*/
	21	#ifndef __STM32H7xx_HAL_CONF_H
	22	#define __STM32H7xx_HAL_CONF_H
	23
	24	#ifdef __cplusplus
	25	extern "C" {
	26	#endif
	27
	28	/* Exported types ------------------------------------------------------------*/
	29	/* Exported constants --------------------------------------------------------*/
	30
	31	/* ########################## Module Selection ############################## */
	32	/**
	33	* @brief This is the list of modules to be used in the HAL driver
	34	*/
	35	#define HAL_MODULE_ENABLED
	36
	37	#define HAL_ADC_MODULE_ENABLED
	38	/* #define HAL_FDCAN_MODULE_ENABLED */
	39	/* #define HAL_CEC_MODULE_ENABLED */
	40	/* #define HAL_COMP_MODULE_ENABLED */
	41	/* #define HAL_CRC_MODULE_ENABLED */
	42	/* #define HAL_CRYP_MODULE_ENABLED */
	43	/* #define HAL_DAC_MODULE_ENABLED */
	44	/* #define HAL_DCMI_MODULE_ENABLED */
	45	/* #define HAL_DMA2D_MODULE_ENABLED */
	46	/* #define HAL_ETH_MODULE_ENABLED */
	47	/* #define HAL_NAND_MODULE_ENABLED */
	48	/* #define HAL_NOR_MODULE_ENABLED */
	49	/* #define HAL_OTFDEC_MODULE_ENABLED */
	50	/* #define HAL_SRAM_MODULE_ENABLED */
	51	#define HAL_SDRAM_MODULE_ENABLED
	52	/* #define HAL_HASH_MODULE_ENABLED */
	53	/* #define HAL_HRTIM_MODULE_ENABLED */
	54	/* #define HAL_HSEM_MODULE_ENABLED */
	55	/* #define HAL_GFXMMU_MODULE_ENABLED */
	56	/* #define HAL_JPEG_MODULE_ENABLED */
	57	/* #define HAL_OPAMP_MODULE_ENABLED */
	58	/* #define HAL_OSPI_MODULE_ENABLED */
	59	/* #define HAL_OSPI_MODULE_ENABLED */
	60	/* #define HAL_I2S_MODULE_ENABLED */
	61	/* #define HAL_SMBUS_MODULE_ENABLED */
	62	/* #define HAL_IWDG_MODULE_ENABLED */
	63	/* #define HAL_LPTIM_MODULE_ENABLED */
	64	/* #define HAL_LTDC_MODULE_ENABLED */
	65	/* #define HAL_QSPI_MODULE_ENABLED */
	66	#define HAL_RNG_MODULE_ENABLED
	67	/* #define HAL_RTC_MODULE_ENABLED */
	68	#define HAL_SAI_MODULE_ENABLED
	69	#define HAL_SD_MODULE_ENABLED
	70	/* #define HAL_MMC_MODULE_ENABLED */
	71	/* #define HAL_SPDIFRX_MODULE_ENABLED */
	72	/* #define HAL_SPI_MODULE_ENABLED */
	73	/* #define HAL_SWPMI_MODULE_ENABLED */
	74	#define HAL_TIM_MODULE_ENABLED
	75	/* #define HAL_UART_MODULE_ENABLED */
	76	/* #define HAL_USART_MODULE_ENABLED */
	77	/* #define HAL_IRDA_MODULE_ENABLED */
	78	/* #define HAL_SMARTCARD_MODULE_ENABLED */
	79	/* #define HAL_WWDG_MODULE_ENABLED */
	80	/* #define HAL_PCD_MODULE_ENABLED */
	81	#define HAL_HCD_MODULE_ENABLED
	82	/* #define HAL_DFSDM_MODULE_ENABLED */
	83	/* #define HAL_DSI_MODULE_ENABLED */
	84	/* #define HAL_JPEG_MODULE_ENABLED */
	85	/* #define HAL_MDIOS_MODULE_ENABLED */
	86	/* #define HAL_PSSI_MODULE_ENABLED */
	87	/* #define HAL_DTS_MODULE_ENABLED */
	88	#define HAL_GPIO_MODULE_ENABLED
	89	#define HAL_DMA_MODULE_ENABLED
	90	#define HAL_MDMA_MODULE_ENABLED
	91	#define HAL_RCC_MODULE_ENABLED
	92	#define HAL_FLASH_MODULE_ENABLED
	93	#define HAL_EXTI_MODULE_ENABLED
	94	#define HAL_PWR_MODULE_ENABLED
	95	#define HAL_I2C_MODULE_ENABLED
	96	#define HAL_CORTEX_MODULE_ENABLED
	97	#define HAL_HSEM_MODULE_ENABLED
	98
	99	/* ########################## Oscillator Values adaptation ####################*/
	100	/**
	101	* @brief Adjust the value of External High Speed oscillator (HSE) used in your application.
	102	* This value is used by the RCC HAL module to compute the system frequency
	103	* (when HSE is used as system clock source, directly or through the PLL).
	104	*/
	105	#if !defined (HSE_VALUE)
	106	#define HSE_VALUE ((uint32_t)25000000) /!< Value of the External oscillator in Hz : FPGA case fixed to 60MHZ /
	107	#endif /* HSE_VALUE */
	108
	109	#if !defined (HSE_STARTUP_TIMEOUT)
	110	#define HSE_STARTUP_TIMEOUT ((uint32_t)100U) /!< Time out for HSE start up, in ms /
	111	#endif /* HSE_STARTUP_TIMEOUT */
	112
	113	/**
	114	* @brief Internal oscillator (CSI) default value.
	115	* This value is the default CSI value after Reset.
	116	*/
	117	#if !defined (CSI_VALUE)
	118	#define CSI_VALUE ((uint32_t)4000000) /!< Value of the Internal oscillator in Hz/
	119	#endif /* CSI_VALUE */
	120
	121	/**
	122	* @brief Internal High Speed oscillator (HSI) value.
	123	* This value is used by the RCC HAL module to compute the system frequency
	124	* (when HSI is used as system clock source, directly or through the PLL).
	125	*/
	126	#if !defined (HSI_VALUE)
	127	#define HSI_VALUE ((uint32_t)64000000) /!< Value of the Internal oscillator in Hz/
	128	#endif /* HSI_VALUE */
	129
	130	/**
	131	* @brief External Low Speed oscillator (LSE) value.
	132	* This value is used by the UART, RTC HAL module to compute the system frequency
	133	*/
	134	#if !defined (LSE_VALUE)
	135	#define LSE_VALUE ((uint32_t)32768U) /!< Value of the External oscillator in Hz/
	136	#endif /* LSE_VALUE */
	137
	138	#if !defined (LSE_STARTUP_TIMEOUT)
	139	#define LSE_STARTUP_TIMEOUT ((uint32_t)5000U) /!< Time out for LSE start up, in ms /
	140	#endif /* LSE_STARTUP_TIMEOUT */
	141
	142	/**
	143	* @brief External clock source for I2S peripheral
	144	* This value is used by the I2S HAL module to compute the I2S clock source
	145	* frequency, this source is inserted directly through I2S_CKIN pad.
	146	*/
	147	#if !defined (EXTERNAL_CLOCK_VALUE)
	148	#define EXTERNAL_CLOCK_VALUE 12288000U /!< Value of the External clock in Hz/
	149	#endif /* EXTERNAL_CLOCK_VALUE */
	150
	151	/* Tip: To avoid modifying this file each time you need to use different HSE,
	152	=== you can define the HSE value in your toolchain compiler preprocessor. */
	153
	154	/* ########################### System Configuration ######################### */
	155	/**
	156	* @brief This is the HAL system configuration section
	157	*/
	158	#define VDD_VALUE ((uint32_t)3300U) /!< Value of VDD in mv /
	159	#define TICK_INT_PRIORITY ((uint32_t)0U) /!< tick interrupt priority /
	160	#define USE_RTOS 0U
	161	#define USE_SD_TRANSCEIVER 1U /!< use uSD Transceiver /
	162
	163	#define USE_HAL_ADC_REGISTER_CALLBACKS 0U /* ADC register callback disabled */
	164	#define USE_HAL_CEC_REGISTER_CALLBACKS 0U /* CEC register callback disabled */
	165	#define USE_HAL_COMP_REGISTER_CALLBACKS 0U /* COMP register callback disabled */
	166	#define USE_HAL_CRYP_REGISTER_CALLBACKS 0U /* CRYP register callback disabled */
	167	#define USE_HAL_DAC_REGISTER_CALLBACKS 0U /* DAC register callback disabled */
	168	#define USE_HAL_DCMI_REGISTER_CALLBACKS 0U /* DCMI register callback disabled */
	169	#define USE_HAL_DFSDM_REGISTER_CALLBACKS 0U /* DFSDM register callback disabled */
	170	#define USE_HAL_DMA2D_REGISTER_CALLBACKS 0U /* DMA2D register callback disabled */
	171	#define USE_HAL_DSI_REGISTER_CALLBACKS 0U /* DSI register callback disabled */
	172	#define USE_HAL_DTS_REGISTER_CALLBACKS 0U /* DTS register callback disabled */
	173	#define USE_HAL_ETH_REGISTER_CALLBACKS 0U /* ETH register callback disabled */
	174	#define USE_HAL_FDCAN_REGISTER_CALLBACKS 0U /* FDCAN register callback disabled */
	175	#define USE_HAL_NAND_REGISTER_CALLBACKS 0U /* NAND register callback disabled */
	176	#define USE_HAL_NOR_REGISTER_CALLBACKS 0U /* NOR register callback disabled */
	177	#define USE_HAL_SDRAM_REGISTER_CALLBACKS 0U /* SDRAM register callback disabled */
	178	#define USE_HAL_SRAM_REGISTER_CALLBACKS 0U /* SRAM register callback disabled */
	179	#define USE_HAL_HASH_REGISTER_CALLBACKS 0U /* HASH register callback disabled */
	180	#define USE_HAL_HCD_REGISTER_CALLBACKS 0U /* HCD register callback disabled */
	181	#define USE_HAL_GFXMMU_REGISTER_CALLBACKS 0U /* GFXMMU register callback disabled */
	182	#define USE_HAL_HRTIM_REGISTER_CALLBACKS 0U /* HRTIM register callback disabled */
	183	#define USE_HAL_I2C_REGISTER_CALLBACKS 0U /* I2C register callback disabled */
	184	#define USE_HAL_I2S_REGISTER_CALLBACKS 0U /* I2S register callback disabled */
	185	#define USE_HAL_IRDA_REGISTER_CALLBACKS 0U /* IRDA register callback disabled */
	186	#define USE_HAL_JPEG_REGISTER_CALLBACKS 0U /* JPEG register callback disabled */
	187	#define USE_HAL_LPTIM_REGISTER_CALLBACKS 0U /* LPTIM register callback disabled */
	188	#define USE_HAL_LTDC_REGISTER_CALLBACKS 0U /* LTDC register callback disabled */
	189	#define USE_HAL_MDIOS_REGISTER_CALLBACKS 0U /* MDIO register callback disabled */
	190	#define USE_HAL_MMC_REGISTER_CALLBACKS 0U /* MMC register callback disabled */
	191	#define USE_HAL_OPAMP_REGISTER_CALLBACKS 0U /* MDIO register callback disabled */
	192	#define USE_HAL_OSPI_REGISTER_CALLBACKS 0U /* OSPI register callback disabled */
	193	#define USE_HAL_OTFDEC_REGISTER_CALLBACKS 0U /* OTFDEC register callback disabled */
	194	#define USE_HAL_PCD_REGISTER_CALLBACKS 0U /* PCD register callback disabled */
	195	#define USE_HAL_QSPI_REGISTER_CALLBACKS 0U /* QSPI register callback disabled */
	196	#define USE_HAL_RNG_REGISTER_CALLBACKS 0U /* RNG register callback disabled */
	197	#define USE_HAL_RTC_REGISTER_CALLBACKS 0U /* RTC register callback disabled */
	198	#define USE_HAL_SAI_REGISTER_CALLBACKS 0U /* SAI register callback disabled */
	199	#define USE_HAL_SD_REGISTER_CALLBACKS 0U /* SD register callback disabled */
	200	#define USE_HAL_SMARTCARD_REGISTER_CALLBACKS 0U /* SMARTCARD register callback disabled */
	201	#define USE_HAL_SPDIFRX_REGISTER_CALLBACKS 0U /* SPDIFRX register callback disabled */
	202	#define USE_HAL_SMBUS_REGISTER_CALLBACKS 0U /* SMBUS register callback disabled */
	203	#define USE_HAL_SPI_REGISTER_CALLBACKS 0U /* SPI register callback disabled */
	204	#define USE_HAL_SWPMI_REGISTER_CALLBACKS 0U /* SWPMI register callback disabled */
	205	#define USE_HAL_TIM_REGISTER_CALLBACKS 0U /* TIM register callback disabled */
	206	#define USE_HAL_UART_REGISTER_CALLBACKS 0U /* UART register callback disabled */
	207	#define USE_HAL_USART_REGISTER_CALLBACKS 0U /* USART register callback disabled */
	208	#define USE_HAL_WWDG_REGISTER_CALLBACKS 0U /* WWDG register callback disabled */
	209
	210	/* ########################### Ethernet Configuration ######################### */
	211	#define ETH_TX_DESC_CNT 4 /* number of Ethernet Tx DMA descriptors */
	212	#define ETH_RX_DESC_CNT 4 /* number of Ethernet Rx DMA descriptors */
	213
	214	#define ETH_MAC_ADDR0 ((uint8_t)0x02)
	215	#define ETH_MAC_ADDR1 ((uint8_t)0x00)
	216	#define ETH_MAC_ADDR2 ((uint8_t)0x00)
	217	#define ETH_MAC_ADDR3 ((uint8_t)0x00)
	218	#define ETH_MAC_ADDR4 ((uint8_t)0x00)
	219	#define ETH_MAC_ADDR5 ((uint8_t)0x00)
	220
	221	/* ########################## Assert Selection ############################## */
	222	/**
	223	* @brief Uncomment the line below to expanse the "assert_param" macro in the
	224	* HAL drivers code
	225	*/
	226	/* #define USE_FULL_ASSERT 1U */
	227
	228	/* Includes ------------------------------------------------------------------*/
	229	/**
	230	* @brief Include module's header file
	231	*/
	232
	233	#ifdef HAL_RCC_MODULE_ENABLED
	234	#include "stm32h7xx_hal_rcc.h"
	235	#endif /* HAL_RCC_MODULE_ENABLED */
	236
	237	#ifdef HAL_GPIO_MODULE_ENABLED
	238	#include "stm32h7xx_hal_gpio.h"
	239	#endif /* HAL_GPIO_MODULE_ENABLED */
	240
	241	#ifdef HAL_DMA_MODULE_ENABLED
	242	#include "stm32h7xx_hal_dma.h"
	243	#endif /* HAL_DMA_MODULE_ENABLED */
	244
	245	#ifdef HAL_MDMA_MODULE_ENABLED
	246	#include "stm32h7xx_hal_mdma.h"
	247	#endif /* HAL_MDMA_MODULE_ENABLED */
	248
	249	#ifdef HAL_HASH_MODULE_ENABLED
	250	#include "stm32h7xx_hal_hash.h"
	251	#endif /* HAL_HASH_MODULE_ENABLED */
	252
	253	#ifdef HAL_DCMI_MODULE_ENABLED
	254	#include "stm32h7xx_hal_dcmi.h"
	255	#endif /* HAL_DCMI_MODULE_ENABLED */
	256
	257	#ifdef HAL_DMA2D_MODULE_ENABLED
	258	#include "stm32h7xx_hal_dma2d.h"
	259	#endif /* HAL_DMA2D_MODULE_ENABLED */
	260
	261	#ifdef HAL_DSI_MODULE_ENABLED
	262	#include "stm32h7xx_hal_dsi.h"
	263	#endif /* HAL_DSI_MODULE_ENABLED */
	264
	265	#ifdef HAL_DFSDM_MODULE_ENABLED
	266	#include "stm32h7xx_hal_dfsdm.h"
	267	#endif /* HAL_DFSDM_MODULE_ENABLED */
	268
	269	#ifdef HAL_ETH_MODULE_ENABLED
	270	#include "stm32h7xx_hal_eth.h"
	271	#endif /* HAL_ETH_MODULE_ENABLED */
	272
	273	#ifdef HAL_EXTI_MODULE_ENABLED
	274	#include "stm32h7xx_hal_exti.h"
	275	#endif /* HAL_EXTI_MODULE_ENABLED */
	276
	277	#ifdef HAL_CORTEX_MODULE_ENABLED
	278	#include "stm32h7xx_hal_cortex.h"
	279	#endif /* HAL_CORTEX_MODULE_ENABLED */
	280
	281	#ifdef HAL_ADC_MODULE_ENABLED
	282	#include "stm32h7xx_hal_adc.h"
	283	#endif /* HAL_ADC_MODULE_ENABLED */
	284
	285	#ifdef HAL_FDCAN_MODULE_ENABLED
	286	#include "stm32h7xx_hal_fdcan.h"
	287	#endif /* HAL_FDCAN_MODULE_ENABLED */
	288
	289	#ifdef HAL_CEC_MODULE_ENABLED
	290	#include "stm32h7xx_hal_cec.h"
	291	#endif /* HAL_CEC_MODULE_ENABLED */
	292
	293	#ifdef HAL_COMP_MODULE_ENABLED
	294	#include "stm32h7xx_hal_comp.h"
	295	#endif /* HAL_COMP_MODULE_ENABLED */
	296
	297	#ifdef HAL_CRC_MODULE_ENABLED
	298	#include "stm32h7xx_hal_crc.h"
	299	#endif /* HAL_CRC_MODULE_ENABLED */
	300
	301	#ifdef HAL_CRYP_MODULE_ENABLED
	302	#include "stm32h7xx_hal_cryp.h"
	303	#endif /* HAL_CRYP_MODULE_ENABLED */
	304
	305	#ifdef HAL_DAC_MODULE_ENABLED
	306	#include "stm32h7xx_hal_dac.h"
	307	#endif /* HAL_DAC_MODULE_ENABLED */
	308
	309	#ifdef HAL_FLASH_MODULE_ENABLED
	310	#include "stm32h7xx_hal_flash.h"
	311	#endif /* HAL_FLASH_MODULE_ENABLED */
	312
	313	#ifdef HAL_GFXMMU_MODULE_ENABLED
	314	#include "stm32h7xx_hal_gfxmmu.h"
	315	#endif /* HAL_GFXMMU_MODULE_ENABLED */
	316
	317	#ifdef HAL_HRTIM_MODULE_ENABLED
	318	#include "stm32h7xx_hal_hrtim.h"
	319	#endif /* HAL_HRTIM_MODULE_ENABLED */
	320
	321	#ifdef HAL_HSEM_MODULE_ENABLED
	322	#include "stm32h7xx_hal_hsem.h"
	323	#endif /* HAL_HSEM_MODULE_ENABLED */
	324
	325	#ifdef HAL_SRAM_MODULE_ENABLED
	326	#include "stm32h7xx_hal_sram.h"
	327	#endif /* HAL_SRAM_MODULE_ENABLED */
	328
	329	#ifdef HAL_NOR_MODULE_ENABLED
	330	#include "stm32h7xx_hal_nor.h"
	331	#endif /* HAL_NOR_MODULE_ENABLED */
	332
	333	#ifdef HAL_NAND_MODULE_ENABLED
	334	#include "stm32h7xx_hal_nand.h"
	335	#endif /* HAL_NAND_MODULE_ENABLED */
	336
	337	#ifdef HAL_I2C_MODULE_ENABLED
	338	#include "stm32h7xx_hal_i2c.h"
	339	#endif /* HAL_I2C_MODULE_ENABLED */
	340
	341	#ifdef HAL_I2S_MODULE_ENABLED
	342	#include "stm32h7xx_hal_i2s.h"
	343	#endif /* HAL_I2S_MODULE_ENABLED */
	344
	345	#ifdef HAL_IWDG_MODULE_ENABLED
	346	#include "stm32h7xx_hal_iwdg.h"
	347	#endif /* HAL_IWDG_MODULE_ENABLED */
	348
	349	#ifdef HAL_JPEG_MODULE_ENABLED
	350	#include "stm32h7xx_hal_jpeg.h"
	351	#endif /* HAL_JPEG_MODULE_ENABLED */
	352
	353	#ifdef HAL_MDIOS_MODULE_ENABLED
	354	#include "stm32h7xx_hal_mdios.h"
	355	#endif /* HAL_MDIOS_MODULE_ENABLED */
	356
	357	#ifdef HAL_MMC_MODULE_ENABLED
	358	#include "stm32h7xx_hal_mmc.h"
	359	#endif /* HAL_MMC_MODULE_ENABLED */
	360
	361	#ifdef HAL_LPTIM_MODULE_ENABLED
	362	#include "stm32h7xx_hal_lptim.h"
	363	#endif /* HAL_LPTIM_MODULE_ENABLED */
	364
	365	#ifdef HAL_LTDC_MODULE_ENABLED
	366	#include "stm32h7xx_hal_ltdc.h"
	367	#endif /* HAL_LTDC_MODULE_ENABLED */
	368
	369	#ifdef HAL_OPAMP_MODULE_ENABLED
	370	#include "stm32h7xx_hal_opamp.h"
	371	#endif /* HAL_OPAMP_MODULE_ENABLED */
	372
	373	#ifdef HAL_OSPI_MODULE_ENABLED
	374	#include "stm32h7xx_hal_ospi.h"
	375	#endif /* HAL_OSPI_MODULE_ENABLED */
	376
	377	#ifdef HAL_OTFDEC_MODULE_ENABLED
	378	#include "stm32h7xx_hal_otfdec.h"
	379	#endif /* HAL_OTFDEC_MODULE_ENABLED */
	380
	381	#ifdef HAL_PWR_MODULE_ENABLED
	382	#include "stm32h7xx_hal_pwr.h"
	383	#endif /* HAL_PWR_MODULE_ENABLED */
	384
	385	#ifdef HAL_QSPI_MODULE_ENABLED
	386	#include "stm32h7xx_hal_qspi.h"
	387	#endif /* HAL_QSPI_MODULE_ENABLED */
	388
	389	#ifdef HAL_RAMECC_MODULE_ENABLED
	390	#include "stm32h7xx_hal_ramecc.h"
	391	#endif /* HAL_HCD_MODULE_ENABLED */
	392
	393	#ifdef HAL_RNG_MODULE_ENABLED
	394	#include "stm32h7xx_hal_rng.h"
	395	#endif /* HAL_RNG_MODULE_ENABLED */
	396
	397	#ifdef HAL_RTC_MODULE_ENABLED
	398	#include "stm32h7xx_hal_rtc.h"
	399	#endif /* HAL_RTC_MODULE_ENABLED */
	400
	401	#ifdef HAL_SAI_MODULE_ENABLED
	402	#include "stm32h7xx_hal_sai.h"
	403	#endif /* HAL_SAI_MODULE_ENABLED */
	404
	405	#ifdef HAL_SD_MODULE_ENABLED
	406	#include "stm32h7xx_hal_sd.h"
	407	#endif /* HAL_SD_MODULE_ENABLED */
	408
	409	#ifdef HAL_SDRAM_MODULE_ENABLED
	410	#include "stm32h7xx_hal_sdram.h"
	411	#endif /* HAL_SDRAM_MODULE_ENABLED */
	412
	413	#ifdef HAL_SPI_MODULE_ENABLED
	414	#include "stm32h7xx_hal_spi.h"
	415	#endif /* HAL_SPI_MODULE_ENABLED */
	416
	417	#ifdef HAL_SPDIFRX_MODULE_ENABLED
	418	#include "stm32h7xx_hal_spdifrx.h"
	419	#endif /* HAL_SPDIFRX_MODULE_ENABLED */
	420
	421	#ifdef HAL_SWPMI_MODULE_ENABLED
	422	#include "stm32h7xx_hal_swpmi.h"
	423	#endif /* HAL_SWPMI_MODULE_ENABLED */
	424
	425	#ifdef HAL_TIM_MODULE_ENABLED
	426	#include "stm32h7xx_hal_tim.h"
	427	#endif /* HAL_TIM_MODULE_ENABLED */
	428
	429	#ifdef HAL_UART_MODULE_ENABLED
	430	#include "stm32h7xx_hal_uart.h"
	431	#endif /* HAL_UART_MODULE_ENABLED */
	432
	433	#ifdef HAL_USART_MODULE_ENABLED
	434	#include "stm32h7xx_hal_usart.h"
	435	#endif /* HAL_USART_MODULE_ENABLED */
	436
	437	#ifdef HAL_IRDA_MODULE_ENABLED
	438	#include "stm32h7xx_hal_irda.h"
	439	#endif /* HAL_IRDA_MODULE_ENABLED */
	440
	441	#ifdef HAL_SMARTCARD_MODULE_ENABLED
	442	#include "stm32h7xx_hal_smartcard.h"
	443	#endif /* HAL_SMARTCARD_MODULE_ENABLED */
	444
	445	#ifdef HAL_SMBUS_MODULE_ENABLED
	446	#include "stm32h7xx_hal_smbus.h"
	447	#endif /* HAL_SMBUS_MODULE_ENABLED */
	448
	449	#ifdef HAL_WWDG_MODULE_ENABLED
	450	#include "stm32h7xx_hal_wwdg.h"
	451	#endif /* HAL_WWDG_MODULE_ENABLED */
	452
	453	#ifdef HAL_PCD_MODULE_ENABLED
	454	#include "stm32h7xx_hal_pcd.h"
	455	#endif /* HAL_PCD_MODULE_ENABLED */
	456
	457	#ifdef HAL_HCD_MODULE_ENABLED
	458	#include "stm32h7xx_hal_hcd.h"
	459	#endif /* HAL_HCD_MODULE_ENABLED */
	460
	461	#ifdef HAL_PSSI_MODULE_ENABLED
	462	#include "stm32h7xx_hal_pssi.h"
	463	#endif /* HAL_PSSI_MODULE_ENABLED */
	464
	465	#ifdef HAL_DTS_MODULE_ENABLED
	466	#include "stm32h7xx_hal_dts.h"
	467	#endif /* HAL_DTS_MODULE_ENABLED */
	468
	469	/* Exported macro ------------------------------------------------------------*/
	470	#ifdef USE_FULL_ASSERT
	471	/**
	472	* @brief The assert_param macro is used for function's parameters check.
	473	* @param expr: If expr is false, it calls assert_failed function
	474	* which reports the name of the source file and the source
	475	* line number of the call that failed.
	476	* If expr is true, it returns no value.
	477	* @retval None
	478	*/
	479	#define assert_param(expr) ((expr) ? (void)0U : assert_failed((uint8_t *)__FILE__, __LINE__))
	480	/* Exported functions ------------------------------------------------------- */
	481	void assert_failed(uint8_t* file, uint32_t line);
	482	#else
	483	#define assert_param(expr) ((void)0U)
	484	#endif /* USE_FULL_ASSERT */
	485
	486	#ifdef __cplusplus
	487	}
	488	#endif
	489
	490	#endif /* __STM32H7xx_HAL_CONF_H */
	491
	492
	493	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

LEAF/Inc/stm32h7xx_it.h+81−0

@@ -0,0 +1,81 @@
	1	/* USER CODE BEGIN Header */
	2	/**
	3	******************************************************************************
	4	* @file stm32h7xx_it.h
	5	* @brief This file contains the headers of the interrupt handlers.
	6	******************************************************************************
	7	* @attention
	8	*
	9	* <h2><center>© Copyright (c) 2019 STMicroelectronics.
	10	* All rights reserved.</center></h2>
	11	*
	12	* This software component is licensed by ST under Ultimate Liberty license
	13	* SLA0044, the "License"; You may not use this file except in compliance with
	14	* the License. You may obtain a copy of the License at:
	15	* www.st.com/SLA0044
	16	*
	17	******************************************************************************
	18	*/
	19	/* USER CODE END Header */
	20
	21	/* Define to prevent recursive inclusion -------------------------------------*/
	22	#ifndef __STM32H7xx_IT_H
	23	#define __STM32H7xx_IT_H
	24
	25	#ifdef __cplusplus
	26	extern "C" {
	27	#endif
	28
	29	/* Private includes ----------------------------------------------------------*/
	30	/* USER CODE BEGIN Includes */
	31
	32	/* USER CODE END Includes */
	33
	34	/* Exported types ------------------------------------------------------------*/
	35	/* USER CODE BEGIN ET */
	36
	37	/* USER CODE END ET */
	38
	39	/* Exported constants --------------------------------------------------------*/
	40	/* USER CODE BEGIN EC */
	41
	42	/* USER CODE END EC */
	43
	44	/* Exported macro ------------------------------------------------------------*/
	45	/* USER CODE BEGIN EM */
	46
	47	/* USER CODE END EM */
	48
	49	/* Exported functions prototypes ---------------------------------------------*/
	50	void NMI_Handler(void);
	51	void HardFault_Handler(void);
	52	void MemManage_Handler(void);
	53	void BusFault_Handler(void);
	54	void UsageFault_Handler(void);
	55	void SVC_Handler(void);
	56	void DebugMon_Handler(void);
	57	void PendSV_Handler(void);
	58	void SysTick_Handler(void);
	59	void DMA1_Stream0_IRQHandler(void);
	60	void DMA1_Stream1_IRQHandler(void);
	61	void DMA1_Stream2_IRQHandler(void);
	62	void ADC_IRQHandler(void);
	63	void I2C4_EV_IRQHandler(void);
	64	void I2C4_ER_IRQHandler(void);
	65	void OTG_FS_EP1_OUT_IRQHandler(void);
	66	void OTG_FS_EP1_IN_IRQHandler(void);
	67	void OTG_FS_IRQHandler(void);
	68	void DMAMUX1_OVR_IRQHandler(void);
	69	void BDMA_Channel0_IRQHandler(void);
	70	void BDMA_Channel1_IRQHandler(void);
	71	/* USER CODE BEGIN EFP */
	72
	73	/* USER CODE END EFP */
	74
	75	#ifdef __cplusplus
	76	}
	77	#endif
	78
	79	#endif /* __STM32H7xx_IT_H */
	80
	81	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

LEAF/Inc/sys.h+56−0

@@ -0,0 +1,56 @@
	1	/**
	2	******************************************************************************
	3	* File Name : SYS.h
	4	* Description : This file provides code for the configuration
	5	* of the SYS instances.
	6	******************************************************************************
	7	* @attention
	8	*
	9	* <h2><center>© Copyright (c) 2020 STMicroelectronics.
	10	* All rights reserved.</center></h2>
	11	*
	12	* This software component is licensed by ST under Ultimate Liberty license
	13	* SLA0044, the "License"; You may not use this file except in compliance with
	14	* the License. You may obtain a copy of the License at:
	15	* www.st.com/SLA0044
	16	*
	17	******************************************************************************
	18	*/
	19	/* Define to prevent recursive inclusion -------------------------------------*/
	20	#ifndef __sys_H
	21	#define __sys_H
	22	#ifdef __cplusplus
	23	extern "C" {
	24	#endif
	25
	26	/* Includes ------------------------------------------------------------------*/
	27	#include "main.h"
	28
	29	/* USER CODE BEGIN Includes */
	30
	31	/* USER CODE END Includes */
	32
	33	/* USER CODE BEGIN Private defines */
	34
	35	/* USER CODE END Private defines */
	36
	37	void MX_SYS_Init(void);
	38
	39	/* USER CODE BEGIN Prototypes */
	40
	41	/* USER CODE END Prototypes */
	42
	43	#ifdef __cplusplus
	44	}
	45	#endif
	46	#endif /__ sys_H /
	47
	48	/**
	49	* @}
	50	*/
	51
	52	/**
	53	* @}
	54	*/
	55
	56	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

LEAF/Inc/tim.h+62−0

@@ -0,0 +1,62 @@
	1	/**
	2	******************************************************************************
	3	* File Name : TIM.h
	4	* Description : This file provides code for the configuration
	5	* of the TIM instances.
	6	******************************************************************************
	7	* @attention
	8	*
	9	* <h2><center>© Copyright (c) 2020 STMicroelectronics.
	10	* All rights reserved.</center></h2>
	11	*
	12	* This software component is licensed by ST under Ultimate Liberty license
	13	* SLA0044, the "License"; You may not use this file except in compliance with
	14	* the License. You may obtain a copy of the License at:
	15	* www.st.com/SLA0044
	16	*
	17	******************************************************************************
	18	*/
	19	/* Define to prevent recursive inclusion -------------------------------------*/
	20	#ifndef __tim_H
	21	#define __tim_H
	22	#ifdef __cplusplus
	23	extern "C" {
	24	#endif
	25
	26	/* Includes ------------------------------------------------------------------*/
	27	#include "main.h"
	28
	29	/* USER CODE BEGIN Includes */
	30
	31	/* USER CODE END Includes */
	32
	33	extern TIM_HandleTypeDef htim3;
	34	extern TIM_HandleTypeDef htim4;
	35
	36	/* USER CODE BEGIN Private defines */
	37
	38	/* USER CODE END Private defines */
	39
	40	void MX_TIM3_Init(void);
	41	void MX_TIM4_Init(void);
	42
	43	void HAL_TIM_MspPostInit(TIM_HandleTypeDef *htim);
	44
	45	/* USER CODE BEGIN Prototypes */
	46
	47	/* USER CODE END Prototypes */
	48
	49	#ifdef __cplusplus
	50	}
	51	#endif
	52	#endif /__ tim_H /
	53
	54	/**
	55	* @}
	56	*/
	57
	58	/**
	59	* @}
	60	*/
	61
	62	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

LEAF/Inc/tunings.h+20−0

@@ -0,0 +1,20 @@
	1	/*
	2	* tunings.h
	3	*
	4	* Created on: Dec 18, 2019
	5	* Author: josnyder
	6	*/
	7
	8	#ifndef TUNINGS_H_
	9	#define TUNINGS_H_
	10
	11	#define NUM_TUNINGS 66
	12
	13	extern float centsDeviation[12];
	14	extern float tuningPresets[NUM_TUNINGS][12];
	15	extern uint32_t currentTuning;
	16	extern uint8_t keyCenter;
	17	extern char tuningNames[NUM_TUNINGS][6];
	18
	19
	20	#endif /* TUNINGS_H_ */

LEAF/Inc/ui.h+116−0

@@ -0,0 +1,116 @@
	1	/*
	2	* ui.h
	3	*
	4	* Created on: Aug 30, 2019
	5	* Author: jeffsnyder
	6	*/
	7	#ifndef UI_H_
	8	#define UI_H_
	9
	10	#define NUM_ADC_CHANNELS 6
	11	#define NUM_BUTTONS 10
	12
	13	//PresetNil is used as a counter for the size of the enum
	14	typedef enum _VocodecPresetType
	15	{
	16	Vocoder = 0,
	17	Pitchshift,
	18	AutotuneMono,
	19	AutotunePoly,
	20	SamplerButtonPress,
	21	SamplerAutoGrab,
	22	Distortion,
	23	Wavefolder,
	24	BitCrusher,
	25	Delay,
	26	Reverb,
	27	Reverb2,
	28	LivingString,
	29	LivingStringSynth,
	30	ClassicSynth,
	31	Rhodes,
	32	PresetNil
	33	} VocodecPresetType;
	34
	35	typedef enum _VocodecButton
	36	{
	37	ButtonEdit = 0,
	38	ButtonLeft,
	39	ButtonRight,
	40	ButtonDown,
	41	ButtonUp,
	42	ButtonA,
	43	ButtonB,
	44	ButtonC,
	45	ButtonD,
	46	ButtonE,
	47	ButtonNil
	48	} VocodecButton;
	49
	50	typedef enum _ButtonAction
	51	{
	52	ActionPress = 0,
	53	ActionRelease,
	54	ActionHoldInstant,
	55	ActionHoldContinuous,
	56	ActionNil
	57	} ButtonAction;
	58
	59	extern uint16_t ADC_values[NUM_ADC_CHANNELS];
	60
	61	extern uint8_t buttonValues[NUM_BUTTONS];
	62	//extern uint8_t buttonPressed[NUM_BUTTONS];
	63	//extern uint8_t buttonReleased[NUM_BUTTONS];
	64
	65	extern int8_t writeKnobFlag;
	66	extern int8_t writeButtonFlag;
	67	extern int8_t writeActionFlag;
	68
	69	extern float floatADCUI[NUM_ADC_CHANNELS];
	70
	71	extern uint8_t currentPreset;
	72	extern uint8_t previousPreset;
	73	extern uint8_t loadingPreset;
	74	// Display values
	75	extern char* modeNames[PresetNil];
	76	extern char* modeNamesDetails[PresetNil];
	77	extern char* shortModeNames[PresetNil];
	78	extern char* paramNames[PresetNil][NUM_ADC_CHANNELS + NUM_BUTTONS];
	79	extern float knobParams[NUM_ADC_CHANNELS];
	80	extern int8_t cvAddParam;
	81	extern uint8_t buttonActionsSFX[NUM_BUTTONS][ActionNil];
	82	extern char* (*buttonActionFunctions[PresetNil])(VocodecButton, ButtonAction);
	83
	84	void initModeNames(void);
	85
	86	void buttonCheck(void);
	87
	88	void adcCheck(void);
	89
	90	void clearButtonActions(void);
	91
	92	void changeTuning(void);
	93
	94	void writeCurrentPresetToFlash(void);
	95
	96	char* UIVocoderButtons(VocodecButton button, ButtonAction action);
	97	char* UIPitchShiftButtons(VocodecButton button, ButtonAction action);
	98	char* UINeartuneButtons(VocodecButton button, ButtonAction action);
	99	char* UIAutotuneButtons(VocodecButton button, ButtonAction action);
	100	char* UISamplerBPButtons(VocodecButton button, ButtonAction action);
	101	char* UISamplerAutoButtons(VocodecButton button, ButtonAction action);
	102	char* UIDistortionButtons(VocodecButton button, ButtonAction action);
	103	char* UIWaveFolderButtons(VocodecButton button, ButtonAction action);
	104	char* UIBitcrusherButtons(VocodecButton button, ButtonAction action);
	105	char* UIDelayButtons(VocodecButton button, ButtonAction action);
	106	char* UIReverbButtons(VocodecButton button, ButtonAction action);
	107	char* UIReverb2Buttons(VocodecButton button, ButtonAction action);
	108	char* UILivingStringButtons(VocodecButton button, ButtonAction action);
	109	char* UILivingStringSynthButtons(VocodecButton button, ButtonAction action);
	110	char* UIClassicSynthButtons(VocodecButton button, ButtonAction action);
	111	char* UIRhodesButtons(VocodecButton button, ButtonAction action);
	112
	113
	114
	115	#endif /* UI_H_ */
	116

LEAF/Inc/usb_host.h+94−0

@@ -0,0 +1,94 @@
	1	/* USER CODE BEGIN Header */
	2	/**
	3	******************************************************************************
	4	* @file : usb_host.h
	5	* @version : v1.0_Cube
	6	* @brief : Header for usb_host.c file.
	7	******************************************************************************
	8	* @attention
	9	*
	10	* <h2><center>© Copyright (c) 2019 STMicroelectronics.
	11	* All rights reserved.</center></h2>
	12	*
	13	* This software component is licensed by ST under Ultimate Liberty license
	14	* SLA0044, the "License"; You may not use this file except in compliance with
	15	* the License. You may obtain a copy of the License at:
	16	* www.st.com/SLA0044
	17	*
	18	******************************************************************************
	19	*/
	20	/* USER CODE END Header */
	21
	22	/* Define to prevent recursive inclusion -------------------------------------*/
	23	#ifndef __USB_HOST__H__
	24	#define __USB_HOST__H__
	25
	26	#ifdef __cplusplus
	27	extern "C" {
	28	#endif
	29
	30	/* Includes ------------------------------------------------------------------*/
	31	#include "stm32h7xx.h"
	32	#include "stm32h7xx_hal.h"
	33
	34	/* USER CODE BEGIN INCLUDE */
	35
	36	/* USER CODE END INCLUDE */
	37
	38	/** @addtogroup USBH_OTG_DRIVER
	39	* @{
	40	*/
	41
	42	/** @defgroup USBH_HOST USBH_HOST
	43	* @brief Host file for Usb otg low level driver.
	44	* @{
	45	*/
	46
	47	/** @defgroup USBH_HOST_Exported_Variables USBH_HOST_Exported_Variables
	48	* @brief Public variables.
	49	* @{
	50	*/
	51
	52	/**
	53	* @}
	54	*/
	55
	56	/** Status of the application. */
	57	typedef enum {
	58	APPLICATION_IDLE = 0,
	59	APPLICATION_START,
	60	APPLICATION_READY,
	61	APPLICATION_DISCONNECT
	62	}ApplicationTypeDef;
	63
	64	/** @defgroup USBH_HOST_Exported_FunctionsPrototype USBH_HOST_Exported_FunctionsPrototype
	65	* @brief Declaration of public functions for Usb host.
	66	* @{
	67	*/
	68
	69	/* Exported functions -------------------------------------------------------*/
	70
	71	/** @brief USB Host initialization function. */
	72	void MX_USB_HOST_Init(void);
	73
	74	void MX_USB_HOST_Process(void);
	75
	76	/**
	77	* @}
	78	*/
	79
	80	/**
	81	* @}
	82	*/
	83
	84	/**
	85	* @}
	86	*/
	87
	88	#ifdef __cplusplus
	89	}
	90	#endif
	91
	92	#endif /* __USB_HOST__H__ */
	93
	94	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

LEAF/Inc/usbh_MIDI.h+211−0

@@ -0,0 +1,211 @@
	1	/**
	2	******************************************************************************
	3	* @file usbh_MIDI.h
	4	* @author Xavier Halgand
	5	* @version
	6	* @date
	7	* @brief This file contains all the prototypes for the usbh_MIDI.c
	8	******************************************************************************
	9	*/
	10	/*
	11	* This program is free software; you can redistribute it and/or modify
	12	* it under the terms of the GNU General Public License as published by
	13	* the Free Software Foundation; either version 2 of the License, or
	14	* (at your option) any later version.
	15	*
	16	* This program is distributed in the hope that it will be useful,
	17	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	19	* GNU General Public License for more details.
	20	*
	21	* You should have received a copy of the GNU General Public License
	22	* along with this program; if not, write to the Free Software
	23	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	24	*
	25	*/
	26
	27	/* Define to prevent recursive ----------------------------------------------*/
	28	#ifndef __USBH_MIDI_CORE_H
	29	#define __USBH_MIDI_CORE_H
	30
	31	#ifdef __cplusplus
	32	extern "C" {
	33	#endif
	34
	35	/* Includes ------------------------------------------------------------------*/
	36	#include "usbh_core.h"
	37	//#include "stm32f7xx_nucleo_144.h"
	38
	39	/-------------------------------------------------------------------------------/
	40	// buffer size (should be at least >= MIOS32_USB_MIDI_DESC_DATA_*_SIZE/4)
	41	#define USB_MIDI_RX_BUFFER_SIZE 64 // packages
	42	#define USB_MIDI_TX_BUFFER_SIZE 64 // packages
	43
	44	// size of IN/OUT pipe
	45	#define USB_MIDI_DATA_IN_SIZE 64
	46	#define USB_MIDI_DATA_OUT_SIZE 64
	47
	48	// endpoint assignments (don't change!)
	49	#define USB_MIDI_DATA_OUT_EP 0x02
	50	#define USB_MIDI_DATA_IN_EP 0x81
	51	/** @defgroup USBH_MIDI_CORE_Exported_Defines
	52	* @{
	53	*/
	54	#define USB_AUDIO_CLASS 0x01
	55	#define USB_MIDISTREAMING_SubCLASS 0x03
	56	#define USB_MIDI_DESC_SIZE 9
	57	#define USBH_MIDI_CLASS &MIDI_Class
	58
	59	/-------------------------------------------------------------------------------/
	60
	61	extern USBH_ClassTypeDef MIDI_Class;
	62
	63	/* -------------------- Exported_Types ------------------------------------------*/
	64
	65	typedef enum {
	66	NoteOff = 0x8,
	67	NoteOn = 0x9,
	68	PolyPressure = 0xa,
	69	CC = 0xb,
	70	ProgramChange = 0xc,
	71	Aftertouch = 0xd,
	72	PitchBend = 0xe
	73	} midi_event_t;
	74
	75
	76	typedef enum {
	77	Chn1,
	78	Chn2,
	79	Chn3,
	80	Chn4,
	81	Chn5,
	82	Chn6,
	83	Chn7,
	84	Chn8,
	85	Chn9,
	86	Chn10,
	87	Chn11,
	88	Chn12,
	89	Chn13,
	90	Chn14,
	91	Chn15,
	92	Chn16
	93	} midi_chn_t;
	94
	95	#pragma anon_unions
	96
	97	typedef union {
	98	struct {
	99	uint32_t ALL;
	100	};
	101	struct {
	102	uint8_t cin_cable;
	103	uint8_t evnt0;
	104	uint8_t evnt1;
	105	uint8_t evnt2;
	106	};
	107	struct {
	108	uint8_t type:4;
	109	uint8_t cable:4;
	110	uint8_t chn:4; // mios32_midi_chn_t
	111	uint8_t event:4; // mios32_midi_event_t
	112	uint8_t value1;
	113	uint8_t value2;
	114	};
	115
	116	// C++ doesn't allow to redefine names in anonymous unions
	117	// as a simple workaround, we rename these redundant names
	118	struct {
	119	uint8_t cin:4;
	120	uint8_t dummy1_cable:4;
	121	uint8_t dummy1_chn:4; // mios32_midi_chn_t
	122	uint8_t dummy1_event:4; // mios32_midi_event_t
	123	uint8_t note:8;
	124	uint8_t velocity:8;
	125	};
	126	struct {
	127	uint8_t dummy2_cin:4;
	128	uint8_t dummy2_cable:4;
	129	uint8_t dummy2_chn:4; // mios32_midi_chn_t
	130	uint8_t dummy2_event:4; // mios32_midi_event_t
	131	uint8_t cc_number:8;
	132	uint8_t value:8;
	133	};
	134	struct {
	135	uint8_t dummy3_cin:4;
	136	uint8_t dummy3_cable:4;
	137	uint8_t dummy3_chn:4; // mios32_midi_chn_t
	138	uint8_t dummy3_event:4; // mios32_midi_event_t
	139	uint8_t program_change:8;
	140	uint8_t dummy3:8;
	141	};
	142	} midi_package_t;
	143
	144	/* States for MIDI State Machine */
	145	typedef enum
	146	{
	147	MIDI_IDLE= 0,
	148	MIDI_SEND_DATA,
	149	MIDI_SEND_DATA_WAIT,
	150	MIDI_RECEIVE_DATA,
	151	MIDI_RECEIVE_DATA_WAIT,
	152	}
	153	MIDI_DataStateTypeDef;
	154
	155	typedef enum
	156	{
	157	MIDI_IDLE_STATE= 0,
	158	MIDI_TRANSFER_DATA,
	159	MIDI_ERROR_STATE,
	160	}
	161	MIDI_StateTypeDef;
	162
	163	/* Structure for MIDI process */
	164	typedef struct _MIDI_Process
	165	{
	166	MIDI_StateTypeDef state;
	167	uint8_t InPipe;
	168	uint8_t OutPipe;
	169	uint8_t OutEp;
	170	uint8_t InEp;
	171	uint16_t OutEpSize;
	172	uint16_t InEpSize;
	173
	174	uint8_t *pTxData;
	175	uint8_t *pRxData;
	176	uint16_t TxDataLength;
	177	uint16_t RxDataLength;
	178	MIDI_DataStateTypeDef data_tx_state;
	179	MIDI_DataStateTypeDef data_rx_state;
	180	uint8_t Rx_Poll;
	181	//uint8_t buff[8];
	182	//MIDI_DataItfTypedef DataItf;
	183	//CDC_InterfaceDesc_Typedef CDC_Desc;
	184	}
	185	MIDI_HandleTypeDef;
	186
	187	/---------------------------Exported_FunctionsPrototype-------------------------------------/
	188
	189	USBH_StatusTypeDef USBH_MIDI_Transmit(USBH_HandleTypeDef *phost,
	190	uint8_t *pbuff,
	191	uint16_t length);
	192
	193	USBH_StatusTypeDef USBH_MIDI_Receive(USBH_HandleTypeDef *phost,
	194	uint8_t *pbuff,
	195	uint16_t length);
	196
	197
	198	uint32_t USBH_MIDI_GetLastReceivedDataSize(USBH_HandleTypeDef *phost);
	199
	200	USBH_StatusTypeDef USBH_MIDI_Stop(USBH_HandleTypeDef *phost);
	201
	202	void USBH_MIDI_TransmitCallback(USBH_HandleTypeDef *phost);
	203
	204	void USBH_MIDI_ReceiveCallback(USBH_HandleTypeDef *phost, uint32_t myLength);
	205
	206	/-------------------------------------------------------------------------------------------/
	207	#endif /* __USBH_MIDI_CORE_H */
	208
	209
	210	/***************************END OF FILE***********************************************************/
	211

LEAF/Inc/usbh_conf.h+199−0

@@ -0,0 +1,199 @@
	1	/* USER CODE BEGIN Header */
	2	/**
	3	******************************************************************************
	4	* @file : usbh_conf.h
	5	* @version : v1.0_Cube
	6	* @brief : Header for usbh_conf.c file.
	7	******************************************************************************
	8	* @attention
	9	*
	10	* <h2><center>© Copyright (c) 2019 STMicroelectronics.
	11	* All rights reserved.</center></h2>
	12	*
	13	* This software component is licensed by ST under Ultimate Liberty license
	14	* SLA0044, the "License"; You may not use this file except in compliance with
	15	* the License. You may obtain a copy of the License at:
	16	* www.st.com/SLA0044
	17	*
	18	******************************************************************************
	19	*/
	20	/* USER CODE END Header */
	21
	22	/* Define to prevent recursive inclusion -------------------------------------*/
	23	#ifndef __USBH_CONF__H__
	24	#define __USBH_CONF__H__
	25	#ifdef __cplusplus
	26	extern "C" {
	27	#endif
	28	/* Includes ------------------------------------------------------------------*/
	29
	30	#include <stdio.h>
	31	#include <stdlib.h>
	32	#include <string.h>
	33	#include "main.h"
	34
	35	#include "stm32h7xx.h"
	36	#include "stm32h7xx_hal.h"
	37
	38	/* USER CODE BEGIN INCLUDE */
	39
	40	/* USER CODE END INCLUDE */
	41
	42	/** @addtogroup STM32_USB_HOST_LIBRARY
	43	* @{
	44	*/
	45
	46	/** @defgroup USBH_CONF
	47	* @brief usb host low level driver configuration file
	48	* @{
	49	*/
	50
	51	/** @defgroup USBH_CONF_Exported_Variables USBH_CONF_Exported_Variables
	52	* @brief Public variables.
	53	* @{
	54	*/
	55
	56	/**
	57	* @}
	58	*/
	59
	60	/** @defgroup USBH_CONF_Exported_Defines USBH_CONF_Exported_Defines
	61	* @brief Defines for configuration of the Usb host.
	62	* @{
	63	*/
	64
	65	/---------- -----------/
	66	#define USBH_MAX_NUM_ENDPOINTS 2U
	67
	68	/---------- -----------/
	69	#define USBH_MAX_NUM_INTERFACES 10U
	70
	71	/---------- -----------/
	72	#define USBH_MAX_NUM_CONFIGURATION 10U
	73
	74	/---------- -----------/
	75	#define USBH_KEEP_CFG_DESCRIPTOR 1U
	76
	77	/---------- -----------/
	78	#define USBH_MAX_NUM_SUPPORTED_CLASS 1U
	79
	80	/---------- -----------/
	81	#define USBH_MAX_SIZE_CONFIGURATION 256U
	82
	83	/---------- -----------/
	84	#define USBH_MAX_DATA_BUFFER 512U
	85
	86	/---------- -----------/
	87	#define USBH_DEBUG_LEVEL 0U
	88
	89	/---------- -----------/
	90	#define USBH_USE_OS 0U
	91
	92
	93
	94
	95	/****************************************/
	96	/* #define for FS and HS identification */
	97	#define HOST_HS 0
	98	#define HOST_FS 1
	99
	100	#if (USBH_USE_OS == 1)
	101	#include "cmsis_os.h"
	102	#define USBH_PROCESS_PRIO osPriorityNormal
	103	#define USBH_PROCESS_STACK_SIZE ((uint16_t)0)
	104	#endif /* (USBH_USE_OS == 1) */
	105
	106	/**
	107	* @}
	108	*/
	109
	110	/** @defgroup USBH_CONF_Exported_Macros USBH_CONF_Exported_Macros
	111	* @brief Aliases.
	112	* @{
	113	*/
	114
	115	/* Memory management macros */
	116
	117	/** Alias for memory allocation. */
	118	#define USBH_malloc malloc
	119
	120	/** Alias for memory release. */
	121	#define USBH_free free
	122
	123	/** Alias for memory set. */
	124	#define USBH_memset memset
	125
	126	/** Alias for memory copy. */
	127	#define USBH_memcpy memcpy
	128
	129	/* DEBUG macros */
	130
	131	#if (USBH_DEBUG_LEVEL > 0U)
	132	#define USBH_UsrLog(...) do { \
	133	printf(__VA_ARGS__); \
	134	printf("\n"); \
	135	} while (0)
	136	#else
	137	#define USBH_UsrLog(...) do {} while (0)
	138	#endif
	139
	140	#if (USBH_DEBUG_LEVEL > 1U)
	141
	142	#define USBH_ErrLog(...) do { \
	143	printf("ERROR: ") ; \
	144	printf(__VA_ARGS__); \
	145	printf("\n"); \
	146	} while (0)
	147	#else
	148	#define USBH_ErrLog(...) do {} while (0)
	149	#endif
	150
	151	#if (USBH_DEBUG_LEVEL > 2U)
	152	#define USBH_DbgLog(...) do { \
	153	printf("DEBUG : ") ; \
	154	printf(__VA_ARGS__); \
	155	printf("\n"); \
	156	} while (0)
	157	#else
	158	#define USBH_DbgLog(...) do {} while (0)
	159	#endif
	160
	161	/**
	162	* @}
	163	*/
	164
	165	/** @defgroup USBH_CONF_Exported_Types USBH_CONF_Exported_Types
	166	* @brief Types.
	167	* @{
	168	*/
	169
	170	/**
	171	* @}
	172	*/
	173
	174	/** @defgroup USBH_CONF_Exported_FunctionsPrototype USBH_CONF_Exported_FunctionsPrototype
	175	* @brief Declaration of public functions for Usb host.
	176	* @{
	177	*/
	178
	179	/* Exported functions -------------------------------------------------------*/
	180
	181	/**
	182	* @}
	183	*/
	184
	185	/**
	186	* @}
	187	*/
	188
	189	/**
	190	* @}
	191	*/
	192
	193	#ifdef __cplusplus
	194	}
	195	#endif
	196
	197	#endif /* __USBH_CONF__H__ */
	198
	199	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

LEAF/Inc/usbh_platform.h+44−0

@@ -0,0 +1,44 @@
	1	/* USER CODE BEGIN Header */
	2	/**
	3	******************************************************************************
	4	* @file : usbh_platform.h
	5	* @brief : Header for usbh_platform.c file.
	6	******************************************************************************
	7	* @attention
	8	*
	9	* <h2><center>© Copyright (c) 2019 STMicroelectronics.
	10	* All rights reserved.</center></h2>
	11	*
	12	* This software component is licensed by ST under Ultimate Liberty license
	13	* SLA0044, the "License"; You may not use this file except in compliance with
	14	* the License. You may obtain a copy of the License at:
	15	* www.st.com/SLA0044
	16	*
	17	******************************************************************************
	18	*/
	19	/* USER CODE END Header */
	20
	21	/* Define to prevent recursive inclusion -------------------------------------*/
	22	#ifndef __USBH_PLATFORM_H__
	23	#define __USBH_PLATFORM_H__
	24
	25	#ifdef __cplusplus
	26	extern "C" {
	27	#endif
	28
	29	/* Includes ------------------------------------------------------------------*/
	30	#include "usb_host.h"
	31
	32	/* USER CODE BEGIN INCLUDE */
	33
	34	/* USER CODE END INCLUDE */
	35
	36	void MX_DriverVbusFS(uint8_t state);
	37
	38	#ifdef __cplusplus
	39	}
	40	#endif
	41
	42	#endif /* __USBH_PLATFORM_H__ */
	43
	44	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

LEAF/Src/.DS_Store+0−0

Binary file not shown.

LEAF/Src/MIDI_application.c+192−0

@@ -0,0 +1,192 @@
	1	/*
	2	* MIDI_application.c
	3	*
	4	* Created on: 6 d�c. 2014
	5	* Author: Xavier Halgand
	6	*
	7	* Modified on: 9/12/16 by C.P. to handle the MIDI_IDLE state properly, and
	8	* added required code to be compatible with "NucleoSynth"
	9	*
	10	* 11/8/17 by C.P.: Version 0.7.7 - Use for Casio CTK-6200 Keyboard
	11	*/
	12
	13	/* Includes ------------------------------------------------------------------*/
	14	#include "audiostream.h"
	15	#include "MIDI_application.h"
	16	#include "usbh_core.h"
	17	#include "usbh_MIDI.h"
	18	#include "usb_host.h"
	19	#include "sfx.h"
	20
	21	MIDI_ApplicationTypeDef MIDI_Appli_state = MIDI_APPLICATION_READY;
	22	extern ApplicationTypeDef Appli_state;
	23	extern USBH_HandleTypeDef hUsbHostFS;
	24	uint8_t MIDI_RX_Buffer[RX_BUFF_SIZE]__ATTR_RAM_D2; // MIDI reception buffer
	25
	26	uint8_t key, velocity, ctrl, data, sustainInverted;
	27
	28	uint8_t CCs[128];
	29	/* Private define ------------------------------------------------------------*/
	30
	31	/* Private function prototypes -----------------------------------------------*/
	32
	33
	34
	35
	36	/-----------------------------------------------------------------------------/
	37	/**
	38	* @brief Main routine for MIDI application, looped in main.c
	39	* @param None
	40	* @retval none
	41	*/
	42	void MIDI_Application(void)
	43	{
	44	if(Appli_state == APPLICATION_READY)
	45	{
	46	if(MIDI_Appli_state == MIDI_APPLICATION_READY)
	47	{
	48
	49	USBH_MIDI_Receive(&hUsbHostFS, MIDI_RX_Buffer, RX_BUFF_SIZE); // just once at the beginning, start the first reception
	50	MIDI_Appli_state = MIDI_APPLICATION_RUNNING;
	51	}
	52	}
	53	if(Appli_state == APPLICATION_DISCONNECT)
	54	{
	55	MIDI_Appli_state = MIDI_APPLICATION_READY;
	56	USBH_MIDI_Stop(&hUsbHostFS);
	57	}
	58	}
	59
	60	/-----------------------------------------------------------------------------/
	61	void ProcessReceivedMidiDatas(uint32_t myLength)
	62	{
	63	uint16_t numberOfPackets;
	64	uint8_t *ptr = MIDI_RX_Buffer;
	65	midi_package_t pack;
	66
	67	numberOfPackets = myLength >> 2; //each USB midi package is 4 bytes long
	68
	69	if (numberOfPackets != 0)
	70	{
	71	while(numberOfPackets--)
	72	{
	73	pack.cin_cable = *ptr ; ptr++ ;
	74	pack.evnt0 = *ptr ; ptr++ ;
	75	pack.evnt1 = *ptr ; ptr++ ;
	76	pack.evnt2 = *ptr ; ptr++ ;
	77
	78	// Handle MIDI messages
	79	switch(pack.evnt0)
	80	{
	81	case (0x80): // Note Off
	82	key = pack.evnt1;
	83	velocity = pack.evnt2;
	84
	85	noteOff(key, velocity);
	86
	87	break;
	88	case (0x90): // Note On
	89	key = pack.evnt1;
	90	velocity = pack.evnt2;
	91
	92	noteOn(key, velocity);
	93
	94	break;
	95	case (0xA0):
	96	break;
	97	case (0xB0):
	98	ctrl = pack.evnt1;
	99	data = pack.evnt2;
	100	CCs[ctrl] = data;
	101	switch(ctrl)
	102	{
	103	case (0x01):
	104	break;
	105	case (0x02):
	106	break;
	107	case (0x03):
	108	break;
	109	case (0x04):
	110	break;
	111	case (0x0D):
	112	break;
	113	case (0x4B):
	114	break;
	115	case (0x4C):
	116	break;
	117	case (0x5C):
	118	break;
	119	case (0x5F):
	120	break;
	121	case (0x49):
	122	break;
	123	case (0x48):
	124	break;
	125	case (0x5B):
	126	break;
	127	case (0x5D):
	128	break;
	129	case (0x4A):
	130	break;
	131	case (0x47):
	132	break;
	133	case (0x05):
	134	break;
	135	case (0x54):
	136	break;
	137	case (0x10):
	138	break;
	139	case (0x11):
	140	break;
	141	case (0x12):
	142	break;
	143	case (0x07):
	144	break;
	145	case (0x13):
	146	break;
	147	case (0x14):
	148	break;
	149	case (64): // sustain
	150	if (data)
	151	{
	152	if (sustainInverted) sustainOff();
	153	else sustainOn();
	154	}
	155	else
	156	{
	157	if (sustainInverted) sustainOn();
	158	else sustainOff();
	159	}
	160	break;
	161	}
	162
	163
	164	break;
	165	case (0xC0): // Program Change
	166	break;
	167	case (0xD0): // Mono Aftertouch
	168	break;
	169	case (0xE0): // Pitch Bend
	170	pitchBend((pack.evnt1) + (pack.evnt2 << 7));
	171	break;
	172	case (0xF0):
	173	break;
	174	}
	175	}
	176	}
	177	}
	178
	179
	180
	181	/-----------------------------------------------------------------------------/
	182	/**
	183	* @brief MIDI data receive callback.
	184	* @param phost: Host handle
	185	* @retval None
	186	*/
	187	void USBH_MIDI_ReceiveCallback(USBH_HandleTypeDef *phost, uint32_t myLength)
	188	{
	189	ProcessReceivedMidiDatas(myLength);
	190	USBH_MIDI_Receive(&hUsbHostFS, MIDI_RX_Buffer, RX_BUFF_SIZE); // start a new reception
	191	}
	192

LEAF/Src/adc.c+239−0

@@ -0,0 +1,239 @@
	1	/**
	2	******************************************************************************
	3	* File Name : ADC.c
	4	* Description : This file provides code for the configuration
	5	* of the ADC instances.
	6	******************************************************************************
	7	* @attention
	8	*
	9	* <h2><center>© Copyright (c) 2020 STMicroelectronics.
	10	* All rights reserved.</center></h2>
	11	*
	12	* This software component is licensed by ST under Ultimate Liberty license
	13	* SLA0044, the "License"; You may not use this file except in compliance with
	14	* the License. You may obtain a copy of the License at:
	15	* www.st.com/SLA0044
	16	*
	17	******************************************************************************
	18	*/
	19
	20	/* Includes ------------------------------------------------------------------*/
	21	#include "adc.h"
	22
	23	/* USER CODE BEGIN 0 */
	24
	25	/* USER CODE END 0 */
	26
	27	ADC_HandleTypeDef hadc1;
	28	DMA_HandleTypeDef hdma_adc1;
	29
	30	/* ADC1 init function */
	31	void MX_ADC1_Init(void)
	32	{
	33	ADC_MultiModeTypeDef multimode = {0};
	34	ADC_ChannelConfTypeDef sConfig = {0};
	35
	36	/** Common config
	37	*/
	38	hadc1.Instance = ADC1;
	39	hadc1.Init.ClockPrescaler = ADC_CLOCK_ASYNC_DIV4;
	40	hadc1.Init.Resolution = ADC_RESOLUTION_16B;
	41	hadc1.Init.ScanConvMode = ADC_SCAN_ENABLE;
	42	hadc1.Init.EOCSelection = ADC_EOC_SEQ_CONV;
	43	hadc1.Init.LowPowerAutoWait = DISABLE;
	44	hadc1.Init.ContinuousConvMode = ENABLE;
	45	hadc1.Init.NbrOfConversion = 6;
	46	hadc1.Init.DiscontinuousConvMode = DISABLE;
	47	hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
	48	hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
	49	hadc1.Init.ConversionDataManagement = ADC_CONVERSIONDATA_DMA_CIRCULAR;
	50	hadc1.Init.Overrun = ADC_OVR_DATA_PRESERVED;
	51	hadc1.Init.LeftBitShift = ADC_LEFTBITSHIFT_NONE;
	52	hadc1.Init.OversamplingMode = ENABLE;
	53	hadc1.Init.Oversampling.Ratio = 64;
	54	hadc1.Init.Oversampling.RightBitShift = ADC_RIGHTBITSHIFT_6;
	55	hadc1.Init.Oversampling.TriggeredMode = ADC_TRIGGEREDMODE_SINGLE_TRIGGER;
	56	hadc1.Init.Oversampling.OversamplingStopReset = ADC_REGOVERSAMPLING_CONTINUED_MODE;
	57	if (HAL_ADC_Init(&hadc1) != HAL_OK)
	58	{
	59	Error_Handler();
	60	}
	61	/** Configure the ADC multi-mode
	62	*/
	63	multimode.Mode = ADC_MODE_INDEPENDENT;
	64	if (HAL_ADCEx_MultiModeConfigChannel(&hadc1, &multimode) != HAL_OK)
	65	{
	66	Error_Handler();
	67	}
	68	/** Configure Regular Channel
	69	*/
	70	sConfig.Channel = ADC_CHANNEL_7;
	71	sConfig.Rank = ADC_REGULAR_RANK_1;
	72	sConfig.SamplingTime = ADC_SAMPLETIME_64CYCLES_5;
	73	sConfig.SingleDiff = ADC_SINGLE_ENDED;
	74	sConfig.OffsetNumber = ADC_OFFSET_NONE;
	75	sConfig.Offset = 0;
	76	if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
	77	{
	78	Error_Handler();
	79	}
	80	/** Configure Regular Channel
	81	*/
	82	sConfig.Channel = ADC_CHANNEL_19;
	83	sConfig.Rank = ADC_REGULAR_RANK_2;
	84	if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
	85	{
	86	Error_Handler();
	87	}
	88	/** Configure Regular Channel
	89	*/
	90	sConfig.Channel = ADC_CHANNEL_14;
	91	sConfig.Rank = ADC_REGULAR_RANK_3;
	92	if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
	93	{
	94	Error_Handler();
	95	}
	96	/** Configure Regular Channel
	97	*/
	98	sConfig.Channel = ADC_CHANNEL_16;
	99	sConfig.Rank = ADC_REGULAR_RANK_4;
	100	if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
	101	{
	102	Error_Handler();
	103	}
	104	/** Configure Regular Channel
	105	*/
	106	sConfig.Channel = ADC_CHANNEL_15;
	107	sConfig.Rank = ADC_REGULAR_RANK_5;
	108	if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
	109	{
	110	Error_Handler();
	111	}
	112	/** Configure Regular Channel
	113	*/
	114	sConfig.Channel = ADC_CHANNEL_8;
	115	sConfig.Rank = ADC_REGULAR_RANK_6;
	116	if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
	117	{
	118	Error_Handler();
	119	}
	120
	121	}
	122
	123	void HAL_ADC_MspInit(ADC_HandleTypeDef* adcHandle)
	124	{
	125
	126	GPIO_InitTypeDef GPIO_InitStruct = {0};
	127	HAL_DMA_MuxSyncConfigTypeDef pSyncConfig= {0};
	128	if(adcHandle->Instance==ADC1)
	129	{
	130	/* USER CODE BEGIN ADC1_MspInit 0 */
	131
	132	/* USER CODE END ADC1_MspInit 0 */
	133	/* ADC1 clock enable */
	134	__HAL_RCC_ADC12_CLK_ENABLE();
	135
	136	__HAL_RCC_GPIOC_CLK_ENABLE();
	137	__HAL_RCC_GPIOA_CLK_ENABLE();
	138	/**ADC1 GPIO Configuration
	139	PC1 ------> ADC1_INP11
	140	PA0 ------> ADC1_INP16
	141	PA2 ------> ADC1_INP14
	142	PA3 ------> ADC1_INP15
	143	PA5 ------> ADC1_INP19
	144	PA7 ------> ADC1_INP7
	145	PC5 ------> ADC1_INP8
	146	*/
	147	GPIO_InitStruct.Pin = GPIO_PIN_1\|GPIO_PIN_5;
	148	GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
	149	GPIO_InitStruct.Pull = GPIO_NOPULL;
	150	HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
	151
	152	GPIO_InitStruct.Pin = GPIO_PIN_0\|GPIO_PIN_2\|GPIO_PIN_3\|GPIO_PIN_5
	153	\|GPIO_PIN_7;
	154	GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
	155	GPIO_InitStruct.Pull = GPIO_NOPULL;
	156	HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
	157
	158	/* ADC1 DMA Init */
	159	/* ADC1 Init */
	160	hdma_adc1.Instance = DMA1_Stream0;
	161	hdma_adc1.Init.Request = DMA_REQUEST_ADC1;
	162	hdma_adc1.Init.Direction = DMA_PERIPH_TO_MEMORY;
	163	hdma_adc1.Init.PeriphInc = DMA_PINC_DISABLE;
	164	hdma_adc1.Init.MemInc = DMA_MINC_ENABLE;
	165	hdma_adc1.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
	166	hdma_adc1.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
	167	hdma_adc1.Init.Mode = DMA_CIRCULAR;
	168	hdma_adc1.Init.Priority = DMA_PRIORITY_HIGH;
	169	hdma_adc1.Init.FIFOMode = DMA_FIFOMODE_ENABLE;
	170	hdma_adc1.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_1QUARTERFULL;
	171	hdma_adc1.Init.MemBurst = DMA_MBURST_SINGLE;
	172	hdma_adc1.Init.PeriphBurst = DMA_PBURST_SINGLE;
	173	if (HAL_DMA_Init(&hdma_adc1) != HAL_OK)
	174	{
	175	Error_Handler();
	176	}
	177
	178	pSyncConfig.SyncSignalID = HAL_DMAMUX1_SYNC_EXTI0;
	179	pSyncConfig.SyncPolarity = HAL_DMAMUX_SYNC_RISING;
	180	pSyncConfig.SyncEnable = DISABLE;
	181	pSyncConfig.EventEnable = ENABLE;
	182	pSyncConfig.RequestNumber = 1;
	183	if (HAL_DMAEx_ConfigMuxSync(&hdma_adc1, &pSyncConfig) != HAL_OK)
	184	{
	185	Error_Handler();
	186	}
	187
	188	__HAL_LINKDMA(adcHandle,DMA_Handle,hdma_adc1);
	189
	190	/* ADC1 interrupt Init */
	191	HAL_NVIC_SetPriority(ADC_IRQn, 0, 0);
	192	HAL_NVIC_EnableIRQ(ADC_IRQn);
	193	/* USER CODE BEGIN ADC1_MspInit 1 */
	194
	195	/* USER CODE END ADC1_MspInit 1 */
	196	}
	197	}
	198
	199	void HAL_ADC_MspDeInit(ADC_HandleTypeDef* adcHandle)
	200	{
	201
	202	if(adcHandle->Instance==ADC1)
	203	{
	204	/* USER CODE BEGIN ADC1_MspDeInit 0 */
	205
	206	/* USER CODE END ADC1_MspDeInit 0 */
	207	/* Peripheral clock disable */
	208	__HAL_RCC_ADC12_CLK_DISABLE();
	209
	210	/**ADC1 GPIO Configuration
	211	PC1 ------> ADC1_INP11
	212	PA0 ------> ADC1_INP16
	213	PA2 ------> ADC1_INP14
	214	PA3 ------> ADC1_INP15
	215	PA5 ------> ADC1_INP19
	216	PA7 ------> ADC1_INP7
	217	PC5 ------> ADC1_INP8
	218	*/
	219	HAL_GPIO_DeInit(GPIOC, GPIO_PIN_1\|GPIO_PIN_5);
	220
	221	HAL_GPIO_DeInit(GPIOA, GPIO_PIN_0\|GPIO_PIN_2\|GPIO_PIN_3\|GPIO_PIN_5
	222	\|GPIO_PIN_7);
	223
	224	/* ADC1 DMA DeInit */
	225	HAL_DMA_DeInit(adcHandle->DMA_Handle);
	226
	227	/* ADC1 interrupt Deinit */
	228	HAL_NVIC_DisableIRQ(ADC_IRQn);
	229	/* USER CODE BEGIN ADC1_MspDeInit 1 */
	230
	231	/* USER CODE END ADC1_MspDeInit 1 */
	232	}
	233	}
	234
	235	/* USER CODE BEGIN 1 */
	236
	237	/* USER CODE END 1 */
	238
	239	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

LEAF/Src/audiostream.c+518−0

@@ -0,0 +1,518 @@
	1	/*
	2	* audiostream.c
	3	*
	4	* Created on: Aug 30, 2019
	5	* Author: jeffsnyder
	6	*/
	7
	8
	9	/* Includes ------------------------------------------------------------------*/
	10	#include "audiostream.h"
	11	#include "main.h"
	12	#include "leaf.h"
	13	#include "codec.h"
	14	#include "ui.h"
	15	#include "oled.h"
	16	#include "tunings.h"
	17	#include "i2c.h"
	18	#include "gpio.h"
	19	#include "sfx.h"
	20	#include "tim.h"
	21
	22	//the audio buffers are put in the D2 RAM area because that is a memory location that the DMA has access to.
	23	int32_t audioOutBuffer[AUDIO_BUFFER_SIZE] __ATTR_RAM_D2;
	24	int32_t audioInBuffer[AUDIO_BUFFER_SIZE] __ATTR_RAM_D2;
	25
	26	#define SMALL_MEM_SIZE 8192
	27	#define MED_MEM_SIZE 500000
	28	#define LARGE_MEM_SIZE 33554432 //32 MBytes - size of SDRAM IC
	29	char small_memory[SMALL_MEM_SIZE];
	30	char medium_memory[MED_MEM_SIZE]__ATTR_RAM_D1;
	31	char large_memory[LARGE_MEM_SIZE] __ATTR_SDRAM;
	32
	33	#define DISPLAY_BLOCK_SIZE 512
	34	float audioDisplayBuffer[128];
	35	uint8_t displayBufferIndex = 0;
	36	float displayBlockVal = 0.0f;
	37	uint32_t displayBlockCount = 0;
	38
	39
	40	void audioFrame(uint16_t buffer_offset);
	41	float audioTickL(float audioIn);
	42	float audioTickR(float audioIn);
	43	void buttonCheck(void);
	44
	45	HAL_StatusTypeDef transmit_status;
	46	HAL_StatusTypeDef receive_status;
	47
	48	uint8_t codecReady = 0;
	49
	50	uint16_t frameCounter = 0;
	51
	52	tMempool smallPool;
	53	tMempool largePool;
	54
	55	tRamp adc[6];
	56
	57	tNoise myNoise;
	58	tCycle mySine[2];
	59	float smoothedADC[6];
	60	tEnvelopeFollower LED_envelope[4];
	61
	62	uint32_t clipCounter[4] = {0,0,0,0};
	63	uint8_t clipped[4] = {0,0,0,0};
	64
	65
	66	float rightIn = 0.0f;
	67	float rightOut = 0.0f;
	68	float sample = 0.0f;
	69
	70
	71
	72	// Vocoder
	73	float glideTimeVoc = 5.0f;
	74
	75	// Formant
	76	float formantShiftFactor = -1.0f;
	77	float formantKnob = 0.0f;
	78
	79	// PitchShift
	80	float pitchFactor = 2.0f;
	81	float formantWarp = 1.0f;
	82	float formantIntensity = 1.0f;
	83
	84	// Autotune1
	85
	86	// Autotune2
	87	float glideTimeAuto = 5.0f;
	88
	89	// Sampler Button Press
	90
	91
	92	// Sampler Auto Grab
	93
	94
	95
	96
	97
	98
	99	BOOL frameCompleted = TRUE;
	100
	101	BOOL bufferCleared = TRUE;
	102
	103	int numBuffersToClearOnLoad = 2;
	104	int numBuffersCleared = 0;
	105
	106	/**********************************************/
	107
	108	void (*allocFunctions[PresetNil])(void);
	109	void (*frameFunctions[PresetNil])(void);
	110	void (*tickFunctions[PresetNil])(float);
	111	void (*freeFunctions[PresetNil])(void);
	112
	113	void audioInit(I2C_HandleTypeDef* hi2c, SAI_HandleTypeDef* hsaiOut, SAI_HandleTypeDef* hsaiIn)
	114	{
	115	// Initialize LEAF.
	116
	117	LEAF_init(SAMPLE_RATE, AUDIO_FRAME_SIZE, medium_memory, MED_MEM_SIZE, &randomNumber);
	118
	119	tMempool_init (&smallPool, small_memory, SMALL_MEM_SIZE);
	120	tMempool_init (&largePool, large_memory, LARGE_MEM_SIZE);
	121
	122	initFunctionPointers();
	123
	124	//ramps to smooth the knobs
	125	for (int i = 0; i < 6; i++)
	126	{
	127	tRamp_init(&adc[i],19.0f, 1); //set all ramps for knobs to be 9ms ramp time and let the init function know they will be ticked every sample
	128	}
	129
	130	for (int i = 0; i < 4; i++)
	131	{
	132	tEnvelopeFollower_init(&LED_envelope[i], 0.02f, .9995f);
	133	}
	134
	135	initGlobalSFXObjects();
	136
	137	// allocFunctions[currentPreset]();
	138
	139	loadingPreset = 1;
	140	previousPreset = PresetNil;
	141
	142	HAL_Delay(10);
	143
	144	for (int i = 0; i < AUDIO_BUFFER_SIZE; i++)
	145	{
	146	audioOutBuffer[i] = 0;
	147	}
	148
	149	HAL_Delay(1);
	150
	151	// set up the I2S driver to send audio data to the codec (and retrieve input as well)
	152	transmit_status = HAL_SAI_Transmit_DMA(hsaiOut, (uint8_t *)&audioOutBuffer[0], AUDIO_BUFFER_SIZE);
	153	receive_status = HAL_SAI_Receive_DMA(hsaiIn, (uint8_t *)&audioInBuffer[0], AUDIO_BUFFER_SIZE);
	154
	155	// with the CS4271 codec IC, the SAI Transmit and Receive must be happening before the chip will respond to
	156	// I2C setup messages (it seems to use the masterclock input as it's own internal clock for i2c data, etc)
	157	// so while we used to set up codec before starting SAI, now we need to set up codec afterwards, and set a flag to make sure it's ready
	158
	159	//now to send all the necessary messages to the codec
	160	AudioCodec_init(hi2c);
	161	HAL_Delay(1);
	162
	163	//now reconfigue so buttons C and E can be used (they were also connected to I2C for codec setup)
	164	HAL_I2C_MspDeInit(hi2c);
	165
	166	GPIO_InitTypeDef GPIO_InitStruct = {0};
	167
	168	//PB10, PB11 ------> buttons C and E
	169	GPIO_InitStruct.Pin = GPIO_PIN_10\|GPIO_PIN_11;
	170	GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
	171	GPIO_InitStruct.Pull = GPIO_PULLUP;
	172	HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
	173	}
	174
	175	void audioFrame(uint16_t buffer_offset)
	176	{
	177	frameCompleted = FALSE;
	178
	179	int i;
	180	int32_t current_sample;
	181
	182	buttonCheck();
	183	adcCheck();
	184
	185	if (!loadingPreset)
	186	{
	187	frameFunctions[currentPreset]();
	188	}
	189
	190	//if the codec isn't ready, keep the buffer as all zeros
	191	//otherwise, start computing audio!
	192
	193	bufferCleared = TRUE;
	194
	195	if (codecReady)
	196	{
	197	for (i = 0; i < (HALF_BUFFER_SIZE); i++)
	198	{
	199	if ((i & 1) == 0)
	200	{
	201	current_sample = (int32_t)(audioTickR((float) (audioInBuffer[buffer_offset + i] << 8) * INV_TWO_TO_31) * TWO_TO_23);
	202	}
	203	else
	204	{
	205	current_sample = (int32_t)(audioTickL((float) (audioInBuffer[buffer_offset + i] << 8) * INV_TWO_TO_31) * TWO_TO_23);
	206	}
	207
	208	audioOutBuffer[buffer_offset + i] = current_sample;
	209	}
	210
	211	}
	212
	213	if (bufferCleared)
	214	{
	215	numBuffersCleared++;
	216	if (numBuffersCleared >= numBuffersToClearOnLoad)
	217	{
	218	numBuffersCleared = numBuffersToClearOnLoad;
	219	if (loadingPreset)
	220	{
	221	if (previousPreset != PresetNil)
	222	{
	223	// do this if you want to save knob values when changing off a preset
	224	// for (int i = 0; i < NUM_ADC_CHANNELS; i++)
	225	// {
	226	// presetKnobValues[previousPreset][i] = smoothedADC[i];
	227	// }
	228	freeFunctions[previousPreset]();
	229	}
	230	else
	231	{
	232	leaf.clearOnAllocation = 1;
	233	}
	234	setLED_A(0);
	235	setLED_B(0);
	236	setLED_1(0);
	237	allocFunctions[currentPreset]();
	238	for (int i = 0; i < NUM_ADC_CHANNELS; i++)
	239	{
	240	knobActive[i] = 0;
	241	floatADCUI[i] = -1.0f;
	242	tRamp_setVal(&adc[i], presetKnobValues[currentPreset][i]);
	243	tRamp_setDest(&adc[i], presetKnobValues[currentPreset][i]);
	244	smoothedADC[i] = presetKnobValues[currentPreset][i];
	245	}
	246	leaf.clearOnAllocation = 0;
	247	loadingPreset = 0;
	248	}
	249	}
	250	}
	251	else numBuffersCleared = 0;
	252
	253	frameCompleted = TRUE;
	254
	255	OLED_process(); // process what to write to the screen but don't actually draw
	256	}
	257
	258
	259
	260
	261	float audioTickL(float audioIn)
	262	{
	263	sample = 0.0f;
	264
	265	for (int i = 0; i < NUM_ADC_CHANNELS; i++)
	266	{
	267	smoothedADC[i] = tRamp_tick(&adc[i]);
	268	}
	269
	270	if (loadingPreset) return sample;
	271
	272	bufferCleared = FALSE;
	273
	274	tickFunctions[currentPreset](audioIn);
	275	/*
	276	displayBlockVal += fabsf(sample);
	277	displayBlockCount++;
	278	if (displayBlockCount >= DISPLAY_BLOCK_SIZE)
	279	{
	280	displayBlockVal *= INV_TWO_TO_9;
	281	audioDisplayBuffer[displayBufferIndex] = displayBlockVal;
	282	displayBlockVal = 0.0f;
	283	displayBlockCount = 0;
	284	displayBufferIndex++;
	285	if (displayBufferIndex >= 128) displayBufferIndex = 0;
	286	}
	287	*/
	288
	289	if ((audioIn >= 0.999999f) \|\| (audioIn <= -0.999999f))
	290	{
	291	setLED_leftin_clip(1);
	292	clipCounter[0] = 10000;
	293	clipped[0] = 1;
	294	}
	295	if ((clipCounter[0] > 0) && (clipped[0] == 1))
	296	{
	297	clipCounter[0]--;
	298	}
	299	else if ((clipCounter[0] == 0) && (clipped[0] == 1))
	300	{
	301	setLED_leftin_clip(0);
	302	clipped[0] = 0;
	303	}
	304
	305	float current_env = tEnvelopeFollower_tick(&LED_envelope[0], audioIn);
	306	uint16_t audioLEDLevel = LEAF_clip(0, (current_env * 32.0f), 16);
	307	__HAL_TIM_SET_COMPARE(&htim3, TIM_CHANNEL_2, audioLEDLevel);
	308
	309
	310	current_env = tEnvelopeFollower_tick(&LED_envelope[1], sample);
	311	audioLEDLevel = LEAF_clip(0, (current_env * 32.0f), 15);
	312	__HAL_TIM_SET_COMPARE(&htim4, TIM_CHANNEL_3, audioLEDLevel);
	313
	314
	315
	316	if ((sample >= 0.999999f) \|\| (sample <= -0.999999f))
	317	{
	318	setLED_leftout_clip(1);
	319	clipCounter[2] = 10000;
	320	clipped[2] = 1;
	321	}
	322	if ((clipCounter[2] > 0) && (clipped[2] == 1))
	323	{
	324	clipCounter[2]--;
	325	}
	326	else if ((clipCounter[2] == 0) && (clipped[2] == 1))
	327	{
	328	setLED_leftout_clip(0);
	329	clipped[2] = 0;
	330	}
	331
	332	return sample;
	333	}
	334
	335
	336
	337	float audioTickR(float audioIn)
	338	{
	339	rightIn = audioIn;
	340
	341
	342	if ((rightIn >= 0.999999f) \|\| (rightIn <= -0.999999f))
	343	{
	344	setLED_rightin_clip(1);
	345	clipCounter[1] = 10000;
	346	clipped[1] = 1;
	347	}
	348	if ((clipCounter[1] > 0) && (clipped[1] == 1))
	349	{
	350	clipCounter[1]--;
	351	}
	352	else if ((clipCounter[1] == 0) && (clipped[1] == 1))
	353	{
	354	setLED_rightin_clip(0);
	355	clipped[1] = 0;
	356	}
	357
	358
	359
	360	if ((rightOut >= 0.999999f) \|\| (rightOut <= -0.999999f))
	361	{
	362	setLED_rightout_clip(1);
	363	clipCounter[3] = 10000;
	364	clipped[3] = 1;
	365	}
	366	if ((clipCounter[3] > 0) && (clipped[3] == 1))
	367	{
	368	clipCounter[3]--;
	369	}
	370	else if ((clipCounter[3] == 0) && (clipped[3] == 1))
	371	{
	372	setLED_rightout_clip(0);
	373	clipped[3] = 0;
	374	}
	375
	376
	377	float current_env = tEnvelopeFollower_tick(&LED_envelope[2], rightIn);
	378	uint16_t audioLEDLevel = LEAF_clip(0, (current_env * 32.0f), 16);
	379	__HAL_TIM_SET_COMPARE(&htim4, TIM_CHANNEL_2, audioLEDLevel);
	380
	381
	382	current_env = tEnvelopeFollower_tick(&LED_envelope[3], rightOut);
	383	audioLEDLevel = LEAF_clip(0, (current_env * 32.0f), 16);
	384	__HAL_TIM_SET_COMPARE(&htim4, TIM_CHANNEL_1, audioLEDLevel);
	385
	386
	387	return rightOut;
	388	}
	389
	390	void initFunctionPointers(void)
	391	{
	392	allocFunctions[Vocoder] = SFXVocoderAlloc;
	393	frameFunctions[Vocoder] = SFXVocoderFrame;
	394	tickFunctions[Vocoder] = SFXVocoderTick;
	395	freeFunctions[Vocoder] = SFXVocoderFree;
	396
	397	allocFunctions[Pitchshift] = SFXPitchShiftAlloc;
	398	frameFunctions[Pitchshift] = SFXPitchShiftFrame;
	399	tickFunctions[Pitchshift] = SFXPitchShiftTick;
	400	freeFunctions[Pitchshift] = SFXPitchShiftFree;
	401
	402	allocFunctions[AutotuneMono] = SFXNeartuneAlloc;
	403	frameFunctions[AutotuneMono] = SFXNeartuneFrame;
	404	tickFunctions[AutotuneMono] = SFXNeartuneTick;
	405	freeFunctions[AutotuneMono] = SFXNeartuneFree;
	406
	407	allocFunctions[AutotunePoly] = SFXAutotuneAlloc;
	408	frameFunctions[AutotunePoly] = SFXAutotuneFrame;
	409	tickFunctions[AutotunePoly] = SFXAutotuneTick;
	410	freeFunctions[AutotunePoly] = SFXAutotuneFree;
	411
	412	allocFunctions[SamplerButtonPress] = SFXSamplerBPAlloc;
	413	frameFunctions[SamplerButtonPress] = SFXSamplerBPFrame;
	414	tickFunctions[SamplerButtonPress] = SFXSamplerBPTick;
	415	freeFunctions[SamplerButtonPress] = SFXSamplerBPFree;
	416
	417	allocFunctions[SamplerAutoGrab] = SFXSamplerAutoAlloc;
	418	frameFunctions[SamplerAutoGrab] = SFXSamplerAutoFrame;
	419	tickFunctions[SamplerAutoGrab] = SFXSamplerAutoTick;
	420	freeFunctions[SamplerAutoGrab] = SFXSamplerAutoFree;
	421
	422	allocFunctions[Distortion] = SFXDistortionAlloc;
	423	frameFunctions[Distortion] = SFXDistortionFrame;
	424	tickFunctions[Distortion] = SFXDistortionTick;
	425	freeFunctions[Distortion] = SFXDistortionFree;
	426
	427	allocFunctions[Wavefolder] = SFXWaveFolderAlloc;
	428	frameFunctions[Wavefolder] = SFXWaveFolderFrame;
	429	tickFunctions[Wavefolder] = SFXWaveFolderTick;
	430	freeFunctions[Wavefolder] = SFXWaveFolderFree;
	431
	432	allocFunctions[BitCrusher] = SFXBitcrusherAlloc;
	433	frameFunctions[BitCrusher] = SFXBitcrusherFrame;
	434	tickFunctions[BitCrusher] = SFXBitcrusherTick;
	435	freeFunctions[BitCrusher] = SFXBitcrusherFree;
	436
	437	allocFunctions[Delay] = SFXDelayAlloc;
	438	frameFunctions[Delay] = SFXDelayFrame;
	439	tickFunctions[Delay] = SFXDelayTick;
	440	freeFunctions[Delay] = SFXDelayFree;
	441
	442	allocFunctions[Reverb] = SFXReverbAlloc;
	443	frameFunctions[Reverb] = SFXReverbFrame;
	444	tickFunctions[Reverb] = SFXReverbTick;
	445	freeFunctions[Reverb] = SFXReverbFree;
	446
	447	allocFunctions[Reverb2] = SFXReverb2Alloc;
	448	frameFunctions[Reverb2] = SFXReverb2Frame;
	449	tickFunctions[Reverb2] = SFXReverb2Tick;
	450	freeFunctions[Reverb2] = SFXReverb2Free;
	451
	452	allocFunctions[LivingString] = SFXLivingStringAlloc;
	453	frameFunctions[LivingString] = SFXLivingStringFrame;
	454	tickFunctions[LivingString] = SFXLivingStringTick;
	455	freeFunctions[LivingString] = SFXLivingStringFree;
	456
	457	allocFunctions[LivingStringSynth] = SFXLivingStringSynthAlloc;
	458	frameFunctions[LivingStringSynth] = SFXLivingStringSynthFrame;
	459	tickFunctions[LivingStringSynth] = SFXLivingStringSynthTick;
	460	freeFunctions[LivingStringSynth] = SFXLivingStringSynthFree;
	461
	462	allocFunctions[ClassicSynth] = SFXClassicSynthAlloc;
	463	frameFunctions[ClassicSynth] = SFXClassicSynthFrame;
	464	tickFunctions[ClassicSynth] = SFXClassicSynthTick;
	465	freeFunctions[ClassicSynth] = SFXClassicSynthFree;
	466
	467	allocFunctions[Rhodes] = SFXRhodesAlloc;
	468	frameFunctions[Rhodes] = SFXRhodesFrame;
	469	tickFunctions[Rhodes] = SFXRhodesTick;
	470	freeFunctions[Rhodes] = SFXRhodesFree;
	471	}
	472
	473
	474
	475	void HAL_SAI_ErrorCallback(SAI_HandleTypeDef *hsai)
	476	{
	477	if (!frameCompleted)
	478	{
	479	setLED_C(1);
	480	}
	481	}
	482
	483	void HAL_SAI_TxCpltCallback(SAI_HandleTypeDef *hsai)
	484	{
	485	if (!frameCompleted)
	486	{
	487	setLED_C(1);
	488	}
	489	}
	490
	491	void HAL_SAI_TxHalfCpltCallback(SAI_HandleTypeDef *hsai)
	492	{
	493	if (!frameCompleted)
	494	{
	495	setLED_C(1);
	496	}
	497	}
	498
	499
	500	void HAL_SAI_RxCpltCallback(SAI_HandleTypeDef *hsai)
	501	{
	502	if (!frameCompleted)
	503	{
	504	setLED_C(1);
	505	}
	506
	507	audioFrame(HALF_BUFFER_SIZE);
	508	}
	509
	510	void HAL_SAI_RxHalfCpltCallback(SAI_HandleTypeDef *hsai)
	511	{
	512	if (!frameCompleted)
	513	{
	514	setLED_C(1);
	515	}
	516
	517	audioFrame(0);
	518	}

LEAF/Src/bdma.c+66−0

@@ -0,0 +1,66 @@
	1	/**
	2	******************************************************************************
	3	* File Name : dma.c
	4	* Description : This file provides code for the configuration
	5	* of all the requested memory to memory DMA transfers.
	6	******************************************************************************
	7	* @attention
	8	*
	9	* <h2><center>© Copyright (c) 2020 STMicroelectronics.
	10	* All rights reserved.</center></h2>
	11	*
	12	* This software component is licensed by ST under Ultimate Liberty license
	13	* SLA0044, the "License"; You may not use this file except in compliance with
	14	* the License. You may obtain a copy of the License at:
	15	* www.st.com/SLA0044
	16	*
	17	******************************************************************************
	18	*/
	19
	20	/* Includes ------------------------------------------------------------------*/
	21	#include "bdma.h"
	22
	23	/* USER CODE BEGIN 0 */
	24
	25	/* USER CODE END 0 */
	26
	27	/----------------------------------------------------------------------------/
	28	/* Configure DMA */
	29	/----------------------------------------------------------------------------/
	30
	31	/* USER CODE BEGIN 1 */
	32
	33	/* USER CODE END 1 */
	34
	35	/**
	36	* Enable DMA controller clock
	37	*/
	38	void MX_BDMA_Init(void)
	39	{
	40
	41	/* DMA controller clock enable */
	42	__HAL_RCC_BDMA_CLK_ENABLE();
	43
	44	/* DMA interrupt init */
	45	/* BDMA_Channel0_IRQn interrupt configuration */
	46	HAL_NVIC_SetPriority(BDMA_Channel0_IRQn, 0, 0);
	47	HAL_NVIC_EnableIRQ(BDMA_Channel0_IRQn);
	48	/* BDMA_Channel1_IRQn interrupt configuration */
	49	HAL_NVIC_SetPriority(BDMA_Channel1_IRQn, 0, 0);
	50	HAL_NVIC_EnableIRQ(BDMA_Channel1_IRQn);
	51
	52	}
	53
	54	/* USER CODE BEGIN 2 */
	55
	56	/* USER CODE END 2 */
	57
	58	/**
	59	* @}
	60	*/
	61
	62	/**
	63	* @}
	64	*/
	65
	66	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

LEAF/Src/bsp_driver_sd.c+307−0

@@ -0,0 +1,307 @@
	1	/* USER CODE BEGIN Header */
	2	/**
	3	******************************************************************************
	4	* @file bsp_driver_sd.c for H7 (based on stm32h743i_eval_sd.c)
	5	* @brief This file includes a generic uSD card driver.
	6	* To be completed by the user according to the board used for the project.
	7	* @note Functions generated as weak: they can be overriden by
	8	* - code in user files
	9	* - or BSP code from the FW pack files
	10	* if such files are added to the generated project (by the user).
	11	******************************************************************************
	12	* @attention
	13	*
	14	* <h2><center>© Copyright (c) 2020 STMicroelectronics.
	15	* All rights reserved.</center></h2>
	16	*
	17	* This software component is licensed by ST under Ultimate Liberty license
	18	* SLA0044, the "License"; You may not use this file except in compliance with
	19	* the License. You may obtain a copy of the License at:
	20	* www.st.com/SLA0044
	21	*
	22	******************************************************************************
	23	*/
	24	/* USER CODE END Header */
	25
	26	/* USER CODE BEGIN FirstSection */
	27	/* can be used to modify / undefine following code or add new definitions */
	28	/* USER CODE END FirstSection */
	29	/* Includes ------------------------------------------------------------------*/
	30	#include "bsp_driver_sd.h"
	31
	32	/* Extern variables ---------------------------------------------------------*/
	33
	34	extern SD_HandleTypeDef hsd1;
	35
	36	/* USER CODE BEGIN BeforeInitSection */
	37	/* can be used to modify / undefine following code or add code */
	38	/* USER CODE END BeforeInitSection */
	39	/**
	40	* @brief Initializes the SD card device.
	41	* @retval SD status
	42	*/
	43	__weak uint8_t BSP_SD_Init(void)
	44	{
	45	uint8_t sd_state = MSD_OK;
	46	/* Check if the SD card is plugged in the slot */
	47	if (BSP_SD_IsDetected() != SD_PRESENT)
	48	{
	49	return MSD_ERROR_SD_NOT_PRESENT;
	50	}
	51	/* HAL SD initialization */
	52	sd_state = HAL_SD_Init(&hsd1);
	53	/* Configure SD Bus width (4 bits mode selected) */
	54	if (sd_state == MSD_OK)
	55	{
	56	/* Enable wide operation */
	57	if (HAL_SD_ConfigWideBusOperation(&hsd1, SDMMC_BUS_WIDE_4B) != HAL_OK)
	58	{
	59	sd_state = MSD_ERROR;
	60	}
	61	}
	62
	63	return sd_state;
	64	}
	65	/* USER CODE BEGIN AfterInitSection */
	66	/* can be used to modify previous code / undefine following code / add code */
	67	/* USER CODE END AfterInitSection */
	68
	69	/* USER CODE BEGIN InterruptMode */
	70	/**
	71	* @brief Configures Interrupt mode for SD detection pin.
	72	* @retval Returns 0
	73	*/
	74	__weak uint8_t BSP_SD_ITConfig(void)
	75	{
	76	/* Code to be updated by the user or replaced by one from the FW pack (in a stmxxxx_sd.c file) */
	77
	78	return (uint8_t)0;
	79	}
	80
	81	/* USER CODE END InterruptMode */
	82
	83	/* USER CODE BEGIN BeforeReadBlocksSection */
	84	/* can be used to modify previous code / undefine following code / add code */
	85	/* USER CODE END BeforeReadBlocksSection */
	86	/**
	87	* @brief Reads block(s) from a specified address in an SD card, in polling mode.
	88	* @param pData: Pointer to the buffer that will contain the data to transmit
	89	* @param ReadAddr: Address from where data is to be read
	90	* @param NumOfBlocks: Number of SD blocks to read
	91	* @param Timeout: Timeout for read operation
	92	* @retval SD status
	93	*/
	94	__weak uint8_t BSP_SD_ReadBlocks(uint32_t *pData, uint32_t ReadAddr, uint32_t NumOfBlocks, uint32_t Timeout)
	95	{
	96	uint8_t sd_state = MSD_OK;
	97
	98	if (HAL_SD_ReadBlocks(&hsd1, (uint8_t *)pData, ReadAddr, NumOfBlocks, Timeout) != HAL_OK)
	99	{
	100	sd_state = MSD_ERROR;
	101	}
	102
	103	return sd_state;
	104	}
	105
	106	/* USER CODE BEGIN BeforeWriteBlocksSection */
	107	/* can be used to modify previous code / undefine following code / add code */
	108	/* USER CODE END BeforeWriteBlocksSection */
	109	/**
	110	* @brief Writes block(s) to a specified address in an SD card, in polling mode.
	111	* @param pData: Pointer to the buffer that will contain the data to transmit
	112	* @param WriteAddr: Address from where data is to be written
	113	* @param NumOfBlocks: Number of SD blocks to write
	114	* @param Timeout: Timeout for write operation
	115	* @retval SD status
	116	*/
	117	__weak uint8_t BSP_SD_WriteBlocks(uint32_t *pData, uint32_t WriteAddr, uint32_t NumOfBlocks, uint32_t Timeout)
	118	{
	119	uint8_t sd_state = MSD_OK;
	120
	121	if (HAL_SD_WriteBlocks(&hsd1, (uint8_t *)pData, WriteAddr, NumOfBlocks, Timeout) != HAL_OK)
	122	{
	123	sd_state = MSD_ERROR;
	124	}
	125
	126	return sd_state;
	127	}
	128
	129	/* USER CODE BEGIN BeforeReadDMABlocksSection */
	130	/* can be used to modify previous code / undefine following code / add code */
	131	/* USER CODE END BeforeReadDMABlocksSection */
	132	/**
	133	* @brief Reads block(s) from a specified address in an SD card, in DMA mode.
	134	* @param pData: Pointer to the buffer that will contain the data to transmit
	135	* @param ReadAddr: Address from where data is to be read
	136	* @param NumOfBlocks: Number of SD blocks to read
	137	* @retval SD status
	138	*/
	139	__weak uint8_t BSP_SD_ReadBlocks_DMA(uint32_t *pData, uint32_t ReadAddr, uint32_t NumOfBlocks)
	140	{
	141	uint8_t sd_state = MSD_OK;
	142
	143	/* Read block(s) in DMA transfer mode */
	144	if (HAL_SD_ReadBlocks_DMA(&hsd1, (uint8_t *)pData, ReadAddr, NumOfBlocks) != HAL_OK)
	145	{
	146	sd_state = MSD_ERROR;
	147	}
	148
	149	return sd_state;
	150	}
	151
	152	/* USER CODE BEGIN BeforeWriteDMABlocksSection */
	153	/* can be used to modify previous code / undefine following code / add code */
	154	/* USER CODE END BeforeWriteDMABlocksSection */
	155	/**
	156	* @brief Writes block(s) to a specified address in an SD card, in DMA mode.
	157	* @param pData: Pointer to the buffer that will contain the data to transmit
	158	* @param WriteAddr: Address from where data is to be written
	159	* @param NumOfBlocks: Number of SD blocks to write
	160	* @retval SD status
	161	*/
	162	__weak uint8_t BSP_SD_WriteBlocks_DMA(uint32_t *pData, uint32_t WriteAddr, uint32_t NumOfBlocks)
	163	{
	164	uint8_t sd_state = MSD_OK;
	165
	166	/* Write block(s) in DMA transfer mode */
	167	if (HAL_SD_WriteBlocks_DMA(&hsd1, (uint8_t *)pData, WriteAddr, NumOfBlocks) != HAL_OK)
	168	{
	169	sd_state = MSD_ERROR;
	170	}
	171
	172	return sd_state;
	173	}
	174
	175	/* USER CODE BEGIN BeforeEraseSection */
	176	/* can be used to modify previous code / undefine following code / add code */
	177	/* USER CODE END BeforeEraseSection */
	178	/**
	179	* @brief Erases the specified memory area of the given SD card.
	180	* @param StartAddr: Start byte address
	181	* @param EndAddr: End byte address
	182	* @retval SD status
	183	*/
	184	__weak uint8_t BSP_SD_Erase(uint32_t StartAddr, uint32_t EndAddr)
	185	{
	186	uint8_t sd_state = MSD_OK;
	187
	188	if (HAL_SD_Erase(&hsd1, StartAddr, EndAddr) != HAL_OK)
	189	{
	190	sd_state = MSD_ERROR;
	191	}
	192
	193	return sd_state;
	194	}
	195
	196	/* USER CODE BEGIN BeforeGetCardStateSection */
	197	/* can be used to modify previous code / undefine following code / add code */
	198	/* USER CODE END BeforeGetCardStateSection */
	199
	200	/**
	201	* @brief Gets the current SD card data status.
	202	* @param None
	203	* @retval Data transfer state.
	204	* This value can be one of the following values:
	205	* @arg SD_TRANSFER_OK: No data transfer is acting
	206	* @arg SD_TRANSFER_BUSY: Data transfer is acting
	207	*/
	208	__weak uint8_t BSP_SD_GetCardState(void)
	209	{
	210	return ((HAL_SD_GetCardState(&hsd1) == HAL_SD_CARD_TRANSFER ) ? SD_TRANSFER_OK : SD_TRANSFER_BUSY);
	211	}
	212
	213	/**
	214	* @brief Get SD information about specific SD card.
	215	* @param CardInfo: Pointer to HAL_SD_CardInfoTypedef structure
	216	* @retval None
	217	*/
	218	__weak void BSP_SD_GetCardInfo(HAL_SD_CardInfoTypeDef *CardInfo)
	219	{
	220	/* Get SD card Information */
	221	HAL_SD_GetCardInfo(&hsd1, CardInfo);
	222	}
	223
	224	/* USER CODE BEGIN BeforeCallBacksSection */
	225	/* can be used to modify previous code / undefine following code / add code */
	226	/* USER CODE END BeforeCallBacksSection */
	227	/**
	228	* @brief SD Abort callbacks
	229	* @param hsd: SD handle
	230	* @retval None
	231	*/
	232	__weak void HAL_SD_AbortCallback(SD_HandleTypeDef *hsd)
	233	{
	234	BSP_SD_AbortCallback();
	235	}
	236
	237	/**
	238	* @brief Tx Transfer completed callback
	239	* @param hsd: SD handle
	240	* @retval None
	241	*/
	242	__weak void HAL_SD_TxCpltCallback(SD_HandleTypeDef *hsd)
	243	{
	244	BSP_SD_WriteCpltCallback();
	245	}
	246
	247	/**
	248	* @brief Rx Transfer completed callback
	249	* @param hsd: SD handle
	250	* @retval None
	251	*/
	252	__weak void HAL_SD_RxCpltCallback(SD_HandleTypeDef *hsd)
	253	{
	254	BSP_SD_ReadCpltCallback();
	255	}
	256
	257	/* USER CODE BEGIN CallBacksSection_C */
	258	/**
	259	* @brief BSP SD Abort callback
	260	* @retval None
	261	*/
	262	__weak void BSP_SD_AbortCallback(void)
	263	{
	264
	265	}
	266
	267	/**
	268	* @brief BSP Tx Transfer completed callback
	269	* @retval None
	270	*/
	271	__weak void BSP_SD_WriteCpltCallback(void)
	272	{
	273
	274	}
	275
	276	/**
	277	* @brief BSP Rx Transfer completed callback
	278	* @retval None
	279	*/
	280	__weak void BSP_SD_ReadCpltCallback(void)
	281	{
	282
	283	}
	284	/* USER CODE END CallBacksSection_C */
	285
	286	/**
	287	* @brief Detects if SD card is correctly plugged in the memory slot or not.
	288	* @param None
	289	* @retval Returns if SD is detected or not
	290	*/
	291	__weak uint8_t BSP_SD_IsDetected(void)
	292	{
	293	__IO uint8_t status = SD_PRESENT;
	294
	295	if (BSP_PlatformIsDetected() == 0x0)
	296	{
	297	status = SD_NOT_PRESENT;
	298	}
	299
	300	return status;
	301	}
	302
	303	/* USER CODE BEGIN AdditionalCode */
	304	/* user code can be inserted here */
	305	/* USER CODE END AdditionalCode */
	306
	307	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

LEAF/Src/codec.c+125−0

@@ -0,0 +1,125 @@
	1	#include "codec.h"
	2	#include "main.h"
	3	#include "gpio.h"
	4	#include "audiostream.h"
	5
	6	uint16_t i2cDataSize = 2;
	7	uint8_t myI2cData[2] = {0,0};
	8	uint32_t I2Ctimeout = 2000;
	9
	10	//Settings for CS4271
	11	// translated from the datasheet by JS
	12
	13	// 01h mode control 1
	14	//
	15	// M1 M0 ratio1 ratio0 m/s dac_dif2 dac_dif1 dac_dif0 // unsure if setting bit selects master means 1
	16	// for 48k == 0 1 0 0 0 0 0 1 ( ratio bit chosen as 0 0 based on assumption of 256X master clock)
	17	// == 0x41
	18	// for 96k == 1 0 0 0 0 0 0 1 ( ratio bit chosen as 0 0 based on assumption of <= 256X master clock)
	19	// == 0x81
	20	// for 192k == 1 1 1 0 0 0 0 1 ( ratio bit chosen as 1 0 based on assumption of 256X master clock, choose 0 0 (full word would be 0xc1 instead of 0xe1) instead if using something like 64X)
	21	// == 0xe1
	22
	23	// 02h DAC control
	24	// AMUTE, FILT_SEL, DEM1, DEM0, RMP_UP, RMP_DN, INV_A, INV_B
	25	// 0 0 0 0 1 1 0 0
	26	// == 0x0c if you want a slow ramp up when the part turns on
	27	// == 0x00 if you want quick start up (which may click)
	28
	29	// 03h dac volume and mixing
	30	// (NA) B=A soft zerocross ATAPI3 ATAPI2 ATAPI1 ATAPI0 (B=A makes channel volumes not independent)
	31	// 0 1 1 1 1 0 0 1 (the last four bits set channel L to go to output A and channel R to go to output B, but this is easily changed with mixing or reversal)
	32	// == 0x79
	33	//or without soft ramp for any programmed volume changes // == 0x39
	34
	35	// 04h Volume A
	36	// MUTE vol6 vol5 vol4 vol3 vol2 vol1 vol0
	37	// 0 0 0 0 0 0 0 0
	38	// == 0x00
	39	//or 0x14 for -20db
	40
	41	// 05h Volume B
	42	// MUTE vol6 vol5 vol4 vol3 vol2 vol1 vol0
	43	// 0 0 0 0 0 0 0 0
	44	// == 0x00
	45	//or 0x14 for -20db
	46
	47	// 06h ADC control
	48	// (NA) (NA) Dither16 ADC_DIF MUTEA MUTEB HPFDisableA HPFDisableB
	49	// 0 0 0 1 0 0 0 0
	50	// ==0x10
	51
	52	// 07h mode control 2
	53	// (NA) (NA) (NA) LOOP MUTECA=B FREEZE CPEN PDN
	54	// for power down version == 0 0 0 0 0 0 1 1
	55	// == 0x03
	56	// to send dry ADC input into DAC (it seems this will mute the normal DAC output) == 0 0 0 1 0 0 1 0
	57	// == 0x12
	58	// for normal operation == 0 0 0 0 0 0 1 0
	59	// == 0x02
	60
	61	HAL_StatusTypeDef testVal;
	62
	63
	64	volatile int blankCount = 0;
	65	uint16_t addressCounter = 0;
	66
	67
	68	void AudioCodec_init(I2C_HandleTypeDef* hi2c) {
	69
	70	//pull codec reset pin high to start codec working
	71	HAL_GPIO_WritePin(GPIOC, GPIO_PIN_14, GPIO_PIN_SET);
	72
	73	HAL_Delay(2);
	74	//enable control port and put part in power-down mode while loading registers
	75	myI2cData[0] = 0x07;
	76	myI2cData[1] = 0x03;
	77	testVal = HAL_I2C_Master_Transmit(hi2c, CODEC_I2C_ADDRESS, myI2cData, i2cDataSize, I2Ctimeout);
	78	//HAL_Delay(2);
	79
	80	myI2cData[0] = 0x01;
	81	myI2cData[1] = 0x41;
	82	testVal = HAL_I2C_Master_Transmit(hi2c, CODEC_I2C_ADDRESS, myI2cData, i2cDataSize, I2Ctimeout);
	83
	84	//HAL_Delay(1); // might not be necessary
	85
	86	myI2cData[0] = 0x02;
	87	myI2cData[1] = 0x00;
	88	testVal = HAL_I2C_Master_Transmit(hi2c, CODEC_I2C_ADDRESS, myI2cData, i2cDataSize, I2Ctimeout);
	89
	90	//HAL_Delay(1); // might not be necessary
	91
	92	myI2cData[0] = 0x03;
	93	myI2cData[1] = 0x79;
	94	testVal = HAL_I2C_Master_Transmit(hi2c, CODEC_I2C_ADDRESS, myI2cData, i2cDataSize, I2Ctimeout);
	95
	96	//HAL_Delay(1); // might not be necessary
	97
	98	myI2cData[0] = 0x04;
	99	myI2cData[1] = 0x01;
	100	testVal = HAL_I2C_Master_Transmit(hi2c, CODEC_I2C_ADDRESS, myI2cData, i2cDataSize, I2Ctimeout);
	101
	102	//HAL_Delay(1); // might not be necessary
	103
	104	myI2cData[0] = 0x05;
	105	myI2cData[1] = 0x01;
	106	testVal = HAL_I2C_Master_Transmit(hi2c, CODEC_I2C_ADDRESS, myI2cData, i2cDataSize, I2Ctimeout);
	107
	108	//HAL_Delay(1); // might not be necessary
	109
	110	myI2cData[0] = 0x06;
	111	myI2cData[1] = 0x10;
	112	testVal = HAL_I2C_Master_Transmit(hi2c, CODEC_I2C_ADDRESS, myI2cData, i2cDataSize, I2Ctimeout);
	113
	114	//HAL_Delay(1); // might not be necessary
	115
	116	//turn off power down bit to start things cookin'
	117	myI2cData[0] = 0x07;
	118	myI2cData[1] = 0x02;
	119	HAL_I2C_Master_Transmit(hi2c, CODEC_I2C_ADDRESS, myI2cData, i2cDataSize, I2Ctimeout);
	120
	121
	122	//HAL_Delay(1); // might not be necessary
	123	codecReady = 1;
	124
	125	}

LEAF/Src/debug.c+37−0

@@ -0,0 +1,37 @@
	1	/**
	2	******************************************************************************
	3	* File Name : DEBUG.c
	4	* Description : This file provides code for the configuration
	5	* of the DEBUG instances.
	6	******************************************************************************
	7	* @attention
	8	*
	9	* <h2><center>© Copyright (c) 2020 STMicroelectronics.
	10	* All rights reserved.</center></h2>
	11	*
	12	* This software component is licensed by ST under Ultimate Liberty license
	13	* SLA0044, the "License"; You may not use this file except in compliance with
	14	* the License. You may obtain a copy of the License at:
	15	* www.st.com/SLA0044
	16	*
	17	******************************************************************************
	18	*/
	19
	20	/* Includes ------------------------------------------------------------------*/
	21	#include "debug.h"
	22
	23	/* USER CODE BEGIN 0 */
	24
	25	/* USER CODE END 0 */
	26
	27	/* DEBUG init function */
	28	void MX_DEBUG_Init(void)
	29	{
	30
	31	}
	32
	33	/* USER CODE BEGIN 1 */
	34
	35	/* USER CODE END 1 */
	36
	37	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

LEAF/Src/dma.c+72−0

@@ -0,0 +1,72 @@
	1	/**
	2	******************************************************************************
	3	* File Name : dma.c
	4	* Description : This file provides code for the configuration
	5	* of all the requested memory to memory DMA transfers.
	6	******************************************************************************
	7	* @attention
	8	*
	9	* <h2><center>© Copyright (c) 2020 STMicroelectronics.
	10	* All rights reserved.</center></h2>
	11	*
	12	* This software component is licensed by ST under Ultimate Liberty license
	13	* SLA0044, the "License"; You may not use this file except in compliance with
	14	* the License. You may obtain a copy of the License at:
	15	* www.st.com/SLA0044
	16	*
	17	******************************************************************************
	18	*/
	19
	20	/* Includes ------------------------------------------------------------------*/
	21	#include "dma.h"
	22
	23	/* USER CODE BEGIN 0 */
	24
	25	/* USER CODE END 0 */
	26
	27	/----------------------------------------------------------------------------/
	28	/* Configure DMA */
	29	/----------------------------------------------------------------------------/
	30
	31	/* USER CODE BEGIN 1 */
	32
	33	/* USER CODE END 1 */
	34
	35	/**
	36	* Enable DMA controller clock
	37	*/
	38	void MX_DMA_Init(void)
	39	{
	40
	41	/* DMA controller clock enable */
	42	__HAL_RCC_DMA1_CLK_ENABLE();
	43
	44	/* DMA interrupt init */
	45	/* DMA1_Stream0_IRQn interrupt configuration */
	46	HAL_NVIC_SetPriority(DMA1_Stream0_IRQn, 5, 0);
	47	HAL_NVIC_EnableIRQ(DMA1_Stream0_IRQn);
	48	/* DMA1_Stream1_IRQn interrupt configuration */
	49	HAL_NVIC_SetPriority(DMA1_Stream1_IRQn, 2, 0);
	50	HAL_NVIC_EnableIRQ(DMA1_Stream1_IRQn);
	51	/* DMA1_Stream2_IRQn interrupt configuration */
	52	HAL_NVIC_SetPriority(DMA1_Stream2_IRQn, 2, 0);
	53	HAL_NVIC_EnableIRQ(DMA1_Stream2_IRQn);
	54	/* DMAMUX1_OVR_IRQn interrupt configuration */
	55	HAL_NVIC_SetPriority(DMAMUX1_OVR_IRQn, 0, 0);
	56	HAL_NVIC_EnableIRQ(DMAMUX1_OVR_IRQn);
	57
	58	}
	59
	60	/* USER CODE BEGIN 2 */
	61
	62	/* USER CODE END 2 */
	63
	64	/**
	65	* @}
	66	*/
	67
	68	/**
	69	* @}
	70	*/
	71
	72	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

LEAF/Src/eeprom.c+718−0

@@ -0,0 +1,718 @@
	1
	2
	3	/** @addtogroup EEPROM_Emulation
	4	* @{
	5	*/
	6
	7	/* Includes ------------------------------------------------------------------*/
	8	#include "eeprom.h"
	9
	10	/* Private typedef -----------------------------------------------------------*/
	11	/* Private define ------------------------------------------------------------*/
	12	/* Private macro -------------------------------------------------------------*/
	13	/* Private variables ---------------------------------------------------------*/
	14
	15	/* Global variable used to store variable value in read sequence */
	16	uint16_t DataVar = 0;
	17
	18	/* Virtual address defined by the user: 0xFFFF value is prohibited */
	19
	20	uint16_t VirtAddVarTab[NB_OF_VAR] = {0x5555, 0x6666, 0x7777};
	21	uint32_t Address = 0;
	22	/* Private function prototypes -----------------------------------------------*/
	23	/* Private functions ---------------------------------------------------------*/
	24	static HAL_StatusTypeDef EE_Format(void);
	25	static uint16_t EE_FindValidPage(uint8_t Operation);
	26	static uint16_t EE_VerifyPageFullWriteVariable(uint16_t VirtAddress, uint16_t Data);
	27	static uint16_t EE_PageTransfer(uint16_t VirtAddress, uint16_t Data);
	28	static uint16_t EE_VerifyPageFullyErased(uint32_t Address);
	29
	30	/**
	31	* @brief Restore the pages to a known good state in case of page's status
	32	* corruption after a power loss.
	33	* @param None.
	34	* @retval - Flash error code: on write Flash error
	35	* - FLASH_COMPLETE: on success
	36	*/
	37
	38	uint16_t EE_Init(void)
	39	{
	40	uint16_t PageStatus0 = 6, PageStatus1 = 6;
	41	uint16_t VarIdx = 0;
	42	uint16_t EepromStatus = 0, ReadStatus = 0;
	43	int16_t x = -1;
	44	HAL_StatusTypeDef FlashStatus;
	45	uint32_t SectorError = 0;
	46	FLASH_EraseInitTypeDef pEraseInit;
	47	uint32_t valid[8] = {0x0000};
	48
	49	/* Get Page0 status */
	50	PageStatus0 = ((__IO uint16_t)PAGE0_BASE_ADDRESS);
	51	/* Get Page1 status */
	52	PageStatus1 = ((__IO uint16_t)PAGE1_BASE_ADDRESS);
	53
	54	pEraseInit.TypeErase = TYPEERASE_SECTORS;
	55	pEraseInit.Banks = FLASH_BANK_2 ;
	56	pEraseInit.Sector = PAGE0_ID;
	57	pEraseInit.NbSectors = 1;
	58	pEraseInit.VoltageRange = VOLTAGE_RANGE;
	59
	60	/* Check for invalid header states and repair if necessary */
	61	switch (PageStatus0)
	62	{
	63	case ERASED:
	64	if (PageStatus1 == VALID_PAGE) /* Page0 erased, Page1 valid */
	65	{
	66	/* Erase Page0 */
	67	if(!EE_VerifyPageFullyErased(PAGE0_BASE_ADDRESS))
	68	{
	69	FlashStatus = HAL_FLASHEx_Erase(&pEraseInit, &SectorError);
	70	/* If erase operation was failed, a Flash error code is returned */
	71	if (FlashStatus != HAL_OK)
	72	{
	73	return FlashStatus;
	74	}
	75	}
	76	}
	77	else if (PageStatus1 == RECEIVE_DATA) /* Page0 erased, Page1 receive */
	78	{
	79	/* Erase Page0 */
	80	if(!EE_VerifyPageFullyErased(PAGE0_BASE_ADDRESS))
	81	{
	82	FlashStatus = HAL_FLASHEx_Erase(&pEraseInit, &SectorError);
	83	/* If erase operation was failed, a Flash error code is returned */
	84	if (FlashStatus != HAL_OK)
	85	{
	86	return FlashStatus;
	87	}
	88	}
	89	/* Mark Page1 as valid */
	90	FlashStatus = HAL_FLASH_Program(FLASH_TYPEPROGRAM_FLASHWORD, PAGE1_BASE_ADDRESS, ((uint32_t)valid));
	91
	92	/* If program operation was failed, a Flash error code is returned */
	93	if (FlashStatus != HAL_OK)
	94	{
	95	return FlashStatus;
	96	}
	97	}
	98	else /* First EEPROM access (Page0&1 are erased) or invalid state -> format EEPROM */
	99	{
	100	/* Erase both Page0 and Page1 and set Page0 as valid page */
	101	FlashStatus = EE_Format();
	102	/* If erase/program operation was failed, a Flash error code is returned */
	103	if (FlashStatus != HAL_OK)
	104	{
	105	return FlashStatus;
	106	}
	107	}
	108	break;
	109
	110	case RECEIVE_DATA:
	111	if (PageStatus1 == VALID_PAGE) /* Page0 receive, Page1 valid */
	112	{
	113	/* Transfer data from Page1 to Page0 */
	114	for (VarIdx = 0; VarIdx < NB_OF_VAR; VarIdx++)
	115	{
	116	if (( (__IO uint16_t)(PAGE0_BASE_ADDRESS + 6)) == VirtAddVarTab[VarIdx])
	117	{
	118	x = VarIdx;
	119	}
	120	if (VarIdx != x)
	121	{
	122	/* Read the last variables' updates */
	123	ReadStatus = EE_ReadVariable(VirtAddVarTab[VarIdx], &DataVar);
	124	/* In case variable corresponding to the virtual address was found */
	125	if (ReadStatus != 0x1)
	126	{
	127	/* Transfer the variable to the Page0 */
	128	EepromStatus = EE_VerifyPageFullWriteVariable(VirtAddVarTab[VarIdx], DataVar);
	129	/* If program operation was failed, a Flash error code is returned */
	130	if (EepromStatus != HAL_OK)
	131	{
	132	return EepromStatus;
	133	}
	134	}
	135	}
	136	}
	137	/* Mark Page0 as valid */
	138	FlashStatus = HAL_FLASH_Program(FLASH_TYPEPROGRAM_FLASHWORD, PAGE0_BASE_ADDRESS, ((uint32_t)valid));
	139
	140	/* If program operation was failed, a Flash error code is returned */
	141	if (FlashStatus != HAL_OK)
	142	{
	143	return FlashStatus;
	144	}
	145	pEraseInit.Sector = PAGE1_ID;
	146	pEraseInit.Banks = FLASH_BANK_2 ;
	147	pEraseInit.NbSectors = 1;
	148	pEraseInit.VoltageRange = VOLTAGE_RANGE;
	149	/* Erase Page1 */
	150	if(!EE_VerifyPageFullyErased(PAGE1_BASE_ADDRESS))
	151	{
	152	FlashStatus = HAL_FLASHEx_Erase(&pEraseInit, &SectorError);
	153	/* If erase operation was failed, a Flash error code is returned */
	154	if (FlashStatus != HAL_OK)
	155	{
	156	return FlashStatus;
	157	}
	158	}
	159	}
	160	else if (PageStatus1 == ERASED) /* Page0 receive, Page1 erased */
	161	{
	162	pEraseInit.Sector = PAGE1_ID;
	163	pEraseInit.Banks = FLASH_BANK_1 ;
	164	pEraseInit.NbSectors = 1;
	165	pEraseInit.VoltageRange = VOLTAGE_RANGE;
	166	/* Erase Page1 */
	167	if(!EE_VerifyPageFullyErased(PAGE1_BASE_ADDRESS))
	168	{
	169	FlashStatus = HAL_FLASHEx_Erase(&pEraseInit, &SectorError);
	170	/* If erase operation was failed, a Flash error code is returned */
	171	if (FlashStatus != HAL_OK)
	172	{
	173	return FlashStatus;
	174	}
	175	}
	176	/* Mark Page0 as valid */
	177	FlashStatus = HAL_FLASH_Program(FLASH_TYPEPROGRAM_FLASHWORD, PAGE0_BASE_ADDRESS, ((uint32_t)valid));
	178	/* If program operation was failed, a Flash error code is returned */
	179	if (FlashStatus != HAL_OK)
	180	{
	181	return FlashStatus;
	182	}
	183	}
	184	else /* Invalid state -> format eeprom */
	185	{
	186	/* Erase both Page0 and Page1 and set Page0 as valid page */
	187	FlashStatus = EE_Format();
	188	/* If erase/program operation was failed, a Flash error code is returned */
	189	if (FlashStatus != HAL_OK)
	190	{
	191	return FlashStatus;
	192	}
	193	}
	194	break;
	195
	196	case VALID_PAGE:
	197	if (PageStatus1 == VALID_PAGE) /* Invalid state -> format eeprom */
	198	{
	199	/* Erase both Page0 and Page1 and set Page0 as valid page */
	200	FlashStatus = EE_Format();
	201	/* If erase/program operation was failed, a Flash error code is returned */
	202	if (FlashStatus != HAL_OK)
	203	{
	204	return FlashStatus;
	205	}
	206	}
	207	else if (PageStatus1 == ERASED) /* Page0 valid, Page1 erased */
	208	{
	209	pEraseInit.Sector = PAGE1_ID;
	210	pEraseInit.Banks = FLASH_BANK_2 ;
	211	pEraseInit.NbSectors = 1;
	212	pEraseInit.VoltageRange = VOLTAGE_RANGE;
	213	/* Erase Page1 */
	214	if(!EE_VerifyPageFullyErased(PAGE1_BASE_ADDRESS))
	215	{
	216	FlashStatus = HAL_FLASHEx_Erase(&pEraseInit, &SectorError);
	217	/* If erase operation was failed, a Flash error code is returned */
	218	if (FlashStatus != HAL_OK)
	219	{
	220	return FlashStatus;
	221	}
	222	}
	223	}
	224	else /* Page0 valid, Page1 receive */
	225	{
	226	/* Transfer data from Page0 to Page1 */
	227	for (VarIdx = 0; VarIdx < NB_OF_VAR; VarIdx++)
	228	{
	229	if (((__IO uint16_t)(PAGE1_BASE_ADDRESS + 6)) == VirtAddVarTab[VarIdx])
	230	{
	231	x = VarIdx;
	232	}
	233	if (VarIdx != x)
	234	{
	235	/* Read the last variables' updates */
	236	ReadStatus = EE_ReadVariable(VirtAddVarTab[VarIdx], &DataVar);
	237	/* In case variable corresponding to the virtual address was found */
	238	if (ReadStatus != 0x1)
	239	{
	240	/* Transfer the variable to the Page1 */
	241	EepromStatus = EE_VerifyPageFullWriteVariable(VirtAddVarTab[VarIdx], DataVar);
	242	/* If program operation was failed, a Flash error code is returned */
	243	if (EepromStatus != HAL_OK)
	244	{
	245	return EepromStatus;
	246	}
	247	}
	248	}
	249	}
	250	/* Mark Page1 as valid */
	251	FlashStatus = HAL_FLASH_Program(FLASH_TYPEPROGRAM_FLASHWORD, PAGE1_BASE_ADDRESS, ((uint32_t)valid));
	252
	253	/* If program operation was failed, a Flash error code is returned */
	254	if (FlashStatus != HAL_OK)
	255	{
	256	return FlashStatus;
	257	}
	258	pEraseInit.Sector = PAGE0_ID;
	259	pEraseInit.Banks = FLASH_BANK_2 ;
	260	pEraseInit.NbSectors = 1;
	261	pEraseInit.VoltageRange = VOLTAGE_RANGE;
	262	/* Erase Page0 */
	263	if(!EE_VerifyPageFullyErased(PAGE0_BASE_ADDRESS))
	264	{
	265	FlashStatus = HAL_FLASHEx_Erase(&pEraseInit, &SectorError);
	266	/* If erase operation was failed, a Flash error code is returned */
	267	if (FlashStatus != HAL_OK)
	268	{
	269	return FlashStatus;
	270	}
	271	}
	272	}
	273	break;
	274
	275	default: /* Any other state -> format eeprom */
	276	/* Erase both Page0 and Page1 and set Page0 as valid page */
	277	FlashStatus = EE_Format();
	278	/* If erase/program operation was failed, a Flash error code is returned */
	279	if (FlashStatus != HAL_OK)
	280	{
	281	return FlashStatus;
	282	}
	283	break;
	284	}
	285
	286	return HAL_OK;
	287	}
	288
	289	/**
	290	* @brief Verify if specified page is fully erased.
	291	* @param Address: page address
	292	* This parameter can be one of the following values:
	293	* @arg PAGE0_BASE_ADDRESS: Page0 base address
	294	* @arg PAGE1_BASE_ADDRESS: Page1 base address
	295	* @retval page fully erased status:
	296	* - 0: if Page not erased
	297	* - 1: if Page erased
	298	*/
	299	uint16_t EE_VerifyPageFullyErased(uint32_t Address)
	300	{
	301	uint32_t ReadStatus = 1;
	302	uint16_t AddressValue = 0x5555;
	303
	304	/* Check each active page address starting from end */
	305	while (Address <= PAGE0_END_ADDRESS)
	306	{
	307	/* Get the current location content to be compared with virtual address */
	308	AddressValue = ((__IO uint16_t)Address);
	309
	310	/* Compare the read address with the virtual address */
	311	if (AddressValue != ERASED)
	312	{
	313
	314	/* In case variable value is read, reset ReadStatus flag */
	315	ReadStatus = 0;
	316
	317	break;
	318	}
	319	/* Next address location */
	320	Address = Address + 4;
	321	}
	322
	323	/* Return ReadStatus value: (0: Page not erased, 1: Sector erased) */
	324	return ReadStatus;
	325	}
	326
	327	/**
	328	* @brief Returns the last stored variable data, if found, which correspond to
	329	* the passed virtual address
	330	* @param VirtAddress: Variable virtual address
	331	* @param Data: Global variable contains the read variable value
	332	* @retval Success or error status:
	333	* - 0: if variable was found
	334	* - 1: if the variable was not found
	335	* - NO_VALID_PAGE: if no valid page was found.
	336	*/
	337	uint16_t EE_ReadVariable(uint16_t VirtAddress, uint16_t* Data)
	338	{
	339	uint16_t ValidPage = PAGE0;
	340	uint16_t AddressValue = 0x5555, ReadStatus = 1;
	341	uint32_t Address = EEPROM_START_ADDRESS, PageStartAddress = EEPROM_START_ADDRESS;
	342
	343	/* Get active Page for read operation */
	344	ValidPage = EE_FindValidPage(READ_FROM_VALID_PAGE);
	345
	346	/* Check if there is no valid page */
	347	if (ValidPage == NO_VALID_PAGE)
	348	{
	349	return NO_VALID_PAGE;
	350	}
	351
	352	/* Get the valid Page start Address */
	353	PageStartAddress = (uint32_t)(EEPROM_START_ADDRESS + (uint32_t)(ValidPage * PAGE_SIZE));
	354
	355	/* Get the valid Page end Address */
	356	Address = (uint32_t)((EEPROM_START_ADDRESS - 32) + (uint32_t)((1 + ValidPage) * PAGE_SIZE));
	357
	358	/* Check each active page address starting from end */
	359	while (Address > (PageStartAddress + 32))
	360	{
	361	/* Get the current location content to be compared with virtual address */
	362	AddressValue = ((__IO uint16_t)Address);
	363
	364	/* Compare the read address with the virtual address */
	365	if (AddressValue == VirtAddress)
	366	{
	367	/* Get content of Address-2 which is variable value */
	368	Data = ((__IO uint16_t*)(Address - 32));
	369
	370	/* In case variable value is read, reset ReadStatus flag */
	371	ReadStatus = 0;
	372
	373	break;
	374	}
	375	else
	376	{
	377	/* Next address location */
	378	Address = Address - 32;
	379	}
	380	}
	381
	382	/* Return ReadStatus value: (0: variable exist, 1: variable doesn't exist) */
	383	return ReadStatus;
	384	}
	385
	386	/**
	387	* @brief Writes/upadtes variable data in EEPROM.
	388	* @param VirtAddress: Variable virtual address
	389	* @param Data: 16 bit data to be written
	390	* @retval Success or error status:
	391	* - FLASH_COMPLETE: on success
	392	* - PAGE_FULL: if valid page is full
	393	* - NO_VALID_PAGE: if no valid page was found
	394	* - Flash error code: on write Flash error
	395	*/
	396	uint16_t EE_WriteVariable(uint16_t VirtAddress, uint16_t Data)
	397	{
	398	uint16_t Status = 0;
	399
	400	/* Write the variable virtual address and value in the EEPROM */
	401	Status = EE_VerifyPageFullWriteVariable(VirtAddress, Data);
	402
	403	/* In case the EEPROM active page is full */
	404	if (Status == PAGE_FULL)
	405	{
	406	/* Perform Page transfer */
	407	Status = EE_PageTransfer(VirtAddress, Data);
	408	}
	409
	410	/* Return last operation status */
	411	return Status;
	412	}
	413
	414	/**
	415	* @brief Erases PAGE and PAGE1 and writes VALID_PAGE header to PAGE
	416	* @param None
	417	* @retval Status of the last operation (Flash write or erase) done during
	418	* EEPROM formating
	419	*/
	420	static HAL_StatusTypeDef EE_Format(void)
	421	{
	422	HAL_StatusTypeDef FlashStatus = HAL_OK;
	423	uint32_t SectorError = 0;
	424	FLASH_EraseInitTypeDef pEraseInit;
	425	uint32_t valid[8] = {0x0000};
	426
	427	pEraseInit.TypeErase = FLASH_TYPEERASE_SECTORS;
	428	pEraseInit.Banks = FLASH_BANK_2 ;
	429	pEraseInit.Sector = PAGE0_ID;
	430	pEraseInit.NbSectors = 1;
	431	pEraseInit.VoltageRange = VOLTAGE_RANGE;
	432
	433	/* Erase Page0 */
	434	if(!EE_VerifyPageFullyErased(PAGE0_BASE_ADDRESS))
	435	{
	436	FlashStatus = HAL_FLASHEx_Erase(&pEraseInit, &SectorError);
	437	/* If erase operation was failed, a Flash error code is returned */
	438	if (FlashStatus != HAL_OK)
	439	{
	440	return FlashStatus;
	441	}
	442	}
	443
	444	/* Set Page0 as valid page: Write VALID_PAGE at Page0 base address */
	445	FlashStatus = HAL_FLASH_Program(FLASH_TYPEPROGRAM_FLASHWORD, PAGE0_BASE_ADDRESS,((uint32_t)valid));
	446
	447	/* If program operation was failed, a Flash error code is returned */
	448	if (FlashStatus != HAL_OK)
	449	{
	450	return FlashStatus;
	451	}
	452
	453	pEraseInit.Sector = PAGE1_ID;
	454	/* Erase Page1 */
	455	if(!EE_VerifyPageFullyErased(PAGE1_BASE_ADDRESS))
	456	{
	457	FlashStatus = HAL_FLASHEx_Erase(&pEraseInit, &SectorError);
	458	/* If erase operation was failed, a Flash error code is returned */
	459	if (FlashStatus != HAL_OK)
	460	{
	461	return FlashStatus;
	462	}
	463	}
	464
	465	return HAL_OK;
	466	}
	467
	468	/**
	469	* @brief Find valid Page for write or read operation
	470	* @param Operation: operation to achieve on the valid page.
	471	* This parameter can be one of the following values:
	472	* @arg READ_FROM_VALID_PAGE: read operation from valid page
	473	* @arg WRITE_IN_VALID_PAGE: write operation from valid page
	474	* @retval Valid page number (PAGE or PAGE1) or NO_VALID_PAGE in case
	475	* of no valid page was found
	476	*/
	477	static uint16_t EE_FindValidPage(uint8_t Operation)
	478	{
	479	uint16_t PageStatus0 = 6, PageStatus1 = 6;
	480
	481	/* Get Page0 actual status */
	482	PageStatus0 = ((__IO uint16_t)PAGE0_BASE_ADDRESS);
	483
	484	/* Get Page1 actual status */
	485	PageStatus1 = ((__IO uint16_t)PAGE1_BASE_ADDRESS);
	486
	487	/* Write or read operation */
	488	switch (Operation)
	489	{
	490	case WRITE_IN_VALID_PAGE: /* ---- Write operation ---- */
	491	if (PageStatus1 == VALID_PAGE)
	492	{
	493	/* Page0 receiving data */
	494	if (PageStatus0 == RECEIVE_DATA)
	495	{
	496	return PAGE0; /* Page0 valid */
	497	}
	498	else
	499	{
	500	return PAGE1; /* Page1 valid */
	501	}
	502	}
	503	else if (PageStatus0 == VALID_PAGE)
	504	{
	505	/* Page1 receiving data */
	506	if (PageStatus1 == RECEIVE_DATA)
	507	{
	508	return PAGE1; /* Page1 valid */
	509	}
	510	else
	511	{
	512	return PAGE0; /* Page0 valid */
	513	}
	514	}
	515	else
	516	{
	517	return NO_VALID_PAGE; /* No valid Page */
	518	}
	519
	520	case READ_FROM_VALID_PAGE: /* ---- Read operation ---- */
	521	if (PageStatus0 == VALID_PAGE)
	522	{
	523	return PAGE0; /* Page0 valid */
	524	}
	525	else if (PageStatus1 == VALID_PAGE)
	526	{
	527	return PAGE1; /* Page1 valid */
	528	}
	529	else
	530	{
	531	return NO_VALID_PAGE ; /* No valid Page */
	532	}
	533
	534	default:
	535	return PAGE0; /* Page0 valid */
	536	}
	537	}
	538
	539	/**
	540	* @brief Verify if active page is full and Writes variable in EEPROM.
	541	* @param VirtAddress: 16 bit virtual address of the variable
	542	* @param Data: 16 bit data to be written as variable value
	543	* @retval Success or error status:
	544	* - FLASH_COMPLETE: on success
	545	* - PAGE_FULL: if valid page is full
	546	* - NO_VALID_PAGE: if no valid page was found
	547	* - Flash error code: on write Flash error
	548	*/
	549	static uint16_t EE_VerifyPageFullWriteVariable(uint16_t VirtAddress, uint16_t Data)
	550	{
	551	HAL_StatusTypeDef FlashStatus = HAL_OK;
	552	uint16_t ValidPage = PAGE0;
	553	uint32_t Address = EEPROM_START_ADDRESS, PageEndAddress = EEPROM_START_ADDRESS+PAGE_SIZE;
	554
	555	uint32_t data32[8] = {Data};
	556	uint32_t VirtAddress1[8] = {VirtAddress};
	557	/* Get valid Page for write operation */
	558	ValidPage = EE_FindValidPage(WRITE_IN_VALID_PAGE);
	559
	560	/* Check if there is no valid page */
	561	if (ValidPage == NO_VALID_PAGE)
	562	{
	563	return NO_VALID_PAGE;
	564	}
	565
	566	/* Get the valid Page start Address */
	567	Address = (uint32_t)(EEPROM_START_ADDRESS + (uint32_t)(ValidPage * PAGE_SIZE));
	568
	569	/* Get the valid Page end Address */
	570	PageEndAddress = (uint32_t)((EEPROM_START_ADDRESS - 1) + (uint32_t)((ValidPage + 1) * PAGE_SIZE));
	571
	572	/* Check each active page address starting from begining */
	573	while (Address < PageEndAddress)
	574	{
	575	/* Verify if Address and Address+2 contents are 0xFFFFFFFF */
	576	if (((__IO uint32_t)Address) == 0xFFFFFFFF)
	577	{
	578	/* Set variable data */
	579	FlashStatus = HAL_FLASH_Program(FLASH_TYPEPROGRAM_FLASHWORD, Address, ((uint32_t)data32));
	580
	581	/* If program operation was failed, a Flash error code is returned */
	582	if (FlashStatus != HAL_OK)
	583	{
	584	return FlashStatus;
	585	}
	586	/* Set variable virtual address */
	587	FlashStatus = HAL_FLASH_Program(FLASH_TYPEPROGRAM_FLASHWORD, Address + 32, ((uint32_t)VirtAddress1));
	588
	589	/* Return program operation status */
	590	return FlashStatus;
	591	}
	592	else
	593	{
	594	/* Next address location */
	595	Address = Address + 64;
	596	}
	597	}
	598
	599	/* Return PAGE_FULL in case the valid page is full */
	600	return PAGE_FULL;
	601	}
	602
	603	/**
	604	* @brief Transfers last updated variables data from the full Page to
	605	* an empty one.
	606	* @param VirtAddress: 16 bit virtual address of the variable
	607	* @param Data: 16 bit data to be written as variable value
	608	* @retval Success or error status:
	609	* - FLASH_COMPLETE: on success
	610	* - PAGE_FULL: if valid page is full
	611	* - NO_VALID_PAGE: if no valid page was found
	612	* - Flash error code: on write Flash error
	613	*/
	614	static uint16_t EE_PageTransfer(uint16_t VirtAddress, uint16_t Data)
	615	{
	616	HAL_StatusTypeDef FlashStatus = HAL_OK;
	617	uint32_t NewPageAddress = EEPROM_START_ADDRESS;
	618	uint16_t OldPageId=0;
	619	uint16_t ValidPage = PAGE0, VarIdx = 0;
	620	uint16_t EepromStatus = 0, ReadStatus = 0;
	621	uint32_t SectorError = 0;
	622	FLASH_EraseInitTypeDef pEraseInit;
	623	uint32_t valid[8] = {0x0000};
	624	uint32_t receive[8] = {0xEEEE};
	625	/* Get active Page for read operation */
	626	ValidPage = EE_FindValidPage(READ_FROM_VALID_PAGE);
	627
	628	if (ValidPage == PAGE1) /* Page1 valid */
	629	{
	630	/* New page address where variable will be moved to */
	631	NewPageAddress = PAGE0_BASE_ADDRESS;
	632
	633	/* Old page ID where variable will be taken from */
	634	OldPageId = PAGE1_ID;
	635	}
	636	else if (ValidPage == PAGE0) /* Page0 valid */
	637	{
	638	/* New page address where variable will be moved to */
	639	NewPageAddress = PAGE1_BASE_ADDRESS;
	640
	641	/* Old page ID where variable will be taken from */
	642	OldPageId = PAGE0_ID;
	643	}
	644	else
	645	{
	646	return NO_VALID_PAGE; /* No valid Page */
	647	}
	648
	649	/* Set the new Page status to RECEIVE_DATA status */
	650
	651	FlashStatus = HAL_FLASH_Program(FLASH_TYPEPROGRAM_FLASHWORD, NewPageAddress, ((uint32_t)receive));
	652
	653	/* If program operation was failed, a Flash error code is returned */
	654	if (FlashStatus != HAL_OK)
	655	{
	656	return FlashStatus;
	657	}
	658
	659	/* Write the variable passed as parameter in the new active page */
	660	EepromStatus = EE_VerifyPageFullWriteVariable(VirtAddress, Data);
	661	/* If program operation was failed, a Flash error code is returned */
	662	if (EepromStatus != HAL_OK)
	663	{
	664	return EepromStatus;
	665	}
	666
	667	/* Transfer process: transfer variables from old to the new active page */
	668	for (VarIdx = 0; VarIdx < NB_OF_VAR; VarIdx++)
	669	{
	670	if (VirtAddVarTab[VarIdx] != VirtAddress) /* Check each variable except the one passed as parameter */
	671	{
	672	/* Read the other last variable updates */
	673	ReadStatus = EE_ReadVariable(VirtAddVarTab[VarIdx], &DataVar);
	674	/* In case variable corresponding to the virtual address was found */
	675	if (ReadStatus != 0x1)
	676	{
	677	/* Transfer the variable to the new active page */
	678	EepromStatus = EE_VerifyPageFullWriteVariable(VirtAddVarTab[VarIdx], DataVar);
	679	/* If program operation was failed, a Flash error code is returned */
	680	if (EepromStatus != HAL_OK)
	681	{
	682	return EepromStatus;
	683	}
	684	}
	685	}
	686	}
	687
	688	HAL_FLASH_Unlock();
	689
	690	/* Clear pending flags (if any) */
	691	__HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP \| FLASH_FLAG_OPERR \| FLASH_FLAG_WRPERR \|
	692	FLASH_FLAG_PGSERR \| FLASH_FLAG_WRPERR);
	693
	694	pEraseInit.TypeErase = TYPEERASE_SECTORS;
	695	pEraseInit.Banks = FLASH_BANK_2 ;
	696	pEraseInit.Sector = OldPageId;
	697	pEraseInit.NbSectors = 1;
	698	pEraseInit.VoltageRange = VOLTAGE_RANGE;
	699
	700	/* Erase the old Page: Set old Page status to ERASED status */
	701	FlashStatus = HAL_FLASHEx_Erase(&pEraseInit, &SectorError);
	702	/* If erase operation was failed, a Flash error code is returned */
	703	if (FlashStatus != HAL_OK)
	704	{
	705	return FlashStatus;
	706	}
	707
	708	/* Set new Page status to VALID_PAGE status */
	709	FlashStatus = HAL_FLASH_Program(FLASH_TYPEPROGRAM_FLASHWORD, NewPageAddress, ((uint32_t)valid));
	710	/* If program operation was failed, a Flash error code is returned */
	711	if (FlashStatus != HAL_OK)
	712	{
	713	return FlashStatus;
	714	}
	715
	716	/* Return last operation flash status */
	717	return FlashStatus;
	718	}

LEAF/Src/fatfs.c+56−0

@@ -0,0 +1,56 @@
	1	/**
	2	******************************************************************************
	3	* @file fatfs.c
	4	* @brief Code for fatfs applications
	5	******************************************************************************
	6	* @attention
	7	*
	8	* <h2><center>© Copyright (c) 2020 STMicroelectronics.
	9	* All rights reserved.</center></h2>
	10	*
	11	* This software component is licensed by ST under Ultimate Liberty license
	12	* SLA0044, the "License"; You may not use this file except in compliance with
	13	* the License. You may obtain a copy of the License at:
	14	* www.st.com/SLA0044
	15	*
	16	******************************************************************************
	17	*/
	18
	19	#include "fatfs.h"
	20
	21	uint8_t retSD; /* Return value for SD */
	22	char SDPath[4]; /* SD logical drive path */
	23	FATFS SDFatFS; /* File system object for SD logical drive */
	24	FIL SDFile; /* File object for SD */
	25
	26	/* USER CODE BEGIN Variables */
	27
	28	/* USER CODE END Variables */
	29
	30	void MX_FATFS_Init(void)
	31	{
	32	/## FatFS: Link the SD driver ###########################/
	33	retSD = FATFS_LinkDriver(&SD_Driver, SDPath);
	34
	35	/* USER CODE BEGIN Init */
	36	/* additional user code for init */
	37	/* USER CODE END Init */
	38	}
	39
	40	/**
	41	* @brief Gets Time from RTC
	42	* @param None
	43	* @retval Time in DWORD
	44	*/
	45	DWORD get_fattime(void)
	46	{
	47	/* USER CODE BEGIN get_fattime */
	48	return 0;
	49	/* USER CODE END get_fattime */
	50	}
	51
	52	/* USER CODE BEGIN Application */
	53
	54	/* USER CODE END Application */
	55
	56	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

LEAF/Src/fatfs_platform.c+31−0

@@ -0,0 +1,31 @@
	1	/**
	2	******************************************************************************
	3	* @file : fatfs_platform.c
	4	* @brief : fatfs_platform source file
	5	******************************************************************************
	6	* @attention
	7	*
	8	* <h2><center>© Copyright (c) 2020 STMicroelectronics.
	9	* All rights reserved.</center></h2>
	10	*
	11	* This software component is licensed by ST under Ultimate Liberty license
	12	* SLA0044, the "License"; You may not use this file except in compliance with
	13	* the License. You may obtain a copy of the License at:
	14	* www.st.com/SLA0044
	15	*
	16	******************************************************************************
	17	*/
	18	#include "fatfs_platform.h"
	19
	20	uint8_t BSP_PlatformIsDetected(void) {
	21	uint8_t status = SD_PRESENT;
	22	/* Check SD card detect pin */
	23	if(HAL_GPIO_ReadPin(SD_DETECT_GPIO_PORT, SD_DETECT_PIN) != GPIO_PIN_RESET)
	24	{
	25	status = SD_NOT_PRESENT;
	26	}
	27	/* USER CODE BEGIN 1 */
	28	/* user code can be inserted here */
	29	/* USER CODE END 1 */
	30	return status;
	31	}

LEAF/Src/fmc.c+281−0

@@ -0,0 +1,281 @@
	1	/**
	2	******************************************************************************
	3	* File Name : FMC.c
	4	* Description : This file provides code for the configuration
	5	* of the FMC peripheral.
	6	******************************************************************************
	7	* @attention
	8	*
	9	* <h2><center>© Copyright (c) 2020 STMicroelectronics.
	10	* All rights reserved.</center></h2>
	11	*
	12	* This software component is licensed by ST under Ultimate Liberty license
	13	* SLA0044, the "License"; You may not use this file except in compliance with
	14	* the License. You may obtain a copy of the License at:
	15	* www.st.com/SLA0044
	16	*
	17	******************************************************************************
	18	*/
	19
	20	/* Includes ------------------------------------------------------------------*/
	21	#include "fmc.h"
	22
	23	/* USER CODE BEGIN 0 */
	24
	25	/* USER CODE END 0 */
	26
	27	SDRAM_HandleTypeDef hsdram1;
	28
	29	/* FMC initialization function */
	30	void MX_FMC_Init(void)
	31	{
	32	FMC_SDRAM_TimingTypeDef SdramTiming = {0};
	33
	34	/** Perform the SDRAM1 memory initialization sequence
	35	*/
	36	hsdram1.Instance = FMC_SDRAM_DEVICE;
	37	/* hsdram1.Init */
	38	hsdram1.Init.SDBank = FMC_SDRAM_BANK1;
	39	hsdram1.Init.ColumnBitsNumber = FMC_SDRAM_COLUMN_BITS_NUM_9;
	40	hsdram1.Init.RowBitsNumber = FMC_SDRAM_ROW_BITS_NUM_13;
	41	hsdram1.Init.MemoryDataWidth = FMC_SDRAM_MEM_BUS_WIDTH_16;
	42	hsdram1.Init.InternalBankNumber = FMC_SDRAM_INTERN_BANKS_NUM_4;
	43	hsdram1.Init.CASLatency = FMC_SDRAM_CAS_LATENCY_2;
	44	hsdram1.Init.WriteProtection = FMC_SDRAM_WRITE_PROTECTION_DISABLE;
	45	hsdram1.Init.SDClockPeriod = FMC_SDRAM_CLOCK_PERIOD_3;
	46	hsdram1.Init.ReadBurst = FMC_SDRAM_RBURST_ENABLE;
	47	hsdram1.Init.ReadPipeDelay = FMC_SDRAM_RPIPE_DELAY_0;
	48	/* SdramTiming */
	49	SdramTiming.LoadToActiveDelay = 2;
	50	SdramTiming.ExitSelfRefreshDelay = 6;
	51	SdramTiming.SelfRefreshTime = 4;
	52	SdramTiming.RowCycleDelay = 6;
	53	SdramTiming.WriteRecoveryTime = 2;
	54	SdramTiming.RPDelay = 2;
	55	SdramTiming.RCDDelay = 2;
	56
	57	if (HAL_SDRAM_Init(&hsdram1, &SdramTiming) != HAL_OK)
	58	{
	59	Error_Handler( );
	60	}
	61
	62	HAL_SetFMCMemorySwappingConfig(FMC_SWAPBMAP_SDRAM_SRAM);
	63
	64	}
	65
	66	static uint32_t FMC_Initialized = 0;
	67
	68	static void HAL_FMC_MspInit(void){
	69	/* USER CODE BEGIN FMC_MspInit 0 */
	70
	71	/* USER CODE END FMC_MspInit 0 */
	72	GPIO_InitTypeDef GPIO_InitStruct = {0};
	73	if (FMC_Initialized) {
	74	return;
	75	}
	76	FMC_Initialized = 1;
	77
	78	/* Peripheral clock enable */
	79	__HAL_RCC_FMC_CLK_ENABLE();
	80
	81	/** FMC GPIO Configuration
	82	PF0 ------> FMC_A0
	83	PF1 ------> FMC_A1
	84	PF2 ------> FMC_A2
	85	PF3 ------> FMC_A3
	86	PF4 ------> FMC_A4
	87	PF5 ------> FMC_A5
	88	PC0 ------> FMC_SDNWE
	89	PC2_C ------> FMC_SDNE0
	90	PC3_C ------> FMC_SDCKE0
	91	PF11 ------> FMC_SDNRAS
	92	PF12 ------> FMC_A6
	93	PF13 ------> FMC_A7
	94	PF14 ------> FMC_A8
	95	PF15 ------> FMC_A9
	96	PG0 ------> FMC_A10
	97	PG1 ------> FMC_A11
	98	PE7 ------> FMC_D4
	99	PE8 ------> FMC_D5
	100	PE9 ------> FMC_D6
	101	PE10 ------> FMC_D7
	102	PE11 ------> FMC_D8
	103	PE12 ------> FMC_D9
	104	PE13 ------> FMC_D10
	105	PE14 ------> FMC_D11
	106	PE15 ------> FMC_D12
	107	PD8 ------> FMC_D13
	108	PD9 ------> FMC_D14
	109	PD10 ------> FMC_D15
	110	PD14 ------> FMC_D0
	111	PD15 ------> FMC_D1
	112	PG2 ------> FMC_A12
	113	PG4 ------> FMC_BA0
	114	PG5 ------> FMC_BA1
	115	PG8 ------> FMC_SDCLK
	116	PD0 ------> FMC_D2
	117	PD1 ------> FMC_D3
	118	PG15 ------> FMC_SDNCAS
	119	PE0 ------> FMC_NBL0
	120	PE1 ------> FMC_NBL1
	121	*/
	122	/* GPIO_InitStruct */
	123	GPIO_InitStruct.Pin = GPIO_PIN_0\|GPIO_PIN_1\|GPIO_PIN_2\|GPIO_PIN_3
	124	\|GPIO_PIN_4\|GPIO_PIN_5\|GPIO_PIN_11\|GPIO_PIN_12
	125	\|GPIO_PIN_13\|GPIO_PIN_14\|GPIO_PIN_15;
	126	GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
	127	GPIO_InitStruct.Pull = GPIO_NOPULL;
	128	GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
	129	GPIO_InitStruct.Alternate = GPIO_AF12_FMC;
	130
	131	HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);
	132
	133	/* GPIO_InitStruct */
	134	GPIO_InitStruct.Pin = GPIO_PIN_0\|GPIO_PIN_2\|GPIO_PIN_3;
	135	GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
	136	GPIO_InitStruct.Pull = GPIO_NOPULL;
	137	GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
	138	GPIO_InitStruct.Alternate = GPIO_AF12_FMC;
	139
	140	HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
	141
	142	/* GPIO_InitStruct */
	143	GPIO_InitStruct.Pin = GPIO_PIN_0\|GPIO_PIN_1\|GPIO_PIN_2\|GPIO_PIN_4
	144	\|GPIO_PIN_5\|GPIO_PIN_8\|GPIO_PIN_15;
	145	GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
	146	GPIO_InitStruct.Pull = GPIO_NOPULL;
	147	GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
	148	GPIO_InitStruct.Alternate = GPIO_AF12_FMC;
	149
	150	HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);
	151
	152	/* GPIO_InitStruct */
	153	GPIO_InitStruct.Pin = GPIO_PIN_7\|GPIO_PIN_8\|GPIO_PIN_9\|GPIO_PIN_10
	154	\|GPIO_PIN_11\|GPIO_PIN_12\|GPIO_PIN_13\|GPIO_PIN_14
	155	\|GPIO_PIN_15\|GPIO_PIN_0\|GPIO_PIN_1;
	156	GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
	157	GPIO_InitStruct.Pull = GPIO_NOPULL;
	158	GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
	159	GPIO_InitStruct.Alternate = GPIO_AF12_FMC;
	160
	161	HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
	162
	163	/* GPIO_InitStruct */
	164	GPIO_InitStruct.Pin = GPIO_PIN_8\|GPIO_PIN_9\|GPIO_PIN_10\|GPIO_PIN_14
	165	\|GPIO_PIN_15\|GPIO_PIN_0\|GPIO_PIN_1;
	166	GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
	167	GPIO_InitStruct.Pull = GPIO_NOPULL;
	168	GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
	169	GPIO_InitStruct.Alternate = GPIO_AF12_FMC;
	170
	171	HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
	172
	173	/* USER CODE BEGIN FMC_MspInit 1 */
	174
	175	/* USER CODE END FMC_MspInit 1 */
	176	}
	177
	178	void HAL_SDRAM_MspInit(SDRAM_HandleTypeDef* sdramHandle){
	179	/* USER CODE BEGIN SDRAM_MspInit 0 */
	180
	181	/* USER CODE END SDRAM_MspInit 0 */
	182	HAL_FMC_MspInit();
	183	/* USER CODE BEGIN SDRAM_MspInit 1 */
	184
	185	/* USER CODE END SDRAM_MspInit 1 */
	186	}
	187
	188	static uint32_t FMC_DeInitialized = 0;
	189
	190	static void HAL_FMC_MspDeInit(void){
	191	/* USER CODE BEGIN FMC_MspDeInit 0 */
	192
	193	/* USER CODE END FMC_MspDeInit 0 */
	194	if (FMC_DeInitialized) {
	195	return;
	196	}
	197	FMC_DeInitialized = 1;
	198	/* Peripheral clock enable */
	199	__HAL_RCC_FMC_CLK_DISABLE();
	200
	201	/** FMC GPIO Configuration
	202	PF0 ------> FMC_A0
	203	PF1 ------> FMC_A1
	204	PF2 ------> FMC_A2
	205	PF3 ------> FMC_A3
	206	PF4 ------> FMC_A4
	207	PF5 ------> FMC_A5
	208	PC0 ------> FMC_SDNWE
	209	PC2_C ------> FMC_SDNE0
	210	PC3_C ------> FMC_SDCKE0
	211	PF11 ------> FMC_SDNRAS
	212	PF12 ------> FMC_A6
	213	PF13 ------> FMC_A7
	214	PF14 ------> FMC_A8
	215	PF15 ------> FMC_A9
	216	PG0 ------> FMC_A10
	217	PG1 ------> FMC_A11
	218	PE7 ------> FMC_D4
	219	PE8 ------> FMC_D5
	220	PE9 ------> FMC_D6
	221	PE10 ------> FMC_D7
	222	PE11 ------> FMC_D8
	223	PE12 ------> FMC_D9
	224	PE13 ------> FMC_D10
	225	PE14 ------> FMC_D11
	226	PE15 ------> FMC_D12
	227	PD8 ------> FMC_D13
	228	PD9 ------> FMC_D14
	229	PD10 ------> FMC_D15
	230	PD14 ------> FMC_D0
	231	PD15 ------> FMC_D1
	232	PG2 ------> FMC_A12
	233	PG4 ------> FMC_BA0
	234	PG5 ------> FMC_BA1
	235	PG8 ------> FMC_SDCLK
	236	PD0 ------> FMC_D2
	237	PD1 ------> FMC_D3
	238	PG15 ------> FMC_SDNCAS
	239	PE0 ------> FMC_NBL0
	240	PE1 ------> FMC_NBL1
	241	*/
	242
	243	HAL_GPIO_DeInit(GPIOF, GPIO_PIN_0\|GPIO_PIN_1\|GPIO_PIN_2\|GPIO_PIN_3
	244	\|GPIO_PIN_4\|GPIO_PIN_5\|GPIO_PIN_11\|GPIO_PIN_12
	245	\|GPIO_PIN_13\|GPIO_PIN_14\|GPIO_PIN_15);
	246
	247	HAL_GPIO_DeInit(GPIOC, GPIO_PIN_0\|GPIO_PIN_2\|GPIO_PIN_3);
	248
	249	HAL_GPIO_DeInit(GPIOG, GPIO_PIN_0\|GPIO_PIN_1\|GPIO_PIN_2\|GPIO_PIN_4
	250	\|GPIO_PIN_5\|GPIO_PIN_8\|GPIO_PIN_15);
	251
	252	HAL_GPIO_DeInit(GPIOE, GPIO_PIN_7\|GPIO_PIN_8\|GPIO_PIN_9\|GPIO_PIN_10
	253	\|GPIO_PIN_11\|GPIO_PIN_12\|GPIO_PIN_13\|GPIO_PIN_14
	254	\|GPIO_PIN_15\|GPIO_PIN_0\|GPIO_PIN_1);
	255
	256	HAL_GPIO_DeInit(GPIOD, GPIO_PIN_8\|GPIO_PIN_9\|GPIO_PIN_10\|GPIO_PIN_14
	257	\|GPIO_PIN_15\|GPIO_PIN_0\|GPIO_PIN_1);
	258
	259	/* USER CODE BEGIN FMC_MspDeInit 1 */
	260
	261	/* USER CODE END FMC_MspDeInit 1 */
	262	}
	263
	264	void HAL_SDRAM_MspDeInit(SDRAM_HandleTypeDef* sdramHandle){
	265	/* USER CODE BEGIN SDRAM_MspDeInit 0 */
	266
	267	/* USER CODE END SDRAM_MspDeInit 0 */
	268	HAL_FMC_MspDeInit();
	269	/* USER CODE BEGIN SDRAM_MspDeInit 1 */
	270
	271	/* USER CODE END SDRAM_MspDeInit 1 */
	272	}
	273	/**
	274	* @}
	275	*/
	276
	277	/**
	278	* @}
	279	*/
	280
	281	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

LEAF/Src/gfx.c+983−0

@@ -0,0 +1,983 @@
	1	/*
	2	* gfx.c
	3	* a C port of the Adafruit GFX library
	4	* Created on: Jul 8, 2018
	5	* Author: jeffsnyder
	6	*/
	7
	8
	9	/*
	10	This is the core graphics library for all our displays, providing a common
	11	set of graphics primitives (points, lines, circles, etc.). It needs to be
	12	paired with a hardware-specific library for each display device we carry
	13	(to handle the lower-level functions).
	14
	15	Adafruit invests time and resources providing this open source code, please
	16	support Adafruit & open-source hardware by purchasing products from Adafruit!
	17
	18	Copyright (c) 2013 Adafruit Industries. All rights reserved.
	19
	20	Redistribution and use in source and binary forms, with or without
	21	modification, are permitted provided that the following conditions are met:
	22
	23	- Redistributions of source code must retain the above copyright notice,
	24	this list of conditions and the following disclaimer.
	25	- Redistributions in binary form must reproduce the above copyright notice,
	26	this list of conditions and the following disclaimer in the documentation
	27	and/or other materials provided with the distribution.
	28
	29	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
	30	AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	31	IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	32	ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
	33	LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	34	CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	35	SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	36	INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	37	CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	38	ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	39	POSSIBILITY OF SUCH DAMAGE.
	40	*/
	41	#include "stm32h7xx_hal.h"
	42	#include "gfx.h"
	43	#include "gfx_font.c"
	44	#include "main.h"
	45
	46	// Many (but maybe not all) non-AVR board installs define macros
	47	// for compatibility with existing PROGMEM-reading AVR code.
	48	// Do our own checks and defines here for good measure...
	49
	50	#ifndef pgm_read_byte
	51	#define pgm_read_byte(addr) ((const unsigned char )(addr))
	52	#endif
	53	#ifndef pgm_read_word
	54	#define pgm_read_word(addr) ((const unsigned short )(addr))
	55	#endif
	56	#ifndef pgm_read_dword
	57	#define pgm_read_dword(addr) ((const unsigned long )(addr))
	58	#endif
	59
	60	// Pointers are a peculiar case...typically 16-bit on AVR boards,
	61	// 32 bits elsewhere. Try to accommodate both...
	62
	63
	64	#define pgm_read_pointer(addr) ((void *)pgm_read_dword(addr))
	65
	66
	67	#ifndef min
	68	#define min(a,b) (((a) < (b)) ? (a) : (b))
	69	#endif
	70
	71	#ifndef _swap_int16_t
	72	#define _swap_int16_t(a, b) { int16_t t = a; a = b; b = t; }
	73	#endif
	74
	75	void GFXinit(GFX* myGfx, int16_t w, int16_t h)
	76	{
	77	myGfx->WIDTH = w;
	78	myGfx->HEIGHT = h;
	79	myGfx->_width = w;
	80	myGfx->_height = h;
	81	myGfx->rotation = 0;
	82	myGfx->cursor_y = 0;
	83	myGfx->cursor_x = 0;
	84	myGfx->textsize = 1;
	85	myGfx->textcolor = 0xFFFF;
	86	myGfx->textbgcolor = 0xFFFF;
	87	myGfx->wrap = 1;
	88	myGfx->_cp437 = 0;
	89	myGfx->gfxFont = NULL;
	90	}
	91
	92	// Bresenham's algorithm - thx wikpedia
	93	void GFXwriteLine(GFX* myGFX, int16_t x0, int16_t y0, int16_t x1, int16_t y1,
	94	uint16_t color) {
	95	int16_t steep = abs(y1 - y0) > abs(x1 - x0);
	96	if (steep) {
	97	_swap_int16_t(x0, y0);
	98	_swap_int16_t(x1, y1);
	99	}
	100
	101	if (x0 > x1) {
	102	_swap_int16_t(x0, x1);
	103	_swap_int16_t(y0, y1);
	104	}
	105
	106	int16_t dx, dy;
	107	dx = x1 - x0;
	108	dy = abs(y1 - y0);
	109
	110	int16_t err = dx / 2;
	111	int16_t ystep;
	112
	113	if (y0 < y1) {
	114	ystep = 1;
	115	} else {
	116	ystep = -1;
	117	}
	118
	119	for (; x0<=x1; x0++) {
	120	if (steep) {
	121	GFXwritePixel(myGFX, y0, x0, color);
	122	} else {
	123	GFXwritePixel(myGFX, x0, y0, color);
	124	}
	125	err -= dy;
	126	if (err < 0) {
	127	y0 += ystep;
	128	err += dx;
	129	}
	130	}
	131	}
	132
	133	void GFXstartWrite(GFX* myGFX){
	134	// Overwrite in subclasses if desired!
	135	}
	136
	137	// the most basic function, set a single pixel
	138	void GFXdrawPixel(GFX* myGFX, int16_t x, int16_t y, uint16_t color) {
	139	if ((x < 0) \|\| (x >= myGFX->_width) \|\| (y < 0) \|\| (y >= myGFX->_height))
	140	return;
	141
	142	// check rotation, move pixel around if necessary
	143	switch (GFXgetRotation(myGFX)) {
	144	case 1:
	145	_swap_int16_t(x, y);
	146	x = myGFX->WIDTH - x - 1;
	147	break;
	148	case 2:
	149	x = myGFX->WIDTH - x - 1;
	150	y = myGFX->HEIGHT - y - 1;
	151	break;
	152	case 3:
	153	_swap_int16_t(x, y);
	154	y = myGFX->HEIGHT - y - 1;
	155	break;
	156	}
	157
	158	// x is which column
	159	switch (color)
	160	{
	161	case WHITE: buffer[x+ (y/8)*myGFX->WIDTH] \|= (1 << (y&7)); break;
	162	case BLACK: buffer[x+ (y/8)*myGFX->WIDTH] &= ~(1 << (y&7)); break;
	163	case INVERSE: buffer[x+ (y/8)*myGFX->WIDTH] ^= (1 << (y&7)); break;
	164	}
	165
	166	}
	167
	168	void GFXwritePixel(GFX* myGFX,int16_t x, int16_t y, uint16_t color){
	169	// Overwrite in subclasses if startWrite is defined!
	170	GFXdrawPixel(myGFX, x, y, color);
	171	}
	172
	173	// (x,y) is topmost point; if unsure, calling function
	174	// should sort endpoints or call writeLine() instead
	175	void GFXwriteFastVLine(GFX* myGFX,int16_t x, int16_t y,
	176	int16_t h, uint16_t color) {
	177	// Overwrite in subclasses if startWrite is defined!
	178	// Can be just writeLine(x, y, x, y+h-1, color);
	179	// or writeFillRect(x, y, 1, h, color);
	180	GFXdrawFastVLine(myGFX, x, y, h, color);
	181	}
	182
	183	// (x,y) is leftmost point; if unsure, calling function
	184	// should sort endpoints or call writeLine() instead
	185	void GFXwriteFastHLine(GFX* myGFX, int16_t x, int16_t y,
	186	int16_t w, uint16_t color) {
	187	// Overwrite in subclasses if startWrite is defined!
	188	// Example: writeLine(x, y, x+w-1, y, color);
	189	// or writeFillRect(x, y, w, 1, color);
	190	GFXdrawFastHLine(myGFX,x, y, w, color);
	191	}
	192
	193	void GFXwriteFillRect(GFX* myGFX,int16_t x, int16_t y, int16_t w, int16_t h,
	194	uint16_t color) {
	195	// Overwrite in subclasses if desired!
	196	GFXfillRect(myGFX,x,y,w,h,color);
	197	}
	198
	199	void GFXendWrite(GFX* myGFX){
	200	// Overwrite in subclasses if startWrite is defined!
	201	}
	202
	203	// (x,y) is topmost point; if unsure, calling function
	204	// should sort endpoints or call drawLine() instead
	205	void GFXdrawFastVLine(GFX* myGFX,int16_t x, int16_t y,
	206	int16_t h, uint16_t color) {
	207	// Update in subclasses if desired!
	208	GFXwriteLine(myGFX,x, y, x, y+h-1, color);
	209	}
	210
	211	// (x,y) is leftmost point; if unsure, calling function
	212	// should sort endpoints or call drawLine() instead
	213	void GFXdrawFastHLine(GFX* myGFX,int16_t x, int16_t y,
	214	int16_t w, uint16_t color) {
	215	// Update in subclasses if desired!
	216	GFXwriteLine(myGFX,x, y, x+w-1, y, color);
	217	}
	218
	219	void GFXfillRect(GFX* myGFX,int16_t x, int16_t y, int16_t w, int16_t h,
	220	uint16_t color) {
	221	// Update in subclasses if desired!
	222	for (int16_t i=x; i<x+w; i++) {
	223	GFXwriteFastVLine(myGFX,i, y, h, color);
	224	}
	225	}
	226
	227	void GFXfillScreen(GFX* myGFX,uint16_t color) {
	228	// Update in subclasses if desired!
	229	GFXfillRect(myGFX,0, 0, myGFX->_width, myGFX->_height, color);
	230	}
	231
	232	void GFXdrawLine(GFX* myGFX,int16_t x0, int16_t y0, int16_t x1, int16_t y1,
	233	uint16_t color) {
	234	// Update in subclasses if desired!
	235	if(x0 == x1){
	236	if(y0 > y1) _swap_int16_t(y0, y1);
	237	GFXdrawFastVLine(myGFX,x0, y0, y1 - y0 + 1, color);
	238	} else if(y0 == y1){
	239	if(x0 > x1) _swap_int16_t(x0, x1);
	240	GFXdrawFastHLine(myGFX,x0, y0, x1 - x0 + 1, color);
	241	} else {
	242	GFXwriteLine(myGFX,x0, y0, x1, y1, color);
	243	}
	244	}
	245
	246	// Draw a circle outline
	247	void GFXdrawCircle(GFX* myGFX,int16_t x0, int16_t y0, int16_t r,
	248	uint16_t color) {
	249	int16_t f = 1 - r;
	250	int16_t ddF_x = 1;
	251	int16_t ddF_y = -2 * r;
	252	int16_t x = 0;
	253	int16_t y = r;
	254
	255	GFXwritePixel(myGFX,x0 , y0+r, color);
	256	GFXwritePixel(myGFX,x0 , y0-r, color);
	257	GFXwritePixel(myGFX,x0+r, y0 , color);
	258	GFXwritePixel(myGFX,x0-r, y0 , color);
	259
	260	while (x<y) {
	261	if (f >= 0) {
	262	y--;
	263	ddF_y += 2;
	264	f += ddF_y;
	265	}
	266	x++;
	267	ddF_x += 2;
	268	f += ddF_x;
	269
	270	GFXwritePixel(myGFX,x0 + x, y0 + y, color);
	271	GFXwritePixel(myGFX,x0 - x, y0 + y, color);
	272	GFXwritePixel(myGFX,x0 + x, y0 - y, color);
	273	GFXwritePixel(myGFX,x0 - x, y0 - y, color);
	274	GFXwritePixel(myGFX,x0 + y, y0 + x, color);
	275	GFXwritePixel(myGFX,x0 - y, y0 + x, color);
	276	GFXwritePixel(myGFX,x0 + y, y0 - x, color);
	277	GFXwritePixel(myGFX,x0 - y, y0 - x, color);
	278	}
	279
	280	}
	281
	282	void GFXdrawCircleHelper(GFX* myGFX,int16_t x0, int16_t y0,
	283	int16_t r, uint8_t cornername, uint16_t color) {
	284	int16_t f = 1 - r;
	285	int16_t ddF_x = 1;
	286	int16_t ddF_y = -2 * r;
	287	int16_t x = 0;
	288	int16_t y = r;
	289
	290	while (x<y) {
	291	if (f >= 0) {
	292	y--;
	293	ddF_y += 2;
	294	f += ddF_y;
	295	}
	296	x++;
	297	ddF_x += 2;
	298	f += ddF_x;
	299	if (cornername & 0x4) {
	300	GFXwritePixel(myGFX, x0 + x, y0 + y, color);
	301	GFXwritePixel(myGFX, x0 + y, y0 + x, color);
	302	}
	303	if (cornername & 0x2) {
	304	GFXwritePixel(myGFX, x0 + x, y0 - y, color);
	305	GFXwritePixel(myGFX, x0 + y, y0 - x, color);
	306	}
	307	if (cornername & 0x8) {
	308	GFXwritePixel(myGFX, x0 - y, y0 + x, color);
	309	GFXwritePixel(myGFX, x0 - x, y0 + y, color);
	310	}
	311	if (cornername & 0x1) {
	312	GFXwritePixel(myGFX, x0 - y, y0 - x, color);
	313	GFXwritePixel(myGFX, x0 - x, y0 - y, color);
	314	}
	315	}
	316	}
	317
	318	void GFXfillCircle(GFX* myGFX, int16_t x0, int16_t y0, int16_t r,
	319	uint16_t color) {
	320
	321	GFXwriteFastVLine(myGFX, x0, y0-r, 2*r+1, color);
	322	GFXfillCircleHelper(myGFX, x0, y0, r, 3, 0, color);
	323
	324	}
	325
	326	// Used to do circles and roundrects
	327	void GFXfillCircleHelper(GFX* myGFX, int16_t x0, int16_t y0, int16_t r,
	328	uint8_t cornername, int16_t delta, uint16_t color) {
	329
	330	int16_t f = 1 - r;
	331	int16_t ddF_x = 1;
	332	int16_t ddF_y = -2 * r;
	333	int16_t x = 0;
	334	int16_t y = r;
	335
	336	while (x<y) {
	337	if (f >= 0) {
	338	y--;
	339	ddF_y += 2;
	340	f += ddF_y;
	341	}
	342	x++;
	343	ddF_x += 2;
	344	f += ddF_x;
	345
	346	if (cornername & 0x1) {
	347	GFXwriteFastVLine(myGFX, x0+x, y0-y, 2*y+1+delta, color);
	348	GFXwriteFastVLine(myGFX, x0+y, y0-x, 2*x+1+delta, color);
	349	}
	350	if (cornername & 0x2) {
	351	GFXwriteFastVLine(myGFX, x0-x, y0-y, 2*y+1+delta, color);
	352	GFXwriteFastVLine(myGFX, x0-y, y0-x, 2*x+1+delta, color);
	353	}
	354	}
	355	}
	356
	357	// Draw a rectangle
	358	void GFXdrawRect(GFX* myGFX, int16_t x, int16_t y, int16_t w, int16_t h,
	359	uint16_t color) {
	360
	361	GFXwriteFastHLine(myGFX, x, y, w, color);
	362	GFXwriteFastHLine(myGFX, x, y+h-1, w, color);
	363	GFXwriteFastVLine(myGFX, x, y, h, color);
	364	GFXwriteFastVLine(myGFX, x+w-1, y, h, color);
	365
	366	}
	367
	368	// Draw a rounded rectangle
	369	void GFXdrawRoundRect(GFX* myGFX, int16_t x, int16_t y, int16_t w,
	370	int16_t h, int16_t r, uint16_t color) {
	371	// smarter version
	372	GFXwriteFastHLine(myGFX, x+r , y , w-2*r, color); // Top
	373	GFXwriteFastHLine(myGFX, x+r , y+h-1, w-2*r, color); // Bottom
	374	GFXwriteFastVLine(myGFX, x , y+r , h-2*r, color); // Left
	375	GFXwriteFastVLine(myGFX, x+w-1, y+r , h-2*r, color); // Right
	376	// draw four corners
	377	GFXdrawCircleHelper(myGFX, x+r , y+r , r, 1, color);
	378	GFXdrawCircleHelper(myGFX, x+w-r-1, y+r , r, 2, color);
	379	GFXdrawCircleHelper(myGFX, x+w-r-1, y+h-r-1, r, 4, color);
	380	GFXdrawCircleHelper(myGFX, x+r , y+h-r-1, r, 8, color);
	381
	382	}
	383
	384	// Fill a rounded rectangle
	385	void GFXfillRoundRect(GFX* myGFX, int16_t x, int16_t y, int16_t w,
	386	int16_t h, int16_t r, uint16_t color) {
	387	// smarter version
	388	GFXwriteFillRect(myGFX, x+r, y, w-2*r, h, color);
	389	// draw four corners
	390	GFXfillCircleHelper(myGFX, x+w-r-1, y+r, r, 1, h-2*r-1, color);
	391	GFXfillCircleHelper(myGFX, x+r , y+r, r, 2, h-2*r-1, color);
	392
	393	}
	394
	395	// Draw a triangle
	396	void GFXdrawTriangle(GFX* myGFX, int16_t x0, int16_t y0,
	397	int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color) {
	398	GFXdrawLine(myGFX, x0, y0, x1, y1, color);
	399	GFXdrawLine(myGFX, x1, y1, x2, y2, color);
	400	GFXdrawLine(myGFX, x2, y2, x0, y0, color);
	401	}
	402
	403	// Fill a triangle
	404	void GFXfillTriangle(GFX* myGFX, int16_t x0, int16_t y0,
	405	int16_t x1, int16_t y1, int16_t x2, int16_t y2, uint16_t color) {
	406
	407	int16_t a, b, y, last;
	408
	409	// Sort coordinates by Y order (y2 >= y1 >= y0)
	410	if (y0 > y1) {
	411	_swap_int16_t(y0, y1); _swap_int16_t(x0, x1);
	412	}
	413	if (y1 > y2) {
	414	_swap_int16_t(y2, y1); _swap_int16_t(x2, x1);
	415	}
	416	if (y0 > y1) {
	417	_swap_int16_t(y0, y1); _swap_int16_t(x0, x1);
	418	}
	419
	420
	421	if(y0 == y2) { // Handle awkward all-on-same-line case as its own thing
	422	a = b = x0;
	423	if(x1 < a) a = x1;
	424	else if(x1 > b) b = x1;
	425	if(x2 < a) a = x2;
	426	else if(x2 > b) b = x2;
	427	GFXwriteFastHLine(myGFX, a, y0, b-a+1, color);
	428
	429	return;
	430	}
	431
	432	int16_t
	433	dx01 = x1 - x0,
	434	dy01 = y1 - y0,
	435	dx02 = x2 - x0,
	436	dy02 = y2 - y0,
	437	dx12 = x2 - x1,
	438	dy12 = y2 - y1;
	439	int32_t
	440	sa = 0,
	441	sb = 0;
	442
	443	// For upper part of triangle, find scanline crossings for segments
	444	// 0-1 and 0-2. If y1=y2 (flat-bottomed triangle), the scanline y1
	445	// is included here (and second loop will be skipped, avoiding a /0
	446	// error there), otherwise scanline y1 is skipped here and handled
	447	// in the second loop...which also avoids a /0 error here if y0=y1
	448	// (flat-topped triangle).
	449	if(y1 == y2) last = y1; // Include y1 scanline
	450	else last = y1-1; // Skip it
	451
	452	for(y=y0; y<=last; y++) {
	453	a = x0 + sa / dy01;
	454	b = x0 + sb / dy02;
	455	sa += dx01;
	456	sb += dx02;
	457	/* longhand:
	458	a = x0 + (x1 - x0) * (y - y0) / (y1 - y0);
	459	b = x0 + (x2 - x0) * (y - y0) / (y2 - y0);
	460	*/
	461	if(a > b) _swap_int16_t(a,b);
	462	GFXwriteFastHLine(myGFX,a, y, b-a+1, color);
	463	}
	464
	465	// For lower part of triangle, find scanline crossings for segments
	466	// 0-2 and 1-2. This loop is skipped if y1=y2.
	467	sa = dx12 * (y - y1);
	468	sb = dx02 * (y - y0);
	469	for(; y<=y2; y++) {
	470	a = x1 + sa / dy12;
	471	b = x0 + sb / dy02;
	472	sa += dx12;
	473	sb += dx02;
	474	/* longhand:
	475	a = x1 + (x2 - x1) * (y - y1) / (y2 - y1);
	476	b = x0 + (x2 - x0) * (y - y0) / (y2 - y0);
	477	*/
	478	if(a > b) _swap_int16_t(a,b);
	479	GFXwriteFastHLine(myGFX, a, y, b-a+1, color);
	480	}
	481
	482	}
	483
	484	// BITMAP / XBITMAP / GRAYSCALE / RGB BITMAP FUNCTIONS ---------------------
	485
	486
	487
	488	// Draw a RAM-resident 1-bit image at the specified (x,y) position,
	489	// using the specified foreground (for set bits) and background (unset
	490	// bits) colors.
	491	void GFXdrawBitmap(GFX* myGFX, int16_t x, int16_t y,
	492	uint8_t *bitmap, int16_t w, int16_t h, uint16_t color, uint16_t bg) {
	493
	494	int16_t byteWidth = (w + 7) / 8; // Bitmap scanline pad = whole byte
	495	uint8_t byte = 0;
	496
	497	startWrite();
	498	for(int16_t j=0; j<h; j++, y++) {
	499	for(int16_t i=0; i<w; i++ ) {
	500	if(i & 7) byte <<= 1;
	501	else byte = bitmap[j * byteWidth + i / 8];
	502	GFXwritePixel(myGFX, x+i, y, (byte & 0x80) ? color : bg);
	503	}
	504	}
	505	endWrite();
	506	}
	507
	508
	509
	510	// TEXT- AND CHARACTER-HANDLING FUNCTIONS ----------------------------------
	511
	512	// Draw a character
	513	void GFXdrawChar(GFX* myGFX, int16_t x, int16_t y, unsigned char c,
	514	uint16_t color, uint16_t bg, uint8_t size) {
	515
	516	if(!myGFX->gfxFont) { // 'Classic' built-in font
	517
	518	if((x >= myGFX->_width) \|\| // Clip right
	519	(y >= myGFX->_height) \|\| // Clip bottom
	520	((x + 6 * size - 1) < 0) \|\| // Clip left
	521	((y + 8 * size - 1) < 0)) // Clip top
	522	return;
	523
	524	if(!myGFX->_cp437 && (c >= 176)) c++; // Handle 'classic' charset behavior
	525
	526
	527	for(int8_t i=0; i<5; i++ ) { // Char bitmap = 5 columns
	528	uint8_t line = pgm_read_byte(&standardGFXfont[c * 5 + i]);
	529	for(int8_t j=0; j<8; j++, line >>= 1) {
	530	if(line & 1) {
	531	if(size == 1)
	532	GFXwritePixel(myGFX, x+i, y+j, color);
	533	else
	534	GFXwriteFillRect(myGFX, x+isize, y+jsize, size, size, color);
	535	} else if(bg != color) {
	536	if(size == 1)
	537	GFXwritePixel(myGFX, x+i, y+j, bg);
	538	else
	539	GFXwriteFillRect(myGFX, x+isize, y+jsize, size, size, bg);
	540	}
	541	}
	542	}
	543	if(bg != color) { // If opaque, draw vertical line for last column
	544	if(size == 1) GFXwriteFastVLine(myGFX, x+5, y, 8, bg);
	545	else GFXwriteFillRect(myGFX, x+5size, y, size, 8size, bg);
	546	}
	547
	548
	549	} else { // Custom font
	550
	551	// Character is assumed previously filtered by write() to eliminate
	552	// newlines, returns, non-printable characters, etc. Calling
	553	// drawChar() directly with 'bad' characters of font may cause mayhem!
	554
	555	c -= (uint8_t)pgm_read_byte(&myGFX->gfxFont->first);
	556	GFXglyph glyph = &(((GFXglyph )pgm_read_pointer(&myGFX->gfxFont->glyph))[c]);
	557	uint8_t bitmap = (uint8_t )pgm_read_pointer(&myGFX->gfxFont->bitmap);
	558
	559	uint16_t bo = pgm_read_word(&glyph->bitmapOffset);
	560	uint8_t w = pgm_read_byte(&glyph->width),
	561	h = pgm_read_byte(&glyph->height);
	562	int8_t xo = pgm_read_byte(&glyph->xOffset),
	563	yo = pgm_read_byte(&glyph->yOffset);
	564	uint8_t xx, yy, bits = 0, bit = 0;
	565	int16_t xo16 = 0, yo16 = 0;
	566
	567	if(size > 1) {
	568	xo16 = xo;
	569	yo16 = yo;
	570	}
	571
	572	// Todo: Add character clipping here
	573
	574	// NOTE: THERE IS NO 'BACKGROUND' COLOR OPTION ON CUSTOM FONTS.
	575	// THIS IS ON PURPOSE AND BY DESIGN. The background color feature
	576	// has typically been used with the 'classic' font to overwrite old
	577	// screen contents with new data. This ONLY works because the
	578	// characters are a uniform size; it's not a sensible thing to do with
	579	// proportionally-spaced fonts with glyphs of varying sizes (and that
	580	// may overlap). To replace previously-drawn text when using a custom
	581	// font, use the getTextBounds() function to determine the smallest
	582	// rectangle encompassing a string, erase the area with fillRect(),
	583	// then draw new text. This WILL infortunately 'blink' the text, but
	584	// is unavoidable. Drawing 'background' pixels will NOT fix this,
	585	// only creates a new set of problems. Have an idea to work around
	586	// this (a canvas object type for MCUs that can afford the RAM and
	587	// displays supporting setAddrWindow() and pushColors()), but haven't
	588	// implemented this yet.
	589
	590
	591	for(yy=0; yy<h; yy++) {
	592	for(xx=0; xx<w; xx++) {
	593	if(!(bit++ & 7)) {
	594	bits = pgm_read_byte(&bitmap[bo++]);
	595	}
	596	if(bits & 0x80) {
	597	if(size == 1) {
	598	GFXwritePixel(myGFX, x+xo+xx, y+yo+yy, color);
	599	} else {
	600	GFXwriteFillRect(myGFX, x+(xo16+xx)size, y+(yo16+yy)size,
	601	size, size, color);
	602	}
	603	}
	604	bits <<= 1;
	605	}
	606	}
	607
	608
	609	} // End classic vs custom font
	610	}
	611
	612
	613	void GFXwrite(GFX* myGFX, uint8_t c) {
	614
	615	if(!myGFX->gfxFont) { // 'Classic' built-in font
	616
	617	if(c == '\n') { // Newline?
	618	myGFX->cursor_x = 0; // Reset x to zero,
	619	myGFX->cursor_y += myGFX->textsize * 8; // advance y one line
	620	} else if(c != '\r') { // Ignore carriage returns
	621	if(myGFX->wrap && ((myGFX->cursor_x + myGFX->textsize * 6) > myGFX->_width)) { // Off right?
	622	myGFX->cursor_x = 0; // Reset x to zero,
	623	myGFX->cursor_y += myGFX->textsize * 8; // advance y one line
	624	}
	625	GFXdrawChar(myGFX, myGFX->cursor_x, myGFX->cursor_y, c, myGFX->textcolor, myGFX->textbgcolor, myGFX->textsize);
	626	myGFX->cursor_x += myGFX->textsize * 6; // Advance x one char
	627	}
	628
	629	} else { // Custom font
	630
	631	if(c == '\n') {
	632	myGFX->cursor_x = 0;
	633	myGFX->cursor_y += (int16_t)myGFX->textsize *
	634	(uint8_t)pgm_read_byte(&myGFX->gfxFont->yAdvance);
	635	} else if(c != '\r') {
	636	uint8_t first = pgm_read_byte(&myGFX->gfxFont->first);
	637	if((c >= first) && (c <= (uint8_t)pgm_read_byte(&myGFX->gfxFont->last))) {
	638	GFXglyph glyph = &(((GFXglyph )pgm_read_pointer(
	639	&myGFX->gfxFont->glyph))[c - first]);
	640	uint8_t w = pgm_read_byte(&glyph->width),
	641	h = pgm_read_byte(&glyph->height);
	642	if((w > 0) && (h > 0)) { // Is there an associated bitmap?
	643	int16_t xo = (int8_t)pgm_read_byte(&glyph->xOffset); // sic
	644	if(myGFX->wrap && ((myGFX->cursor_x + myGFX->textsize * (xo + w)) > myGFX->_width)) {
	645	myGFX->cursor_x = 0;
	646	myGFX->cursor_y += (int16_t)myGFX->textsize *
	647	(uint8_t)pgm_read_byte(&myGFX->gfxFont->yAdvance);
	648	}
	649	GFXdrawChar(myGFX, myGFX->cursor_x, myGFX->cursor_y, c, myGFX->textcolor, myGFX->textbgcolor, myGFX->textsize);
	650	}
	651	myGFX->cursor_x += (uint8_t)pgm_read_byte(&glyph->xAdvance) * (int16_t)myGFX->textsize;
	652	}
	653	}
	654
	655	}
	656
	657	}
	658
	659	void GFXsetCursor(GFX* myGFX, int16_t x, int16_t y) {
	660	myGFX->cursor_x = x;
	661	myGFX->cursor_y = y;
	662	}
	663
	664	int16_t GFXgetCursorX(GFX* myGFX)
	665	{
	666	return myGFX->cursor_x;
	667	}
	668
	669	int16_t GFXgetCursorY(GFX* myGFX)
	670	{
	671	return myGFX->cursor_y;
	672	}
	673
	674	void GFXsetTextSize(GFX* myGFX, uint8_t s) {
	675	myGFX->textsize = (s > 0) ? s : 1;
	676	}
	677
	678	void GFXsetTextColor(GFX* myGFX, uint16_t c, uint16_t b) {
	679	myGFX->textcolor = c;
	680	myGFX->textbgcolor = b;
	681	}
	682
	683	void GFXsetTextWrap(GFX* myGFX, uint8_t w) {
	684	myGFX->wrap = w;
	685	}
	686
	687	uint8_t GFXgetRotation(GFX* myGFX) {
	688	return myGFX->rotation;
	689	}
	690
	691	void GFXsetRotation(GFX* myGFX, uint8_t x) {
	692	myGFX->rotation = (x & 3);
	693	switch(myGFX->rotation) {
	694	case 0:
	695	case 2:
	696	myGFX->_width = myGFX->WIDTH;
	697	myGFX->_height = myGFX->HEIGHT;
	698	break;
	699	case 1:
	700	case 3:
	701	myGFX->_width = myGFX->HEIGHT;
	702	myGFX->_height = myGFX->WIDTH;
	703	break;
	704	}
	705	}
	706
	707	// Enable (or disable) Code Page 437-compatible charset.
	708	// There was an error in glcdfont.c for the longest time -- one character
	709	// (#176, the 'light shade' block) was missing -- this threw off the index
	710	// of every character that followed it. But a TON of code has been written
	711	// with the erroneous character indices. By default, the library uses the
	712	// original 'wrong' behavior and old sketches will still work. Pass 'true'
	713	// to this function to use correct CP437 character values in your code.
	714	void GFXcp437(GFX* myGFX, uint8_t x) {
	715	myGFX->_cp437 = x;
	716	}
	717
	718	void GFXsetFont(GFX* myGFX, const GFXfont *f) {
	719	if(f) { // Font struct pointer passed in?
	720	if(!myGFX->gfxFont) { // And no current font struct?
	721	// Switching from classic to new font behavior.
	722	// Move cursor pos down 6 pixels so it's on baseline.
	723	myGFX->cursor_y += 6;
	724	}
	725	} else if(myGFX->gfxFont) { // NULL passed. Current font struct defined?
	726	// Switching from new to classic font behavior.
	727	// Move cursor pos up 6 pixels so it's at top-left of char.
	728	myGFX->cursor_y -= 6;
	729	}
	730	myGFX->gfxFont = (GFXfont *)f;
	731	}
	732
	733	// Broke this out as it's used by both the PROGMEM- and RAM-resident
	734	// getTextBounds() functions.
	735	void GFXcharBounds(GFX* myGFX, char c, int16_t x, int16_t y,
	736	int16_t minx, int16_t miny, int16_t maxx, int16_t maxy) {
	737
	738	if(myGFX->gfxFont) {
	739
	740	if(c == '\n') { // Newline?
	741	*x = 0; // Reset x to zero, advance y by one line
	742	y += myGFX->textsize (uint8_t)pgm_read_byte(&myGFX->gfxFont->yAdvance);
	743	} else if(c != '\r') { // Not a carriage return; is normal char
	744	uint8_t first = pgm_read_byte(&myGFX->gfxFont->first),
	745	last = pgm_read_byte(&myGFX->gfxFont->last);
	746	if((c >= first) && (c <= last)) { // Char present in this font?
	747	GFXglyph glyph = &(((GFXglyph )pgm_read_pointer(
	748	&myGFX->gfxFont->glyph))[c - first]);
	749	uint8_t gw = pgm_read_byte(&glyph->width),
	750	gh = pgm_read_byte(&glyph->height),
	751	xa = pgm_read_byte(&glyph->xAdvance);
	752	int8_t xo = pgm_read_byte(&glyph->xOffset),
	753	yo = pgm_read_byte(&glyph->yOffset);
	754	if(myGFX->wrap && ((x+(((int16_t)xo+gw)myGFX->textsize)) > myGFX->_width)) {
	755	*x = 0; // Reset x to zero, advance y by one line
	756	y += myGFX->textsize (uint8_t)pgm_read_byte(&myGFX->gfxFont->yAdvance);
	757	}
	758	int16_t ts = (int16_t)myGFX->textsize,
	759	x1 = x + xo ts,
	760	y1 = y + yo ts,
	761	x2 = x1 + gw * ts - 1,
	762	y2 = y1 + gh * ts - 1;
	763	if(x1 < minx) minx = x1;
	764	if(y1 < miny) miny = y1;
	765	if(x2 > maxx) maxx = x2;
	766	if(y2 > maxy) maxy = y2;
	767	x += xa ts;
	768	}
	769	}
	770
	771	} else { // Default font
	772
	773	if(c == '\n') { // Newline?
	774	*x = 0; // Reset x to zero,
	775	y += myGFX->textsize 8; // advance y one line
	776	// min/max x/y unchaged -- that waits for next 'normal' character
	777	} else if(c != '\r') { // Normal char; ignore carriage returns
	778	if(myGFX->wrap && ((x + myGFX->textsize 6) > myGFX->_width)) { // Off right?
	779	*x = 0; // Reset x to zero,
	780	y += myGFX->textsize 8; // advance y one line
	781	}
	782	int x2 = x + myGFX->textsize 6 - 1, // Lower-right pixel of char
	783	y2 = y + myGFX->textsize 8 - 1;
	784	if(x2 > maxx) maxx = x2; // Track max x, y
	785	if(y2 > maxy) maxy = y2;
	786	if(x < minx) minx = x; // Track min x, y
	787	if(y < miny) miny = y;
	788	x += myGFX->textsize 6; // Advance x one char
	789	}
	790	}
	791	}
	792
	793	// Pass string and a cursor position, returns UL corner and W,H.
	794	void GFXgetTextBounds(GFX* myGFX, char *str, int16_t x, int16_t y,
	795	int16_t x1, int16_t y1, uint16_t w, uint16_t h) {
	796	uint8_t c; // Current character
	797
	798	*x1 = x;
	799	*y1 = y;
	800	w = h = 0;
	801
	802	int16_t minx = myGFX->_width, miny = myGFX->_height, maxx = -1, maxy = -1;
	803
	804	while((c = *str++))
	805	GFXcharBounds(myGFX, c, &x, &y, &minx, &miny, &maxx, &maxy);
	806
	807	if(maxx >= minx) {
	808	*x1 = minx;
	809	*w = maxx - minx + 1;
	810	}
	811	if(maxy >= miny) {
	812	*y1 = miny;
	813	*h = maxy - miny + 1;
	814	}
	815	}
	816
	817
	818
	819	// Return the size of the display (per current rotation)
	820	int16_t GFXwidth(GFX* myGFX ) {
	821	return myGFX->_width;
	822	}
	823
	824	int16_t GFXheight(GFX* myGFX) {
	825	return myGFX->_height;
	826	}
	827
	828	void GFXinvertDisplay(GFX* myGFX, uint8_t i) {
	829	// Do nothing, must be subclassed if supported by hardware
	830	}
	831
	832	uint8_t pitches[24] =
	833	{
	834	'C', ' ',
	835	'C', '#',
	836	'D', ' ',
	837	'D', '#',
	838	'E', ' ',
	839	'F', ' ',
	840	'F', '#',
	841	'G', ' ',
	842	'G', '#',
	843	'A', ' ',
	844	'A', '#',
	845	'B', ' '
	846	};
	847
	848	int OLEDparseInt(char* buffer, uint32_t myNumber, uint8_t numDigits)
	849	{
	850	for (int i = 0; i < numDigits; i++)
	851	{
	852	int whichPlace = (uint32_t)(powf(10.0f,(numDigits - 1) - i));
	853	int thisDigit = (myNumber / whichPlace);
	854	buffer[i] = thisDigit + 48;
	855	myNumber -= thisDigit * whichPlace;
	856	}
	857
	858	return numDigits;
	859	}
	860
	861	int OLEDparsePitch(char* buffer, float midi)
	862	{
	863	int pclass, octave, note, neg = 0; float offset;
	864
	865	note = (int)midi;
	866	offset = midi - note;
	867
	868	if ((midi + 0.5f) > (note+1))
	869	{
	870	note += 1;
	871	offset = (1.0f - offset) + 0.01f;
	872	neg = 1;
	873	}
	874
	875	pclass = (note % 12);
	876	octave = (int)(note / 12) - 1;
	877
	878	int idx = 0;
	879
	880	buffer[idx++] = pitches[pclass*2];
	881	buffer[idx++] = pitches[pclass*2+1];
	882
	883	OLEDparseInt(&buffer[idx++], octave, 1);
	884
	885	buffer[idx++] = ' ';
	886
	887	if (neg == 1)
	888	buffer[idx++] = '-';
	889	else
	890	buffer[idx++] = '+';
	891
	892	OLEDparseInt(&buffer[idx], (uint32_t) (offset * 100.0f), 2);
	893
	894	return idx+2;
	895	}
	896
	897	int OLEDparsePitchClass(char* buffer, float midi)
	898	{
	899	int pclass, note;
	900	float offset;
	901
	902	note = (int)midi;
	903	offset = midi - note;
	904
	905	if ((midi + 0.5f) > (note+1))
	906	{
	907	note += 1;
	908	offset = (1.0f - offset) + 0.01f;
	909	}
	910
	911	pclass = (note % 12);
	912
	913	int idx = 0;
	914
	915	buffer[idx++] = pitches[pclass*2];
	916	buffer[idx++] = pitches[pclass*2+1];
	917
	918	return idx;
	919	}
	920
	921	int OLEDparseFixedFloat(char* buffer, float input, uint8_t numDigits, uint8_t numDecimal)
	922	{
	923	float power = powf(10.0f, numDecimal);
	924	float f = ((float)(int)(input * power + 0.5f)) / power;
	925
	926	int nonzeroHasHappened = 0, decimalHasHappened = 0;
	927
	928	int myNumber = (int)(f * power);
	929
	930	int idx = 0, i = 0;
	931
	932	if (myNumber < 0)
	933	{
	934	myNumber *= -1;
	935	buffer[idx++] = '-';
	936	i++;
	937	}
	938
	939	while (i < numDigits)
	940	{
	941	if ((decimalHasHappened == 0) && ((numDigits-i) == numDecimal))
	942	{
	943	if (nonzeroHasHappened == 0)
	944	{
	945	idx++; //get past the negative if there is one - this is hacky should figure out how to do it right
	946	buffer[idx-1] = '0';
	947	nonzeroHasHappened = 1;
	948	}
	949
	950	buffer[idx++] = '.';
	951	decimalHasHappened = 1;
	952	}
	953	else
	954	{
	955
	956	int whichPlace = (uint32_t) powf(10.0f,(numDigits - 1 - i));
	957	int thisDigit = (myNumber / whichPlace);
	958
	959	if (nonzeroHasHappened == 0)
	960	{
	961	if (thisDigit > 0)
	962	{
	963	buffer[idx++] = thisDigit + 48;
	964	nonzeroHasHappened = 1;
	965	}
	966	else
	967	{
	968	buffer[idx++] = ' ';
	969	}
	970	}
	971	else
	972	{
	973	buffer[idx++] = thisDigit + 48;
	974	}
	975
	976	myNumber -= thisDigit * whichPlace;
	977
	978	i++;
	979	}
	980	}
	981
	982	return idx;
	983	}

LEAF/Src/gfx_font.c+281−0

@@ -0,0 +1,281 @@
	1	/*
	2	* gfx_font.c
	3	*
	4	* Created on: Jul 8, 2018
	5	* Author: jeffsnyder
	6	*/
	7
	8
	9	// This is the 'classic' fixed-space bitmap font for Adafruit_GFX since 1.0.
	10	// See gfxfont.h for newer custom bitmap font info.
	11
	12	#ifndef FONT5X7_H
	13	#define FONT5X7_H
	14
	15
	16	#define PROGMEM
	17
	18
	19	// Standard ASCII 5x7 font
	20
	21	static const unsigned char standardGFXfont[] = {
	22	0x00, 0x00, 0x00, 0x00, 0x00,
	23	0x3E, 0x5B, 0x4F, 0x5B, 0x3E,
	24	0x3E, 0x6B, 0x4F, 0x6B, 0x3E,
	25	0x1C, 0x3E, 0x7C, 0x3E, 0x1C,
	26	0x18, 0x3C, 0x7E, 0x3C, 0x18,
	27	0x1C, 0x57, 0x7D, 0x57, 0x1C,
	28	0x1C, 0x5E, 0x7F, 0x5E, 0x1C,
	29	0x00, 0x18, 0x3C, 0x18, 0x00,
	30	0xFF, 0xE7, 0xC3, 0xE7, 0xFF,
	31	0x00, 0x18, 0x24, 0x18, 0x00,
	32	0xFF, 0xE7, 0xDB, 0xE7, 0xFF,
	33	0x30, 0x48, 0x3A, 0x06, 0x0E,
	34	0x26, 0x29, 0x79, 0x29, 0x26,
	35	0x40, 0x7F, 0x05, 0x05, 0x07,
	36	0x40, 0x7F, 0x05, 0x25, 0x3F,
	37	0x5A, 0x3C, 0xE7, 0x3C, 0x5A,
	38	0x7F, 0x3E, 0x1C, 0x1C, 0x08,
	39	0x08, 0x1C, 0x1C, 0x3E, 0x7F,
	40	0x14, 0x22, 0x7F, 0x22, 0x14,
	41	0x5F, 0x5F, 0x00, 0x5F, 0x5F,
	42	0x06, 0x09, 0x7F, 0x01, 0x7F,
	43	0x00, 0x66, 0x89, 0x95, 0x6A,
	44	0x60, 0x60, 0x60, 0x60, 0x60,
	45	0x94, 0xA2, 0xFF, 0xA2, 0x94,
	46	0x08, 0x04, 0x7E, 0x04, 0x08,
	47	0x10, 0x20, 0x7E, 0x20, 0x10,
	48	0x08, 0x08, 0x2A, 0x1C, 0x08,
	49	0x08, 0x1C, 0x2A, 0x08, 0x08,
	50	0x1E, 0x10, 0x10, 0x10, 0x10,
	51	0x0C, 0x1E, 0x0C, 0x1E, 0x0C,
	52	0x30, 0x38, 0x3E, 0x38, 0x30,
	53	0x06, 0x0E, 0x3E, 0x0E, 0x06,
	54	0x00, 0x00, 0x00, 0x00, 0x00,
	55	0x00, 0x00, 0x5F, 0x00, 0x00,
	56	0x00, 0x07, 0x00, 0x07, 0x00,
	57	0x14, 0x7F, 0x14, 0x7F, 0x14,
	58	0x24, 0x2A, 0x7F, 0x2A, 0x12,
	59	0x23, 0x13, 0x08, 0x64, 0x62,
	60	0x36, 0x49, 0x56, 0x20, 0x50,
	61	0x00, 0x08, 0x07, 0x03, 0x00,
	62	0x00, 0x1C, 0x22, 0x41, 0x00,
	63	0x00, 0x41, 0x22, 0x1C, 0x00,
	64	0x2A, 0x1C, 0x7F, 0x1C, 0x2A,
	65	0x08, 0x08, 0x3E, 0x08, 0x08,
	66	0x00, 0x80, 0x70, 0x30, 0x00,
	67	0x08, 0x08, 0x08, 0x08, 0x08,
	68	0x00, 0x00, 0x60, 0x60, 0x00,
	69	0x20, 0x10, 0x08, 0x04, 0x02,
	70	0x3E, 0x51, 0x49, 0x45, 0x3E,
	71	0x00, 0x42, 0x7F, 0x40, 0x00,
	72	0x72, 0x49, 0x49, 0x49, 0x46,
	73	0x21, 0x41, 0x49, 0x4D, 0x33,
	74	0x18, 0x14, 0x12, 0x7F, 0x10,
	75	0x27, 0x45, 0x45, 0x45, 0x39,
	76	0x3C, 0x4A, 0x49, 0x49, 0x31,
	77	0x41, 0x21, 0x11, 0x09, 0x07,
	78	0x36, 0x49, 0x49, 0x49, 0x36,
	79	0x46, 0x49, 0x49, 0x29, 0x1E,
	80	0x00, 0x00, 0x14, 0x00, 0x00,
	81	0x00, 0x40, 0x34, 0x00, 0x00,
	82	0x00, 0x08, 0x14, 0x22, 0x41,
	83	0x14, 0x14, 0x14, 0x14, 0x14,
	84	0x00, 0x41, 0x22, 0x14, 0x08,
	85	0x02, 0x01, 0x59, 0x09, 0x06,
	86	0x3E, 0x41, 0x5D, 0x59, 0x4E,
	87	0x7C, 0x12, 0x11, 0x12, 0x7C,
	88	0x7F, 0x49, 0x49, 0x49, 0x36,
	89	0x3E, 0x41, 0x41, 0x41, 0x22,
	90	0x7F, 0x41, 0x41, 0x41, 0x3E,
	91	0x7F, 0x49, 0x49, 0x49, 0x41,
	92	0x7F, 0x09, 0x09, 0x09, 0x01,
	93	0x3E, 0x41, 0x41, 0x51, 0x73,
	94	0x7F, 0x08, 0x08, 0x08, 0x7F,
	95	0x00, 0x41, 0x7F, 0x41, 0x00,
	96	0x20, 0x40, 0x41, 0x3F, 0x01,
	97	0x7F, 0x08, 0x14, 0x22, 0x41,
	98	0x7F, 0x40, 0x40, 0x40, 0x40,
	99	0x7F, 0x02, 0x1C, 0x02, 0x7F,
	100	0x7F, 0x04, 0x08, 0x10, 0x7F,
	101	0x3E, 0x41, 0x41, 0x41, 0x3E,
	102	0x7F, 0x09, 0x09, 0x09, 0x06,
	103	0x3E, 0x41, 0x51, 0x21, 0x5E,
	104	0x7F, 0x09, 0x19, 0x29, 0x46,
	105	0x26, 0x49, 0x49, 0x49, 0x32,
	106	0x03, 0x01, 0x7F, 0x01, 0x03,
	107	0x3F, 0x40, 0x40, 0x40, 0x3F,
	108	0x1F, 0x20, 0x40, 0x20, 0x1F,
	109	0x3F, 0x40, 0x38, 0x40, 0x3F,
	110	0x63, 0x14, 0x08, 0x14, 0x63,
	111	0x03, 0x04, 0x78, 0x04, 0x03,
	112	0x61, 0x59, 0x49, 0x4D, 0x43,
	113	0x00, 0x7F, 0x41, 0x41, 0x41,
	114	0x02, 0x04, 0x08, 0x10, 0x20,
	115	0x00, 0x41, 0x41, 0x41, 0x7F,
	116	0x04, 0x02, 0x01, 0x02, 0x04,
	117	0x40, 0x40, 0x40, 0x40, 0x40,
	118	0x00, 0x03, 0x07, 0x08, 0x00,
	119	0x20, 0x54, 0x54, 0x78, 0x40,
	120	0x7F, 0x28, 0x44, 0x44, 0x38,
	121	0x38, 0x44, 0x44, 0x44, 0x28,
	122	0x38, 0x44, 0x44, 0x28, 0x7F,
	123	0x38, 0x54, 0x54, 0x54, 0x18,
	124	0x00, 0x08, 0x7E, 0x09, 0x02,
	125	0x18, 0xA4, 0xA4, 0x9C, 0x78,
	126	0x7F, 0x08, 0x04, 0x04, 0x78,
	127	0x00, 0x44, 0x7D, 0x40, 0x00,
	128	0x20, 0x40, 0x40, 0x3D, 0x00,
	129	0x7F, 0x10, 0x28, 0x44, 0x00,
	130	0x00, 0x41, 0x7F, 0x40, 0x00,
	131	0x7C, 0x04, 0x78, 0x04, 0x78,
	132	0x7C, 0x08, 0x04, 0x04, 0x78,
	133	0x38, 0x44, 0x44, 0x44, 0x38,
	134	0xFC, 0x18, 0x24, 0x24, 0x18,
	135	0x18, 0x24, 0x24, 0x18, 0xFC,
	136	0x7C, 0x08, 0x04, 0x04, 0x08,
	137	0x48, 0x54, 0x54, 0x54, 0x24,
	138	0x04, 0x04, 0x3F, 0x44, 0x24,
	139	0x3C, 0x40, 0x40, 0x20, 0x7C,
	140	0x1C, 0x20, 0x40, 0x20, 0x1C,
	141	0x3C, 0x40, 0x30, 0x40, 0x3C,
	142	0x44, 0x28, 0x10, 0x28, 0x44,
	143	0x4C, 0x90, 0x90, 0x90, 0x7C,
	144	0x44, 0x64, 0x54, 0x4C, 0x44,
	145	0x00, 0x08, 0x36, 0x41, 0x00,
	146	0x00, 0x00, 0x77, 0x00, 0x00,
	147	0x00, 0x41, 0x36, 0x08, 0x00,
	148	0x02, 0x01, 0x02, 0x04, 0x02,
	149	0x3C, 0x26, 0x23, 0x26, 0x3C,
	150	0x1E, 0xA1, 0xA1, 0x61, 0x12,
	151	0x3A, 0x40, 0x40, 0x20, 0x7A,
	152	0x38, 0x54, 0x54, 0x55, 0x59,
	153	0x21, 0x55, 0x55, 0x79, 0x41,
	154	0x22, 0x54, 0x54, 0x78, 0x42, // a-umlaut
	155	0x21, 0x55, 0x54, 0x78, 0x40,
	156	0x20, 0x54, 0x55, 0x79, 0x40,
	157	0x0C, 0x1E, 0x52, 0x72, 0x12,
	158	0x39, 0x55, 0x55, 0x55, 0x59,
	159	0x39, 0x54, 0x54, 0x54, 0x59,
	160	0x39, 0x55, 0x54, 0x54, 0x58,
	161	0x00, 0x00, 0x45, 0x7C, 0x41,
	162	0x00, 0x02, 0x45, 0x7D, 0x42,
	163	0x00, 0x01, 0x45, 0x7C, 0x40,
	164	0x7D, 0x12, 0x11, 0x12, 0x7D, // A-umlaut
	165	0xF0, 0x28, 0x25, 0x28, 0xF0,
	166	0x7C, 0x54, 0x55, 0x45, 0x00,
	167	0x20, 0x54, 0x54, 0x7C, 0x54,
	168	0x7C, 0x0A, 0x09, 0x7F, 0x49,
	169	0x32, 0x49, 0x49, 0x49, 0x32,
	170	0x3A, 0x44, 0x44, 0x44, 0x3A, // o-umlaut
	171	0x32, 0x4A, 0x48, 0x48, 0x30,
	172	0x3A, 0x41, 0x41, 0x21, 0x7A,
	173	0x3A, 0x42, 0x40, 0x20, 0x78,
	174	0x00, 0x9D, 0xA0, 0xA0, 0x7D,
	175	0x3D, 0x42, 0x42, 0x42, 0x3D, // O-umlaut
	176	0x3D, 0x40, 0x40, 0x40, 0x3D,
	177	0x3C, 0x24, 0xFF, 0x24, 0x24,
	178	0x48, 0x7E, 0x49, 0x43, 0x66,
	179	0x2B, 0x2F, 0xFC, 0x2F, 0x2B,
	180	0xFF, 0x09, 0x29, 0xF6, 0x20,
	181	0xC0, 0x88, 0x7E, 0x09, 0x03,
	182	0x20, 0x54, 0x54, 0x79, 0x41,
	183	0x00, 0x00, 0x44, 0x7D, 0x41,
	184	0x30, 0x48, 0x48, 0x4A, 0x32,
	185	0x38, 0x40, 0x40, 0x22, 0x7A,
	186	0x00, 0x7A, 0x0A, 0x0A, 0x72,
	187	0x7D, 0x0D, 0x19, 0x31, 0x7D,
	188	0x26, 0x29, 0x29, 0x2F, 0x28,
	189	0x26, 0x29, 0x29, 0x29, 0x26,
	190	0x30, 0x48, 0x4D, 0x40, 0x20,
	191	0x38, 0x08, 0x08, 0x08, 0x08,
	192	0x08, 0x08, 0x08, 0x08, 0x38,
	193	0x2F, 0x10, 0xC8, 0xAC, 0xBA,
	194	0x2F, 0x10, 0x28, 0x34, 0xFA,
	195	0x00, 0x00, 0x7B, 0x00, 0x00,
	196	0x08, 0x14, 0x2A, 0x14, 0x22,
	197	0x22, 0x14, 0x2A, 0x14, 0x08,
	198	0x55, 0x00, 0x55, 0x00, 0x55, // #176 (25% block) missing in old code
	199	0xAA, 0x55, 0xAA, 0x55, 0xAA, // 50% block
	200	0xFF, 0x55, 0xFF, 0x55, 0xFF, // 75% block
	201	0x00, 0x00, 0x00, 0xFF, 0x00,
	202	0x10, 0x10, 0x10, 0xFF, 0x00,
	203	0x14, 0x14, 0x14, 0xFF, 0x00,
	204	0x10, 0x10, 0xFF, 0x00, 0xFF,
	205	0x10, 0x10, 0xF0, 0x10, 0xF0,
	206	0x14, 0x14, 0x14, 0xFC, 0x00,
	207	0x14, 0x14, 0xF7, 0x00, 0xFF,
	208	0x00, 0x00, 0xFF, 0x00, 0xFF,
	209	0x14, 0x14, 0xF4, 0x04, 0xFC,
	210	0x14, 0x14, 0x17, 0x10, 0x1F,
	211	0x10, 0x10, 0x1F, 0x10, 0x1F,
	212	0x14, 0x14, 0x14, 0x1F, 0x00,
	213	0x10, 0x10, 0x10, 0xF0, 0x00,
	214	0x00, 0x00, 0x00, 0x1F, 0x10,
	215	0x10, 0x10, 0x10, 0x1F, 0x10,
	216	0x10, 0x10, 0x10, 0xF0, 0x10,
	217	0x00, 0x00, 0x00, 0xFF, 0x10,
	218	0x10, 0x10, 0x10, 0x10, 0x10,
	219	0x10, 0x10, 0x10, 0xFF, 0x10,
	220	0x00, 0x00, 0x00, 0xFF, 0x14,
	221	0x00, 0x00, 0xFF, 0x00, 0xFF,
	222	0x00, 0x00, 0x1F, 0x10, 0x17,
	223	0x00, 0x00, 0xFC, 0x04, 0xF4,
	224	0x14, 0x14, 0x17, 0x10, 0x17,
	225	0x14, 0x14, 0xF4, 0x04, 0xF4,
	226	0x00, 0x00, 0xFF, 0x00, 0xF7,
	227	0x14, 0x14, 0x14, 0x14, 0x14,
	228	0x14, 0x14, 0xF7, 0x00, 0xF7,
	229	0x14, 0x14, 0x14, 0x17, 0x14,
	230	0x10, 0x10, 0x1F, 0x10, 0x1F,
	231	0x14, 0x14, 0x14, 0xF4, 0x14,
	232	0x10, 0x10, 0xF0, 0x10, 0xF0,
	233	0x00, 0x00, 0x1F, 0x10, 0x1F,
	234	0x00, 0x00, 0x00, 0x1F, 0x14,
	235	0x00, 0x00, 0x00, 0xFC, 0x14,
	236	0x00, 0x00, 0xF0, 0x10, 0xF0,
	237	0x10, 0x10, 0xFF, 0x10, 0xFF,
	238	0x14, 0x14, 0x14, 0xFF, 0x14,
	239	0x10, 0x10, 0x10, 0x1F, 0x00,
	240	0x00, 0x00, 0x00, 0xF0, 0x10,
	241	0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
	242	0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
	243	0xFF, 0xFF, 0xFF, 0x00, 0x00,
	244	0x00, 0x00, 0x00, 0xFF, 0xFF,
	245	0x0F, 0x0F, 0x0F, 0x0F, 0x0F,
	246	0x38, 0x44, 0x44, 0x38, 0x44,
	247	0xFC, 0x4A, 0x4A, 0x4A, 0x34, // sharp-s or beta
	248	0x7E, 0x02, 0x02, 0x06, 0x06,
	249	0x02, 0x7E, 0x02, 0x7E, 0x02,
	250	0x63, 0x55, 0x49, 0x41, 0x63,
	251	0x38, 0x44, 0x44, 0x3C, 0x04,
	252	0x40, 0x7E, 0x20, 0x1E, 0x20,
	253	0x06, 0x02, 0x7E, 0x02, 0x02,
	254	0x99, 0xA5, 0xE7, 0xA5, 0x99,
	255	0x1C, 0x2A, 0x49, 0x2A, 0x1C,
	256	0x4C, 0x72, 0x01, 0x72, 0x4C,
	257	0x30, 0x4A, 0x4D, 0x4D, 0x30,
	258	0x30, 0x48, 0x78, 0x48, 0x30,
	259	0xBC, 0x62, 0x5A, 0x46, 0x3D,
	260	0x3E, 0x49, 0x49, 0x49, 0x00,
	261	0x7E, 0x01, 0x01, 0x01, 0x7E,
	262	0x2A, 0x2A, 0x2A, 0x2A, 0x2A,
	263	0x44, 0x44, 0x5F, 0x44, 0x44,
	264	0x40, 0x51, 0x4A, 0x44, 0x40,
	265	0x40, 0x44, 0x4A, 0x51, 0x40,
	266	0x00, 0x00, 0xFF, 0x01, 0x03,
	267	0xE0, 0x80, 0xFF, 0x00, 0x00,
	268	0x08, 0x08, 0x6B, 0x6B, 0x08,
	269	0x36, 0x12, 0x36, 0x24, 0x36,
	270	0x06, 0x0F, 0x09, 0x0F, 0x06,
	271	0x00, 0x00, 0x18, 0x18, 0x00,
	272	0x00, 0x00, 0x10, 0x10, 0x00,
	273	0x30, 0x40, 0xFF, 0x01, 0x01,
	274	0x00, 0x1F, 0x01, 0x01, 0x1E,
	275	0x00, 0x19, 0x1D, 0x17, 0x12,
	276	0x00, 0x3C, 0x3C, 0x3C, 0x3C,
	277	0x00, 0x00, 0x00, 0x00, 0x00 // #255 NBSP
	278	};
	279
	280
	281	#endif // FONT5X7_H

LEAF/Src/gpio.c+176−0

@@ -0,0 +1,176 @@
	1	/**
	2	******************************************************************************
	3	* File Name : gpio.c
	4	* Description : This file provides code for the configuration
	5	* of all used GPIO pins.
	6	******************************************************************************
	7	* @attention
	8	*
	9	* <h2><center>© Copyright (c) 2020 STMicroelectronics.
	10	* All rights reserved.</center></h2>
	11	*
	12	* This software component is licensed by ST under Ultimate Liberty license
	13	* SLA0044, the "License"; You may not use this file except in compliance with
	14	* the License. You may obtain a copy of the License at:
	15	* www.st.com/SLA0044
	16	*
	17	******************************************************************************
	18	*/
	19
	20	/* Includes ------------------------------------------------------------------*/
	21	#include "gpio.h"
	22	/* USER CODE BEGIN 0 */
	23
	24	/* USER CODE END 0 */
	25
	26	/----------------------------------------------------------------------------/
	27	/* Configure GPIO */
	28	/----------------------------------------------------------------------------/
	29	/* USER CODE BEGIN 1 */
	30
	31	/* USER CODE END 1 */
	32
	33	/** Configure pins
	34	PH0-OSC_IN (PH0) ------> RCC_OSC_IN
	35	PH1-OSC_OUT (PH1) ------> RCC_OSC_OUT
	36	PA13 (JTMS/SWDIO) ------> DEBUG_JTMS-SWDIO
	37	PA14 (JTCK/SWCLK) ------> DEBUG_JTCK-SWCLK
	38	PB3 (JTDO/TRACESWO) ------> DEBUG_JTDO-SWO
	39	*/
	40	void MX_GPIO_Init(void)
	41	{
	42
	43	GPIO_InitTypeDef GPIO_InitStruct = {0};
	44
	45	/* GPIO Ports Clock Enable */
	46	__HAL_RCC_GPIOE_CLK_ENABLE();
	47	__HAL_RCC_GPIOC_CLK_ENABLE();
	48	__HAL_RCC_GPIOF_CLK_ENABLE();
	49	__HAL_RCC_GPIOH_CLK_ENABLE();
	50	__HAL_RCC_GPIOA_CLK_ENABLE();
	51	__HAL_RCC_GPIOB_CLK_ENABLE();
	52	__HAL_RCC_GPIOG_CLK_ENABLE();
	53	__HAL_RCC_GPIOD_CLK_ENABLE();
	54
	55	/Configure GPIO pin Output Level /
	56	HAL_GPIO_WritePin(GPIOC, GPIO_PIN_14\|GPIO_PIN_4\|GPIO_PIN_6\|GPIO_PIN_7, GPIO_PIN_RESET);
	57
	58	/Configure GPIO pin Output Level /
	59	HAL_GPIO_WritePin(GPIOF, GPIO_PIN_6, GPIO_PIN_RESET);
	60
	61	/Configure GPIO pin Output Level /
	62	HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4\|GPIO_PIN_6\|GPIO_PIN_8\|GPIO_PIN_9
	63	\|GPIO_PIN_10, GPIO_PIN_RESET);
	64
	65	/Configure GPIO pin Output Level /
	66	HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0\|GPIO_PIN_4, GPIO_PIN_RESET);
	67
	68	/Configure GPIO pin Output Level /
	69	HAL_GPIO_WritePin(GPIOG, GPIO_PIN_6\|GPIO_PIN_7\|GPIO_PIN_10, GPIO_PIN_RESET);
	70
	71	/Configure GPIO pin : PC13 /
	72	GPIO_InitStruct.Pin = GPIO_PIN_13;
	73	GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
	74	GPIO_InitStruct.Pull = GPIO_NOPULL;
	75	HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
	76
	77	/Configure GPIO pins : PC14 PC4 PC6 PC7 /
	78	GPIO_InitStruct.Pin = GPIO_PIN_14\|GPIO_PIN_4\|GPIO_PIN_6\|GPIO_PIN_7;
	79	GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
	80	GPIO_InitStruct.Pull = GPIO_NOPULL;
	81	GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
	82	HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
	83
	84	/Configure GPIO pin : PC15 /
	85	GPIO_InitStruct.Pin = GPIO_PIN_15;
	86	GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
	87	GPIO_InitStruct.Pull = GPIO_NOPULL;
	88	HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
	89
	90	/Configure GPIO pin : PF6 /
	91	GPIO_InitStruct.Pin = GPIO_PIN_6;
	92	GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
	93	GPIO_InitStruct.Pull = GPIO_NOPULL;
	94	GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
	95	HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);
	96
	97	/Configure GPIO pins : PF7 PF8 PF9 PF10 /
	98	GPIO_InitStruct.Pin = GPIO_PIN_7\|GPIO_PIN_8\|GPIO_PIN_9\|GPIO_PIN_10;
	99	GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
	100	GPIO_InitStruct.Pull = GPIO_NOPULL;
	101	HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);
	102
	103	/Configure GPIO pins : PA1 PA15 /
	104	GPIO_InitStruct.Pin = GPIO_PIN_1\|GPIO_PIN_15;
	105	GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
	106	GPIO_InitStruct.Pull = GPIO_NOPULL;
	107	HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
	108
	109	/*Configure GPIO pins : PA4 PA6 PA8 PA9
	110	PA10 */
	111	GPIO_InitStruct.Pin = GPIO_PIN_4\|GPIO_PIN_6\|GPIO_PIN_8\|GPIO_PIN_9
	112	\|GPIO_PIN_10;
	113	GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
	114	GPIO_InitStruct.Pull = GPIO_NOPULL;
	115	GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
	116	HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
	117
	118	/Configure GPIO pins : PB0 PB4 /
	119	GPIO_InitStruct.Pin = GPIO_PIN_0\|GPIO_PIN_4;
	120	GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
	121	GPIO_InitStruct.Pull = GPIO_NOPULL;
	122	GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
	123	HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
	124
	125	/*Configure GPIO pins : PB1 PB12 PB13 PB14
	126	PB15 */
	127	GPIO_InitStruct.Pin = GPIO_PIN_1\|GPIO_PIN_12\|GPIO_PIN_13\|GPIO_PIN_14
	128	\|GPIO_PIN_15;
	129	GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
	130	GPIO_InitStruct.Pull = GPIO_PULLUP;
	131	HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
	132
	133	/Configure GPIO pins : PB2 PB9 /
	134	GPIO_InitStruct.Pin = GPIO_PIN_2\|GPIO_PIN_9;
	135	GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
	136	GPIO_InitStruct.Pull = GPIO_NOPULL;
	137	HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
	138
	139	/Configure GPIO pins : PD11 PD7 /
	140	GPIO_InitStruct.Pin = GPIO_PIN_11\|GPIO_PIN_7;
	141	GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
	142	GPIO_InitStruct.Pull = GPIO_PULLUP;
	143	HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
	144
	145	/Configure GPIO pins : PG3 PG9 PG13 PG14 /
	146	GPIO_InitStruct.Pin = GPIO_PIN_3\|GPIO_PIN_9\|GPIO_PIN_13\|GPIO_PIN_14;
	147	GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
	148	GPIO_InitStruct.Pull = GPIO_NOPULL;
	149	HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);
	150
	151	/Configure GPIO pins : PG6 PG7 PG10 /
	152	GPIO_InitStruct.Pin = GPIO_PIN_6\|GPIO_PIN_7\|GPIO_PIN_10;
	153	GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
	154	GPIO_InitStruct.Pull = GPIO_NOPULL;
	155	GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
	156	HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);
	157
	158	/Configure GPIO pins : PD3 PD4 PD5 PD6 /
	159	GPIO_InitStruct.Pin = GPIO_PIN_3\|GPIO_PIN_4\|GPIO_PIN_5\|GPIO_PIN_6;
	160	GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
	161	GPIO_InitStruct.Pull = GPIO_NOPULL;
	162	HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
	163
	164	/Configure GPIO pins : PG11 PG12 /
	165	GPIO_InitStruct.Pin = GPIO_PIN_11\|GPIO_PIN_12;
	166	GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
	167	GPIO_InitStruct.Pull = GPIO_PULLUP;
	168	HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);
	169
	170	}
	171
	172	/* USER CODE BEGIN 2 */
	173
	174	/* USER CODE END 2 */
	175
	176	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

LEAF/Src/i2c.c+242−0

@@ -0,0 +1,242 @@
	1	/**
	2	******************************************************************************
	3	* File Name : I2C.c
	4	* Description : This file provides code for the configuration
	5	* of the I2C instances.
	6	******************************************************************************
	7	* @attention
	8	*
	9	* <h2><center>© Copyright (c) 2020 STMicroelectronics.
	10	* All rights reserved.</center></h2>
	11	*
	12	* This software component is licensed by ST under Ultimate Liberty license
	13	* SLA0044, the "License"; You may not use this file except in compliance with
	14	* the License. You may obtain a copy of the License at:
	15	* www.st.com/SLA0044
	16	*
	17	******************************************************************************
	18	*/
	19
	20	/* Includes ------------------------------------------------------------------*/
	21	#include "i2c.h"
	22
	23	/* USER CODE BEGIN 0 */
	24
	25	/* USER CODE END 0 */
	26
	27	I2C_HandleTypeDef hi2c2;
	28	I2C_HandleTypeDef hi2c4;
	29	DMA_HandleTypeDef hdma_i2c4_rx;
	30	DMA_HandleTypeDef hdma_i2c4_tx;
	31
	32	/* I2C2 init function */
	33	void MX_I2C2_Init(void)
	34	{
	35
	36	hi2c2.Instance = I2C2;
	37	hi2c2.Init.Timing = 0x505097F4;
	38	hi2c2.Init.OwnAddress1 = 0;
	39	hi2c2.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
	40	hi2c2.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
	41	hi2c2.Init.OwnAddress2 = 0;
	42	hi2c2.Init.OwnAddress2Masks = I2C_OA2_NOMASK;
	43	hi2c2.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
	44	hi2c2.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
	45	if (HAL_I2C_Init(&hi2c2) != HAL_OK)
	46	{
	47	Error_Handler();
	48	}
	49	/** Configure Analogue filter
	50	*/
	51	if (HAL_I2CEx_ConfigAnalogFilter(&hi2c2, I2C_ANALOGFILTER_ENABLE) != HAL_OK)
	52	{
	53	Error_Handler();
	54	}
	55	/** Configure Digital filter
	56	*/
	57	if (HAL_I2CEx_ConfigDigitalFilter(&hi2c2, 0) != HAL_OK)
	58	{
	59	Error_Handler();
	60	}
	61
	62	}
	63	/* I2C4 init function */
	64	void MX_I2C4_Init(void)
	65	{
	66
	67	hi2c4.Instance = I2C4;
	68	hi2c4.Init.Timing = 0x307075B1;
	69	hi2c4.Init.OwnAddress1 = 0;
	70	hi2c4.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
	71	hi2c4.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
	72	hi2c4.Init.OwnAddress2 = 0;
	73	hi2c4.Init.OwnAddress2Masks = I2C_OA2_NOMASK;
	74	hi2c4.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
	75	hi2c4.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
	76	if (HAL_I2C_Init(&hi2c4) != HAL_OK)
	77	{
	78	Error_Handler();
	79	}
	80	/** Configure Analogue filter
	81	*/
	82	if (HAL_I2CEx_ConfigAnalogFilter(&hi2c4, I2C_ANALOGFILTER_ENABLE) != HAL_OK)
	83	{
	84	Error_Handler();
	85	}
	86	/** Configure Digital filter
	87	*/
	88	if (HAL_I2CEx_ConfigDigitalFilter(&hi2c4, 0) != HAL_OK)
	89	{
	90	Error_Handler();
	91	}
	92
	93	}
	94
	95	void HAL_I2C_MspInit(I2C_HandleTypeDef* i2cHandle)
	96	{
	97
	98	GPIO_InitTypeDef GPIO_InitStruct = {0};
	99	if(i2cHandle->Instance==I2C2)
	100	{
	101	/* USER CODE BEGIN I2C2_MspInit 0 */
	102
	103	/* USER CODE END I2C2_MspInit 0 */
	104
	105	__HAL_RCC_GPIOB_CLK_ENABLE();
	106	/**I2C2 GPIO Configuration
	107	PB10 ------> I2C2_SCL
	108	PB11 ------> I2C2_SDA
	109	*/
	110	GPIO_InitStruct.Pin = GPIO_PIN_10\|GPIO_PIN_11;
	111	GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
	112	GPIO_InitStruct.Pull = GPIO_NOPULL;
	113	GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
	114	GPIO_InitStruct.Alternate = GPIO_AF4_I2C2;
	115	HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
	116
	117	/* I2C2 clock enable */
	118	__HAL_RCC_I2C2_CLK_ENABLE();
	119	/* USER CODE BEGIN I2C2_MspInit 1 */
	120
	121	/* USER CODE END I2C2_MspInit 1 */
	122	}
	123	else if(i2cHandle->Instance==I2C4)
	124	{
	125	/* USER CODE BEGIN I2C4_MspInit 0 */
	126
	127	/* USER CODE END I2C4_MspInit 0 */
	128
	129	__HAL_RCC_GPIOD_CLK_ENABLE();
	130	/**I2C4 GPIO Configuration
	131	PD12 ------> I2C4_SCL
	132	PD13 ------> I2C4_SDA
	133	*/
	134	GPIO_InitStruct.Pin = GPIO_PIN_12\|GPIO_PIN_13;
	135	GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
	136	GPIO_InitStruct.Pull = GPIO_NOPULL;
	137	GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_MEDIUM;
	138	GPIO_InitStruct.Alternate = GPIO_AF4_I2C4;
	139	HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
	140
	141	/* I2C4 clock enable */
	142	__HAL_RCC_I2C4_CLK_ENABLE();
	143
	144	/* I2C4 DMA Init */
	145	/* I2C4_RX Init */
	146	hdma_i2c4_rx.Instance = BDMA_Channel0;
	147	hdma_i2c4_rx.Init.Request = BDMA_REQUEST_I2C4_RX;
	148	hdma_i2c4_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
	149	hdma_i2c4_rx.Init.PeriphInc = DMA_PINC_DISABLE;
	150	hdma_i2c4_rx.Init.MemInc = DMA_MINC_ENABLE;
	151	hdma_i2c4_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
	152	hdma_i2c4_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
	153	hdma_i2c4_rx.Init.Mode = DMA_NORMAL;
	154	hdma_i2c4_rx.Init.Priority = DMA_PRIORITY_LOW;
	155	if (HAL_DMA_Init(&hdma_i2c4_rx) != HAL_OK)
	156	{
	157	Error_Handler();
	158	}
	159
	160	__HAL_LINKDMA(i2cHandle,hdmarx,hdma_i2c4_rx);
	161
	162	/* I2C4_TX Init */
	163	hdma_i2c4_tx.Instance = BDMA_Channel1;
	164	hdma_i2c4_tx.Init.Request = BDMA_REQUEST_I2C4_TX;
	165	hdma_i2c4_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
	166	hdma_i2c4_tx.Init.PeriphInc = DMA_PINC_DISABLE;
	167	hdma_i2c4_tx.Init.MemInc = DMA_MINC_ENABLE;
	168	hdma_i2c4_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
	169	hdma_i2c4_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
	170	hdma_i2c4_tx.Init.Mode = DMA_NORMAL;
	171	hdma_i2c4_tx.Init.Priority = DMA_PRIORITY_LOW;
	172	if (HAL_DMA_Init(&hdma_i2c4_tx) != HAL_OK)
	173	{
	174	Error_Handler();
	175	}
	176
	177	__HAL_LINKDMA(i2cHandle,hdmatx,hdma_i2c4_tx);
	178
	179	/* I2C4 interrupt Init */
	180	HAL_NVIC_SetPriority(I2C4_EV_IRQn, 6, 0);
	181	HAL_NVIC_EnableIRQ(I2C4_EV_IRQn);
	182	HAL_NVIC_SetPriority(I2C4_ER_IRQn, 6, 0);
	183	HAL_NVIC_EnableIRQ(I2C4_ER_IRQn);
	184	/* USER CODE BEGIN I2C4_MspInit 1 */
	185
	186	/* USER CODE END I2C4_MspInit 1 */
	187	}
	188	}
	189
	190	void HAL_I2C_MspDeInit(I2C_HandleTypeDef* i2cHandle)
	191	{
	192
	193	if(i2cHandle->Instance==I2C2)
	194	{
	195	/* USER CODE BEGIN I2C2_MspDeInit 0 */
	196
	197	/* USER CODE END I2C2_MspDeInit 0 */
	198	/* Peripheral clock disable */
	199	__HAL_RCC_I2C2_CLK_DISABLE();
	200
	201	/**I2C2 GPIO Configuration
	202	PB10 ------> I2C2_SCL
	203	PB11 ------> I2C2_SDA
	204	*/
	205	HAL_GPIO_DeInit(GPIOB, GPIO_PIN_10\|GPIO_PIN_11);
	206
	207	/* USER CODE BEGIN I2C2_MspDeInit 1 */
	208
	209	/* USER CODE END I2C2_MspDeInit 1 */
	210	}
	211	else if(i2cHandle->Instance==I2C4)
	212	{
	213	/* USER CODE BEGIN I2C4_MspDeInit 0 */
	214
	215	/* USER CODE END I2C4_MspDeInit 0 */
	216	/* Peripheral clock disable */
	217	__HAL_RCC_I2C4_CLK_DISABLE();
	218
	219	/**I2C4 GPIO Configuration
	220	PD12 ------> I2C4_SCL
	221	PD13 ------> I2C4_SDA
	222	*/
	223	HAL_GPIO_DeInit(GPIOD, GPIO_PIN_12\|GPIO_PIN_13);
	224
	225	/* I2C4 DMA DeInit */
	226	HAL_DMA_DeInit(i2cHandle->hdmarx);
	227	HAL_DMA_DeInit(i2cHandle->hdmatx);
	228
	229	/* I2C4 interrupt Deinit */
	230	HAL_NVIC_DisableIRQ(I2C4_EV_IRQn);
	231	HAL_NVIC_DisableIRQ(I2C4_ER_IRQn);
	232	/* USER CODE BEGIN I2C4_MspDeInit 1 */
	233
	234	/* USER CODE END I2C4_MspDeInit 1 */
	235	}
	236	}
	237
	238	/* USER CODE BEGIN 1 */
	239
	240	/* USER CODE END 1 */
	241
	242	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

LEAF/Src/leaf-analysis.c+0−946

@@ -1,946 +0,0 @@
1	/*==============================================================================
2
3	leaf-analysis.c
4	Created: 30 Nov 2018 11:56:49am
5	Author: airship
6
7	==============================================================================*/
8
9	#if _WIN32 \|\| _WIN64
10
11	#include "..\Inc\leaf-analysis.h"
12	#include "..\Externals\d_fft_mayer.h"
13
14	#else
15
16	#include "../Inc/leaf-analysis.h"
17	#include "../Externals/d_fft_mayer.h"
18
19	#endif
20
21	//===========================================================================
22	/* Envelope Follower */
23	//===========================================================================
24
25	void tEnvelopeFollower_init(tEnvelopeFollower* const ef, float attackThreshold, float decayCoeff)
26	{
27	_tEnvelopeFollower* e = ef = (_tEnvelopeFollower) leaf_alloc(sizeof(_tEnvelopeFollower));
28
29	e->y = 0.0f;
30	e->a_thresh = attackThreshold;
31	e->d_coeff = decayCoeff;
32	}
33
34	void tEnvelopeFollower_free(tEnvelopeFollower* const ef)
35	{
36	_tEnvelopeFollower* e = *ef;
37
38	leaf_free(e);
39	}
40
41	void tEnvelopeFollower_initToPool (tEnvelopeFollower* const ef, float attackThreshold, float decayCoeff, tMempool* const mp)
42	{
43	_tMempool* m = *mp;
44	_tEnvelopeFollower* e = ef = (_tEnvelopeFollower) mpool_alloc(sizeof(_tEnvelopeFollower), &m->pool);
45
46	e->y = 0.0f;
47	e->a_thresh = attackThreshold;
48	e->d_coeff = decayCoeff;
49	}
50
51	void tEnvelopeFollower_freeFromPool (tEnvelopeFollower* const ef, tMempool* const mp)
52	{
53	_tMempool* m = *mp;
54	_tEnvelopeFollower* e = *ef;
55
56	mpool_free(e, &m->pool);
57	}
58
59	float tEnvelopeFollower_tick(tEnvelopeFollower* const ef, float x)
60	{
61	_tEnvelopeFollower* e = *ef;
62
63	if (x < 0.0f ) x = -x; /* Absolute value. */
64
65	if ((x >= e->y) && (x > e->a_thresh)) e->y = x; /* If we hit a peak, ride the peak to the top. */
66	else e->y = e->y * e->d_coeff; /* Else, exponential decay of output. */
67
68	//ef->y = envelope_pow[(uint16_t)(ef->y * (float)UINT16_MAX)] * ef->d_coeff; //not quite the right behavior - too much loss of precision?
69	//ef->y = powf(ef->y, 1.000009f) * ef->d_coeff; // too expensive
70
71	if( e->y < VSF) e->y = 0.0f;
72
73	return e->y;
74	}
75
76	int tEnvelopeFollower_decayCoeff(tEnvelopeFollower* const ef, float decayCoeff)
77	{
78	_tEnvelopeFollower* e = *ef;
79	return e->d_coeff = decayCoeff;
80	}
81
82	int tEnvelopeFollower_attackThresh(tEnvelopeFollower* const ef, float attackThresh)
83	{
84	_tEnvelopeFollower* e = *ef;
85	return e->a_thresh = attackThresh;
86	}
87
88
89	//===========================================================================
90	/* Power Follower */
91	//===========================================================================
92	void tPowerFollower_init(tPowerFollower* const pf, float factor)
93	{
94	_tPowerFollower* p = pf = (_tPowerFollower) leaf_alloc(sizeof(_tPowerFollower));
95
96	p->curr=0.0f;
97	p->factor=factor;
98	p->oneminusfactor=1.0f-factor;
99	}
100
101	void tPowerFollower_free(tPowerFollower* const pf)
102	{
103	_tPowerFollower* p = *pf;
104
105	leaf_free(p);
106	}
107
108	void tPowerFollower_initToPool (tPowerFollower* const pf, float factor, tMempool* const mp)
109	{
110	_tMempool* m = *mp;
111	_tPowerFollower* p = pf = (_tPowerFollower) mpool_alloc(sizeof(_tPowerFollower), &m->pool);
112
113	p->curr=0.0f;
114	p->factor=factor;
115	p->oneminusfactor=1.0f-factor;
116	}
117
118	void tPowerFollower_freeFromPool (tPowerFollower* const pf, tMempool* const mp)
119	{
120	_tMempool* m = *mp;
121	_tPowerFollower* p = *pf;
122
123	mpool_free(p, &m->pool);
124	}
125
126	int tPowerFollower_setFactor(tPowerFollower* const pf, float factor)
127	{
128	_tPowerFollower* p = *pf;
129
130	if (factor<0) factor=0;
131	if (factor>1) factor=1;
132	p->factor=factor;
133	p->oneminusfactor=1.0f-factor;
134	return 0;
135	}
136
137	float tPowerFollower_tick(tPowerFollower* const pf, float input)
138	{
139	_tPowerFollower* p = *pf;
140	p->curr = p->factorinputinput+p->oneminusfactor*p->curr;
141	return p->curr;
142	}
143
144	float tPowerFollower_sample(tPowerFollower* const pf)
145	{
146	_tPowerFollower* p = *pf;
147	return p->curr;
148	}
149
150
151
152
153	//===========================================================================
154	/* ---------------- env~ - simple envelope follower. ----------------- */
155	//===========================================================================
156
157	void tEnvPD_init(tEnvPD* const xpd, int ws, int hs, int bs)
158	{
159	_tEnvPD* x = xpd = (_tEnvPD) leaf_calloc(sizeof(_tEnvPD));
160
161	int period = hs, npoints = ws;
162
163	int i;
164
165	if (npoints < 1) npoints = 1024;
166	if (period < 1) period = npoints/2;
167	if (period < npoints / MAXOVERLAP + 1)
168	period = npoints / MAXOVERLAP + 1;
169
170	x->x_npoints = npoints;
171	x->x_phase = 0;
172	x->x_period = period;
173
174	x->windowSize = npoints;
175	x->hopSize = period;
176	x->blockSize = bs;
177
178	for (i = 0; i < MAXOVERLAP; i++) x->x_sumbuf[i] = 0.0f;
179	for (i = 0; i < npoints; i++)
180	x->buf[i] = (1.0f - cosf((TWO_PI * i) / npoints))/npoints;
181	for (; i < npoints+INITVSTAKEN; i++) x->buf[i] = 0.0f;
182
183	x->x_f = 0.0f;
184
185	x->x_allocforvs = INITVSTAKEN;
186
187	// ~ ~ ~ dsp ~ ~ ~
188	if (x->x_period % x->blockSize)
189	{
190	x->x_realperiod = x->x_period + x->blockSize - (x->x_period % x->blockSize);
191	}
192	else
193	{
194	x->x_realperiod = x->x_period;
195	}
196	// ~ ~ ~ ~ ~ ~ ~ ~
197	}
198
199	void tEnvPD_free (tEnvPD* const xpd)
200	{
201	_tEnvPD* x = *xpd;
202
203	leaf_free(x);
204	}
205
206	void tEnvPD_initToPool (tEnvPD* const xpd, int ws, int hs, int bs, tMempool* const mp)
207	{
208	_tMempool* m = *mp;
209	_tEnvPD* x = xpd = (_tEnvPD) mpool_calloc(sizeof(_tEnvPD), &m->pool);
210
211	int period = hs, npoints = ws;
212
213	int i;
214
215	if (npoints < 1) npoints = 1024;
216	if (period < 1) period = npoints/2;
217	if (period < npoints / MAXOVERLAP + 1)
218	period = npoints / MAXOVERLAP + 1;
219
220	x->x_npoints = npoints;
221	x->x_phase = 0;
222	x->x_period = period;
223
224	x->windowSize = npoints;
225	x->hopSize = period;
226	x->blockSize = bs;
227
228	for (i = 0; i < MAXOVERLAP; i++) x->x_sumbuf[i] = 0;
229	for (i = 0; i < npoints; i++)
230	x->buf[i] = (1.0f - cosf((2 * PI * i) / npoints))/npoints;
231	for (; i < npoints+INITVSTAKEN; i++) x->buf[i] = 0;
232
233	x->x_f = 0;
234
235	x->x_allocforvs = INITVSTAKEN;
236
237	// ~ ~ ~ dsp ~ ~ ~
238	if (x->x_period % x->blockSize)
239	{
240	x->x_realperiod = x->x_period + x->blockSize - (x->x_period % x->blockSize);
241	}
242	else
243	{
244	x->x_realperiod = x->x_period;
245	}
246	// ~ ~ ~ ~ ~ ~ ~ ~
247	}
248
249	void tEnvPD_freeFromPool (tEnvPD* const xpd, tMempool* const mp)
250	{
251	_tMempool* m = *mp;
252	_tEnvPD* x = *xpd;
253
254	mpool_free(x, &m->pool);
255	}
256
257	float tEnvPD_tick (tEnvPD* const xpd)
258	{
259	_tEnvPD* x = *xpd;
260	return powtodb(x->x_result);
261	}
262
263	void tEnvPD_processBlock(tEnvPD* const xpd, float* in)
264	{
265	_tEnvPD* x = *xpd;
266
267	int n = x->blockSize;
268
269	int count;
270	t_sample *sump;
271	in += n;
272	for (count = x->x_phase, sump = x->x_sumbuf;
273	count < x->x_npoints; count += x->x_realperiod, sump++)
274	{
275	t_sample *hp = x->buf + count;
276	t_sample *fp = in;
277	t_sample sum = *sump;
278	int i;
279
280	for (i = 0; i < n; i++)
281	{
282	fp--;
283	sum += hp++ (fp *fp);
284	}
285	*sump = sum;
286	}
287	sump[0] = 0;
288	x->x_phase -= n;
289	if (x->x_phase < 0)
290	{
291	x->x_result = x->x_sumbuf[0];
292	for (count = x->x_realperiod, sump = x->x_sumbuf;
293	count < x->x_npoints; count += x->x_realperiod, sump++)
294	sump[0] = sump[1];
295	sump[0] = 0;
296	x->x_phase = x->x_realperiod - n;
297	}
298	}
299
300	//===========================================================================
301	// ATTACKDETECTION
302	//===========================================================================
303	/******Private function prototypes********/
304	static void atkdtk_init(tAttackDetection* const a, int blocksize, int atk, int rel);
305	static void atkdtk_envelope(tAttackDetection* const a, float *in);
306
307	/******Constructor/Destructor*************/
308
309	void tAttackDetection_init(tAttackDetection* const ad, int blocksize, int atk, int rel)
310	{
311	ad = (_tAttackDetection) leaf_alloc(sizeof(_tAttackDetection));
312
313	atkdtk_init(ad, blocksize, atk, rel);
314	}
315
316	void tAttackDetection_free(tAttackDetection* const ad)
317	{
318	_tAttackDetection* a = *ad;
319
320	leaf_free(a);
321	}
322
323	void tAttackDetection_initToPool (tAttackDetection* const ad, int blocksize, int atk, int rel, tMempool* const mp)
324	{
325	_tMempool* m = *mp;
326	ad = (_tAttackDetection) mpool_alloc(sizeof(_tAttackDetection), &m->pool);
327
328	atkdtk_init(ad, blocksize, atk, rel);
329	}
330
331	void tAttackDetection_freeFromPool (tAttackDetection* const ad, tMempool* const mp)
332	{
333	_tMempool* m = *mp;
334	_tAttackDetection* a = *ad;
335
336	mpool_free(a, &m->pool);
337	}
338
339	/*****Public Functions*********/
340
341
342	void tAttackDetection_setBlocksize(tAttackDetection* const ad, int size)
343	{
344	_tAttackDetection* a = *ad;
345
346	if(!((size==64)\|(size==128)\|(size==256)\|(size==512)\|(size==1024)\|(size==2048)))
347	size = DEFBLOCKSIZE;
348	a->blocksize = size;
349
350	return;
351
352	}
353
354	void tAttackDetection_setSamplerate(tAttackDetection* const ad, int inRate)
355	{
356	_tAttackDetection* a = *ad;
357
358	a->samplerate = inRate;
359
360	//Reset atk and rel to recalculate coeff
361	tAttackDetection_setAttack(ad, a->atk);
362	tAttackDetection_setRelease(ad, a->rel);
363	}
364
365	void tAttackDetection_setThreshold(tAttackDetection* const ad, float thres)
366	{
367	_tAttackDetection* a = *ad;
368	a->threshold = thres;
369	}
370
371	void tAttackDetection_setAttack(tAttackDetection* const ad, int inAtk)
372	{
373	_tAttackDetection* a = *ad;
374	a->atk = inAtk;
375	a->atk_coeff = pow(0.01, 1.0/(a->atk * a->samplerate * 0.001));
376	}
377
378	void tAttackDetection_setRelease(tAttackDetection* const ad, int inRel)
379	{
380	_tAttackDetection* a = *ad;
381	a->rel = inRel;
382	a->rel_coeff = pow(0.01, 1.0/(a->rel * a->samplerate * 0.001));
383	}
384
385
386	int tAttackDetection_detect(tAttackDetection* const ad, float *in)
387	{
388	_tAttackDetection* a = *ad;
389
390	int result;
391
392	atkdtk_envelope(ad, in);
393
394	if(a->env >= a->prevAmp*2) //2 times greater = 6dB increase
395	result = 1;
396	else
397	result = 0;
398
399	a->prevAmp = a->env;
400
401	return result;
402	}
403
404	/*****Private Functions********/
405
406	static void atkdtk_init(tAttackDetection* const ad, int blocksize, int atk, int rel)
407	{
408	_tAttackDetection* a = *ad;
409
410	a->env = 0;
411	a->blocksize = blocksize;
412	a->threshold = DEFTHRESHOLD;
413	a->samplerate = leaf.sampleRate;
414	a->prevAmp = 0;
415
416	a->env = 0;
417
418	tAttackDetection_setAttack(ad, atk);
419	tAttackDetection_setRelease(ad, rel);
420	}
421
422	static void atkdtk_envelope(tAttackDetection* const ad, float *in)
423	{
424	_tAttackDetection* a = *ad;
425
426	int i = 0;
427	float tmp;
428	for(i = 0; i < a->blocksize; ++i){
429	tmp = fastabsf(in[i]);
430
431	if(tmp > a->env)
432	a->env = a->atk_coeff * (a->env - tmp) + tmp;
433	else
434	a->env = a->rel_coeff * (a->env - tmp) + tmp;
435	}
436
437	}
438
439	//===========================================================================
440	// SNAC
441	//===========================================================================
442	/******************************************************************************/
443	/*************************** private procedures ***************************/
444	/******************************************************************************/
445
446	#define REALFFT mayer_realfft
447	#define REALIFFT mayer_realifft
448
449	static void snac_analyzeframe(tSNAC* const s);
450	static void snac_autocorrelation(tSNAC* const s);
451	static void snac_normalize(tSNAC* const s);
452	static void snac_pickpeak(tSNAC* const s);
453	static void snac_periodandfidelity(tSNAC* const s);
454	static void snac_biasbuf(tSNAC* const s);
455	static float snac_spectralpeak(tSNAC* const s, float periodlength);
456
457
458	/******************************************************************************/
459	/****************************** constructor, destructor *******************/
460	/******************************************************************************/
461
462
463	void tSNAC_init(tSNAC* const snac, int overlaparg)
464	{
465	_tSNAC* s = snac = (_tSNAC) leaf_calloc(sizeof(_tSNAC));
466
467	s->biasfactor = DEFBIAS;
468	s->timeindex = 0;
469	s->periodindex = 0;
470	s->periodlength = 0.;
471	s->fidelity = 0.;
472	s->minrms = DEFMINRMS;
473	s->framesize = SNAC_FRAME_SIZE;
474
475	s->inputbuf = (float) leaf_calloc(sizeof(float) SNAC_FRAME_SIZE);
476	s->processbuf = (float) leaf_calloc(sizeof(float) (SNAC_FRAME_SIZE * 2));
477	s->spectrumbuf = (float) leaf_calloc(sizeof(float) (SNAC_FRAME_SIZE / 2));
478	s->biasbuf = (float) leaf_calloc(sizeof(float) SNAC_FRAME_SIZE);
479
480	snac_biasbuf(snac);
481	tSNAC_setOverlap(snac, overlaparg);
482	}
483
484	void tSNAC_free(tSNAC* const snac)
485	{
486	_tSNAC* s = *snac;
487
488	leaf_free(s->inputbuf);
489	leaf_free(s->processbuf);
490	leaf_free(s->spectrumbuf);
491	leaf_free(s->biasbuf);
492	leaf_free(s);
493	}
494
495	void tSNAC_initToPool (tSNAC* const snac, int overlaparg, tMempool* const mp)
496	{
497	_tMempool* m = *mp;
498	_tSNAC* s = snac = (_tSNAC) mpool_alloc(sizeof(_tSNAC), &m->pool);
499
500	s->biasfactor = DEFBIAS;
501	s->timeindex = 0;
502	s->periodindex = 0;
503	s->periodlength = 0.;
504	s->fidelity = 0.;
505	s->minrms = DEFMINRMS;
506	s->framesize = SNAC_FRAME_SIZE;
507
508	s->inputbuf = (float) mpool_calloc(sizeof(float) SNAC_FRAME_SIZE, &m->pool);
509	s->processbuf = (float) mpool_calloc(sizeof(float) (SNAC_FRAME_SIZE * 2), &m->pool);
510	s->spectrumbuf = (float) mpool_calloc(sizeof(float) (SNAC_FRAME_SIZE / 2), &m->pool);
511	s->biasbuf = (float) mpool_calloc(sizeof(float) SNAC_FRAME_SIZE, &m->pool);
512
513	snac_biasbuf(snac);
514	tSNAC_setOverlap(snac, overlaparg);
515	}
516
517	void tSNAC_freeFromPool (tSNAC* const snac, tMempool* const mp)
518	{
519	_tMempool* m = *mp;
520	_tSNAC* s = *snac;
521
522	mpool_free(s->inputbuf, &m->pool);
523	mpool_free(s->processbuf, &m->pool);
524	mpool_free(s->spectrumbuf, &m->pool);
525	mpool_free(s->biasbuf, &m->pool);
526	mpool_free(s, &m->pool);
527	}
528
529	/******************************************************************************/
530	/************************ public access functions**************************/
531	/******************************************************************************/
532
533
534	void tSNAC_ioSamples(tSNAC* const snac, float in, float out, int size)
535	{
536	_tSNAC* s = *snac;
537
538	int timeindex = s->timeindex;
539	int mask = s->framesize - 1;
540	int outindex = 0;
541	float *inputbuf = s->inputbuf;
542	float *processbuf = s->processbuf;
543
544	// call analysis function when it is time
545	if(!(timeindex & (s->framesize / s->overlap - 1))) snac_analyzeframe(snac);
546
547	while(size--)
548	{
549	inputbuf[timeindex] = *in++;
550	out[outindex++] = processbuf[timeindex++];
551	timeindex &= mask;
552	}
553	s->timeindex = timeindex;
554	}
555
556	void tSNAC_setOverlap(tSNAC* const snac, int lap)
557	{
558	_tSNAC* s = *snac;
559	if(!((lap==1)\|(lap==2)\|(lap==4)\|(lap==8))) lap = DEFOVERLAP;
560	s->overlap = lap;
561	}
562
563
564	void tSNAC_setBias(tSNAC* const snac, float bias)
565	{
566	_tSNAC* s = *snac;
567	if(bias > 1.) bias = 1.;
568	if(bias < 0.) bias = 0.;
569	s->biasfactor = bias;
570	snac_biasbuf(snac);
571	return;
572	}
573
574
575	void tSNAC_setMinRMS(tSNAC* const snac, float rms)
576	{
577	_tSNAC* s = *snac;
578	if(rms > 1.) rms = 1.;
579	if(rms < 0.) rms = 0.;
580	s->minrms = rms;
581	return;
582	}
583
584
585	float tSNAC_getPeriod(tSNAC* const snac)
586	{
587	_tSNAC* s = *snac;
588	return(s->periodlength);
589	}
590
591
592	float tSNAC_getFidelity(tSNAC* const snac)
593	{
594	_tSNAC* s = *snac;
595	return(s->fidelity);
596	}
597
598
599	/******************************************************************************/
600	/*************************** private procedures ***************************/
601	/******************************************************************************/
602
603
604	// main analysis function
605	static void snac_analyzeframe(tSNAC* const snac)
606	{
607	_tSNAC* s = *snac;
608
609	int n, tindex = s->timeindex;
610	int framesize = s->framesize;
611	int mask = framesize - 1;
612	float norm = 1. / sqrt((float)(framesize * 2));
613
614	float *inputbuf = s->inputbuf;
615	float *processbuf = s->processbuf;
616
617	// copy input to processing buffers
618	for(n=0; n<framesize; n++)
619	{
620	processbuf[n] = inputbuf[tindex] * norm;
621	tindex++;
622	tindex &= mask;
623	}
624
625	// zeropadding
626	for(n=framesize; n<(framesize<<1); n++) processbuf[n] = 0.;
627
628	// call analysis procedures
629	snac_autocorrelation(snac);
630	snac_normalize(snac);
631	snac_pickpeak(snac);
632	snac_periodandfidelity(snac);
633	}
634
635
636	static void snac_autocorrelation(tSNAC* const snac)
637	{
638	_tSNAC* s = *snac;
639
640	int n, m;
641	int framesize = s->framesize;
642	int fftsize = framesize * 2;
643	float *processbuf = s->processbuf;
644	float *spectrumbuf = s->spectrumbuf;
645
646	REALFFT(fftsize, processbuf);
647
648	// compute power spectrum
649	processbuf[0] *= processbuf[0]; // DC
650	processbuf[framesize] *= processbuf[framesize]; // Nyquist
651
652	for(n=1; n<framesize; n++)
653	{
654	processbuf[n] = processbuf[n] * processbuf[n]
655	+ processbuf[fftsize-n] * processbuf[fftsize-n]; // imag coefficients appear reversed
656	processbuf[fftsize-n] = 0.;
657	}
658
659	// store power spectrum up to SR/4 for possible later use
660	for(m=0; m<(framesize>>1); m++)
661	{
662	spectrumbuf[m] = processbuf[m];
663	}
664
665	// transform power spectrum to autocorrelation function
666	REALIFFT(fftsize, processbuf);
667	return;
668	}
669
670
671	static void snac_normalize(tSNAC* const snac)
672	{
673	_tSNAC* s = *snac;
674
675	int framesize = s->framesize;
676	int framesizeplustimeindex = s->framesize + s->timeindex;
677	int timeindexminusone = s->timeindex - 1;
678	int n, m;
679	int mask = framesize - 1;
680	int seek = framesize * SEEK;
681	float *inputbuf = s->inputbuf;
682	float *processbuf= s->processbuf;
683	float signal1, signal2;
684
685	// minimum RMS implemented as minimum autocorrelation at index 0
686	// functionally equivalent to white noise floor
687	float rms = s->minrms / sqrt(1.0f / (float)framesize);
688	float minrzero = rms * rms;
689	float rzero = processbuf[0];
690	if(rzero < minrzero) rzero = minrzero;
691	double normintegral = (double)rzero * 2.;
692
693	// normalize biased autocorrelation function
694	// inputbuf is circular buffer: timeindex may be non-zero when overlap > 1
695	processbuf[0] = 1;
696	for(n=1, m=s->timeindex+1; n<seek; n++, m++)
697	{
698	signal1 = inputbuf[(n + timeindexminusone)&mask];
699	signal2 = inputbuf[(framesizeplustimeindex - n)&mask];
700	normintegral -= (double)(signal1 * signal1 + signal2 * signal2);
701	processbuf[n] /= (float)normintegral * 0.5f;
702	}
703
704	// flush instable function tail
705	for(n = seek; n<framesize; n++) processbuf[n] = 0.;
706	return;
707	}
708
709
710	static void snac_periodandfidelity(tSNAC* const snac)
711	{
712	_tSNAC* s = *snac;
713
714	float periodlength;
715
716	if(s->periodindex)
717	{
718	periodlength = (float)s->periodindex +
719	interpolate3phase(s->processbuf, s->periodindex);
720	if(periodlength < 8) periodlength = snac_spectralpeak(snac, periodlength);
721	s->periodlength = periodlength;
722	s->fidelity = interpolate3max(s->processbuf, s->periodindex);
723	}
724	return;
725	}
726
727	// select the peak which most probably represents period length
728	static void snac_pickpeak(tSNAC* const snac)
729	{
730	_tSNAC* s = *snac;
731
732	int n, peakindex=0;
733	int seek = s->framesize * SEEK;
734	float *processbuf= s->processbuf;
735	float maxvalue = 0.;
736	float biasedpeak;
737	float *biasbuf = s->biasbuf;
738
739	// skip main lobe
740	for(n=1; n<seek; n++)
741	{
742	if(processbuf[n] < 0.) break;
743	}
744
745	// find interpolated / biased maximum in SNAC function
746	// interpolation finds the 'real maximum'
747	// biasing favours the first candidate
748	for(; n<seek-1; n++)
749	{
750	if(processbuf[n] >= processbuf[n-1])
751	{
752	if(processbuf[n] > processbuf[n+1]) // we have a local peak
753	{
754	biasedpeak = interpolate3max(processbuf, n) * biasbuf[n];
755
756	if(biasedpeak > maxvalue)
757	{
758	maxvalue = biasedpeak;
759	peakindex = n;
760	}
761	}
762	}
763	}
764	s->periodindex = peakindex;
765	return;
766	}
767
768
769	// verify period length via frequency domain (up till SR/4)
770	// frequency domain is more precise than lag domain for period lengths < 8
771	// argument 'periodlength' is initial estimation from autocorrelation
772	static float snac_spectralpeak(tSNAC* const snac, float periodlength)
773	{
774	_tSNAC* s = *snac;
775
776	if(periodlength < 4.0f) return periodlength;
777
778	float max = 0.;
779	int n, startbin, stopbin, peakbin = 0;
780	int spectrumsize = s->framesize>>1;
781	float *spectrumbuf = s->spectrumbuf;
782	float peaklocation = (float)(s->framesize * 2.0f) / periodlength;
783
784	startbin = (int)(peaklocation * 0.8f + 0.5f);
785	if(startbin < 1) startbin = 1;
786	stopbin = (int)(peaklocation * 1.25f + 0.5f);
787	if(stopbin >= spectrumsize - 1) stopbin = spectrumsize - 1;
788
789	for(n=startbin; n<stopbin; n++)
790	{
791	if(spectrumbuf[n] >= spectrumbuf[n-1])
792	{
793	if(spectrumbuf[n] > spectrumbuf[n+1])
794	{
795	if(spectrumbuf[n] > max)
796	{
797	max = spectrumbuf[n];
798	peakbin = n;
799	}
800	}
801	}
802	}
803
804	// calculate amplitudes in peak region
805	for(n=(peakbin-1); n<(peakbin+2); n++)
806	{
807	spectrumbuf[n] = sqrtf(spectrumbuf[n]);
808	}
809
810	peaklocation = (float)peakbin + interpolate3phase(spectrumbuf, peakbin);
811	periodlength = (float)(s->framesize * 2.0f) / peaklocation;
812
813	return periodlength;
814	}
815
816
817	// modified logarithmic bias function
818	static void snac_biasbuf(tSNAC* const snac)
819	{
820	_tSNAC* s = *snac;
821
822	int n;
823	int maxperiod = (int)(s->framesize * (float)SEEK);
824	float bias = s->biasfactor / logf((float)(maxperiod - 4));
825	float *biasbuf = s->biasbuf;
826
827	for(n=0; n<5; n++) // periods < 5 samples can't be tracked
828	{
829	biasbuf[n] = 0.0f;
830	}
831
832	for(n=5; n<maxperiod; n++)
833	{
834	biasbuf[n] = 1.0f - (float)logf(n - 4) * bias;
835	}
836	}
837
838	//===========================================================================
839	// PERIODDETECTION
840	//===========================================================================
841	void tPeriodDetection_init (tPeriodDetection* const pd, float* in, float* out, int bufSize, int frameSize)
842	{
843	tPeriodDetection_initToPool(pd, in, out, bufSize, frameSize, &leaf_mempool);
844	}
845
846	void tPeriodDetection_free (tPeriodDetection* const pd)
847	{
848	tPeriodDetection_freeFromPool(pd, &leaf_mempool);
849	}
850
851	void tPeriodDetection_initToPool (tPeriodDetection* const pd, float* in, float* out, int bufSize, int frameSize, tMempool* const mp)
852	{
853	_tMempool* m = *mp;
854	_tPeriodDetection* p = pd = (_tPeriodDetection) mpool_calloc(sizeof(_tPeriodDetection), &m->pool);
855
856	p->inBuffer = in;
857	p->outBuffer = out;
858	p->bufSize = bufSize;
859	p->frameSize = frameSize;
860	p->framesPerBuffer = p->bufSize / p->frameSize;
861	p->curBlock = 1;
862	p->lastBlock = 0;
863	p->index = 0;
864
865	p->hopSize = DEFHOPSIZE;
866	p->windowSize = DEFWINDOWSIZE;
867	p->fba = FBA;
868
869	tEnvPD_initToPool(&p->env, p->windowSize, p->hopSize, p->frameSize, mp);
870
871	tSNAC_initToPool(&p->snac, DEFOVERLAP, mp);
872
873	p->timeConstant = DEFTIMECONSTANT;
874	p->radius = expf(-1000.0f * p->hopSize * leaf.invSampleRate / p->timeConstant);
875	p->fidelityThreshold = 0.95;
876	}
877
878	void tPeriodDetection_freeFromPool (tPeriodDetection* const pd, tMempool* const mp)
879	{
880	_tMempool* m = *mp;
881	_tPeriodDetection* p = *pd;
882
883	tEnvPD_freeFromPool(&p->env, mp);
884	tSNAC_freeFromPool(&p->snac, mp);
885	mpool_free(p, &m->pool);
886	}
887
888	float tPeriodDetection_tick (tPeriodDetection* pd, float sample)
889	{
890	_tPeriodDetection* p = *pd;
891
892	int i, iLast;
893
894	i = (p->curBlock*p->frameSize);
895	iLast = (p->lastBlock*p->frameSize)+p->index;
896
897	p->i = i;
898	p->iLast = iLast;
899
900	p->inBuffer[i+p->index] = sample;
901
902	p->index++;
903	p->indexstore = p->index;
904	if (p->index >= p->frameSize)
905	{
906	p->index = 0;
907
908	tEnvPD_processBlock(&p->env, &(p->inBuffer[i]));
909
910	tSNAC_ioSamples(&p->snac, &(p->inBuffer[i]), &(p->outBuffer[i]), p->frameSize);
911	float fidelity = tSNAC_getFidelity(&p->snac);
912	// Fidelity threshold recommended by Katja Vetters is 0.95 for most instruments/voices http://www.katjaas.nl/helmholtz/helmholtz.html
913	if (fidelity > p->fidelityThreshold) p->period = tSNAC_getPeriod(&p->snac);
914
915	p->curBlock++;
916	if (p->curBlock >= p->framesPerBuffer) p->curBlock = 0;
917	p->lastBlock++;
918	if (p->lastBlock >= p->framesPerBuffer) p->lastBlock = 0;
919	}
920
921	return p->period;
922	}
923
924	float tPeriodDetection_getPeriod(tPeriodDetection* pd)
925	{
926	_tPeriodDetection* p = *pd;
927	return p->period;
928	}
929
930	void tPeriodDetection_setHopSize(tPeriodDetection* pd, int hs)
931	{
932	_tPeriodDetection* p = *pd;
933	p->hopSize = hs;
934	}
935
936	void tPeriodDetection_setWindowSize(tPeriodDetection* pd, int ws)
937	{
938	_tPeriodDetection* p = *pd;
939	p->windowSize = ws;
940	}
941
942	void tPeriodDetection_setFidelityThreshold(tPeriodDetection* pd, float threshold)
943	{
944	_tPeriodDetection* p = *pd;
945	p->fidelityThreshold = threshold;
946	}

LEAF/Src/leaf-delay.c+0−928

@@ -1,928 +0,0 @@
1	/*==============================================================================
2
3	leaf-delay.c
4	Created: 20 Jan 2017 12:01:24pm
5	Author: Michael R Mulshine
6
7	==============================================================================*/
8
9	#if _WIN32 \|\| _WIN64
10
11	#include "..\Inc\leaf-delay.h"
12	#include "..\leaf.h"
13
14	#else
15
16	#include "../Inc/leaf-delay.h"
17	#include "../leaf.h"
18
19	#endif
20
21	// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ Delay ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ //
22	void tDelay_init (tDelay* const dl, uint32_t delay, uint32_t maxDelay)
23	{
24	tDelay_initToPool(dl, delay, maxDelay, &leaf_mempool);
25	}
26
27	void tDelay_free(tDelay* const dl)
28	{
29	tDelay_freeFromPool(dl, &leaf_mempool);
30	}
31
32	void tDelay_initToPool (tDelay* const dl, uint32_t delay, uint32_t maxDelay, tMempool* const mp)
33	{
34	_tMempool* m = *mp;
35	_tDelay* d = dl = (_tDelay) mpool_alloc(sizeof(_tDelay), &m->pool);
36
37	d->maxDelay = maxDelay;
38
39	d->delay = delay;
40
41	d->buff = (float) mpool_alloc(sizeof(float) maxDelay, &m->pool);
42
43	d->inPoint = 0;
44	d->outPoint = 0;
45
46	d->lastIn = 0.0f;
47	d->lastOut = 0.0f;
48
49	d->gain = 1.0f;
50
51	tDelay_setDelay(dl, d->delay);
52	}
53
54	void tDelay_freeFromPool (tDelay* const dl, tMempool* const mp)
55	{
56	_tMempool* m = *mp;
57	_tDelay* d = *dl;
58
59	mpool_free(d->buff, &m->pool);
60	mpool_free(d, &m->pool);
61	}
62
63	void tDelay_clear(tDelay* const dl)
64	{
65	_tDelay* d = *dl;
66	for (int i = 0; i < d->maxDelay; i++)
67	{
68	d->buff[i] = 0;
69	}
70	}
71
72	float tDelay_tick (tDelay* const dl, float input)
73	{
74	_tDelay* d = *dl;
75
76	// Input
77	d->lastIn = input;
78	d->buff[d->inPoint] = input * d->gain;
79	if (++(d->inPoint) == d->maxDelay) d->inPoint = 0;
80
81	// Output
82	d->lastOut = d->buff[d->outPoint];
83	if (++(d->outPoint) == d->maxDelay) d->outPoint = 0;
84
85	return d->lastOut;
86	}
87
88	int tDelay_setDelay (tDelay* const dl, uint32_t delay)
89	{
90	_tDelay* d = *dl;
91
92	d->delay = LEAF_clip(0.0f, delay, d->maxDelay);
93
94	// read chases write
95	if ( d->inPoint >= delay ) d->outPoint = d->inPoint - d->delay;
96	else d->outPoint = d->maxDelay + d->inPoint - d->delay;
97
98	return 0;
99	}
100
101	float tDelay_tapOut (tDelay* const dl, uint32_t tapDelay)
102	{
103	_tDelay* d = *dl;
104
105	int32_t tap = d->inPoint - tapDelay - 1;
106
107	// Check for wraparound.
108	while ( tap < 0 ) tap += d->maxDelay;
109
110	return d->buff[tap];
111
112	}
113
114	void tDelay_tapIn (tDelay* const dl, float value, uint32_t tapDelay)
115	{
116	_tDelay* d = *dl;
117
118	int32_t tap = d->inPoint - tapDelay - 1;
119
120	// Check for wraparound.
121	while ( tap < 0 ) tap += d->maxDelay;
122
123	d->buff[tap] = value;
124	}
125
126	float tDelay_addTo (tDelay* const dl, float value, uint32_t tapDelay)
127	{
128	_tDelay* d = *dl;
129
130	int32_t tap = d->inPoint - tapDelay - 1;
131
132	// Check for wraparound.
133	while ( tap < 0 ) tap += d->maxDelay;
134
135	return (d->buff[tap] += value);
136	}
137
138	uint32_t tDelay_getDelay (tDelay* const dl)
139	{
140	_tDelay* d = *dl;
141	return d->delay;
142	}
143
144	float tDelay_getLastOut (tDelay* const dl)
145	{
146	_tDelay* d = *dl;
147	return d->lastOut;
148	}
149
150	float tDelay_getLastIn (tDelay* const dl)
151	{
152	_tDelay* d = *dl;
153	return d->lastIn;
154	}
155
156	void tDelay_setGain (tDelay* const dl, float gain)
157	{
158	_tDelay* d = *dl;
159	if (gain < 0.0f) d->gain = 0.0f;
160	else d->gain = gain;
161	}
162
163	float tDelay_getGain (tDelay* const dl)
164	{
165	_tDelay* d = *dl;
166	return d->gain;
167	}
168
169	// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ LinearDelay ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ //
170	void tLinearDelay_init (tLinearDelay* const dl, float delay, uint32_t maxDelay)
171	{
172	tLinearDelay_initToPool(dl, delay, maxDelay, &leaf_mempool);
173	}
174
175	void tLinearDelay_free(tLinearDelay* const dl)
176	{
177	tLinearDelay_freeFromPool(dl, &leaf_mempool);
178	}
179
180	void tLinearDelay_initToPool (tLinearDelay* const dl, float delay, uint32_t maxDelay, tMempool* const mp)
181	{
182	_tMempool* m = *mp;
183	_tLinearDelay* d = dl = (_tLinearDelay) mpool_alloc(sizeof(_tLinearDelay), &m->pool);
184
185	d->maxDelay = maxDelay;
186
187	if (delay > maxDelay) d->delay = maxDelay;
188	else if (delay < 0.0f) d->delay = 0.0f;
189	else d->delay = delay;
190
191	d->buff = (float) mpool_alloc(sizeof(float) maxDelay, &m->pool);
192
193	d->gain = 1.0f;
194
195	d->lastIn = 0.0f;
196	d->lastOut = 0.0f;
197
198	d->inPoint = 0;
199	d->outPoint = 0;
200
201	tLinearDelay_setDelay(dl, d->delay);
202	}
203
204	void tLinearDelay_freeFromPool(tLinearDelay* const dl, tMempool* const mp)
205	{
206	_tMempool* m = *mp;
207	_tLinearDelay* d = *dl;
208
209	mpool_free(d->buff, &m->pool);
210	mpool_free(d, &m->pool);
211	}
212
213	void tLinearDelay_clear(tLinearDelay* const dl)
214	{
215	_tLinearDelay* d = *dl;
216	for (int i = 0; i < d->maxDelay; i++)
217	{
218	d->buff[i] = 0;
219	}
220	}
221
222	float tLinearDelay_tick (tLinearDelay* const dl, float input)
223	{
224	_tLinearDelay* d = *dl;
225
226	d->buff[d->inPoint] = input * d->gain;
227
228	// Increment input pointer modulo length.
229	if (++(d->inPoint) == d->maxDelay ) d->inPoint = 0;
230
231	uint32_t idx = (uint32_t) d->outPoint;
232	// First 1/2 of interpolation
233	d->lastOut = d->buff[idx] * d->omAlpha;
234	// Second 1/2 of interpolation
235	if ((idx + 1) < d->maxDelay)
236	d->lastOut += d->buff[idx+1] * d->alpha;
237	else
238	d->lastOut += d->buff[0] * d->alpha;
239
240	// Increment output pointer modulo length
241	if ( (++d->outPoint) >= d->maxDelay ) d->outPoint = 0;
242
243	return d->lastOut;
244	}
245
246	void tLinearDelay_tickIn (tLinearDelay* const dl, float input)
247	{
248	_tLinearDelay* d = *dl;
249
250	d->buff[d->inPoint] = input * d->gain;
251
252	// Increment input pointer modulo length.
253	if (++(d->inPoint) == d->maxDelay ) d->inPoint = 0;
254	}
255
256	float tLinearDelay_tickOut (tLinearDelay* const dl)
257	{
258	_tLinearDelay* d = *dl;
259
260	uint32_t idx = (uint32_t) d->outPoint;
261	// First 1/2 of interpolation
262	d->lastOut = d->buff[idx] * d->omAlpha;
263	// Second 1/2 of interpolation
264	if ((idx + 1) < d->maxDelay)
265	d->lastOut += d->buff[idx+1] * d->alpha;
266	else
267	d->lastOut += d->buff[0] * d->alpha;
268
269	// Increment output pointer modulo length
270	if ( (++d->outPoint) >= d->maxDelay ) d->outPoint = 0;
271
272	return d->lastOut;
273	}
274
275	int tLinearDelay_setDelay (tLinearDelay* const dl, float delay)
276	{
277	_tLinearDelay* d = *dl;
278
279	d->delay = LEAF_clip(0.0f, delay, d->maxDelay);
280
281	float outPointer = d->inPoint - d->delay;
282
283	while ( outPointer < 0 )
284	outPointer += d->maxDelay; // modulo maximum length
285
286	d->outPoint = (uint32_t) outPointer; // integer part
287
288	d->alpha = outPointer - d->outPoint; // fractional part
289	d->omAlpha = 1.0f - d->alpha;
290
291	if ( d->outPoint == d->maxDelay ) d->outPoint = 0;
292
293	return 0;
294	}
295
296	float tLinearDelay_tapOut (tLinearDelay* const dl, uint32_t tapDelay)
297	{
298	_tLinearDelay* d = *dl;
299
300	uint32_t tap = d->inPoint - tapDelay - 1;
301	// Check for wraparound.
302	while ( tap < 0 ) tap += d->maxDelay;
303
304	return d->buff[tap];
305	}
306
307	void tLinearDelay_tapIn (tLinearDelay* const dl, float value, uint32_t tapDelay)
308	{
309	_tLinearDelay* d = *dl;
310
311	uint32_t tap = d->inPoint - tapDelay - 1;
312
313	// Check for wraparound.
314	while ( tap < 0 ) tap += d->maxDelay;
315
316	d->buff[tap] = value;
317	}
318
319	float tLinearDelay_addTo (tLinearDelay* const dl, float value, uint32_t tapDelay)
320	{
321	_tLinearDelay* d = *dl;
322
323	int32_t tap = d->inPoint - tapDelay - 1;
324
325	// Check for wraparound.
326	while ( tap < 0 ) tap += d->maxDelay;
327
328	return (d->buff[tap] += value);
329	}
330
331	float tLinearDelay_getDelay (tLinearDelay* const dl)
332	{
333	_tLinearDelay* d = *dl;
334	return d->delay;
335	}
336
337	float tLinearDelay_getLastOut (tLinearDelay* const dl)
338	{
339	_tLinearDelay* d = *dl;
340	return d->lastOut;
341	}
342
343	float tLinearDelay_getLastIn (tLinearDelay* const dl)
344	{
345	_tLinearDelay* d = *dl;
346	return d->lastIn;
347	}
348
349	void tLinearDelay_setGain (tLinearDelay* const dl, float gain)
350	{
351	_tLinearDelay* d = *dl;
352	if (gain < 0.0f) d->gain = 0.0f;
353	else d->gain = gain;
354	}
355
356	float tLinearDelay_getGain (tLinearDelay* const dl)
357	{
358	_tLinearDelay* d = *dl;
359	return d->gain;
360	}
361
362
363
364
365
366	/// Hermite Interpolated Delay
367	// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ LinearDelay ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ //
368	void tHermiteDelay_init (tHermiteDelay* const dl, float delay, uint32_t maxDelay)
369	{
370	tHermiteDelay_initToPool(dl, delay, maxDelay, &leaf_mempool);
371	}
372
373	void tHermiteDelay_free(tHermiteDelay* const dl)
374	{
375	tHermiteDelay_freeFromPool(dl, &leaf_mempool);
376	}
377
378	void tHermiteDelay_initToPool (tHermiteDelay* const dl, float delay, uint32_t maxDelay, tMempool* const mp)
379	{
380	_tMempool* m = *mp;
381	_tHermiteDelay* d = dl = (_tHermiteDelay) mpool_alloc(sizeof(_tHermiteDelay), &m->pool);
382
383	d->maxDelay = maxDelay;
384
385	if (delay > maxDelay) d->delay = maxDelay;
386	else if (delay < 0.0f) d->delay = 0.0f;
387	else d->delay = delay;
388
389	d->buff = (float) mpool_alloc(sizeof(float) maxDelay, &m->pool);
390
391	d->gain = 1.0f;
392
393	d->lastIn = 0.0f;
394	d->lastOut = 0.0f;
395
396	d->inPoint = 0;
397	d->outPoint = 0;
398
399	tHermiteDelay_setDelay(dl, d->delay);
400	}
401
402	void tHermiteDelay_freeFromPool(tHermiteDelay* const dl, tMempool* const mp)
403	{
404	_tMempool* m = *mp;
405	_tHermiteDelay* d = *dl;
406
407	mpool_free(d->buff, &m->pool);
408	mpool_free(d, &m->pool);
409	}
410
411
412	void tHermiteDelay_clear(tHermiteDelay* const dl)
413	{
414	_tHermiteDelay* d = *dl;
415	for (int i = 0; i < d->maxDelay; i++)
416	{
417	d->buff[i] = 0;
418	}
419	}
420
421	float tHermiteDelay_tick (tHermiteDelay* const dl, float input)
422	{
423	_tHermiteDelay* d = *dl;
424
425	d->buff[d->inPoint] = input * d->gain;
426
427	// Increment input pointer modulo length.
428	if (++(d->inPoint) == d->maxDelay ) d->inPoint = 0;
429
430
431	uint32_t idx = (uint32_t) d->outPoint;
432	d->lastOut = LEAF_interpolate_hermite (d->buff[((idx - 1) + d->maxDelay) % d->maxDelay],
433	d->buff[idx],
434	d->buff[(idx + 1) % d->maxDelay],
435	d->buff[(idx + 2) % d->maxDelay],
436	d->alpha);
437
438	// Increment output pointer modulo length
439	if ( (++d->outPoint) >= d->maxDelay ) d->outPoint = 0;
440
441	return d->lastOut;
442	}
443
444	void tHermiteDelay_tickIn (tHermiteDelay* const dl, float input)
445	{
446	_tHermiteDelay* d = *dl;
447
448	d->buff[d->inPoint] = input * d->gain;
449
450	// Increment input pointer modulo length.
451	if (++(d->inPoint) == d->maxDelay ) d->inPoint = 0;
452	}
453
454	float tHermiteDelay_tickOut (tHermiteDelay* const dl)
455	{
456	_tHermiteDelay* d = *dl;
457
458	uint32_t idx = (uint32_t) d->outPoint;
459
460
461
462	d->lastOut = LEAF_interpolate_hermite (d->buff[((idx - 1) + d->maxDelay) % d->maxDelay],
463	d->buff[idx],
464	d->buff[(idx + 1) % d->maxDelay],
465	d->buff[(idx + 2) % d->maxDelay],
466	d->alpha);
467
468	// Increment output pointer modulo length
469	if ( (++d->outPoint) >= d->maxDelay ) d->outPoint = 0;
470
471	return d->lastOut;
472	}
473
474	int tHermiteDelay_setDelay (tHermiteDelay* const dl, float delay)
475	{
476	_tHermiteDelay* d = *dl;
477
478	d->delay = LEAF_clip(0.0f, delay, d->maxDelay);
479
480	float outPointer = d->inPoint - d->delay;
481
482	while ( outPointer < 0 )
483	outPointer += d->maxDelay; // modulo maximum length
484
485	d->outPoint = (uint32_t) outPointer; // integer part
486
487	d->alpha = outPointer - d->outPoint; // fractional part
488	d->omAlpha = 1.0f - d->alpha;
489
490	if ( d->outPoint == d->maxDelay ) d->outPoint = 0;
491
492	return 0;
493	}
494
495	float tHermiteDelay_tapOut (tHermiteDelay* const dl, uint32_t tapDelay)
496	{
497	_tHermiteDelay* d = *dl;
498
499	uint32_t tap = d->inPoint - tapDelay - 1;
500
501	// Check for wraparound.
502	while ( tap < 0 ) tap += d->maxDelay;
503
504	return d->buff[tap];
505
506	}
507
508	void tHermiteDelay_tapIn (tHermiteDelay* const dl, float value, uint32_t tapDelay)
509	{
510	_tHermiteDelay* d = *dl;
511
512	int32_t tap = d->inPoint - tapDelay - 1;
513
514	// Check for wraparound.
515	while ( tap < 0 ) tap += d->maxDelay;
516
517	d->buff[tap] = value;
518	}
519
520	float tHermiteDelay_addTo (tHermiteDelay* const dl, float value, uint32_t tapDelay)
521	{
522	_tHermiteDelay* d = *dl;
523
524	int32_t tap = d->inPoint - tapDelay - 1;
525
526	// Check for wraparound.
527	while ( tap < 0 ) tap += d->maxDelay;
528
529	return (d->buff[tap] += value);
530	}
531
532	float tHermiteDelay_getDelay (tHermiteDelay* const dl)
533	{
534	_tHermiteDelay* d = *dl;
535	return d->delay;
536	}
537
538	float tHermiteDelay_getLastOut (tHermiteDelay* const dl)
539	{
540	_tHermiteDelay* d = *dl;
541	return d->lastOut;
542	}
543
544	float tHermiteDelay_getLastIn (tHermiteDelay* const dl)
545	{
546	_tHermiteDelay* d = *dl;
547	return d->lastIn;
548	}
549
550	void tHermiteDelay_setGain (tHermiteDelay* const dl, float gain)
551	{
552	_tHermiteDelay* d = *dl;
553	if (gain < 0.0f) d->gain = 0.0f;
554	else d->gain = gain;
555	}
556
557	float tHermiteDelay_getGain (tHermiteDelay* const dl)
558	{
559	_tHermiteDelay* d = *dl;
560	return d->gain;
561	}
562
563
564
565
566
567	// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ AllpassDelay ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ //
568	void tAllpassDelay_init (tAllpassDelay* const dl, float delay, uint32_t maxDelay)
569	{
570	tAllpassDelay_initToPool(dl, delay, maxDelay, &leaf_mempool);
571	}
572
573	void tAllpassDelay_free(tAllpassDelay* const dl)
574	{
575	tAllpassDelay_freeFromPool(dl, &leaf_mempool);
576	}
577
578	void tAllpassDelay_initToPool (tAllpassDelay* const dl, float delay, uint32_t maxDelay, tMempool* const mp)
579	{
580	_tMempool* m = *mp;
581	_tAllpassDelay* d = dl = (_tAllpassDelay) mpool_alloc(sizeof(_tAllpassDelay), &m->pool);
582
583	d->maxDelay = maxDelay;
584
585	if (delay > maxDelay) d->delay = maxDelay;
586	else if (delay < 0.0f) d->delay = 0.0f;
587	else d->delay = delay;
588
589	d->buff = (float) mpool_alloc(sizeof(float) maxDelay, &m->pool);
590
591	d->gain = 1.0f;
592
593	d->lastIn = 0.0f;
594	d->lastOut = 0.0f;
595
596	d->inPoint = 0;
597	d->outPoint = 0;
598
599	tAllpassDelay_setDelay(dl, d->delay);
600
601	d->apInput = 0.0f;
602	}
603
604	void tAllpassDelay_freeFromPool(tAllpassDelay* const dl, tMempool* const mp)
605	{
606	_tMempool* m = *mp;
607	_tAllpassDelay* d = *dl;
608
609	mpool_free(d->buff, &m->pool);
610	mpool_free(d, &m->pool);
611	}
612
613	void tAllpassDelay_clear(tAllpassDelay* const dl)
614	{
615	_tAllpassDelay* d = *dl;
616	for (int i = 0; i < d->maxDelay; i++)
617	{
618	d->buff[i] = 0;
619	}
620	}
621
622	float tAllpassDelay_tick (tAllpassDelay* const dl, float input)
623	{
624	_tAllpassDelay* d = *dl;
625
626	d->buff[d->inPoint] = input * d->gain;
627
628	// Increment input pointer modulo length.
629	if ( ++(d->inPoint) >= d->maxDelay ) d->inPoint = 0;
630
631	// Do allpass interpolation delay.
632	float out = d->lastOut * -d->coeff;
633	out += d->apInput + ( d->coeff * d->buff[d->outPoint] );
634	d->lastOut = out;
635
636	// Save allpass input
637	d->apInput = d->buff[d->outPoint];
638
639	// Increment output pointer modulo length.
640	if (++(d->outPoint) >= d->maxDelay ) d->outPoint = 0;
641
642	return d->lastOut;
643	}
644
645	int tAllpassDelay_setDelay (tAllpassDelay* const dl, float delay)
646	{
647	_tAllpassDelay* d = *dl;
648
649	d->delay = LEAF_clip(0.5f, delay, d->maxDelay);
650
651	// outPoint chases inPoint
652	float outPointer = (float)d->inPoint - d->delay + 1.0f;
653
654	while ( outPointer < 0 ) outPointer += d->maxDelay; // mod max length
655
656	d->outPoint = (uint32_t) outPointer; // integer part
657
658	if ( d->outPoint >= d->maxDelay ) d->outPoint = 0;
659
660	d->alpha = 1.0f + (float)d->outPoint - outPointer; // fractional part
661
662	if ( d->alpha < 0.5f )
663	{
664	// The optimal range for alpha is about 0.5 - 1.5 in order to
665	// achieve the flattest phase delay response.
666
667	d->outPoint += 1;
668
669	if ( d->outPoint >= d->maxDelay ) d->outPoint -= d->maxDelay;
670
671	d->alpha += 1.0f;
672	}
673
674	d->coeff = (1.0f - d->alpha) / (1.0f + d->alpha); // coefficient for allpass
675
676	return 0;
677	}
678
679	float tAllpassDelay_tapOut (tAllpassDelay* const dl, uint32_t tapDelay)
680	{
681	_tAllpassDelay* d = *dl;
682
683	int32_t tap = d->inPoint - tapDelay - 1;
684
685	// Check for wraparound.
686	while ( tap < 0 ) tap += d->maxDelay;
687
688	return d->buff[tap];
689
690	}
691
692	void tAllpassDelay_tapIn (tAllpassDelay* const dl, float value, uint32_t tapDelay)
693	{
694	_tAllpassDelay* d = *dl;
695
696	int32_t tap = d->inPoint - tapDelay - 1;
697
698	// Check for wraparound.
699	while ( tap < 0 ) tap += d->maxDelay;
700
701	d->buff[tap] = value;
702	}
703
704	float tAllpassDelay_addTo (tAllpassDelay* const dl, float value, uint32_t tapDelay)
705	{
706	_tAllpassDelay* d = *dl;
707
708	int32_t tap = d->inPoint - tapDelay - 1;
709
710	// Check for wraparound.
711	while ( tap < 0 ) tap += d->maxDelay;
712
713	return (d->buff[tap] += value);
714	}
715
716	float tAllpassDelay_getDelay (tAllpassDelay* const dl)
717	{
718	_tAllpassDelay* d = *dl;
719	return d->delay;
720	}
721
722	float tAllpassDelay_getLastOut (tAllpassDelay* const dl)
723	{
724	_tAllpassDelay* d = *dl;
725	return d->lastOut;
726	}
727
728	float tAllpassDelay_getLastIn (tAllpassDelay* const dl)
729	{
730	_tAllpassDelay* d = *dl;
731	return d->lastIn;
732	}
733
734	void tAllpassDelay_setGain (tAllpassDelay* const dl, float gain)
735	{
736	_tAllpassDelay* d = *dl;
737	if (gain < 0.0f) d->gain = 0.0f;
738	else d->gain = gain;
739	}
740
741	float tAllpassDelay_getGain (tAllpassDelay* const dl)
742	{
743	_tAllpassDelay* d = *dl;
744	return d->gain;
745	}
746
747	// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ TapeDelay ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ //
748	void tTapeDelay_init (tTapeDelay* const dl, float delay, uint32_t maxDelay)
749	{
750	tTapeDelay_initToPool(dl, delay, maxDelay, &leaf_mempool);
751	}
752
753	void tTapeDelay_free(tTapeDelay* const dl)
754	{
755	tTapeDelay_freeFromPool(dl, &leaf_mempool);
756	}
757
758	void tTapeDelay_initToPool (tTapeDelay* const dl, float delay, uint32_t maxDelay, tMempool* const mp)
759	{
760	_tMempool* m = *mp;
761	_tTapeDelay* d = dl = (_tTapeDelay) mpool_alloc(sizeof(_tTapeDelay), &m->pool);
762
763	d->maxDelay = maxDelay;
764
765	d->buff = (float) mpool_alloc(sizeof(float) maxDelay, &m->pool);
766
767	d->gain = 1.0f;
768
769	d->lastIn = 0.0f;
770	d->lastOut = 0.0f;
771
772	d->idx = 0.0f;
773	d->inc = 1.0f;
774	d->inPoint = 0;
775
776	tTapeDelay_setDelay(dl, delay);
777	}
778
779	void tTapeDelay_freeFromPool(tTapeDelay* const dl, tMempool* const mp)
780	{
781	_tMempool* m = *mp;
782	_tTapeDelay* d = *dl;
783
784	mpool_free(d->buff, &m->pool);
785	mpool_free(d, &m->pool);
786	}
787
788	void tTapeDelay_clear(tTapeDelay* const dl)
789	{
790	_tTapeDelay* d = *dl;
791	for (int i = 0; i < d->maxDelay; i++)
792	{
793	d->buff[i] = 0;
794	}
795	}
796
797	//#define SMOOTH_FACTOR 10.f
798
799	float tTapeDelay_tick (tTapeDelay* const dl, float input)
800	{
801	_tTapeDelay* d = *dl;
802
803	d->buff[d->inPoint] = input * d->gain;
804
805	// Increment input pointer modulo length.
806	if (++(d->inPoint) == d->maxDelay ) d->inPoint = 0;
807
808	int idx = (int) d->idx;
809	float alpha = d->idx - idx;
810
811	d->lastOut = LEAF_interpolate_hermite_x (d->buff[((idx - 1) + d->maxDelay) % d->maxDelay],
812	d->buff[idx],
813	d->buff[(idx + 1) % d->maxDelay],
814	d->buff[(idx + 2) % d->maxDelay],
815	alpha);
816
817	float diff = (d->inPoint - d->idx);
818	while (diff < 0.f) diff += d->maxDelay;
819
820	d->inc = 1.0f + (diff - d->delay) / d->delay; //* SMOOTH_FACTOR;
821
822	d->idx += d->inc;
823
824	if (d->idx >= d->maxDelay) d->idx = 0.0f;
825
826	if (d->lastOut)
827	return d->lastOut;
828	return 0.0f;
829	}
830
831	void tTapeDelay_incrementInPoint(tTapeDelay* const dl)
832	{
833	_tTapeDelay* d = *dl;
834	// Increment input pointer modulo length.
835	if (++(d->inPoint) == d->maxDelay ) d->inPoint = 0;
836	}
837
838
839	void tTapeDelay_setRate(tTapeDelay* const dl, float rate)
840	{
841	_tTapeDelay* d = *dl;
842	d->inc = rate;
843	}
844
845	void tTapeDelay_setDelay (tTapeDelay* const dl, float delay)
846	{
847	_tTapeDelay* d = *dl;
848	d->delay = LEAF_clip(1.f, delay, d->maxDelay);
849	}
850
851	float tTapeDelay_tapOut (tTapeDelay* const dl, float tapDelay)
852	{
853	_tTapeDelay* d = *dl;
854
855	float tap = (float) d->inPoint - tapDelay - 1.f;
856
857	// Check for wraparound.
858	while ( tap < 0.f ) tap += (float)d->maxDelay;
859
860	int idx = (int) tap;
861
862	float alpha = tap - idx;
863
864	float samp = LEAF_interpolate_hermite_x (d->buff[((idx - 1) + d->maxDelay) % d->maxDelay],
865	d->buff[idx],
866	d->buff[(idx + 1) % d->maxDelay],
867	d->buff[(idx + 2) % d->maxDelay],
868	alpha);
869
870	return samp;
871
872	}
873
874	void tTapeDelay_tapIn (tTapeDelay* const dl, float value, uint32_t tapDelay)
875	{
876	_tTapeDelay* d = *dl;
877
878	int32_t tap = d->inPoint - tapDelay - 1;
879
880	// Check for wraparound.
881	while ( tap < 0 ) tap += d->maxDelay;
882
883	d->buff[tap] = value;
884	}
885
886	float tTapeDelay_addTo (tTapeDelay* const dl, float value, uint32_t tapDelay)
887	{
888	_tTapeDelay* d = *dl;
889
890	int32_t tap = d->inPoint - tapDelay - 1;
891
892	// Check for wraparound.
893	while ( tap < 0 ) tap += d->maxDelay;
894
895	return (d->buff[tap] += value);
896	}
897
898	float tTapeDelay_getDelay (tTapeDelay *dl)
899	{
900	_tTapeDelay* d = *dl;
901	return d->delay;
902	}
903
904	float tTapeDelay_getLastOut (tTapeDelay* const dl)
905	{
906	_tTapeDelay* d = *dl;
907	return d->lastOut;
908	}
909
910	float tTapeDelay_getLastIn (tTapeDelay* const dl)
911	{
912	_tTapeDelay* d = *dl;
913	return d->lastIn;
914	}
915
916	void tTapeDelay_setGain (tTapeDelay* const dl, float gain)
917	{
918	_tTapeDelay* d = *dl;
919	if (gain < 0.0f) d->gain = 0.0f;
920	else d->gain = gain;
921	}
922
923	float tTapeDelay_getGain (tTapeDelay* const dl)
924	{
925	_tTapeDelay* d = *dl;
926	return d->gain;
927	}
928

LEAF/Src/leaf-distortion.c+0−587

@@ -1,587 +0,0 @@
1	//
2	// leaf-distortion.c
3	// LEAF
4	//
5	// Created by Jeff Snyder, Matthew Wang, Michael Mulshine, and Joshua Becker
6	// Copyright © 2019 Princeton University. All rights reserved.
7	//
8
9	#if _WIN32 \|\| _WIN64
10
11	#include "..\Inc\leaf-distortion.h"
12	#include "..\Inc\leaf-tables.h"
13	#else
14
15
16	#include "../Inc/leaf-distortion.h"
17	#include "../Inc/leaf-tables.h"
18
19	//testing
20	//#include "gpio.h"
21
22	#endif
23
24	//============================================================================================================
25	// Sample-Rate reducer
26	//============================================================================================================
27
28
29	void tSampleReducer_init(tSampleReducer* const sr)
30	{
31	_tSampleReducer* s = sr = (_tSampleReducer) leaf_alloc(sizeof(_tSampleReducer));
32
33	s->invRatio = 1.0f;
34	s->hold = 0.0f;
35	s->count = 0;
36	}
37
38	void tSampleReducer_free (tSampleReducer* const sr)
39	{
40	_tSampleReducer* s = *sr;
41
42	leaf_free(s);
43	}
44
45	void tSampleReducer_initToPool (tSampleReducer* const sr, tMempool* const mp)
46	{
47	_tMempool* m = *mp;
48	_tSampleReducer* s = sr = (_tSampleReducer) mpool_alloc(sizeof(_tSampleReducer), &m->pool);
49
50	s->invRatio = 1.0f;
51	s->hold = 0.0f;
52	s->count = 0;
53	}
54
55	void tSampleReducer_freeFromPool (tSampleReducer* const sr, tMempool* const mp)
56	{
57	_tMempool* m = *mp;
58	_tSampleReducer* s = *sr;
59
60	mpool_free(s, &m->pool);
61	}
62
63	float tSampleReducer_tick(tSampleReducer* const sr, float input)
64	{
65	_tSampleReducer* s = *sr;
66	if (s->count > s->invRatio)
67	{
68	s->hold = input;
69	s->count = 0;
70	}
71
72	s->count++;
73	return s->hold;
74	}
75
76
77	void tSampleReducer_setRatio(tSampleReducer* const sr, float ratio)
78	{
79	_tSampleReducer* s = *sr;
80	if ((ratio <= 1.0f) && (ratio >= 0.0f))
81	s->invRatio = 1.0f / ratio;
82
83	}
84
85	//============================================================================================================
86	// Oversampler
87	//============================================================================================================
88	// Latency is equal to the phase length (numTaps / ratio)
89	void tOversampler_init(tOversampler* const osr, int ratio, oBool extraQuality)
90	{
91	_tOversampler* os = osr = (_tOversampler) leaf_alloc(sizeof(_tOversampler));
92
93	uint8_t offset = 0;
94	if (extraQuality) offset = 6;
95	if (ratio == 2 \|\| ratio == 4 \|\|
96	ratio == 8 \|\| ratio == 16 \|\|
97	ratio == 32 \|\| ratio == 64) {
98	os->ratio = ratio;
99	int idx = (int)(log2f(os->ratio))-1+offset;
100	os->numTaps = firNumTaps[idx];
101	os->phaseLength = os->numTaps / os->ratio;
102	os->pCoeffs = (float*) firCoeffs[idx];
103	os->upState = leaf_alloc(sizeof(float) * os->numTaps * 2);
104	os->downState = leaf_alloc(sizeof(float) * os->numTaps * 2);
105	}
106	}
107
108	void tOversampler_free(tOversampler* const osr)
109	{
110	_tOversampler* os = *osr;
111
112	leaf_free(os->upState);
113	leaf_free(os->downState);
114	leaf_free(os);
115	}
116
117	void tOversampler_initToPool (tOversampler* const osr, int ratio, oBool extraQuality, tMempool* const mp)
118	{
119	_tMempool* m = *mp;
120	_tOversampler* os = osr = (_tOversampler) mpool_alloc(sizeof(_tOversampler), &m->pool);
121
122	uint8_t offset = 0;
123	if (extraQuality) offset = 6;
124	if (ratio == 2 \|\| ratio == 4 \|\|
125	ratio == 8 \|\| ratio == 16 \|\|
126	ratio == 32 \|\| ratio == 64) {
127	os->ratio = ratio;
128	int idx = (int)(log2f(os->ratio))-1+offset;
129	os->numTaps = firNumTaps[idx];
130	os->phaseLength = os->numTaps / os->ratio;
131	os->pCoeffs = (float*) firCoeffs[idx];
132	os->upState = mpool_alloc(sizeof(float) * os->numTaps * 2, &m->pool);
133	os->downState = mpool_alloc(sizeof(float) * os->numTaps * 2, &m->pool);
134	}
135	}
136
137	void tOversampler_freeFromPool (tOversampler* const osr, tMempool* const mp)
138	{
139	_tMempool* m = *mp;
140	_tOversampler* os = *osr;
141
142	mpool_free(os->upState, &m->pool);
143	mpool_free(os->downState, &m->pool);
144	mpool_free(os, &m->pool);
145	}
146
147	float tOversampler_tick(tOversampler* const osr, float input, float (*effectTick)(float))
148	{
149	_tOversampler* os = *osr;
150
151	float buf[os->ratio];
152
153	tOversampler_upsample(osr, input, buf);
154
155	for (int i = 0; i < os->ratio; ++i) {
156	buf[i] = effectTick(buf[i]);
157	}
158
159	return tOversampler_downsample(osr, buf);
160	}
161
162	// From CMSIS DSP Library
163	void tOversampler_upsample(tOversampler* const osr, float input, float* output)
164	{
165	_tOversampler* os = *osr;
166
167	float pState = os->upState; / State pointer */
168	float pCoeffs = os->pCoeffs; / Coefficient pointer */
169	float *pStateCur;
170	float ptr1; / Temporary pointer for state buffer */
171	float ptr2; / Temporary pointer for coefficient buffer */
172	float sum0; /* Accumulators */
173	uint32_t i, tapCnt; /* Loop counters */
174	uint32_t phaseLen = os->phaseLength; /* Length of each polyphase filter component */
175	uint32_t j;
176
177	/* os->pState buffer contains previous frame (phaseLen - 1) samples */
178	/* pStateCur points to the location where the new input data should be written */
179	pStateCur = os->upState + (phaseLen - 1U);
180
181	/* Copy new input sample into the state buffer */
182	*pStateCur = input;
183
184	/* Address modifier index of coefficient buffer */
185	j = 1U;
186
187	/* Loop over the Interpolation factor. */
188	i = os->ratio;
189
190	while (i > 0U)
191	{
192	/* Set accumulator to zero */
193	sum0 = 0.0f;
194
195	/* Initialize state pointer */
196	ptr1 = pState;
197
198	/* Initialize coefficient pointer */
199	ptr2 = pCoeffs + (os->ratio - j);
200
201	/* Loop over the polyPhase length.
202	Repeat until we've computed numTaps-(4os->L) coefficients. /
203
204	/* Initialize tapCnt with number of samples */
205	tapCnt = phaseLen;
206
207	while (tapCnt > 0U)
208	{
209	/* Perform the multiply-accumulate */
210	sum0 += ptr1++ *ptr2;
211
212	/* Upsampling is done by stuffing L-1 zeros between each sample.
213	* So instead of multiplying zeros with coefficients,
214	* Increment the coefficient pointer by interpolation factor times. */
215	ptr2 += os->ratio;
216
217	/* Decrement loop counter */
218	tapCnt--;
219	}
220
221	/* The result is in the accumulator, store in the destination buffer. */
222	output++ = sum0 os->ratio;
223
224	/* Increment the address modifier index of coefficient buffer */
225	j++;
226
227	/* Decrement the loop counter */
228	i--;
229	}
230
231	/* Advance the state pointer by 1
232	* to process the next group of interpolation factor number samples */
233	pState = pState + 1;
234
235	/* Processing is complete.
236	Now copy the last phaseLen - 1 samples to the satrt of the state buffer.
237	This prepares the state buffer for the next function call. */
238
239	/* Points to the start of the state buffer */
240	pStateCur = os->upState;
241
242	/* Initialize tapCnt with number of samples */
243	tapCnt = (phaseLen - 1U);
244
245	/* Copy data */
246	while (tapCnt > 0U)
247	{
248	pStateCur++ = pState++;
249
250	/* Decrement loop counter */
251	tapCnt--;
252	}
253	}
254
255	// From CMSIS DSP Library
256	float tOversampler_downsample(tOversampler const osr, float input)
257	{
258	_tOversampler* os = *osr;
259
260	float pState = os->downState; / State pointer */
261	float pCoeffs = os->pCoeffs; / Coefficient pointer */
262	float pStateCur; / Points to the current sample of the state */
263	float px0; / Temporary pointer for state buffer */
264	float pb; / Temporary pointer for coefficient buffer */
265	float x0, c0; /* Temporary variables to hold state and coefficient values */
266	float acc0; /* Accumulator */
267	uint32_t numTaps = os->numTaps; /* Number of filter coefficients in the filter */
268	uint32_t i, tapCnt;
269	float output;
270
271	/* os->pState buffer contains previous frame (numTaps - 1) samples */
272	/* pStateCur points to the location where the new input data should be written */
273	pStateCur = os->downState + (numTaps - 1U);
274
275	/* Copy decimation factor number of new input samples into the state buffer */
276	i = os->ratio;
277
278	do
279	{
280	pStateCur++ = input++;
281
282	} while (--i);
283
284	/* Set accumulator to zero */
285	acc0 = 0.0f;
286
287	/* Initialize state pointer */
288	px0 = pState;
289
290	/* Initialize coeff pointer */
291	pb = pCoeffs;
292
293	/* Initialize tapCnt with number of taps */
294	tapCnt = numTaps;
295
296	while (tapCnt > 0U)
297	{
298	/* Read coefficients */
299	c0 = *pb++;
300
301	/* Fetch 1 state variable */
302	x0 = *px0++;
303
304	/* Perform the multiply-accumulate */
305	acc0 += x0 * c0;
306
307	/* Decrement loop counter */
308	tapCnt--;
309	}
310
311	/* Advance the state pointer by the decimation factor
312	* to process the next group of decimation factor number samples */
313	pState = pState + os->ratio;
314
315	/* The result is in the accumulator, store in the destination buffer. */
316	output = acc0;
317
318	/* Processing is complete.
319	Now copy the last numTaps - 1 samples to the start of the state buffer.
320	This prepares the state buffer for the next function call. */
321
322	/* Points to the start of the state buffer */
323	pStateCur = os->downState;
324
325	/* Initialize tapCnt with number of taps */
326	tapCnt = (numTaps - 1U);
327
328	/* Copy data */
329	while (tapCnt > 0U)
330	{
331	pStateCur++ = pState++;
332
333	/* Decrement loop counter */
334	tapCnt--;
335	}
336
337	return output;
338	}
339
340	int tOversampler_getLatency(tOversampler* const osr)
341	{
342	_tOversampler* os = *osr;
343	return os->phaseLength;
344	}
345
346	//============================================================================================================
347	// WAVEFOLDER
348	//============================================================================================================
349
350
351	//from the paper: Virtual Analog Model of the Lockhart Wavefolder
352	//by Fabián Esqueda, Henri Pöntynen, Julian D. Parker and Stefan Bilbao
353
354	void tLockhartWavefolder_init(tLockhartWavefolder* const wf)
355	{
356	_tLockhartWavefolder* w = wf = (_tLockhartWavefolder) leaf_alloc(sizeof(_tLockhartWavefolder));
357
358	w->Ln1 = 0.0;
359	w->Fn1 = 0.0;
360	w->xn1 = 0.0f;
361
362	w->RL = 7.5e3;
363	w->R = 15e3;
364	w->VT = 26e-3;
365	w->Is = 10e-16;
366
367	w->a = 2.0*w->RL/w->R;
368	w->b = (w->R+2.0w->RL)/(w->VTw->R);
369	w->d = (w->RL*w->Is)/w->VT;
370	w->half_a = 0.5 * w->a;
371	w->longthing = (0.5*w->VT/w->b);
372
373
374	// Antialiasing error threshold
375	w->thresh = 10e-10;
376	}
377
378	void tLockhartWavefolder_free(tLockhartWavefolder* const wf)
379	{
380	_tLockhartWavefolder* w = *wf;
381
382	leaf_free(w);
383	}
384
385	void tLockhartWavefolder_initToPool (tLockhartWavefolder* const wf, tMempool* const mp)
386	{
387	_tMempool* m = *mp;
388	_tLockhartWavefolder* w = wf = (_tLockhartWavefolder) mpool_alloc(sizeof(_tLockhartWavefolder), &m->pool);
389
390	w->Ln1 = 0.0;
391	w->Fn1 = 0.0;
392	w->xn1 = 0.0f;
393
394	w->RL = 7.5e3;
395	w->R = 15e3;
396	w->VT = 26e-3;
397	w->Is = 10e-16;
398
399	w->a = 2.0*w->RL/w->R;
400	w->b = (w->R+2.0w->RL)/(w->VTw->R);
401	w->d = (w->RL*w->Is)/w->VT;
402	w->half_a = 0.5 * w->a;
403	w->longthing = (0.5*w->VT/w->b);
404
405
406	// Antialiasing error threshold
407	w->thresh = 10e-10;
408	}
409
410	void tLockhartWavefolder_freeFromPool (tLockhartWavefolder* const wf, tMempool* const mp)
411	{
412	_tMempool* m = *mp;
413	_tLockhartWavefolder* w = *wf;
414
415	mpool_free(w, &m->pool);
416	}
417
418	double tLockhartWavefolderLambert(double x, double ln)
419	{
420	double thresh, w, expw, p, r, s, err;
421	// Error threshold
422	thresh = 10e-12;
423	// Initial guess (use previous value)
424	w = ln;
425
426	// Haley's method (Sec. 4.2 of the paper)
427	for(int i=0; i<1000; i+=1) {
428
429	expw = exp(w);
430
431	p = w*expw - x;
432	r = (w+1.0)*expw;
433	s = (w+2.0)/(2.0*(w+1.0));
434	err = (p/(r-(p*s)));
435
436	if (fabs(err)<thresh) {
437
438	break;
439	}
440
441	w = w - err;
442	if (i == 999)
443	{
444	//HAL_GPIO_WritePin(GPIOG, GPIO_PIN_7, GPIO_PIN_SET);
445	}
446
447	}
448	return w;
449	}
450
451	float tLockhartWavefolder_tick(tLockhartWavefolder* const wf, float samp)
452	{
453	_tLockhartWavefolder* w = *wf;
454
455	float out = 0.0f;
456
457	// Compute Antiderivative
458	int l = (samp > 0.0f) - (samp < 0.0f);
459	double u = w->dexp(lw->b*samp);
460	double Ln = tLockhartWavefolderLambert(u,w->Ln1);
461	double Fn = w->longthing(Ln(Ln + 2.0)) - w->half_asampsamp;
462
463	// Check for ill-conditioning
464	if (fabs(samp-w->xn1)<w->thresh) {
465
466	// Compute Averaged Wavefolder Output
467	float xn = 0.5f*(samp+w->xn1);
468	u = w->dexp(lw->b*xn);
469	Ln = tLockhartWavefolderLambert(u,w->Ln1);
470	out = (float) (lw->VTLn - w->a*xn);
471
472	}
473	else {
474
475	// Apply AA Form
476	out = (float) ((Fn-w->Fn1)/(samp-w->xn1));
477	}
478
479	// Update States
480	w->Ln1 = Ln;
481	w->Fn1 = Fn;
482	w->xn1 = samp;
483
484	return out;
485	}
486
487	//============================================================================================================
488	// CRUSHER
489	//============================================================================================================
490	#define SCALAR 5000.f
491
492	void tCrusher_init (tCrusher* const cr)
493	{
494	_tCrusher* c = cr = (_tCrusher) leaf_alloc(sizeof(_tCrusher));
495
496	c->op = 4;
497	c->div = SCALAR;
498	c->rnd = 0.25f;
499	c->srr = 0.25f;
500	tSampleReducer_init(&c->sReducer);
501	c->gain = (c->div / SCALAR) * 0.7f + 0.3f;
502	}
503
504	void tCrusher_free (tCrusher* const cr)
505	{
506	_tCrusher* c = *cr;
507	tSampleReducer_free(&c->sReducer);
508	leaf_free(c);
509	}
510
511	void tCrusher_initToPool (tCrusher* const cr, tMempool* const mp)
512	{
513	_tMempool* m = *mp;
514	_tCrusher* c = cr = (_tCrusher) mpool_alloc(sizeof(_tCrusher), &m->pool);
515
516	c->op = 4;
517	c->div = SCALAR;
518	c->rnd = 0.25f;
519	c->srr = 0.25f;
520	tSampleReducer_initToPool(&c->sReducer, mp);
521	c->gain = (c->div / SCALAR) * 0.7f + 0.3f;
522	}
523
524	void tCrusher_freeFromPool (tCrusher* const cr, tMempool* const mp)
525	{
526	_tMempool* m = *mp;
527	_tCrusher* c = *cr;
528	tSampleReducer_freeFromPool(&c->sReducer, mp);
529	mpool_free(c, &m->pool);
530	}
531
532	float tCrusher_tick (tCrusher* const cr, float input)
533	{
534	_tCrusher* c = *cr;
535
536	float sample = input;
537
538	sample *= SCALAR; // SCALAR is 5000 by default
539
540	sample = (int32_t) sample;
541
542	sample /= c->div;
543
544	sample = LEAF_bitwise_xor(sample, c->op << 23);
545
546	sample = LEAF_clip(-1.f, sample, 1.f);
547
548	sample = LEAF_round(sample, c->rnd);
549
550	sample = tSampleReducer_tick(&c->sReducer, sample);
551
552	return sample * c->gain;
553
554	}
555
556	void tCrusher_setOperation (tCrusher* const cr, float op)
557	{
558	_tCrusher* c = *cr;
559	c->op = (uint32_t) (op * 8.0f);
560	}
561
562	// 0.0 - 1.0
563	void tCrusher_setQuality (tCrusher* const cr, float val)
564	{
565	_tCrusher* c = *cr;
566
567	val = LEAF_clip(0.0f, val, 1.0f);
568
569	c->div = 0.01f + val * SCALAR;
570
571	c->gain = (c->div / SCALAR) * 0.7f + 0.3f;
572	}
573
574	// what decimal to round to
575	void tCrusher_setRound (tCrusher* const cr, float rnd)
576	{
577	_tCrusher* c = *cr;
578	c->rnd = fabsf(rnd);
579	}
580
581	void tCrusher_setSamplingRatio (tCrusher* const cr, float ratio)
582	{
583	_tCrusher* c = *cr;
584	c->srr = ratio;
585	tSampleReducer_setRatio(&c->sReducer, ratio);
586
587	}

LEAF/Src/leaf-dynamics.c+0−221

@@ -1,221 +0,0 @@
1	/*==============================================================================
2
3	leaf-dynamics.c
4	Created: 30 Nov 2018 11:56:49am
5	Author: airship
6
7	==============================================================================*/
8
9	#if _WIN32 \|\| _WIN64
10
11	#include "..\Inc\leaf-dynamics.h"
12
13	#else
14
15	#include "../Inc/leaf-dynamics.h"
16
17	#endif
18
19	//==============================================================================
20
21	// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ Compressor ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ //
22
23	/*
24	tCompressor* tCompressorInit(int tauAttack, int tauRelease)
25	{
26	tCompressor* c = &leaf.tCompressorRegistry[leaf.registryIndex[T_COMPRESSOR]++];
27
28	c->tauAttack = tauAttack;
29	c->tauRelease = tauRelease;
30
31	c->x_G[0] = 0.0f, c->x_G[1] = 0.0f,
32	c->y_G[0] = 0.0f, c->y_G[1] = 0.0f,
33	c->x_T[0] = 0.0f, c->x_T[1] = 0.0f,
34	c->y_T[0] = 0.0f, c->y_T[1] = 0.0f;
35
36	c->T = 0.0f; // Threshold
37	c->R = 1.0f; // compression Ratio
38	c->M = 0.0f; // decibel Make-up gain
39	c->W = 0.0f; // decibel Width of knee transition
40
41	return c;
42	}
43	*/
44	void tCompressor_init(tCompressor* const comp)
45	{
46	_tCompressor* c = comp = (_tCompressor) leaf_alloc(sizeof(_tCompressor));
47
48	c->tauAttack = 100;
49	c->tauRelease = 100;
50
51	c->isActive = OFALSE;
52
53	c->T = 0.0f; // Threshold
54	c->R = 0.5f; // compression Ratio
55	c->M = 3.0f; // decibel Width of knee transition
56	c->W = 1.0f; // decibel Make-up gain
57	}
58
59	void tCompressor_free(tCompressor* const comp)
60	{
61	_tCompressor* c = *comp;
62
63	leaf_free(c);
64	}
65
66	void tCompressor_initToPool (tCompressor* const comp, tMempool* const mp)
67	{
68	_tMempool* m = *mp;
69	_tCompressor* c = comp = (_tCompressor) mpool_alloc(sizeof(_tCompressor), &m->pool);
70
71	c->tauAttack = 100;
72	c->tauRelease = 100;
73
74	c->isActive = OFALSE;
75
76	c->T = 0.0f; // Threshold
77	c->R = 0.5f; // compression Ratio
78	c->M = 3.0f; // decibel Width of knee transition
79	c->W = 1.0f; // decibel Make-up gain
80	}
81
82	void tCompressor_freeFromPool(tCompressor* const comp, tMempool* const mp)
83	{
84	_tMempool* m = *mp;
85	_tCompressor* c = *comp;
86
87	mpool_free(c, &m->pool);
88	}
89
90	float tCompressor_tick(tCompressor* const comp, float in)
91	{
92	_tCompressor* c = *comp;
93
94	float slope, overshoot;
95	float alphaAtt, alphaRel;
96
97	float in_db = 20.0f * log10f( fmaxf( fabsf( in), 0.000001f)), out_db = 0.0f;
98
99	c->y_T[1] = c->y_T[0];
100
101	slope = c->R - 1.0f; // feed-forward topology; was 1/C->R - 1
102
103	overshoot = in_db - c->T;
104
105
106	if (overshoot <= -(c->W * 0.5f))
107	{
108	out_db = in_db;
109	c->isActive = OFALSE;
110	}
111	else if ((overshoot > -(c->W * 0.5f)) && (overshoot < (c->W * 0.5f)))
112	{
113	out_db = in_db + slope * (powf((overshoot + c->W0.5f),2) / (2.0f c->W)); // .^ 2 ???
114	c->isActive = OTRUE;
115	}
116	else if (overshoot >= (c->W * 0.5f))
117	{
118	out_db = in_db + slope * overshoot;
119	c->isActive = OTRUE;
120	}
121
122
123
124	c->x_T[0] = out_db - in_db;
125
126	alphaAtt = expf(-1.0f/(0.001f * c->tauAttack * leaf.sampleRate));
127	alphaRel = expf(-1.0f/(0.001f * c->tauRelease * leaf.sampleRate));
128
129	if (c->x_T[0] > c->y_T[1])
130	c->y_T[0] = alphaAtt * c->y_T[1] + (1-alphaAtt) * c->x_T[0];
131	else
132	c->y_T[0] = alphaRel * c->y_T[1] + (1-alphaRel) * c->x_T[0];
133
134	float attenuation = powf(10.0f, ((c->M - c->y_T[0])/20.0f));
135
136	return attenuation * in;
137	}
138
139	/* Feedback Leveler */
140
141	void tFeedbackLeveler_init(tFeedbackLeveler* const fb, float targetLevel, float factor, float strength, int mode)
142	{
143	_tFeedbackLeveler* p = fb = (_tFeedbackLeveler) leaf_alloc(sizeof(_tFeedbackLeveler));
144
145	p->curr=0.0f;
146	p->targetLevel=targetLevel;
147	tPowerFollower_init(&p->pwrFlw,factor);
148	p->mode=mode;
149	p->strength=strength;
150	}
151
152	void tFeedbackLeveler_free(tFeedbackLeveler* const fb)
153	{
154	_tFeedbackLeveler* p = *fb;
155
156	tPowerFollower_free(&p->pwrFlw);
157	leaf_free(p);
158	}
159
160	void tFeedbackLeveler_initToPool (tFeedbackLeveler* const fb, float targetLevel, float factor, float strength, int mode, tMempool* const mp)
161	{
162	_tMempool* m = *mp;
163	_tFeedbackLeveler* p = fb = (_tFeedbackLeveler) mpool_alloc(sizeof(_tFeedbackLeveler), &m->pool);
164
165	p->curr=0.0f;
166	p->targetLevel=targetLevel;
167	tPowerFollower_initToPool(&p->pwrFlw,factor, mp);
168	p->mode=mode;
169	p->strength=strength;
170	}
171
172	void tFeedbackLeveler_freeFromPool (tFeedbackLeveler* const fb, tMempool* const mp)
173	{
174	_tMempool* m = *mp;
175	_tFeedbackLeveler* p = *fb;
176
177	tPowerFollower_freeFromPool(&p->pwrFlw, mp);
178	mpool_free(p, &m->pool);
179	}
180
181	void tFeedbackLeveler_setStrength(tFeedbackLeveler* const fb, float strength)
182	{ // strength is how strongly level diff is affecting the amp ratio
183	// try 0.125 for a start
184	_tFeedbackLeveler* p = *fb;
185	p->strength=strength;
186	}
187
188	void tFeedbackLeveler_setFactor(tFeedbackLeveler* const fb, float factor)
189	{
190	_tFeedbackLeveler* p = *fb;
191	tPowerFollower_setFactor(&p->pwrFlw,factor);
192	}
193
194	void tFeedbackLeveler_setMode(tFeedbackLeveler* const fb, int mode)
195	{ // 0 for decaying with upwards lev limiting, 1 for constrained absolute level (also downwards limiting)
196	_tFeedbackLeveler* p = *fb;
197	p->mode=mode;
198	}
199
200	float tFeedbackLeveler_tick(tFeedbackLeveler* const fb, float input)
201	{
202	_tFeedbackLeveler* p = *fb;
203	float levdiff=(tPowerFollower_tick(&p->pwrFlw, input)-p->targetLevel);
204	if (p->mode==0 && levdiff<0.0f) levdiff=0.0f;
205	p->curr=input(1.0f-p->strengthlevdiff);
206	return p->curr;
207	}
208
209	float tFeedbackLeveler_sample(tFeedbackLeveler* const fb)
210	{
211	_tFeedbackLeveler* p = *fb;
212	return p->curr;
213	}
214
215
216	void tFeedbackLeveler_setTargetLevel (tFeedbackLeveler* const fb, float TargetLevel)
217	{
218	_tFeedbackLeveler* p = *fb;
219	p->targetLevel=TargetLevel;
220	}
221

LEAF/Src/leaf-effects.c+0−1676

@@ -1,1676 +0,0 @@
1	/*==============================================================================
2
3	leaf-vocoder.c
4	Created: 20 Jan 2017 12:01:54pm
5	Author: Michael R Mulshine
6
7	==============================================================================*/
8
9	#if _WIN32 \|\| _WIN64
10
11	#include "..\Inc\leaf-effects.c"
12	#include "..\leaf.h"
13
14	#else
15
16	#include "../Inc/leaf-effects.h"
17	#include "../leaf.h"
18
19	#endif
20
21
22
23	//============================================================================================================
24	// TALKBOX
25	//============================================================================================================
26
27	void tTalkbox_init(tTalkbox* const voc, int bufsize)
28	{
29
30	_tTalkbox* v = voc = (_tTalkbox) leaf_alloc(sizeof(_tTalkbox));
31
32	v->param[0] = 0.5f; //wet
33	v->param[1] = 0.0f; //dry
34	v->param[2] = 0; // Swap
35	v->param[3] = 1.0f; //quality
36
37	v->bufsize = bufsize;
38
39	v->car0 = (float) leaf_alloc(sizeof(float) v->bufsize);
40	v->car1 = (float) leaf_alloc(sizeof(float) v->bufsize);
41	v->window = (float) leaf_alloc(sizeof(float) v->bufsize);
42	v->buf0 = (float) leaf_alloc(sizeof(float) v->bufsize);
43	v->buf1 = (float) leaf_alloc(sizeof(float) v->bufsize);
44
45	tTalkbox_update(voc);
46	tTalkbox_suspend(voc);
47	}
48
49	void tTalkbox_free(tTalkbox* const voc)
50	{
51	_tTalkbox* v = *voc;
52
53	leaf_free(v->buf1);
54	leaf_free(v->buf0);
55	leaf_free(v->window);
56	leaf_free(v->car1);
57	leaf_free(v->car0);
58
59	leaf_free(v);
60	}
61
62	void tTalkbox_initToPool (tTalkbox* const voc, int bufsize, tMempool* const mp)
63	{
64	_tMempool* m = *mp;
65	_tTalkbox* v = voc = (_tTalkbox) mpool_alloc(sizeof(_tTalkbox), &m->pool);
66
67	v->param[0] = 0.5f; //wet
68	v->param[1] = 0.0f; //dry
69	v->param[2] = 0; // Swap
70	v->param[3] = 1.0f; //quality
71
72	v->bufsize = bufsize;
73
74	v->car0 = (float) mpool_alloc(sizeof(float) v->bufsize, &m->pool);
75	v->car1 = (float) mpool_alloc(sizeof(float) v->bufsize, &m->pool);
76	v->window = (float) mpool_alloc(sizeof(float) v->bufsize, &m->pool);
77	v->buf0 = (float) mpool_alloc(sizeof(float) v->bufsize, &m->pool);
78	v->buf1 = (float) mpool_alloc(sizeof(float) v->bufsize, &m->pool);
79
80	tTalkbox_update(voc);
81	tTalkbox_suspend(voc);
82	}
83
84	void tTalkbox_freeFromPool (tTalkbox* const voc, tMempool* const mp)
85	{
86	_tMempool* m = *mp;
87	_tTalkbox* v = *voc;
88
89	mpool_free(v->buf1, &m->pool);
90	mpool_free(v->buf0, &m->pool);
91	mpool_free(v->window, &m->pool);
92	mpool_free(v->car1, &m->pool);
93	mpool_free(v->car0, &m->pool);
94
95	mpool_free(v, &m->pool);
96	}
97
98	void tTalkbox_update(tTalkbox* const voc) ///update internal parameters...
99	{
100	_tTalkbox* v = *voc;
101
102	float fs = leaf.sampleRate;
103	if(fs < 8000.0f) fs = 8000.0f;
104	if(fs > 96000.0f) fs = 96000.0f;
105
106	int32_t n = (int32_t)(0.01633f * fs);
107	if(n > v->bufsize) n = v->bufsize;
108
109	//O = (VstInt32)(0.0005f * fs);
110	v->O = (int32_t)((0.0001f + 0.0004f * v->param[3]) * fs);
111
112	if(n != v->N) //recalc hanning window
113	{
114	v->N = n;
115	float dp = TWO_PI / v->N;
116	float p = 0.0f;
117	for(n=0; n<v->N; n++)
118	{
119	v->window[n] = 0.5f - 0.5f * cosf(p);
120	p += dp;
121	}
122	}
123	v->wet = 0.5f * v->param[0] * v->param[0];
124	v->dry = 2.0f * v->param[1] * v->param[1];
125	}
126
127	void tTalkbox_suspend(tTalkbox* const voc) ///clear any buffers...
128	{
129	_tTalkbox* v = *voc;
130
131	v->pos = v->K = 0;
132	v->emphasis = 0.0f;
133	v->FX = 0;
134
135	v->u0 = v->u1 = v->u2 = v->u3 = v->u4 = 0.0f;
136	v->d0 = v->d1 = v->d2 = v->d3 = v->d4 = 0.0f;
137
138	for (int32_t i = 0; i < v->bufsize; i++)
139	{
140	v->buf0[i] = 0;
141	v->buf1[i] = 0;
142	v->car0[i] = 0;
143	v->car1[i] = 0;
144	}
145	}
146
147
148	#define ORD_MAX 100 // Was 50. Increasing this gets rid of glitchiness, lowering it breaks it; not sure how it affects performance
149	void tTalkbox_lpc(float buf, float car, int32_t n, int32_t o)
150	{
151	float z[ORD_MAX], r[ORD_MAX], k[ORD_MAX], G, x;
152	int32_t i, j, nn=n;
153
154	for(j=0; j<=o; j++, nn--) //buf[] is already emphasized and windowed
155	{
156	z[j] = r[j] = 0.0f;
157	for(i=0; i<nn; i++) r[j] += buf[i] * buf[i+j]; //autocorrelation
158	}
159	r[0] *= 1.001f; //stability fix
160
161	float min = 0.00001f;
162	if(r[0] < min) { for(i=0; i<n; i++) buf[i] = 0.0f; return; }
163
164	tTalkbox_lpcDurbin(r, o, k, &G); //calc reflection coeffs
165
166	for(i=0; i<=o; i++)
167	{
168	if(k[i] > 0.995f) k[i] = 0.995f; else if(k[i] < -0.995f) k[i] = -.995f;
169	}
170
171	for(i=0; i<n; i++)
172	{
173	x = G * car[i];
174	for(j=o; j>0; j--) //lattice filter
175	{
176	x -= k[j] * z[j-1];
177	z[j] = z[j-1] + k[j] * x;
178	}
179	buf[i] = z[0] = x; //output buf[] will be windowed elsewhere
180	}
181	}
182
183
184	void tTalkbox_lpcDurbin(float r, int p, float k, float *g)
185	{
186	int i, j;
187	float a[ORD_MAX], at[ORD_MAX], e=r[0];
188
189	for(i=0; i<=p; i++) a[i] = at[i] = 0.0f; //probably don't need to clear at[] or k[]
190
191	for(i=1; i<=p; i++)
192	{
193	k[i] = -r[i];
194
195	for(j=1; j<i; j++)
196	{
197	at[j] = a[j];
198	k[i] -= a[j] * r[i-j];
199	}
200	if(fabs(e) < 1.0e-20f) { e = 0.0f; break; }
201	k[i] /= e; // This might be costing us
202
203	a[i] = k[i];
204	for(j=1; j<i; j++) a[j] = at[j] + k[i] * at[i-j];
205
206	e = 1.0f - k[i] k[i];
207	}
208
209	if(e < 1.0e-20f) e = 0.0f;
210	*g = sqrtf(e);
211	}
212
213	float tTalkbox_tick(tTalkbox* const voc, float synth, float voice)
214	{
215	_tTalkbox* v = *voc;
216
217	int32_t p0=v->pos, p1 = (v->pos + v->N/2) % v->N;
218	float e=v->emphasis, w, o, x, dr, fx=v->FX;
219	float p, q, h0=0.3f, h1=0.77f;
220
221	o = voice;
222	x = synth;
223
224	dr = o;
225
226	p = v->d0 + h0 * x; v->d0 = v->d1; v->d1 = x - h0 * p;
227	q = v->d2 + h1 * v->d4; v->d2 = v->d3; v->d3 = v->d4 - h1 * q;
228	v->d4 = x;
229	x = p + q;
230
231	if(v->K++)
232	{
233	v->K = 0;
234
235	v->car0[p0] = v->car1[p1] = x; //carrier input
236
237	x = o - e; e = o; //6dB/oct pre-emphasis
238
239	w = v->window[p0]; fx = v->buf0[p0] * w; v->buf0[p0] = x * w; //50% overlapping hanning windows
240	if(++p0 >= v->N) { tTalkbox_lpc(v->buf0, v->car0, v->N, v->O); p0 = 0; }
241
242	w = 1.0f - w; fx += v->buf1[p1] * w; v->buf1[p1] = x * w;
243	if(++p1 >= v->N) { tTalkbox_lpc(v->buf1, v->car1, v->N, v->O); p1 = 0; }
244	}
245
246	p = v->u0 + h0 * fx; v->u0 = v->u1; v->u1 = fx - h0 * p;
247	q = v->u2 + h1 * v->u4; v->u2 = v->u3; v->u3 = v->u4 - h1 * q;
248	v->u4 = fx;
249	x = p + q;
250
251	o = x;
252
253	v->emphasis = e;
254	v->pos = p0;
255	v->FX = fx;
256
257
258	return o;
259	}
260
261	void tTalkbox_setQuality(tTalkbox* const voc, float quality)
262	{
263	_tTalkbox* v = *voc;
264
265	v->param[3] = quality;
266	v->O = (int32_t)((0.0001f + 0.0004f * v->param[3]) * leaf.sampleRate);
267	}
268
269
270	//============================================================================================================
271	// VOCODER
272	//============================================================================================================
273
274	void tVocoder_init (tVocoder* const voc)
275	{
276	_tVocoder* v = voc = (_tVocoder) leaf_alloc(sizeof(_tVocoder));
277
278	v->param[0] = 0.33f; //input select
279	v->param[1] = 0.50f; //output dB
280	v->param[2] = 0.40f; //hi thru
281	v->param[3] = 0.40f; //hi band
282	v->param[4] = 0.16f; //envelope
283	v->param[5] = 0.55f; //filter q
284	v->param[6] = 0.6667f;//freq range
285	v->param[7] = 0.33f; //num bands
286
287	tVocoder_update(voc);
288	}
289
290	void tVocoder_free (tVocoder* const voc)
291	{
292	_tVocoder* v = *voc;
293
294	leaf_free(v);
295	}
296
297	void tVocoder_initToPool (tVocoder* const voc, tMempool* const mp)
298	{
299	_tMempool* m = *mp;
300	_tVocoder* v = voc = (_tVocoder) mpool_alloc(sizeof(_tVocoder), &m->pool);
301
302	v->param[0] = 0.33f; //input select
303	v->param[1] = 0.50f; //output dB
304	v->param[2] = 0.40f; //hi thru
305	v->param[3] = 0.40f; //hi band
306	v->param[4] = 0.16f; //envelope
307	v->param[5] = 0.55f; //filter q
308	v->param[6] = 0.6667f;//freq range
309	v->param[7] = 0.33f; //num bands
310
311	tVocoder_update(voc);
312	}
313
314	void tVocoder_freeFromPool (tVocoder* const voc, tMempool* const mp)
315	{
316	_tMempool* m = *mp;
317	_tVocoder* v = *voc;
318
319	mpool_free(v, &m->pool);
320	}
321
322	void tVocoder_update (tVocoder* const voc)
323	{
324	_tVocoder* v = *voc;
325
326	float tpofs = 6.2831853f * leaf.invSampleRate;
327
328	float rr, th, re;
329
330	float sh;
331
332	int32_t i;
333
334	v->gain = (float)pow(10.0f, 2.0f * v->param[1] - 3.0f * v->param[5] - 2.0f);
335
336	v->thru = (float)pow(10.0f, 0.5f + 2.0f * v->param[1]);
337	v->high = v->param[3] * v->param[3] * v->param[3] * v->thru;
338	v->thru = v->param[2] v->param[2] * v->param[2];
339
340	if(v->param[7]<0.5f)
341	{
342	v->nbnd=8;
343	re=0.003f;
344	v->f[1][2] = 3000.0f;
345	v->f[2][2] = 2200.0f;
346	v->f[3][2] = 1500.0f;
347	v->f[4][2] = 1080.0f;
348	v->f[5][2] = 700.0f;
349	v->f[6][2] = 390.0f;
350	v->f[7][2] = 190.0f;
351	}
352	else
353	{
354	v->nbnd=16;
355	re=0.0015f;
356	v->f[ 1][2] = 5000.0f; //+1000
357	v->f[ 2][2] = 4000.0f; //+750
358	v->f[ 3][2] = 3250.0f; //+500
359	v->f[ 4][2] = 2750.0f; //+450
360	v->f[ 5][2] = 2300.0f; //+300
361	v->f[ 6][2] = 2000.0f; //+250
362	v->f[ 7][2] = 1750.0f; //+250
363	v->f[ 8][2] = 1500.0f; //+250
364	v->f[ 9][2] = 1250.0f; //+250
365	v->f[10][2] = 1000.0f; //+250
366	v->f[11][2] = 750.0f; //+210
367	v->f[12][2] = 540.0f; //+190
368	v->f[13][2] = 350.0f; //+155
369	v->f[14][2] = 195.0f; //+100
370	v->f[15][2] = 95.0f;
371	}
372
373	if(v->param[4]<0.05f) //freeze
374	{
375	for(i=0;i<v->nbnd;i++) v->f[i][12]=0.0f;
376	}
377	else
378	{
379	v->f[0][12] = (float)pow(10.0, -1.7 - 2.7f * v->param[4]); //envelope speed
380
381	rr = 0.022f / (float)v->nbnd; //minimum proportional to frequency to stop distortion
382	for(i=1;i<v->nbnd;i++)
383	{
384	v->f[i][12] = (float)(0.025 - rr * (double)i);
385	if(v->f[0][12] < v->f[i][12]) v->f[i][12] = v->f[0][12];
386	}
387	v->f[0][12] = 0.5f * v->f[0][12]; //only top band is at full rate
388	}
389
390	rr = 1.0 - pow(10.0f, -1.0f - 1.2f * v->param[5]);
391	sh = (float)pow(2.0f, 3.0f * v->param[6] - 1.0f); //filter bank range shift
392
393	for(i=1;i<v->nbnd;i++)
394	{
395	v->f[i][2] *= sh;
396	th = acos((2.0 * rr * cos(tpofs * v->f[i][2])) / (1.0 + rr * rr));
397	v->f[i][0] = (float)(2.0 * rr * cos(th)); //a0
398	v->f[i][1] = (float)(-rr * rr); //a1
399	//was .98
400	v->f[i][2] *= 0.96f; //shift 2nd stage slightly to stop high resonance peaks
401	th = acos((2.0 * rr * cos(tpofs * v->f[i][2])) / (1.0 + rr * rr));
402	v->f[i][2] = (float)(2.0 * rr * cos(th));
403	}
404	}
405
406	float tVocoder_tick (tVocoder* const voc, float synth, float voice)
407	{
408	_tVocoder* v = *voc;
409
410	float a, b, o=0.0f, aa, bb, oo = v->kout, g = v->gain, ht = v->thru, hh = v->high, tmp;
411	uint32_t i, k = v->kval, nb = v->nbnd;
412
413	a = voice; //speech
414	b = synth; //synth
415
416	tmp = a - v->f[0][7]; //integrate modulator for HF band and filter bank pre-emphasis
417	v->f[0][7] = a;
418	a = tmp;
419
420	if(tmp<0.0f) tmp = -tmp;
421	v->f[0][11] -= v->f[0][12] * (v->f[0][11] - tmp); //high band envelope
422	o = v->f[0][11] * (ht * a + hh * (b - v->f[0][3])); //high band + high thru
423
424	v->f[0][3] = b; //integrate carrier for HF band
425
426	if(++k & 0x1) //this block runs at half sample rate
427	{
428	oo = 0.0f;
429	aa = a + v->f[0][9] - v->f[0][8] - v->f[0][8]; //apply zeros here instead of in each reson
430	v->f[0][9] = v->f[0][8]; v->f[0][8] = a;
431	bb = b + v->f[0][5] - v->f[0][4] - v->f[0][4];
432	v->f[0][5] = v->f[0][4]; v->f[0][4] = b;
433
434	for(i=1; i<nb; i++) //filter bank: 4th-order band pass
435	{
436	tmp = v->f[i][0] * v->f[i][3] + v->f[i][1] * v->f[i][4] + bb;
437	v->f[i][4] = v->f[i][3];
438	v->f[i][3] = tmp;
439	tmp += v->f[i][2] * v->f[i][5] + v->f[i][1] * v->f[i][6];
440	v->f[i][6] = v->f[i][5];
441	v->f[i][5] = tmp;
442
443	tmp = v->f[i][0] * v->f[i][7] + v->f[i][1] * v->f[i][8] + aa;
444	v->f[i][8] = v->f[i][7];
445	v->f[i][7] = tmp;
446	tmp += v->f[i][2] * v->f[i][9] + v->f[i][1] * v->f[i][10];
447	v->f[i][10] = v->f[i][9];
448	v->f[i][9] = tmp;
449
450	if(tmp<0.0f) tmp = -tmp;
451	v->f[i][11] -= v->f[i][12] * (v->f[i][11] - tmp);
452	oo += v->f[i][5] * v->f[i][11];
453	}
454	}
455	o += oo * g; //effect of interpolating back up to Fs would be minimal (aliasing >16kHz)
456
457	v->kout = oo;
458	v->kval = k & 0x1;
459	if(fabs(v->f[0][11])<1.0e-10) v->f[0][11] = 0.0f; //catch HF envelope denormal
460
461	for(i=1;i<nb;i++)
462	if(fabs(v->f[i][3])<1.0e-10 \|\| fabs(v->f[i][7])<1.0e-10)
463	for(k=3; k<12; k++) v->f[i][k] = 0.0f; //catch reson & envelope denormals
464
465	if(fabs(o)>10.0f) tVocoder_suspend(voc); //catch instability
466
467	return o;
468
469	}
470
471	void tVocoder_suspend (tVocoder* const voc)
472	{
473	_tVocoder* v = *voc;
474
475	int32_t i, j;
476
477	for(i=0; i<v->nbnd; i++) for(j=3; j<12; j++) v->f[i][j] = 0.0f; //zero band filters and envelopes
478	v->kout = 0.0f;
479	v->kval = 0;
480	}
481
482	//============================================================================================================
483	// SOLAD
484	//============================================================================================================
485	/******************************************************************************/
486	/*************** static function declarations *****************************/
487	/******************************************************************************/
488
489	static void solad_init(_tSOLAD *w);
490	static inline float read_sample(_tSOLAD *w, float floatindex);
491	static void pitchdown(_tSOLAD w, float out);
492	static void pitchup(_tSOLAD w, float out);
493
494	/******************************************************************************/
495	/*************** public access functions **********************************/
496	/******************************************************************************/
497
498	// init
499	void tSOLAD_init(tSOLAD* const wp)
500	{
501	_tSOLAD* w = wp = (_tSOLAD) leaf_calloc(sizeof(_tSOLAD));
502
503	w->pitchfactor = 1.;
504	w->delaybuf = (float) leaf_calloc(sizeof(float) (LOOPSIZE+16));
505
506	solad_init(w);
507	}
508
509	void tSOLAD_free(tSOLAD* const wp)
510	{
511	_tSOLAD* w = *wp;
512
513	leaf_free(w->delaybuf);
514	leaf_free(w);
515	}
516
517	void tSOLAD_initToPool (tSOLAD* const wp, tMempool* const mp)
518	{
519	_tMempool* m = *mp;
520
521	_tSOLAD* w = wp = (_tSOLAD) mpool_calloc(sizeof(_tSOLAD), &m->pool);
522
523	w->pitchfactor = 1.;
524	w->delaybuf = (float) mpool_calloc(sizeof(float) (LOOPSIZE+16), &m->pool);
525
526	solad_init(w);
527	}
528
529	void tSOLAD_freeFromPool (tSOLAD* const wp, tMempool* const mp)
530	{
531	_tMempool* m = *mp;
532	_tSOLAD* w = *wp;
533
534	mpool_free(w->delaybuf, &m->pool);
535	mpool_free(w, &m->pool);
536	}
537
538	// send one block of input samples, receive one block of output samples
539	void tSOLAD_ioSamples(tSOLAD* const wp, float* in, float* out, int blocksize)
540	{
541	_tSOLAD* w = *wp;
542
543	int i = w->timeindex;
544	int n = w->blocksize = blocksize;
545
546	if(!i) w->delaybuf[LOOPSIZE] = in[0]; // copy one sample for interpolation
547	while(n--) w->delaybuf[i++] = *in++; // copy one input block to delay buffer
548
549	if(w->pitchfactor > 1) pitchup(w, out);
550	else pitchdown(w, out);
551
552	w->timeindex += blocksize;
553	w->timeindex &= LOOPMASK;
554	}
555
556	// set periodicity analysis data
557	void tSOLAD_setPeriod(tSOLAD* const wp, float period)
558	{
559	_tSOLAD* w = *wp;
560
561	if(period > MAXPERIOD) period = MAXPERIOD;
562	if(period > MINPERIOD) w->period = period; // ignore period when too small
563	}
564
565	// set pitch factor between 0.25 and 4
566	void tSOLAD_setPitchFactor(tSOLAD* const wp, float pitchfactor)
567	{
568	_tSOLAD* w = *wp;
569
570	if (pitchfactor <= 0.0f) return;
571	w->pitchfactor = pitchfactor;
572	}
573
574	// force readpointer lag
575	void tSOLAD_setReadLag(tSOLAD* const wp, float readlag)
576	{
577	_tSOLAD* w = *wp;
578
579	if(readlag < 0) readlag = 0;
580	if(readlag < w->readlag) // do not jump backward, only forward
581	{
582	w->jump = w->readlag - readlag;
583	w->readlag = readlag;
584	w->xfadelength = readlag;
585	w->xfadevalue = 1;
586	}
587	}
588
589	// reset state variables
590	void tSOLAD_resetState(tSOLAD* const wp)
591	{
592	_tSOLAD* w = *wp;
593
594	int n = LOOPSIZE + 1;
595	float *buf = w->delaybuf;
596
597	while(n--) *buf++ = 0;
598	solad_init(w);
599	}
600
601	/******************************************************************************/
602	/****************** private procedures ************************************/
603	/******************************************************************************/
604
605	/*
606	Function pitchdown() is called to read samples from the delay buffer when pitch
607	factor is between 0.25 and 1. The read pointer lags behind because of the slowed
608	down speed, and it must jump forward towards the write pointer soon as there is
609	sufficient space to jump. That is, if there is at least one period of the input
610	signal between read pointer and write pointer. When short periods follow up on
611	long periods, the read pointer may have space to jump over more than one period
612	lenghts. Jump length must be [periodlength ^ 2] in any case.
613
614	A linear crossfade function joins the jump-from point with the jump-to point.
615	The crossfade must be completed before another read pointer jump is allowed.
616	Length of the crossfade function is stored as a number of samples in terms of
617	the input sample rate. This length is dynamically translated
618	to a crossfade length expressed in output reading rate, according to pitch
619	factor which can change before the crossfade is completed. Crossfade length does
620	not cover an invariable length in periods for all pitch transposition factors.
621	For pitch factors from 0.5 till 1, crossfade length is stretched in the
622	output just as much as the signal itself, as crossfade speed is set to equal
623	pitch factor. For pitch factors below 0.5, the read pointer wants to jump
624	forward before one period is read, therefore the crossfade length as expressed
625	in output periods must be shorter. Crossfade speed is set to [1 - pitchfactor]
626	for those cases. Pitch factor 0.5 is the natural switch point between crossfade
627	speeds [pitchfactor] and [1 - pitchfactor] because 0.5 == 1 - 0.5. The crossfade
628	speed modification for pitch factors below 0.5 also means that much of the
629	original signal content will be skipped.
630	*/
631
632
633	static void pitchdown(_tSOLAD* const w, float *out)
634	{
635	int n = w->blocksize;
636	float refindex = (float)(w->timeindex + LOOPSIZE); // no negative values!
637	float pitchfactor = w->pitchfactor;
638	float period = w->period;
639	float readlag = w->readlag;
640	float readlagstep = 1 - pitchfactor;
641	float jump = w->jump;
642	float xfadevalue = w->xfadevalue;
643	float xfadelength = w->xfadelength;
644	float xfadespeed, xfadestep, readindex, outputsample;
645
646	if(pitchfactor > 0.5) xfadespeed = pitchfactor;
647	else xfadespeed = 1 - pitchfactor;
648	xfadestep = xfadespeed / xfadelength;
649
650	while(n--)
651	{
652	if(readlag > period) // check if read pointer may jump forward...
653	{
654	if(xfadevalue <= 0) // ...but do not interrupt crossfade
655	{
656	jump = period; // jump forward
657	while((jump * 2) < readlag) jump *= 2; // use available space
658	readlag -= jump; // reduce read pointer lag
659	xfadevalue = 1; // start crossfade
660	xfadelength = period - 1;
661	xfadestep = xfadespeed / xfadelength;
662	}
663	}
664
665	readindex = refindex - readlag;
666	outputsample = read_sample(w, readindex);
667
668	if(xfadevalue > 0)
669	{
670	outputsample *= (1 - xfadevalue); // fadein
671	outputsample += read_sample(w, readindex - jump) * xfadevalue; // fadeout
672	xfadevalue -= xfadestep;
673	}
674
675	*out++ = outputsample;
676	refindex += 1;
677	readlag += readlagstep;
678	}
679
680	w->jump = jump; // state variables
681	w->readlag = readlag;
682	w->xfadevalue = xfadevalue;
683	w->xfadelength = xfadelength;
684	}
685
686
687	/*
688	Function pitchup() for pitch factors above 1 is more complicated than
689	pitchdown(). The read pointer increments faster than the write pointer and a
690	backward jump must happen in time, reckoning with the crossfade region. The read
691	pointer backward jump length is always one period. In order to minimize the area
692	of signal duplicates, crossfade length is aimed at [period / pitchfactor].
693	This leads to a crossfade speed of [pitchfactor * pitchfactor].
694
695	Some samples for the fade out (but not all of them) must already be in the
696	buffer, otherwise we will run out of input samples before the crossfade is
697	completed. The ratio of past samples and future samples for a crossfade of any
698	length is as follows:
699
700	past samples: xfadelength * (1 - 1 / pitchfactor)
701	future samples: xfadelength * (1 / pitchfactor)
702
703	For example in the case of pitch factor 1.5 this would be:
704
705	past samples: xfadelength * (1 - 1 / 1.5) = xfadelength * 1 / 3
706	future samples: xfadelength * (1 / 1.5) = xfadelength * 2 / 3
707
708	In the case of pitch factor 4 this would be:
709
710	past samples: xfadelength * (1 - 1 / 4) = xfadelength * 3 / 4
711	future samples: xfadelength * (1 / 4) = xfadelength * 1 / 4
712
713	The read pointer lag must therefore preserve a minimum dependent on pitch
714	factor. The minimum is called 'limit' here:
715
716	limit = period * (pitchfactor - 1) / pitchfactor * pitchfactor
717
718	Components of this expression are combined to reuse them in operations, while
719	(pitchfactor - 1) is changed to (pitchfactor - 0.99) to avoid numerical
720	resolution issues for pitch factors slightly above 1:
721
722	xfadespeed = pitchfactor * pitchfactor
723	limitfactor = (pitchfactor - 0.99) / xfadespeed
724	limit = period * limitfactor
725
726	When read lag is smaller than this limit, the read pointer must preferably
727	jump backward, unless a previous crossfade is not yet completed. Crossfades must
728	preferably be completed, unless the read pointer lag becomes smaller than zero.
729	With fluctuating period lengths and pitch factors, the readpointer lag limit may
730	change from one input block to the next in such a way that the actual lag is
731	suddenly much smaller than the limit, and the intended crossfade length can not
732	be applied. Therefore the crossfade length is simply calculated from the
733	available amount of samples for all cases, like so:
734
735	xfadelength = readlag / limitfactor
736
737	For most occurrences, this will amount to a crossfade length reduced to
738	[period / pitchfactor] in the output for pitch factors above 1, while in some
739	cases it will be considerably shorter. Fortunately, an incidental aberration of
740	the intended crossfade length hardly ever creates an audible artifact. The
741	reason to specify preferred crossfade length according to pitch factor is to
742	minimize the impression of echoes without sacrificing too much of the signal
743	content. The readpointer jump length remains one period in any case.
744
745	Sometimes, the input signal periodicity may decrease substantially between one
746	signal block and the next. In such cases it may be possible for the read pointer
747	to jump forward and reduce latency. For every signal block, a check on this
748	possibility is done. A previous crossfade must be completed before a forward
749	jump is allowed.
750	*/
751	static void pitchup(_tSOLAD* const w, float *out)
752	{
753	int n = w->blocksize;
754	float refindex = (float)(w->timeindex + LOOPSIZE); // no negative values
755	float pitchfactor = w->pitchfactor;
756	float period = w->period;
757	float readlag = w->readlag;
758	float jump = w->jump;
759	float xfadevalue = w->xfadevalue;
760	float xfadelength = w->xfadelength;
761
762	float readlagstep = pitchfactor - 1;
763	float xfadespeed = pitchfactor * pitchfactor;
764	float xfadestep = xfadespeed / xfadelength;
765	float limitfactor = (pitchfactor - (float)0.99) / xfadespeed;
766	float limit = period * limitfactor;
767	float readindex, outputsample;
768
769	if((readlag > (period + 2 * limit)) & (xfadevalue < 0))
770	{
771	jump = period; // jump forward
772	while((jump * 2) < (readlag - 2 * limit)) jump *= 2; // use available space
773	readlag -= jump; // reduce read pointer lag
774	xfadevalue = 1; // start crossfade
775	xfadelength = period - 1;
776	xfadestep = xfadespeed / xfadelength;
777	}
778
779	while(n--)
780	{
781	if(readlag < limit) // check if read pointer should jump backward...
782	{
783	if((xfadevalue < 0) \| (readlag < 0)) // ...but try not to interrupt crossfade
784	{
785	xfadelength = readlag / limitfactor;
786	if(xfadelength < 1) xfadelength = 1;
787	xfadestep = xfadespeed / xfadelength;
788
789	jump = -period; // jump backward
790	readlag += period; // increase read pointer lag
791	xfadevalue = 1; // start crossfade
792	}
793	}
794
795	readindex = refindex - readlag;
796	outputsample = read_sample(w, readindex);
797
798	if(xfadevalue > 0)
799	{
800	outputsample *= (1 - xfadevalue);
801	outputsample += read_sample(w, readindex - jump) * xfadevalue;
802	xfadevalue -= xfadestep;
803	}
804
805	*out++ = outputsample;
806	refindex += 1;
807	readlag -= readlagstep;
808	}
809
810	w->readlag = readlag; // state variables
811	w->jump = jump;
812	w->xfadelength = xfadelength;
813	w->xfadevalue = xfadevalue;
814	}
815
816	// read one sample from delay buffer, with linear interpolation
817	static inline float read_sample(_tSOLAD* const w, float floatindex)
818	{
819	int index = (int)floatindex;
820	float fraction = floatindex - (float)index;
821	float *buf = w->delaybuf;
822	index &= LOOPMASK;
823
824	return (buf[index] + (fraction * (buf[index+1] - buf[index])));
825	}
826
827	static void solad_init(_tSOLAD* const w)
828	{
829	w->timeindex = 0;
830	w->xfadevalue = -1;
831	w->period = INITPERIOD;
832	w->readlag = INITPERIOD;
833	w->blocksize = INITPERIOD;
834	}
835
836	//============================================================================================================
837	// PITCHSHIFT
838	//============================================================================================================
839
840	static int pitchshift_attackdetect(_tPitchShift* ps)
841	{
842	float envout;
843
844	_tPeriodDetection* p = *ps->p;
845
846	envout = tEnvPD_tick(&p->env);
847
848	if (envout >= 1.0f)
849	{
850	p->lastmax = p->max;
851	if (envout > p->max)
852	{
853	p->max = envout;
854	}
855	else
856	{
857	p->deltamax = envout - p->max;
858	p->max = p->max * ps->radius;
859	}
860	p->deltamax = p->max - p->lastmax;
861	}
862
863	p->fba = p->fba ? (p->fba - 1) : 0;
864
865	return (p->fba == 0 && (p->max > 60 && p->deltamax > 6)) ? 1 : 0;
866	}
867
868	void tPitchShift_init (tPitchShift* const psr, tPeriodDetection* pd, float* out, int bufSize)
869	{
870	_tPitchShift* ps = psr = (_tPitchShift) leaf_calloc(sizeof(_tPitchShift));
871	_tPeriodDetection* p = *pd;
872
873	ps->p = pd;
874
875	ps->outBuffer = out;
876	ps->bufSize = bufSize;
877	ps->frameSize = p->frameSize;
878	ps->framesPerBuffer = ps->bufSize / ps->frameSize;
879	ps->curBlock = 1;
880	ps->lastBlock = 0;
881	ps->index = 0;
882	ps->pitchFactor = 1.0f;
883
884	tSOLAD_init(&ps->sola);
885
886	tHighpass_init(&ps->hp, HPFREQ);
887
888	tSOLAD_setPitchFactor(&ps->sola, DEFPITCHRATIO);
889	}
890
891	void tPitchShift_free(tPitchShift* const psr)
892	{
893	_tPitchShift* ps = *psr;
894
895	tSOLAD_free(&ps->sola);
896	tHighpass_free(&ps->hp);
897	leaf_free(ps);
898	}
899
900	void tPitchShift_initToPool (tPitchShift* const psr, tPeriodDetection* const pd, float* out, int bufSize, tMempool* const mp)
901	{
902	_tMempool* m = *mp;
903
904	_tPitchShift* ps = psr = (_tPitchShift) mpool_calloc(sizeof(_tPitchShift), &m->pool);
905
906	_tPeriodDetection* p = *pd;
907
908	ps->p = pd;
909
910	ps->outBuffer = out;
911	ps->bufSize = bufSize;
912	ps->frameSize = p->frameSize;
913	ps->framesPerBuffer = ps->bufSize / ps->frameSize;
914	ps->curBlock = 1;
915	ps->lastBlock = 0;
916	ps->index = 0;
917	ps->pitchFactor = 1.0f;
918
919	tSOLAD_initToPool(&ps->sola, mp);
920
921	tHighpass_initToPool(&ps->hp, HPFREQ, mp);
922
923	tSOLAD_setPitchFactor(&ps->sola, DEFPITCHRATIO);
924	}
925
926	void tPitchShift_freeFromPool (tPitchShift* const psr, tMempool* const mp)
927	{
928	_tMempool* m = *mp;
929	_tPitchShift* ps = *psr;
930
931	tSOLAD_freeFromPool(&ps->sola, mp);
932	tHighpass_freeFromPool(&ps->hp, mp);
933	mpool_free(ps, &m->pool);
934	}
935
936	void tPitchShift_setPitchFactor(tPitchShift* psr, float pf)
937	{
938	_tPitchShift* ps = *psr;
939
940	ps->pitchFactor = pf;
941	}
942
943	float tPitchShift_shift (tPitchShift* psr)
944	{
945	_tPitchShift* ps = *psr;
946	_tPeriodDetection* p = *ps->p;
947
948	float period, out;
949	int i, iLast;
950
951	i = p->i;
952	iLast = p->iLast;
953
954	out = tHighpass_tick(&ps->hp, ps->outBuffer[iLast]);
955
956	if (p->indexstore >= ps->frameSize)
957	{
958	period = tPeriodDetection_getPeriod(&p);
959
960	if(pitchshift_attackdetect(ps) == 1)
961	{
962	p->fba = 5;
963	tSOLAD_setReadLag(&ps->sola, p->windowSize);
964	}
965
966	tSOLAD_setPeriod(&ps->sola, period);
967	tSOLAD_setPitchFactor(&ps->sola, ps->pitchFactor);
968
969	tSOLAD_ioSamples(&ps->sola, &(p->inBuffer[i]), &(ps->outBuffer[i]), ps->frameSize);
970	}
971
972	return out;
973	}
974
975	float tPitchShift_shiftToFreq (tPitchShift* psr, float freq)
976	{
977	_tPitchShift* ps = *psr;
978	_tPeriodDetection* p = *ps->p;
979
980	float period, out;
981	int i, iLast;
982
983	i = p->i;
984	iLast = p->iLast;
985
986	out = tHighpass_tick(&ps->hp, ps->outBuffer[iLast]);
987
988	if (p->indexstore >= ps->frameSize)
989	{
990	period = tPeriodDetection_getPeriod(&p);
991
992	if(pitchshift_attackdetect(ps) == 1)
993	{
994	p->fba = 5;
995	tSOLAD_setReadLag(&ps->sola, p->windowSize);
996	}
997
998	tSOLAD_setPeriod(&ps->sola, period);
999
1000	if (period != 0) ps->pitchFactor = periodfreqleaf.invSampleRate;
1001	else ps->pitchFactor = 1.0f;
1002
1003	tSOLAD_setPitchFactor(&ps->sola, ps->pitchFactor);
1004
1005	tSOLAD_ioSamples(&ps->sola, &(p->inBuffer[i]), &(ps->outBuffer[i]), ps->frameSize);
1006	}
1007	return out;
1008	}
1009
1010	float tPitchShift_shiftToFunc (tPitchShift* psr, float (*fun)(float))
1011	{
1012	_tPitchShift* ps = *psr;
1013	_tPeriodDetection* p = *ps->p;
1014
1015	float period, out;
1016	int i, iLast;
1017
1018	i = p->i;
1019	iLast = p->iLast;
1020
1021	out = tHighpass_tick(&ps->hp, ps->outBuffer[iLast]);
1022
1023	if (p->indexstore >= ps->frameSize)
1024	{
1025	period = tPeriodDetection_getPeriod(&p);
1026
1027	if(pitchshift_attackdetect(ps) == 1)
1028	{
1029	p->fba = 5;
1030	tSOLAD_setReadLag(&ps->sola, p->windowSize);
1031	}
1032
1033	tSOLAD_setPeriod(&ps->sola, period);
1034
1035	ps->pitchFactor = period/fun(period);
1036	tSOLAD_setPitchFactor(&ps->sola, ps->pitchFactor);
1037
1038	tSOLAD_ioSamples(&ps->sola, &(p->inBuffer[i]), &(ps->outBuffer[i]), ps->frameSize);
1039
1040	ps->curBlock++;
1041	if (ps->curBlock >= p->framesPerBuffer) ps->curBlock = 0;
1042	ps->lastBlock++;
1043	if (ps->lastBlock >= ps->framesPerBuffer) ps->lastBlock = 0;
1044	}
1045
1046	return out;
1047	}
1048
1049	//============================================================================================================
1050	// RETUNE
1051	//============================================================================================================
1052
1053	void tRetune_init(tRetune* const rt, int numVoices, int bufSize, int frameSize)
1054	{
1055	tRetune_initToPool(rt, numVoices, bufSize, frameSize, &leaf_mempool);
1056	}
1057
1058	void tRetune_free(tRetune* const rt)
1059	{
1060	tRetune_freeFromPool(rt, &leaf_mempool);
1061	}
1062
1063	void tRetune_initToPool (tRetune* const rt, int numVoices, int bufSize, int frameSize, tMempool* const mp)
1064	{
1065	_tMempool* m = *mp;
1066	_tRetune* r = rt = (_tRetune) mpool_alloc(sizeof(_tRetune), &m->pool);
1067
1068	r->bufSize = bufSize;
1069	r->frameSize = frameSize;
1070	r->numVoices = numVoices;
1071
1072	r->inBuffer = (float) mpool_calloc(sizeof(float) r->bufSize, &m->pool);
1073	r->outBuffers = (float*) mpool_calloc(sizeof(float) * r->numVoices, &m->pool);
1074
1075	r->hopSize = DEFHOPSIZE;
1076	r->windowSize = DEFWINDOWSIZE;
1077	r->fba = FBA;
1078	tRetune_setTimeConstant(rt, DEFTIMECONSTANT);
1079
1080	r->inputPeriod = 0.0f;
1081
1082	r->ps = (tPitchShift) mpool_calloc(sizeof(tPitchShift) r->numVoices, &m->pool);
1083	r->pitchFactor = (float) mpool_calloc(sizeof(float) r->numVoices, &m->pool);
1084	r->tickOutput = (float) mpool_calloc(sizeof(float) r->numVoices, &m->pool);
1085	for (int i = 0; i < r->numVoices; ++i)
1086	{
1087	r->outBuffers[i] = (float) mpool_calloc(sizeof(float) r->bufSize, &m->pool);
1088	}
1089
1090	tPeriodDetection_initToPool(&r->pd, r->inBuffer, r->outBuffers[0], r->bufSize, r->frameSize, mp);
1091
1092	for (int i = 0; i < r->numVoices; ++i)
1093	{
1094	tPitchShift_initToPool(&r->ps[i], &r->pd, r->outBuffers[i], r->bufSize, mp);
1095	}
1096	}
1097
1098	void tRetune_freeFromPool (tRetune* const rt, tMempool* const mp)
1099	{
1100	_tMempool* m = *mp;
1101	_tRetune* r = *rt;
1102
1103	tPeriodDetection_freeFromPool(&r->pd, mp);
1104	for (int i = 0; i < r->numVoices; ++i)
1105	{
1106	tPitchShift_freeFromPool(&r->ps[i], mp);
1107	mpool_free(r->outBuffers[i], &m->pool);
1108	}
1109	mpool_free(r->tickOutput, &m->pool);
1110	mpool_free(r->pitchFactor, &m->pool);
1111	mpool_free(r->ps, &m->pool);
1112	mpool_free(r->inBuffer, &m->pool);
1113	mpool_free(r->outBuffers, &m->pool);
1114	mpool_free(r, &m->pool);
1115	}
1116
1117	float* tRetune_tick(tRetune* const rt, float sample)
1118	{
1119	_tRetune* r = *rt;
1120
1121	r->inputPeriod = tPeriodDetection_tick(&r->pd, sample);
1122
1123	for (int v = 0; v < r->numVoices; ++v)
1124	{
1125	r->tickOutput[v] = tPitchShift_shift(&r->ps[v]);
1126	}
1127
1128	return r->tickOutput;
1129	}
1130
1131	void tRetune_setNumVoices(tRetune* const rt, int numVoices)
1132	{
1133	_tRetune* r = *rt;
1134
1135	for (int i = 0; i < r->numVoices; ++i)
1136	{
1137	tPitchShift_free(&r->ps[i]);
1138	leaf_free(r->outBuffers[i]);
1139	}
1140	leaf_free(r->tickOutput);
1141	leaf_free(r->pitchFactor);
1142	leaf_free(r->ps);
1143	leaf_free(r->outBuffers);
1144
1145	r->numVoices = numVoices;
1146
1147	r->outBuffers = (float*) leaf_alloc(sizeof(float) * r->numVoices);
1148	r->ps = (tPitchShift) leaf_alloc(sizeof(tPitchShift) r->numVoices);
1149	r->pitchFactor = (float) leaf_alloc(sizeof(float) r->numVoices);
1150	r->tickOutput = (float) leaf_alloc(sizeof(float) r->numVoices);
1151	for (int i = 0; i < r->numVoices; ++i)
1152	{
1153	r->outBuffers[i] = (float) leaf_alloc(sizeof(float) r->bufSize);
1154	tPitchShift_init(&r->ps[i], &r->pd, r->outBuffers[i], r->bufSize);
1155	}
1156	}
1157
1158	void tRetune_setPitchFactors(tRetune* const rt, float pf)
1159	{
1160	_tRetune* r = *rt;
1161
1162	for (int i = 0; i < r->numVoices; ++i)
1163	{
1164	r->pitchFactor[i] = pf;
1165	tPitchShift_setPitchFactor(&r->ps[i], r->pitchFactor[i]);
1166	}
1167	}
1168
1169	void tRetune_setPitchFactor(tRetune* const rt, float pf, int voice)
1170	{
1171	_tRetune* r = *rt;
1172
1173	r->pitchFactor[voice] = pf;
1174	tPitchShift_setPitchFactor(&r->ps[voice], r->pitchFactor[voice]);
1175	}
1176
1177	void tRetune_setTimeConstant(tRetune* const rt, float tc)
1178	{
1179	_tRetune* r = *rt;
1180
1181	r->timeConstant = tc;
1182	r->radius = expf(-1000.0f * r->hopSize * leaf.invSampleRate / r->timeConstant);
1183	}
1184
1185	void tRetune_setHopSize(tRetune* const rt, int hs)
1186	{
1187	_tRetune* r = *rt;
1188
1189	r->hopSize = hs;
1190	tPeriodDetection_setHopSize(&r->pd, r->hopSize);
1191	}
1192
1193	void tRetune_setWindowSize(tRetune* const rt, int ws)
1194	{
1195	_tRetune* r = *rt;
1196
1197	r->windowSize = ws;
1198	tPeriodDetection_setWindowSize(&r->pd, r->windowSize);
1199	}
1200
1201	void tRetune_setFidelityThreshold(tRetune* const rt, float threshold)
1202	{
1203	_tRetune* r = *rt;
1204
1205	tPeriodDetection_setFidelityThreshold(&r->pd, threshold);
1206	}
1207
1208	float tRetune_getInputPeriod(tRetune* const rt)
1209	{
1210	_tRetune* r = *rt;
1211
1212	return r->inputPeriod;
1213	}
1214
1215	float tRetune_getInputFreq(tRetune* const rt)
1216	{
1217	_tRetune* r = *rt;
1218
1219	return 1.0f/r->inputPeriod;
1220	}
1221
1222	//============================================================================================================
1223	// AUTOTUNE