Sojus07/hackrf
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

hack: add rad1o ui code

Browse Source
This commit is contained in:
schneider
2021-05-16 22:56:44 +02:00
parent bf84a3a9ba
commit 0c514839ca
19 changed files with 3970 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

128
firmware/common/rad1o_decoder.c Normal file
View File

@ -0,0 +1,128 @@
#include "rad1o_fonts.h"
#include "rad1o_render.h"
// Local function: Get next nibble.
static int ctr=0; // offset for next nibble
static int hilo=0; // 0= high nibble next, 1=low nibble next
const uint8_t * data;
static char gnn(){ // Get next nibble
static int byte;
int val;
if(hilo==1)
ctr++;
hilo=1-hilo;
if(hilo==1){
if(efont.type==FONT_EXTERNAL){
#if 0
byte=_getFontData(GET_DATA,0);
#endif
}else{
byte=data[ctr];
};
val=byte>>4;
}else{
val=byte&0x0f;
};
return val;
}
// Local function: Unpack "long run".
int upl(int off){
int retval;
while((retval=gnn())==0){
off++;
};
while(off-->0){
retval=retval<<4;
retval+=gnn();
};
return retval;
}
uint8_t * pk_decode(const uint8_t * ldata,int * len){
ctr=0;hilo=0;
data=ldata;
int length=*len; // Length of character bytestream
int height; // Height of character in bytes
int hoff; // bit position for non-integer heights
uint8_t * bufptr=charBuf; // Output buffer for decoded character
height=(font->u8Height-1)/8+1;
hoff=font->u8Height%8;
#define DYN (12) // Decoder parameter: Fixed value for now.
int repeat=0; // Decoder internal: repeat colum?
int curbit=0; // Decoder internal: current bit (1 or 0)
int pos=0; // Decoder internal: current bit position (0..7)
int nyb; // Decoder internal: current nibble / value
if(efont.type==FONT_EXTERNAL){
#if 0
if(_getFontData(PEEK_DATA,0)>>4 == 14){ // Char starts with 1-bits.
gnn();
curbit=1;
};
#endif
}else{
if(data[ctr]>>4 == 14){ // Char starts with 1-bits.
gnn();
curbit=1;
};
};
while(ctr<length){ /* Iterate the whole input stream */
/* Get next encoded nibble and decode */
nyb=gnn();
if(nyb==15){
repeat++;
continue;
}else if(nyb==14){
nyb=upl(0);
nyb+=1;
repeat+=nyb;
continue;
}else if(nyb>DYN){
nyb=(16*(nyb-DYN-1))+gnn()+DYN+1;
}else if(nyb==0){
nyb=upl(1);
nyb+=(16*(13-DYN)+DYN)-16;
};
/* Generate & output bits */
while(nyb-->0){
if(pos==0) // Clear each byte before we start.
*bufptr=0;
if(curbit==1){
*bufptr|=1<<(7-pos);
};
pos++;
if(((bufptr-charBuf)%height)==(height-1) && (pos==hoff)){
// Finish incomplete last byte per column
pos=8;
};
if(pos==8){
bufptr++;
if((bufptr-charBuf)%height==0){ // End of column?
while(repeat>0){
for(int y=0;y<height;y++){
bufptr[0]=bufptr[-height];
bufptr++;
};
repeat--;
};
};
pos=0;
};
};
curbit=1-curbit;
};
*len=(bufptr-charBuf)/height; // return size of output buffer.
return charBuf;
}

2
firmware/common/rad1o_decoder.h Normal file
View File

@ -0,0 +1,2 @@
uint8_t * pk_decode(const uint8_t * data,int * len);

251
firmware/common/rad1o_display.c Normal file
View File

@ -0,0 +1,251 @@
#include "rad1o_display.h"
#include "rad1o_print.h"
#include "hackrf_core.h"
#include "gpio_lpc.h"
#include <libopencm3/lpc43xx/ssp.h>
#include <libopencm3/lpc43xx/scu.h>
#include <string.h>
static void delayms(const uint32_t milliseconds) {
/* NOTE: Naively assumes 204 MHz instruction cycle clock and five instructions per count */
delay(milliseconds * 40800);
}
static struct gpio_t gpio_lcd_cs = GPIO(4, 12); /* P9_0 */
static struct gpio_t gpio_lcd_bl_en = GPIO(0, 8); /* P1_1 */
static struct gpio_t gpio_lcd_reset = GPIO(5, 17); /* P9_4 */
/**************************************************************************/
/* Utility routines to manage nokia display */
/**************************************************************************/
uint8_t lcdBuffer[RESX*RESY];
uint8_t displayType;
static char isTurned;
void lcd_select() {
/*
* The LCD requires 9-Bit frames
* Freq = PCLK / (CPSDVSR * [SCR+1])
* We want 120ns / bit -> 8.3 MHz.
* SPI1 BASE CLOCK is expected to be 204 MHz.
* 204 MHz / ( 12 * (1 + 1)) = 8.5 MHz
*
* Set CPSDVSR = 12
*/
uint8_t serial_clock_rate = 1;
uint8_t clock_prescale_rate = 12;
//uint8_t clock_prescale_rate = 6;
ssp_init(LCD_SSP,
SSP_DATA_9BITS,
SSP_FRAME_SPI,
SSP_CPOL_0_CPHA_0,
serial_clock_rate,
clock_prescale_rate,
SSP_MODE_NORMAL,
SSP_MASTER,
SSP_SLAVE_OUT_ENABLE);
gpio_clear(&gpio_lcd_cs);
}
void lcd_deselect() {
gpio_set(&gpio_lcd_cs);
}
void lcdWrite(uint8_t cd, uint8_t data) {
uint16_t frame = 0x0;
frame = cd << 8;
frame |= data;
ssp_transfer(LCD_SSP, frame );
}
void lcdInit(void) {
gpio_output(&gpio_lcd_bl_en);
gpio_output(&gpio_lcd_reset);
gpio_output(&gpio_lcd_cs);
/* prepare SPI */
SETUPpin(LCD_MOSI);
SETUPpin(LCD_SCK);
// Reset the display
gpio_clear(&gpio_lcd_reset);
delayms(100); /* 1 ms */
gpio_set(&gpio_lcd_reset);
delayms(100); /* 5 ms */
lcd_select();
static uint8_t initseq_d[] = {
/* The controller is a PCF8833 -
documentation can be found online.
*/
0x11, // SLEEP_OUT (wake up)
0x3A, 2, // mode 8bpp (2= 8bpp, 3= 12bpp, 5= 16bpp)
0x36, 0b11000000, // my,mx,v,lao,rgb,x,x,x
0x25, 0x3a, // set contrast
0x29, // display on
0x03, // BSTRON (booster voltage)
0x2A, 1, RESX,
0x2B, 1, RESY
};
uint16_t initseq_c = ~ ( /* commands: 1, data: 0 */
(1<< 0) |
(1<< 1) | (0<< 2) |
(1<< 3) | (0<< 4) |
(1<< 5) | (0<< 6) |
(1<< 7) |
(1<< 8) |
(1<< 9) | (0<<10) | (0<<11) |
(1<<12) | (0<<13) | (0<<14) |
0);
lcdWrite(0, 0x01); /* most color displays need the pause */
delayms(10);
size_t i = 0;
while(i<sizeof(initseq_d)){
lcdWrite(initseq_c&1, initseq_d[i++]);
initseq_c = initseq_c >> 1;
}
lcd_deselect();
lcdFill(0xff); /* Clear display buffer */
lcdRotate();
setSystemFont();
gpio_set(&gpio_lcd_bl_en);
}
void lcdDeInit(void) {
gpio_clear(&gpio_lcd_bl_en);
lcdClear();
lcdFill(0x00);
lcdDisplay();
}
void lcdFill(char f){
memset(lcdBuffer,f,RESX*RESY);
#if 0
int x;
for(x=0;x<RESX*RESY;x++) {
lcdBuffer[x]=f;
}
#endif
}
void lcdSetPixel(char x, char y, uint8_t f){
if (x> RESX || y > RESY)
return;
lcdBuffer[y*RESX+x] = f;
}
uint8_t lcdGetPixel(char x, char y){
return lcdBuffer[y*RESX+x];
}
void lcdDisplay(void) {
lcd_select();
uint16_t x,y;
/* set (back) to 8 bpp mode */
lcdWrite(TYPE_CMD,0x3a); lcdWrite(TYPE_DATA,2);
lcdWrite(TYPE_CMD,0x2C); // memory write (RAMWR)
for(y=0;y<RESY;y++){
for(x=0;x<RESX;x++){
lcdWrite(TYPE_DATA,lcdGetPixel(x,y));
};
}
lcd_deselect();
}
void lcdSetContrast(int c) {
lcd_select();
lcdWrite(TYPE_CMD,0x25);
lcdWrite(TYPE_DATA,c);
lcd_deselect();
}
void lcdSetRotation(char doit) {
isTurned = doit;
lcdRotate();
}
void lcdRotate(void) {
lcd_select();
lcdWrite(TYPE_CMD,0x36); // MDAC-Command
if (isTurned) {
lcdWrite(TYPE_DATA,0b01100000); // my,mx,v,lao,rgb,x,x,x
} else {
lcdWrite(TYPE_DATA,0b11000000); // my,mx,v,lao,rgb,x,x,x
}
lcd_deselect();
lcdDisplay();
}
void lcdShiftH(bool right, int wrap) {
uint8_t tmp;
for (int yb = 0; yb<RESY; yb++) {
if (right) {
tmp = lcdBuffer[yb*RESX];
memmove(lcdBuffer + yb*RESX,lcdBuffer + yb*RESX+1 ,RESX-1);
lcdBuffer[yb*RESX+(RESX-1)] = wrap?tmp:0xff;
} else {
tmp = lcdBuffer[yb*RESX+(RESX-1)];
memmove(lcdBuffer + yb*RESX+1,lcdBuffer + yb*RESX ,RESX-1);
lcdBuffer[yb*RESX] = wrap?tmp:0xff;
}
}
}
void lcdShiftV(bool up, int wrap) {
uint8_t tmp[RESX];
if (up) {
if (wrap)
memmove(tmp, lcdBuffer, RESX);
else
memset(tmp,0xff,RESX);
memmove(lcdBuffer,lcdBuffer+RESX ,RESX*(RESY-1));
memmove(lcdBuffer+RESX*(RESY-1),tmp,RESX);
} else {
if (wrap)
memmove(tmp, lcdBuffer+RESX*(RESY-1), RESX);
else
memset(tmp,0xff,RESX);
memmove(lcdBuffer+RESX,lcdBuffer ,RESX*(RESY-1));
memmove(lcdBuffer,tmp,RESX);
}
}
void lcdShift(int x, int y, int wrap) {
bool dir=true;
if(x<0){
dir=false;
x=-x;
};
while(x-->0)
lcdShiftH(dir, wrap);
if(y<0){
dir=false;
y=-y;
}else{
dir=true;
};
while(y-->0)
lcdShiftV(dir, wrap);
}

45
firmware/common/rad1o_display.h Normal file
View File

@ -0,0 +1,45 @@
#ifndef __DISPLAY_H_
#define __DISPLAY_H_
#include <libopencm3/cm3/common.h>
#define RESX 130
#define RESY 130
#define TYPE_CMD 0
#define TYPE_DATA 1
#define RGB(rgb) (rgb & 0b111000000000000000000000) >> 16 | (rgb & 0b000000001110000000000000) >> 11 | (rgb & 0b000000000000000011000000) >> 6
#define _PIN(pin, func, ...) pin
#define _FUNC(pin, func, ...) func
#define SETUPpin(args...) scu_pinmux(_PIN(args),_FUNC(args))
#define LCD_MOSI P1_4, SCU_CONF_FUNCTION5|SCU_SSP_IO
#define LCD_SCK P1_19, SCU_CONF_FUNCTION1|SCU_SSP_IO
#define LCD_SSP SSP1_NUM
/* Display buffer */
extern uint8_t lcdBuffer[RESX*RESY];
void lcdInit(void);
void lcdDeInit(void);
void lcdFill(char f);
void lcdDisplay(void);
void lcdSetPixel(char x, char y, uint8_t f);
uint8_t lcdGetPixel(char x, char y);
void lcdShift(int x, int y, int wrap);
void lcdSetContrast(int c);
void lcdSetRotation(char doit);
void lcdRotate(void);
void lcd_select();
void lcd_deselect();
void lcdWrite(uint8_t cd, uint8_t data);
#define RGB_TO_8BIT(r, g, b) \
((r & 0b11100000) | ((g >> 3) & 0b11100) | ((b >> 6) & 0b11))
#endif

99
firmware/common/rad1o_draw.c Normal file
View File

@ -0,0 +1,99 @@
#include "rad1o_display.h"
#define MAX_LINE_THICKNESS 16
#define SWAP(p1, p2) do { int SWAP = p1; p1 = p2; p2 = SWAP; } while (0)
#define ABS(p) (((p)<0) ? -(p) : (p))
void drawHLine(int y, int x1, int x2, uint8_t color) {
if(x1>x2) {
SWAP(x1, x2);
}
for (int i=x1; i<=x2; ++i) {
lcdSetPixel(i, y, color);
}
}
void drawVLine(int x, int y1, int y2, uint8_t color) {
if(y1>y2) {
SWAP(y1,y2);
}
for (int i=y1; i<=y2; ++i) {
lcdSetPixel(x, i, color);
}
}
void drawRectFill(int x, int y, int width, int heigth, uint8_t color) {
for (int i=y; i<y+heigth; ++i) {
drawHLine(i, x, x+width-1, color);
}
}
void drawLine(int x1, int y1, int x2, int y2, uint8_t color, int thickness) {
if(thickness<1) {
thickness = 1;
}
if(thickness>MAX_LINE_THICKNESS) {
thickness = MAX_LINE_THICKNESS;
}
bool xSwap = x1 > x2;
bool ySwap = y1 > y2;
if(x1==x2) {
if(ySwap) { SWAP(y1,y2); }
drawRectFill(x1-thickness/2, y1, thickness, y2-y1, color);
return;
}
if(y1==y2) {
if(xSwap) { SWAP(x1,x2); }
drawRectFill(x1, y1-thickness/2, x2-x1, thickness, color);
return;
}
if(xSwap){
x1 = -x1;
x2 = -x2;
}
if(ySwap){
y1 = -y1;
y2 = -y2;
}
bool mSwap = ABS(x2-x1) < ABS(y2-y1);
if(mSwap) {
SWAP(x1,y1);
SWAP(x2,y2);
}
int dx = x2-x1;
int dy = y2-y1;
int D = 2*dy - dx;
// lcdSetPixel(x1, y1, color);
int y = y1;
for(int x = x1; x <= x2; x++) {
int px = mSwap ? y : x;
if(xSwap) {
px = -px;
}
int py = mSwap ? x : y;
if(ySwap) {
py = -py;
}
lcdSetPixel(px, py, color);
if(D > 0) {
y++;
D += 2 * dy - 2 * dx;
} else {
D += 2 * dy;
}
for(int t=1; t<thickness; t++) {
int offset = ((t-1)/2+1)*(t%2*2-1);
int tx = px;
int ty = py;
if(mSwap) {
tx += offset;
} else {
ty += offset;
}
lcdSetPixel(tx, ty, color);
}
}
}

11
firmware/common/rad1o_draw.h Normal file
View File

@ -0,0 +1,11 @@
#ifndef F1RMWARE_DRAW_H
#define F1RMWARE_DRAW_H
void drawHLine(int y, int x1, int x2, uint8_t color);
void drawVLine(int x, int y1, int y2, uint8_t color);
void drawRectFill(int x, int y, int width, int heigth, uint8_t color);
void drawLine(int x1, int y1, int x2, int y2, uint8_t color, int thickness);
#endif //F1RMWARE_DRAW_H

38
firmware/common/rad1o_fonts.h Normal file
View File

@ -0,0 +1,38 @@
#ifndef __FONTS_H_
#define __FONTS_H_
#include <stdint.h>
/* Partially based on original code for the KS0108 by Stephane Rey */
/* Based on code code by Kevin Townsend */
typedef struct {
const uint8_t widthBits; // width, in bits (or pixels), of the character
} FONT_CHAR_INFO;
struct FONT_DEF {
uint8_t u8Width; /* Character width for storage */
uint8_t u8Height; /* Character height for storage */
uint8_t u8FirstChar; /* The first character available */
uint8_t u8LastChar; /* The last character available */
const uint8_t *au8FontTable; /* Font table start address in memory */
const FONT_CHAR_INFO *charInfo; /* Pointer to array of char information */
const uint16_t *charExtra; /* Pointer to array of extra char info */
};
struct EXTFONT {
char type; // 0: none, 1: static, 2: loaded
char name[13];
struct FONT_DEF def;
};
typedef const struct FONT_DEF * FONT;
#define FONT_DEFAULT 0
#define FONT_INTERNAL 1
#define FONT_EXTERNAL 2
extern const struct FONT_DEF * font;
extern struct EXTFONT efont;
#endif

63
firmware/common/rad1o_itoa.c Normal file
View File

@ -0,0 +1,63 @@
#include "rad1o_itoa.h"
/* flags:
F_ZEROS Print with leading zeros
F_LONG Print with leading spaces
F_SPLUS Prefix '+' on positive number
F_SSPACE Prefix ' ' on positive numbers
F_HEX Print as (fixed-width) hex number
*/
#define LEN 11 /* Maximum length we support */
const char* IntToStr(int num, unsigned int mxlen, char flag){
static char s[LEN+1];
unsigned int len;
s[LEN]=0;
char neg=0;
if(flag&F_HEX){
unsigned int hex=num;
for (len=(LEN-1);len>=(LEN-mxlen);len--){
s[len]=(hex%16)+'0';
if(s[len]>'9')
s[len]+='A'-'9'-1;
hex/=16;
};
len++;
}else{
if(num<0){
num=-num;
neg=1;
};
for (len=(LEN-1);len>=(LEN-mxlen);len--){
s[len]=(num%10)+'0';
num/=10;
};
len++;
if(!(flag&F_LONG)){
while(s[len]=='0' && len < (LEN-1))
len++;
}else if(!(flag&F_ZEROS)){
int x=len;
while(s[x]=='0' && x < (LEN-1)){
s[x]=' ';
x++;
};
}
if(neg==1){
len--;
s[len]='-';
}else if(flag&F_SPLUS){
len--;
s[len]='+';
}else if(flag&F_SSPACE){
len--;
s[len]=' ';
};
};
return &s[len];
}
#undef LEN

11
firmware/common/rad1o_itoa.h Normal file
View File

@ -0,0 +1,11 @@
#ifndef _ITOA_H
#define _ITOA_H 1
#define F_ZEROS (1<<0) // Print with leading zeros
#define F_LONG (1<<1) // Print with leading spaces
#define F_SPLUS (1<<2) // Prefix '+' on positive number
#define F_SSPACE (1<<3) // Prefix ' ' on positive numbers
#define F_HEX (1<<4) // Print as (fixed-width) hex number
const char* IntToStr(int num, unsigned int mxlen, char flag);
#endif /* _ITOA_H */

78
firmware/common/rad1o_print.c Normal file
View File

@ -0,0 +1,78 @@
#include "rad1o_print.h"
#include "rad1o_display.h"
#include "rad1o_render.h"
#include "rad1o_fonts.h"
#include "rad1o_smallfonts.h"
#include "rad1o_itoa.h"
int x=0;
int y=0;
static void checkScroll(void){
if(y+font->u8Height>RESY){
lcdShift(0,y+font->u8Height-RESY,false);
y=RESY-font->u8Height;
};
}
void lcdPrint(const char *string){
checkScroll();
x=DoString(x,y,string);
}
void lcdNl(void){
x=0;y+=font->u8Height;
}
void lcdCheckNl(void){
if(x>RESX)
lcdNl();
}
void lcdPrintln(const char *string){
lcdPrint(string);
lcdNl();
}
void lcdPrintInt(int number){
// On the ARM chips, int has 32 bits.
const char* string = IntToStr(number, 10, 0);
lcdPrint(string);
}
void lcdClear(){
x=0;y=0;
lcdFill(0xff);
}
void lcdMoveCrsr(signed int dx,signed int dy){
x+=dx;
y+=dy;
}
void lcdSetCrsr(int dx,int dy){
x=dx;
y=dy;
}
void lcdSetCrsrX(int dx){
x=dx;
}
int lcdGetCrsrX(){
return x;
}
int lcdGetCrsrY(){
return y;
}
void setSystemFont(void){
setIntFont(&Font_7x8);
}
int lcdGetVisibleLines(void){
return (RESY/getFontHeight()); // subtract title line
}

20
firmware/common/rad1o_print.h Normal file
View File

@ -0,0 +1,20 @@
#ifndef _PRINT_H
#define _PRINT_H 1
#include <stdint.h>
void lcdPrint(const char *string);
void lcdNl(void);
void lcdCheckNl(void);
void lcdPrintln(const char *string);
void lcdPrintInt(int number);
void lcdClear();
void lcdRefresh();
void lcdMoveCrsr(signed int dx,signed int dy);
void lcdSetCrsr(int dx,int dy);
void lcdSetCrsrX(int dx);
int lcdGetCrsrX();
int lcdGetCrsrY();
void setSystemFont(void);
int lcdGetVisibleLines(void);
#endif /* _PRINT_H */

622
firmware/common/rad1o_render.c Normal file
View File

@ -0,0 +1,622 @@
#include "rad1o_render.h"
#include "rad1o_decoder.h"
#include "rad1o_fonts.h"
#include "rad1o_smallfonts.h"
#include "rad1o_display.h"
#include <string.h>
#include <math.h>
void swap( int * a, int * b )
{
int x = *a;
*a = *b;
*b = x;
}
void swapd( float * a, float * b )
{
float x = *a;
*a = *b;
*b = x;
}
typedef struct
{
float x, y, z;
} Vector3D;
Vector3D addVec3D( Vector3D a, Vector3D b )
{
Vector3D v = {a.x+b.x, a.y+b.y, a.z+b.z};
return v;
}
Vector3D subVec3D( Vector3D a, Vector3D b )
{
Vector3D v = {a.x-b.x, a.y-b.y, a.z-b.z};
return v;
}
float lengthVec3D( Vector3D v )
{
return sqrt( v.x*v.x + v.y*v.y + v.z*v.z );
}
Vector3D roundVec3D( Vector3D v )
{
Vector3D r = { (int)(v.x + 0.5),
(int)(v.y + 0.5),
(int)(v.z + 0.5) };
return r;
}
Vector3D multMat3DVec3D( float* mat, Vector3D v )
{
Vector3D r = { mat[0] * v.x + mat[1] * v.y + mat[2] * v.z,
mat[3] * v.x + mat[4] * v.y + mat[5] * v.z,
mat[6] * v.x + mat[7] * v.y + mat[8] * v.z };
return r;
}
/* Global Variables */
const struct FONT_DEF * font = NULL;
struct EXTFONT efont;
uint8_t color_bg = 0xff; /* background color */
uint8_t color_fg = 0x00; /* foreground color */
/* Exported Functions */
void setTextColor(uint8_t bg, uint8_t fg){
color_bg = bg;
color_fg = fg;
}
void setIntFont(const struct FONT_DEF * newfont){
memcpy(&efont.def,newfont,sizeof(struct FONT_DEF));
efont.type=FONT_INTERNAL;
font=&efont.def;
}
void setExtFont(const char *fname){
#if 0
if(strlen(fname)>8+4)
return;
strcpy(efont.name,fname);
efont.type=FONT_EXTERNAL;
font=NULL;
UINT res;
res=f_open(&file, efont.name, FA_OPEN_EXISTING|FA_READ);
if(res!=FR_OK){
efont.type=0;
font=&Font_7x8;
}else{
_getFontData(START_FONT,0);
font=&efont.def;
};
#endif
}
int getFontHeight(void){
if(font)
return font->u8Height;
return 8; // XXX: Should be done right.
}
#if 0
static uint8_t read_byte (void)
{
UINT readbytes;
uint8_t byte;
UINT res;
res=f_read(&file, &byte, sizeof(uint8_t), &readbytes);
if(res!=FR_OK || readbytes!=1){
ASSERT(0) ;
};
return byte;
}
int _getFontData(int type, int offset){
UINT readbytes;
UINT res;
static uint16_t extras;
static uint16_t character;
// static const void * ptr;
if(efont.type == FONT_EXTERNAL){
if (type == START_FONT){
efont.def.u8Width = read_byte ();
efont.def.u8Height = read_byte ();
efont.def.u8FirstChar = read_byte ();
efont.def.u8LastChar = read_byte ();
res = f_read(&file, &extras, sizeof(uint16_t), &readbytes);
ASSERT(res==FR_OK);
return 0;
};
if (type == SEEK_EXTRAS){
f_lseek(&file,6);
return 0;
};
if(type == GET_EXTRAS){
uint16_t word;
res = f_read(&file, &word, sizeof(uint16_t), &readbytes);
ASSERT(res==FR_OK);
return word;
};
if (type == SEEK_WIDTH){
f_lseek(&file,6+(extras*sizeof(uint16_t)));
return 0;
};
if(type == GET_WIDTH || type == GET_DATA){
return read_byte ();
};
if(type == SEEK_DATA){
character=offset;
f_lseek(&file,6+
(extras*sizeof(uint16_t))+
((extras+font->u8LastChar-font->u8FirstChar)*sizeof(uint8_t))+
(offset*sizeof(uint8_t))
);
return 0;
};
if(type == PEEK_DATA){
uint8_t width;
width = read_byte ();
f_lseek(&file,6+
(extras*sizeof(uint16_t))+
((extras+font->u8LastChar-font->u8FirstChar)*sizeof(uint8_t))+
(character*sizeof(uint8_t))
);
return width;
};
#ifdef NOTYET
}else{ // efont.type==FONT_INTERNAL
if (type == START_FONT){
memcpy(&efont.def,font,sizeof(struct FONT_DEF));
return 0;
};
if (type == SEEK_EXTRAS){
ptr=efont.def.charExtra;
return 0;
};
if(type == GET_EXTRAS){
uint16_t word;
word=*(uint16_t*)ptr;
ptr=((uint16_t*)ptr)+1;
return word;
};
if (type == SEEK_WIDTH){
ptr=efont.def.charInfo;
return 0;
};
if(type == GET_WIDTH || type == GET_DATA){
uint8_t width;
width=*(uint8_t*)ptr;
ptr=((uint8_t*)ptr)+1;
return width;
};
if(type == SEEK_DATA){
if(offset==REPEAT_LAST_CHARACTER)
offset=character;
else
character=offset;
ptr=efont.def.au8FontTable;
return 0;
};
#endif
};
/* NOTREACHED */
return 0;
}
#endif
static int _getIndex(int c){
#define ERRCHR (font->u8FirstChar+1)
/* Does this font provide this character? */
if(c<font->u8FirstChar)
c=ERRCHR;
if(c>font->u8LastChar && efont.type!=FONT_EXTERNAL && font->charExtra == NULL)
c=ERRCHR;
if(c>font->u8LastChar && (efont.type==FONT_EXTERNAL || font->charExtra != NULL)){
if(efont.type==FONT_EXTERNAL){
#if 0
_getFontData(SEEK_EXTRAS,0);
int cc=0;
int cache;
while( (cache=_getFontData(GET_EXTRAS,0)) < c)
cc++;
if( cache > c)
c=ERRCHR;
else
c=font->u8LastChar+cc+1;
#endif
}else{
int cc=0;
while( font->charExtra[cc] < c)
cc++;
if(font->charExtra[cc] > c)
c=ERRCHR;
else
c=font->u8LastChar+cc+1;
};
};
c-=font->u8FirstChar;
return c;
}
uint8_t charBuf[MAXCHR];
int DoChar(int sx, int sy, int c){
if(font==NULL){
font=&Font_7x8;
};
/* how many bytes is it high? */
char height=(font->u8Height-1)/8+1;
char hoff=(8-(font->u8Height%8))%8;
const uint8_t * data;
int width,preblank=0,postblank=0;
do { /* Get Character data */
/* Get intex into character list */
c=_getIndex(c);
/* starting offset into character source data */
int toff=0;
if(font->u8Width==0){
if(efont.type == FONT_EXTERNAL){
#if 0
_getFontData(SEEK_WIDTH,0);
for(int y=0;y<c;y++)
toff+=_getFontData(GET_WIDTH,0);
width=_getFontData(GET_WIDTH,0);
_getFontData(SEEK_DATA,toff);
UINT res;
UINT readbytes;
UINT size = width * height;
if(size > MAXCHR) size = MAXCHR;
res = f_read(&file, charBuf, size, &readbytes);
if(res != FR_OK || readbytes<width*height)
return sx;
data=charBuf;
#endif
}else{
for(int y=0;y<c;y++)
toff+=font->charInfo[y].widthBits;
width=font->charInfo[c].widthBits;
toff*=height;
data=&font->au8FontTable[toff];
};
postblank=1;
}else if(font->u8Width==1){ // NEW CODE
if(efont.type == FONT_EXTERNAL){
#if 0
_getFontData(SEEK_WIDTH,0);
for(int y=0;y<c;y++)
toff+=_getFontData(GET_WIDTH,0);
width=_getFontData(GET_WIDTH,0);
_getFontData(SEEK_DATA,toff);
UINT res;
UINT readbytes;
uint8_t testbyte;
testbyte = read_byte ();
if(testbyte>>4 ==15){
preblank = read_byte ();
postblank = read_byte ();
width-=3;
width/=height;
UINT size = width * height;
if(size > MAXCHR) size = MAXCHR;
res = f_read(&file, charBuf, size, &readbytes);
if(res != FR_OK || readbytes<width*height)
return sx;
data=charBuf;
}else{
_getFontData(SEEK_DATA,toff);
data=pk_decode(NULL,&width); // Hackety-hack
};
#endif
}else{
// Find offset and length for our character
for(int y=0;y<c;y++)
toff+=font->charInfo[y].widthBits;
width=font->charInfo[c].widthBits;
if(font->au8FontTable[toff]>>4 == 15){ // It's a raw character!
preblank = font->au8FontTable[toff+1];
postblank= font->au8FontTable[toff+2];
data=&font->au8FontTable[toff+3];
width=(width-3/height);
}else{
data=pk_decode(&font->au8FontTable[toff],&width);
}
};
}else{
toff=(c)*font->u8Width*1;
width=font->u8Width;
data=&font->au8FontTable[toff];
};
}while(0);
#define xy_(x,y) ((x<0||y<0||x>=RESX||y>=RESY)?0:(y)*RESX+(x))
#define gPx(x,y) (data[x*height+(height-y/8-1)]&(1<<(y%8)))
int x=0;
/* Our display height is non-integer. Adjust for that. */
// sy+=RESY%8;
/* Fonts may not be byte-aligned, shift up so the top matches */
sy-=hoff;
sx+=preblank;
/* per line */
for(int y=hoff;y<height*8;y++){
if(sy+y>=RESY)
continue;
/* Optional: empty space to the left */
for(int b=1;b<=preblank;b++){
if(sx>=RESX)
continue;
lcdBuffer[xy_(sx-b,sy+y)]=color_bg;
};
/* Render character */
for(x=0;x<width;x++){
if(sx+x>=RESX)
continue;
if (gPx(x,y)){
lcdBuffer[xy_(sx+x,sy+y)]=color_fg;
}else{
lcdBuffer[xy_(sx+x,sy+y)]=color_bg;
};
};
/* Optional: empty space to the right */
for(int m=0;m<postblank;m++){
if(sx+x+m>=RESX)
continue;
lcdBuffer[xy_(sx+x+m,sy+y)]=color_bg;
};
};
return sx+(width+postblank);
}
#define UTF8
// decode 2 and 3-byte utf-8 strings.
#define UT2(a) ( ((a[0]&31)<<6) + (a[1]&63) )
#define UT3(a) ( ((a[0]&15)<<12) + ((a[1]&63)<<6) + (a[2]&63) )
int DoString(int sx, int sy, const char *s){
const char *c;
int uc;
for(c=s;*c!=0;c++){
#ifdef UTF8
/* will b0rk on non-utf8 */
if((*c&(128+64+32))==(128+64) && c[1]!=0){
uc=UT2(c); c+=1;
sx=DoChar(sx,sy,uc);
}else if( (*c&(128+64+32+16))==(128+64+32) && c[1]!=0 && c[2] !=0){
uc=UT3(c); c+=2;
sx=DoChar(sx,sy,uc);
}else
#endif
sx=DoChar(sx,sy,*c);
};
return sx;
}
void DoRect( int x, int y, int width, int height )
{
for(int py = y; py < y+height; ++py)
{
uint8_t * p = &lcdBuffer[py*RESX];
for(int px = x; px < x+width; ++px)
{
p[px] = color_fg;
}
}
}
int abs( int x )
{
return x < 0 ? -x : x;
}
void DoLine(int x1, int y1, int x2, int y2 )
{
if( (x1 < 0 && x2 < 0)
|| (y1 < 0 && y2 < 0)
|| (x1 >= RESX && x2 >= RESX )
|| (y1 >= RESY && y2 >= RESY )) return;
int dx = abs(x2-x1), sx = x1<x2 ? 1 : -1;
int dy = abs(y2-y1), sy = y1<y2 ? 1 : -1;
if(dx != 0)
{
float m = dy/(float)(dx*sx*sy);
float n = y1 - m*x1+0.5;
// y = mx+n
if( x1 < 0 )
{
x1 = 0; y1 = (int)(n);
}
else if( x1 >= RESX )
{
x1 = RESX - 1; y1 = (int)(x1*m + n);
}
if( x2 < 0 )
{
x2 = 0; y2 = (int)(n);
}
else if( x2 >= RESX)
{
x2 = RESX - 1; y2 = (int)(x2*m + n);
}
}
if(dy != 0)
{
float q = dx/(float)(dy*sx*sy);
float r = x1 - q*y1+0.5;
// x = qy+r
if( y1 < 0 )
{
y1 = 0; x1 = (int)(r);
}
else if( y1 >= RESY)
{
y1 = RESY - 1; x1 = (int)(y1*q + r);
}
if( y2 < 0 )
{
y2 = 0; x2 = (int)(r);
}
else if( y2 >= RESY)
{
y2 = RESY - 1; x2 = (int)(y2*q + r);
}
}
if(x1 < 0 || y1 < 0 || x2 < 0 || y2 < 0
|| x1 >= RESX || y1 >= RESY
|| x2 >= RESX || y2 >= RESY)
return;
if(y1>y2)
{
int xz = x1, yz = y1;
x1 = x2; y1 = y2;
x2 = xz; y2 = yz;
}
dx = abs(x2-x1); sx = x1<x2 ? 1 : -1;
dy = y1-y2; sy = y1<y2 ? 1 : -1;
int err = dx+dy, e2;
int* pxmin = x1<x2 ? &x1: &x2;
int* pxmax = x1>x2 ? &x1: &x2;
while(*pxmin < *pxmax || y1 < y2)
{
lcdBuffer[xy_(x1,y1)]=color_fg;
e2 = 2*err;
if (e2 > dy) { err += dy; x1 += sx; }
if (e2 < dx) { err += dx; y1 ++; }
}
}
void DoCube( int* p, int len, float* r )
{
int px = p[0];
int py = p[1];
int pz = p[2];
float rx = r[0];
float ry = r[1];
float rz = r[2];
float cx = cos(rx), sx = sin(rx);
float cy = cos(ry), sy = sin(ry);
float cz = cos(rz), sz = sin(rz);
float rotation[9] = { cy*cz, -cy*sz, sy,
cx*sz+cz*sx*sy, cx*cz-sx*sy*sz, -cy*sx,
sx*sz-cx*cz*sy, cz*sx+cx*sy*sz, cx*cy };
Vector3D xAxis = { len * 0.5, 0, 0 };
Vector3D yAxis = { 0, len * 0.5, 0 };
Vector3D zAxis = { 0, 0, len * 0.5 };
xAxis = multMat3DVec3D( rotation, xAxis );
yAxis = multMat3DVec3D( rotation, yAxis );
zAxis = multMat3DVec3D( rotation, zAxis );
Vector3D p000 = { px, py, pz };
Vector3D p100 = { px, py, pz };
Vector3D p010 = { px, py, pz };
Vector3D p110 = { px, py, pz };
Vector3D p001 = { px, py, pz };
Vector3D p101 = { px, py, pz };
Vector3D p011 = { px, py, pz };
Vector3D p111 = { px, py, pz };
p000 = roundVec3D( subVec3D( subVec3D( subVec3D( p000, xAxis ), yAxis ), zAxis ) );
p100 = roundVec3D( subVec3D( subVec3D( addVec3D( p100, xAxis ), yAxis ), zAxis ) );
p010 = roundVec3D( subVec3D( addVec3D( subVec3D( p010, xAxis ), yAxis ), zAxis ) );
p110 = roundVec3D( subVec3D( addVec3D( addVec3D( p110, xAxis ), yAxis ), zAxis ) );
p001 = roundVec3D( addVec3D( subVec3D( subVec3D( p001, xAxis ), yAxis ), zAxis ) );
p101 = roundVec3D( addVec3D( subVec3D( addVec3D( p101, xAxis ), yAxis ), zAxis ) );
p011 = roundVec3D( addVec3D( addVec3D( subVec3D( p011, xAxis ), yAxis ), zAxis ) );
p111 = roundVec3D( addVec3D( addVec3D( addVec3D( p111, xAxis ), yAxis ), zAxis ) );
// 010_________110
// /| /|
// / | / |
// 000/__+____/100|
// | | | |
// 011|____|___|111
// | / | /
// | / | /
// |/______|/
// 001 101
DoLine( p000.x, p000.y, p100.x, p100.y );
DoLine( p000.x, p000.y, p010.x, p010.y );
DoLine( p000.x, p000.y, p001.x, p001.y );
DoLine( p111.x, p111.y, p011.x, p011.y );
DoLine( p111.x, p111.y, p101.x, p101.y );
DoLine( p111.x, p111.y, p110.x, p110.y );
DoLine( p011.x, p011.y, p001.x, p001.y );
DoLine( p011.x, p011.y, p010.x, p010.y );
DoLine( p010.x, p010.y, p110.x, p110.y );
DoLine( p100.x, p100.y, p110.x, p110.y );
DoLine( p100.x, p100.y, p101.x, p101.y );
DoLine( p001.x, p001.y, p101.x, p101.y );
}
void DoMesh( float* verts, int numbVerts, int* faces, int numbfaces, float* rot, int* p, int scale )
{
float rx = rot[0];
float ry = rot[1];
float rz = rot[2];
float cx = cos(rx), sx = sin(rx);
float cy = cos(ry), sy = sin(ry);
float cz = cos(rz), sz = sin(rz);
float rotation[9] = { scale*cy*cz, scale*-cy*sz, -scale*sy,
scale*cx*sz+cz*sx*sy, scale*cx*cz-sx*sy*sz, -scale*-cy*sx,
scale*sx*sz-cx*cz*sy, scale*cz*sx+cx*sy*sz, -scale*cx*cy };
Vector3D transformed[numbVerts];
Vector3D* vertsVec = (Vector3D*)verts;
Vector3D pos = {p[0], p[1], p[2] };
for( int i = 0; i < numbVerts; ++i )
{
transformed[i] = roundVec3D( addVec3D( multMat3DVec3D( rotation, vertsVec[i]), pos ) );
}
for( int i = 0; i < numbfaces; ++i )
{
Vector3D v1 = transformed[ faces[i*3 + 0] ];
Vector3D v2 = transformed[ faces[i*3 + 1] ];
Vector3D v3 = transformed[ faces[i*3 + 2] ];
DoLine( v1.x, v1.y, v2.x, v2.y );
DoLine( v2.x, v2.y, v3.x, v3.y );
DoLine( v3.x, v3.y, v1.x, v1.y );
}
}

66
firmware/common/rad1o_render.h Normal file
View File

@ -0,0 +1,66 @@
#ifndef __RENDER_H_
#define __RENDER_H_
#include "rad1o_fonts.h"
// ARM supports byte flip natively. Yay!
#define flip(byte) \
__asm("rbit %[value], %[value];" \
"rev %[value], %[value];" \
: [value] "+r" (byte) : )
/* Alternatively you could use normal byte flipping:
#define flip(c) do {\
c = ((c>>1)&0x55)|((c<<1)&0xAA); \
c = ((c>>2)&0x33)|((c<<2)&0xCC); \
c = (c>>4) | (c<<4); \
}while(0)
*/
void setTextColor(uint8_t bg, uint8_t fg);
void setIntFont(const struct FONT_DEF * font);
void setExtFont(const char *file);
int getFontHeight(void);
int DoString(int sx, int sy, const char *s);
int DoChar(int sx, int sy, int c);
// print a rect starting at position (x,y) with size (width, height)
void DoRect( int x, int y, int width, int height );
// print a line starting at position (x1,y1) going to (x2,y2)
void DoLine(int x1, int y1, int x2, int y2 );
// print a 3D-Cube.
// p is a array with 3 elements (x,y,z) and sets the 3d position
// len is the cube edge length
// r is a array with 3 elements (angle around x-axis, angle around y-axis,
// angle around z-axis ) and sets the rotation of the cube
void DoCube(int* p, int len, float* r );
// prints a whole mesh on the screen
// verts is an array of size numbVerts*3 because we have for every vertex
// 3 axis-coordinates ( x,y,z )
// faces is an array of indices of size 3*numbFaces because
// it holds 3-tupels which describe triangles. The indices are the indices
// in the verts array.
// rot is the rotation like the cube has one
// p is a position of the mesh on the screen
// scale is a scaling factor for the whole mesh
void DoMesh( float* verts, int numbVerts, int* faces, int numbfaces, float* rot, int* p, int scale );
#define START_FONT 0
#define SEEK_EXTRAS 1
#define GET_EXTRAS 2
#define SEEK_WIDTH 3
#define GET_WIDTH 4
#define SEEK_DATA 5
#define GET_DATA 6
#define PEEK_DATA 7
int _getFontData(int type, int offset);
#define MAXCHR (30*20)
extern uint8_t charBuf[MAXCHR];
#endif

556
firmware/common/rad1o_smallfonts.c Normal file
View File

@ -0,0 +1,556 @@
/* Partially based on original code for the KS0108 by Stephane Rey */
/**************************************************************************/
/*!
@file smallfonts.c
@author K. Townsend (microBuilder.eu)
@date 22 March 2010
@version 0.10
@section LICENSE
Software License Agreement (BSD License)
Copyright (c) 2010, microBuilder SARL
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the copyright holders nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/**************************************************************************/
#include "rad1o_smallfonts.h"
/* System 3x6 - UPPER CASE ONLY */
const uint8_t au8Font3x6[]= {
0x00,0x00,0x00, /* Space */
0x00,0x5C,0x00, /* ! */
0x0C,0x00,0x0C, /* " */
0x7C,0x28,0x7C, /* # */
0x7C,0x44,0x7C, /* $ */
0x24,0x10,0x48, /* % */
0x28,0x54,0x08, /* & */
0x00,0x0C,0x00, /* ' */
0x38,0x44,0x00, /* ( */
0x44,0x38,0x00, /* ) */
0x20,0x10,0x08, /* / */
0x10,0x38,0x10, /* + */
0x80,0x40,0x00, /* , */
0x10,0x10,0x10, /* - */
0x00,0x40,0x00, /* . */
0x20,0x10,0x08, /* / */
0x38,0x44,0x38, /* 0 */
0x00,0x7C,0x00, /* 1 */
0x64,0x54,0x48, /* 2 */
0x44,0x54,0x28, /* 3 */
0x1C,0x10,0x7C, /* 4 */
0x4C,0x54,0x24, /* 5 */
0x38,0x54,0x20, /* 6 */
0x04,0x74,0x0C, /* 7 */
0x28,0x54,0x28, /* 8 */
0x08,0x54,0x38, /* 9 */
0x00,0x50,0x00, /* : */
0x80,0x50,0x00, /* ; */
0x10,0x28,0x44, /* < */
0x28,0x28,0x28, /* = */
0x44,0x28,0x10, /* > */
0x04,0x54,0x08, /* ? */
0x38,0x4C,0x5C, /* @ */
0x78,0x14,0x78, /* A */
0x7C,0x54,0x28, /* B */
0x38,0x44,0x44, /* C */
0x7C,0x44,0x38, /* D */
0x7C,0x54,0x44, /* E */
0x7C,0x14,0x04, /* F */
0x38,0x44,0x34, /* G */
0x7C,0x10,0x7C, /* H */
0x00,0x7C,0x00, /* I */
0x20,0x40,0x3C, /* J */
0x7C,0x10,0x6C, /* K */
0x7C,0x40,0x40, /* L */
0x7C,0x08,0x7C, /* M */
0x7C,0x04,0x7C, /* N */
0x7C,0x44,0x7C, /* O */
0x7C,0x14,0x08, /* P */
0x38,0x44,0x78, /* Q */
0x7C,0x14,0x68, /* R */
0x48,0x54,0x24, /* S */
0x04,0x7C,0x04, /* T */
0x7C,0x40,0x7C, /* U */
0x3C,0x40,0x3C, /* V */
0x7C,0x20,0x7C, /* W */
0x6C,0x10,0x6C, /* X */
0x1C,0x60,0x1C, /* Y */
0x64,0x54,0x4C, /* Z */
0x7C,0x44,0x00, /* [ */
0x08,0x10,0x20, /* \ */
0x44,0x7C,0x00, /* ] */
0x08,0x04,0x08, /* ^ */
0x80,0x80,0x80, /* _ */
0x04,0x08,0x00 /* ` */
};
/* System 5x8 */
const uint8_t au8Font5x8[]=
{
0x00,0x00,0x00,0x00,0x00, /* Space */
0x00,0x00,0x4f,0x00,0x00, /* ! */
0x00,0x07,0x00,0x07,0x00, /* " */
0x14,0x7f,0x14,0x7f,0x14, /* # */
0x24,0x2a,0x7f,0x2a,0x12, /* $ */
0x23,0x13,0x08,0x64,0x62, /* % */
0x36,0x49,0x55,0x22,0x20, /* & */
0x00,0x05,0x03,0x00,0x00, /* ' */
0x00,0x1c,0x22,0x41,0x00, /* ( */
0x00,0x41,0x22,0x1c,0x00, /* ) */
0x14,0x08,0x3e,0x08,0x14, /* / */
0x08,0x08,0x3e,0x08,0x08, /* + */
0x50,0x30,0x00,0x00,0x00, /* , */
0x08,0x08,0x08,0x08,0x08, /* - */
0x00,0x60,0x60,0x00,0x00, /* . */
0x20,0x10,0x08,0x04,0x02, /* / */
0x3e,0x51,0x49,0x45,0x3e, /* 0 */
0x00,0x42,0x7f,0x40,0x00, /* 1 */
0x42,0x61,0x51,0x49,0x46, /* 2 */
0x21,0x41,0x45,0x4b,0x31, /* 3 */
0x18,0x14,0x12,0x7f,0x10, /* 4 */
0x27,0x45,0x45,0x45,0x39, /* 5 */
0x3c,0x4a,0x49,0x49,0x30, /* 6 */
0x01,0x71,0x09,0x05,0x03, /* 7 */
0x36,0x49,0x49,0x49,0x36, /* 8 */
0x06,0x49,0x49,0x29,0x1e, /* 9 */
0x00,0x36,0x36,0x00,0x00, /* : */
0x00,0x56,0x36,0x00,0x00, /* ; */
0x08,0x14,0x22,0x41,0x00, /* < */
0x14,0x14,0x14,0x14,0x14, /* = */
0x00,0x41,0x22,0x14,0x08, /* > */
0x02,0x01,0x51,0x09,0x06, /* ? */
0x3e,0x41,0x5d,0x55,0x1e, /* @ */
0x7e,0x11,0x11,0x11,0x7e, /* A */
0x7f,0x49,0x49,0x49,0x36, /* B */
0x3e,0x41,0x41,0x41,0x22, /* C */
0x7f,0x41,0x41,0x22,0x1c, /* D */
0x7f,0x49,0x49,0x49,0x41, /* E */
0x7f,0x09,0x09,0x09,0x01, /* F */
0x3e,0x41,0x49,0x49,0x7a, /* G */
0x7f,0x08,0x08,0x08,0x7f, /* H */
0x00,0x41,0x7f,0x41,0x00, /* I */
0x20,0x40,0x41,0x3f,0x01, /* J */
0x7f,0x08,0x14,0x22,0x41, /* K */
0x7f,0x40,0x40,0x40,0x40, /* L */
0x7f,0x02,0x0c,0x02,0x7f, /* M */
0x7f,0x04,0x08,0x10,0x7f, /* N */
0x3e,0x41,0x41,0x41,0x3e, /* O */
0x7f,0x09,0x09,0x09,0x06, /* P */
0x3e,0x41,0x51,0x21,0x5e, /* Q */
0x7f,0x09,0x19,0x29,0x46, /* R */
0x26,0x49,0x49,0x49,0x32, /* S */
0x01,0x01,0x7f,0x01,0x01, /* T */
0x3f,0x40,0x40,0x40,0x3f, /* U */
0x1f,0x20,0x40,0x20,0x1f, /* V */
0x3f,0x40,0x38,0x40,0x3f, /* W */
0x63,0x14,0x08,0x14,0x63, /* X */
0x07,0x08,0x70,0x08,0x07, /* Y */
0x61,0x51,0x49,0x45,0x43, /* Z */
0x00,0x7f,0x41,0x41,0x00, /* [ */
0x02,0x04,0x08,0x10,0x20, /* \ */
0x00,0x41,0x41,0x7f,0x00, /* ] */
0x04,0x02,0x01,0x02,0x04, /* ^ */
0x40,0x40,0x40,0x40,0x40, /* _ */
0x00,0x00,0x03,0x05,0x00, /* ` */
0x20,0x54,0x54,0x54,0x78, /* a */
0x7F,0x44,0x44,0x44,0x38, /* b */
0x38,0x44,0x44,0x44,0x44, /* c */
0x38,0x44,0x44,0x44,0x7f, /* d */
0x38,0x54,0x54,0x54,0x18, /* e */
0x04,0x04,0x7e,0x05,0x05, /* f */
0x08,0x54,0x54,0x54,0x3c, /* g */
0x7f,0x08,0x04,0x04,0x78, /* h */
0x00,0x44,0x7d,0x40,0x00, /* i */
0x20,0x40,0x44,0x3d,0x00, /* j */
0x7f,0x10,0x28,0x44,0x00, /* k */
0x00,0x41,0x7f,0x40,0x00, /* l */
0x7c,0x04,0x7c,0x04,0x78, /* m */
0x7c,0x08,0x04,0x04,0x78, /* n */
0x38,0x44,0x44,0x44,0x38, /* o */
0x7c,0x14,0x14,0x14,0x08, /* p */
0x08,0x14,0x14,0x14,0x7c, /* q */
0x7c,0x08,0x04,0x04,0x00, /* r */
0x48,0x54,0x54,0x54,0x24, /* s */
0x04,0x04,0x3f,0x44,0x44, /* t */
0x3c,0x40,0x40,0x20,0x7c, /* u */
0x1c,0x20,0x40,0x20,0x1c, /* v */
0x3c,0x40,0x30,0x40,0x3c, /* w */
0x44,0x28,0x10,0x28,0x44, /* x */
0x0c,0x50,0x50,0x50,0x3c, /* y */
0x44,0x64,0x54,0x4c,0x44, /* z */
0x08,0x36,0x41,0x41,0x00, /* { */
0x00,0x00,0x77,0x00,0x00, /* | */
0x00,0x41,0x41,0x36,0x08, /* } */
0x08,0x08,0x2a,0x1c,0x08, /* <- */
0x08,0x1c,0x2a,0x08,0x08, /* -> */
0xff,0xff,0xff,0xff,0xff, /* ^? */
};
/* System 7x8 */
const uint8_t au8Font7x8[]=
{
0, 0, 0, 0, 0, 0, 0, //' '
0, 6, 95, 95, 6, 0, 0, //'!'
0, 7, 7, 0, 7, 7, 0, //'"'
20, 127, 127, 20, 127, 127, 20, //'#'
36, 46, 107, 107, 58, 18, 0, //'$'
70, 102, 48, 24, 12, 102, 98, //'%'
48, 122, 79, 93, 55, 122, 72, //'&'
4, 7, 3, 0, 0, 0, 0, //'''
0, 28, 62, 99, 65, 0, 0, //'('
0, 65, 99, 62, 28, 0, 0, //')'
8, 42, 62, 28, 28, 62, 42, //'*'
8, 8, 62, 62, 8, 8, 0, //'+'
0, 128, 224, 96, 0, 0, 0, //','
8, 8, 8, 8, 8, 8, 0, //'-'
0, 0, 96, 96, 0, 0, 0, //'.'
96, 48, 24, 12, 6, 3, 1, //'/'
62, 127, 113, 89, 77, 127, 62, //'0'
64, 66, 127, 127, 64, 64, 0, //'1'
98, 115, 89, 73, 111, 102, 0, //'2'
34, 99, 73, 73, 127, 54, 0, //'3'
24, 28, 22, 83, 127, 127, 80, //'4'
39, 103, 69, 69, 125, 57, 0, //'5'
60, 126, 75, 73, 121, 48, 0, //'6'
3, 3, 113, 121, 15, 7, 0, //'7'
54, 127, 73, 73, 127, 54, 0, //'8'
6, 79, 73, 105, 63, 30, 0, //'9'
0, 0, 102, 102, 0, 0, 0, //':'
0, 128, 230, 102, 0, 0, 0, //';'
8, 28, 54, 99, 65, 0, 0, //'<'
36, 36, 36, 36, 36, 36, 0, //'='
0, 65, 99, 54, 28, 8, 0, //'>'
2, 3, 81, 89, 15, 6, 0, //'?'
62, 127, 65, 93, 93, 31, 30, //'@'
124,126, 19, 19, 126, 124, 0, //'A'
65, 127, 127, 73, 73, 127, 54, //'B'
28, 62, 99, 65, 65, 99, 34, //'C'
65, 127, 127, 65, 99, 62, 28, //'D'
65, 127, 127, 73, 93, 65, 99, //'E'
65, 127, 127, 73, 29, 1, 3, //'F'
28, 62, 99, 65, 81, 115, 114, //'G'
127,127, 8, 8, 127, 127, 0, //'H'
0, 65, 127, 127, 65, 0, 0, //'I'
48, 112, 64, 65, 127, 63, 1, //'J'
65, 127, 127, 8, 28, 119, 99, //'K'
65, 127, 127, 65, 64, 96, 112, //'L'
127,127, 14, 28, 14, 127, 127, //'M'
127,127, 6, 12, 24, 127, 127, //'N'
28, 62, 99, 65, 99, 62, 28, //'O'
65, 127, 127, 73, 9, 15, 6, //'P'
30, 63, 33, 113, 127, 94, 0, //'Q'
65, 127, 127, 9, 25, 127, 102, //'R'
38, 111, 77, 89, 115, 50, 0, //'S'
3, 65, 127, 127, 65, 3, 0, //'T'
127,127, 64, 64, 127, 127, 0, //'U'
31, 63, 96, 96, 63, 31, 0, //'V'
127,127, 48, 24, 48, 127, 127, //'W'
67, 103, 60, 24, 60, 103, 67, //'X'
7, 79, 120, 120, 79, 7, 0, //'Y'
71, 99, 113, 89, 77, 103, 115, //'Z'
0, 127, 127, 65, 65, 0, 0, //'['
1, 3, 6, 12, 24, 48, 96, //'\'
0, 65, 65, 127, 127, 0, 0, //']'
8, 12, 6, 3, 6, 12, 8, //'^'
128,128, 128, 128, 128, 128, 128, //'_'
0, 0, 3, 7, 4, 0, 0, //'`'
32, 116, 84, 84, 60, 120, 64, //'a'
65, 127, 63, 72, 72, 120, 48, //'b'
56, 124, 68, 68, 108, 40, 0, //'c'
48, 120, 72, 73, 63, 127, 64, //'d'
56, 124, 84, 84, 92, 24, 0, //'e'
72, 126, 127, 73, 3, 2, 0, //'f'
56, 188, 164, 164, 252, 120, 0, //'g'
65, 127, 127, 8, 4, 124, 120, //'h'
0, 68, 125, 125, 64, 0, 0, //'i'
96, 224, 128, 128, 253, 125, 0, //'j'
65, 127, 127, 16, 56, 108, 68, //'k'
0, 65, 127, 127, 64, 0, 0, //'l'
120,124, 28, 56, 28, 124, 120, //'m'
124,124, 4, 4, 124, 120, 0, //'n'
56, 124, 68, 68, 124, 56, 0, //'o'
0, 252, 252, 164, 36, 60, 24, //'p'
24, 60, 36, 164, 248, 252, 132, //'q'
68, 124, 120, 76, 4, 28, 24, //'r'
72, 92, 84, 84, 116, 36, 0, //'s'
0, 4, 62, 127, 68, 36, 0, //'t'
60, 124, 64, 64, 60, 124, 64, //'u'
28, 60, 96, 96, 60, 28, 0, //'v'
60, 124, 112, 56, 112, 124, 60, //'w'
68, 108, 56, 16, 56, 108, 68, //'x'
60, 188, 160, 160, 252, 124, 0, //'y'
76, 100, 116, 92, 76, 100, 0, //'z'
8, 8, 62, 119, 65, 65, 0, //'{'
0, 0, 0, 119, 119, 0, 0, //'|'
65, 65, 119, 62, 8, 8, 0, //'}'
2, 3, 1, 3, 2, 3, 1, //'~'
255,129, 129, 129, 129, 129, 255, //'^?'
14, 159, 145, 177, 251, 74, 0 //'?'
};
/* 8x8 Normal */
const uint8_t au8Font8x8[]= {
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // ASCII - 32
0x00,0x00,0x00,0x5F,0x5F,0x00,0x00,0x00, // ASCII - 33
0x00,0x00,0x03,0x07,0x00,0x07,0x03,0x00, // ASCII - 34
0x00,0x10,0x74,0x1C,0x77,0x1C,0x17,0x04, // ASCII - 35
0x00,0x24,0x2E,0x2A,0x7F,0x2A,0x3A,0x10, // ASCII - 36
0x00,0x4C,0x6A,0x76,0x1A,0x6A,0x56,0x33, // ASCII - 37
0x00,0x30,0x7A,0x4F,0x5D,0x37,0x7A,0x48, // ASCII - 38
0x00,0x00,0x04,0x07,0x03,0x00,0x00,0x00, // ASCII - 39
0x00,0x00,0x00,0x1C,0x3E,0x63,0x41,0x00, // ASCII - 40
0x00,0x00,0x41,0x63,0x3E,0x1C,0x00,0x00, // ASCII - 41
0x00,0x08,0x2A,0x3E,0x1C,0x3E,0x2A,0x08, // ASCII - 42
0x00,0x08,0x08,0x3E,0x3E,0x08,0x08,0x00, // ASCII - 43
0x00,0x00,0x00,0x60,0x60,0x00,0x00,0x00, // ASCII - 44
0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, // ASCII - 45
0x00,0x00,0x00,0x60,0x60,0x00,0x00,0x00, // ASCII - 46
0x00,0x60,0x30,0x18,0x0C,0x06,0x03,0x01, // ASCII - 47
0x00,0x1C,0x3E,0x61,0x43,0x3E,0x1C,0x00, // ASCII - 48
0x00,0x00,0x44,0x7F,0x7F,0x40,0x00,0x00, // ASCII - 49
0x00,0x46,0x67,0x71,0x59,0x4F,0x66,0x00, // ASCII - 50
0x00,0x22,0x63,0x49,0x4D,0x7F,0x32,0x00, // ASCII - 51
0x00,0x18,0x1C,0x52,0x7F,0x7F,0x50,0x00, // ASCII - 52
0x00,0x2F,0x6F,0x45,0x45,0x7D,0x39,0x00, // ASCII - 53
0x00,0x3C,0x7E,0x4B,0x49,0x79,0x30,0x00, // ASCII - 54
0x00,0x07,0x43,0x71,0x7D,0x0F,0x03,0x00, // ASCII - 55
0x00,0x36,0x7F,0x4D,0x59,0x7F,0x36,0x00, // ASCII - 56
0x00,0x06,0x4F,0x49,0x69,0x3F,0x1E,0x00, // ASCII - 57
0x00,0x00,0x00,0x66,0x66,0x00,0x00,0x00, // ASCII - 58
0x00,0x00,0x00,0x66,0x66,0x00,0x00,0x00, // ASCII - 59
0x00,0x00,0x08,0x1C,0x36,0x63,0x41,0x00, // ASCII - 60
0x00,0x14,0x14,0x14,0x14,0x14,0x14,0x00, // ASCII - 61
0x00,0x00,0x41,0x63,0x36,0x1C,0x08,0x00, // ASCII - 62
0x00,0x02,0x07,0x51,0x59,0x0F,0x06,0x00, // ASCII - 63
0x00,0x3E,0x41,0x5D,0x55,0x5D,0x51,0x1E, // ASCII - 64
0x00,0x40,0x70,0x1D,0x17,0x1F,0x78,0x60, // ASCII - 65
0x00,0x41,0x7F,0x7F,0x49,0x4F,0x7E,0x30, // ASCII - 66
0x00,0x1C,0x3E,0x63,0x41,0x41,0x42,0x27, // ASCII - 67
0x00,0x41,0x7F,0x7F,0x41,0x63,0x3E,0x1C, // ASCII - 68
0x00,0x41,0x7F,0x7F,0x49,0x5D,0x41,0x63, // ASCII - 69
0x00,0x41,0x7F,0x7F,0x49,0x1D,0x01,0x03, // ASCII - 70
0x00,0x1C,0x3E,0x63,0x41,0x51,0x72,0x77, // ASCII - 71
0x00,0x7F,0x7F,0x08,0x08,0x7F,0x7F,0x00, // ASCII - 72
0x00,0x00,0x41,0x7F,0x7F,0x41,0x00,0x00, // ASCII - 73
0x00,0x30,0x70,0x41,0x41,0x7F,0x3F,0x01, // ASCII - 74
0x00,0x7F,0x7F,0x08,0x1C,0x77,0x63,0x41, // ASCII - 75
0x00,0x41,0x7F,0x7F,0x41,0x40,0x60,0x70, // ASCII - 76
0x00,0x7F,0x7E,0x0C,0x18,0x0C,0x7E,0x7F, // ASCII - 77
0x00,0x7F,0x7E,0x0C,0x18,0x30,0x7F,0x7F, // ASCII - 78
0x00,0x1C,0x3E,0x63,0x41,0x63,0x3E,0x1C, // ASCII - 79
0x00,0x41,0x7F,0x7F,0x49,0x09,0x0F,0x06, // ASCII - 80
0x00,0x1C,0x3E,0x63,0x51,0x63,0x3E,0x1C, // ASCII - 81
0x00,0x7F,0x7F,0x09,0x19,0x7F,0x66,0x40, // ASCII - 82
0x00,0x66,0x6F,0x4D,0x59,0x7B,0x33,0x00, // ASCII - 83
0x00,0x03,0x41,0x7F,0x7F,0x41,0x03,0x00, // ASCII - 84
0x00,0x3F,0x7F,0x40,0x40,0x40,0x7F,0x3F, // ASCII - 85
0x00,0x03,0x0F,0x3D,0x70,0x1D,0x07,0x01, // ASCII - 86
0x00,0x0F,0x7F,0x30,0x1C,0x30,0x7F,0x0F, // ASCII - 87
0x00,0x63,0x77,0x1C,0x1C,0x77,0x63,0x00, // ASCII - 88
0x01,0x03,0x47,0x7C,0x78,0x47,0x03,0x01, // ASCII - 89
0x00,0x67,0x73,0x59,0x4D,0x67,0x73,0x00, // ASCII - 90
0x00,0x00,0x00,0x7F,0x7F,0x41,0x41,0x00, // ASCII - 91
0x00,0x01,0x03,0x06,0x0C,0x18,0x30,0x60, // ASCII - 92
0x00,0x00,0x41,0x41,0x7F,0x7F,0x00,0x00, // ASCII - 93
0x00,0x00,0x04,0x06,0x03,0x06,0x04,0x00, // ASCII - 94
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // ASCII - 95
0x00,0x00,0x01,0x03,0x06,0x04,0x00,0x00, // ASCII - 96
0x00,0x68,0x6C,0x54,0x54,0x3C,0x78,0x40, // ASCII - 97
0x00,0x41,0x7F,0x3F,0x6C,0x44,0x7C,0x38, // ASCII - 98
0x00,0x38,0x7C,0x44,0x44,0x6C,0x2C,0x00, // ASCII - 99
0x00,0x38,0x7C,0x44,0x49,0x3F,0x7F,0x40, // ASCII - 100
0x00,0x38,0x7C,0x54,0x54,0x5C,0x58,0x00, // ASCII - 101
0x00,0x00,0x48,0x7E,0x7F,0x49,0x0B,0x02, // ASCII - 102
0x00,0x48,0x7C,0x34,0x34,0x2C,0x68,0x44, // ASCII - 103
0x00,0x41,0x7F,0x7F,0x08,0x04,0x7C,0x78, // ASCII - 104
0x00,0x00,0x44,0x7D,0x7D,0x40,0x00,0x00, // ASCII - 105
0x00,0x60,0x60,0x04,0x7D,0x7D,0x00,0x00, // ASCII - 106
0x00,0x41,0x7F,0x7F,0x10,0x78,0x6C,0x44, // ASCII - 107
0x00,0x00,0x41,0x7F,0x7F,0x40,0x00,0x00, // ASCII - 108
0x00,0x7C,0x7C,0x0C,0x78,0x0C,0x7C,0x78, // ASCII - 109
0x00,0x44,0x7C,0x7C,0x08,0x04,0x7C,0x78, // ASCII - 110
0x00,0x38,0x7C,0x44,0x44,0x7C,0x38,0x00, // ASCII - 111
0x00,0x04,0x7C,0x78,0x24,0x24,0x3C,0x18, // ASCII - 112
0x00,0x18,0x3C,0x24,0x24,0x78,0x7C,0x00, // ASCII - 113
0x00,0x44,0x7C,0x78,0x4C,0x04,0x1C,0x18, // ASCII - 114
0x00,0x48,0x5C,0x5C,0x74,0x74,0x24,0x00, // ASCII - 115
0x00,0x00,0x04,0x3E,0x7F,0x44,0x24,0x00, // ASCII - 116
0x00,0x3C,0x7C,0x40,0x40,0x3C,0x7C,0x40, // ASCII - 117
0x00,0x04,0x1C,0x3C,0x60,0x30,0x1C,0x04, // ASCII - 118
0x00,0x1C,0x7C,0x30,0x1C,0x30,0x7C,0x1C, // ASCII - 119
0x00,0x44,0x6C,0x3C,0x10,0x78,0x6C,0x44, // ASCII - 120
0x00,0x44,0x4C,0x1C,0x70,0x64,0x1C,0x0C, // ASCII - 121
0x00,0x4C,0x64,0x74,0x5C,0x4C,0x64,0x00, // ASCII - 122
0x00,0x08,0x08,0x3E,0x77,0x41,0x41,0x00, // ASCII - 123
0x00,0x00,0x00,0x7F,0x7F,0x00,0x00,0x00, // ASCII - 124
0x00,0x41,0x41,0x77,0x3E,0x08,0x08,0x00, // ASCII - 125
0x00,0x02,0x01,0x01,0x03,0x02,0x02,0x01, // ASCII - 126
0x00,0x60,0x78,0x4E,0x47,0x5E,0x78,0x60, // ASCII - 127
0x00,0x1C,0x3E,0x23,0x41,0x41,0x42,0x27, // ASCII - 128
0x00,0x3D,0x7D,0x40,0x41,0x3D,0x7C,0x40, // ASCII - 129
};
/* 8x8 Thin */
const uint8_t au8Font8x8Thin[]= {
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x5F,0x00,0x00,0x00,0x00,
0x00,0x00,0x07,0x00,0x00,0x07,0x00,0x00,
0x00,0x14,0x7F,0x14,0x14,0x7F,0x14,0x00,
0x00,0x24,0x2A,0x6B,0x6B,0x2A,0x12,0x00,
0x00,0x46,0x26,0x10,0x08,0x64,0x62,0x00,
0x30,0x4A,0x45,0x4D,0x32,0x48,0x48,0x00,
0x00,0x00,0x04,0x03,0x00,0x00,0x00,0x00,
0x00,0x1C,0x22,0x41,0x00,0x00,0x00,0x00,
0x00,0x00,0x41,0x22,0x1C,0x00,0x00,0x00,
0x08,0x2A,0x1C,0x1C,0x1C,0x2A,0x08,0x00,
0x00,0x08,0x08,0x3E,0x08,0x08,0x00,0x00,
0x00,0x00,0x80,0x60,0x00,0x00,0x00,0x00,
0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00,
0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x00,
0x00,0x40,0x20,0x10,0x08,0x04,0x02,0x00,
0x00,0x3E,0x61,0x51,0x49,0x45,0x3E,0x00,
0x00,0x44,0x42,0x7F,0x40,0x40,0x00,0x00,
0x00,0x62,0x51,0x51,0x49,0x49,0x66,0x00,
0x00,0x22,0x41,0x49,0x49,0x49,0x36,0x00,
0x10,0x18,0x14,0x52,0x7F,0x50,0x10,0x00,
0x00,0x27,0x45,0x45,0x45,0x45,0x39,0x00,
0x00,0x3C,0x4A,0x49,0x49,0x49,0x30,0x00,
0x00,0x03,0x01,0x71,0x09,0x05,0x03,0x00,
0x00,0x36,0x49,0x49,0x49,0x49,0x36,0x00,
0x00,0x06,0x49,0x49,0x49,0x29,0x1E,0x00,
0x00,0x00,0x00,0x66,0x00,0x00,0x00,0x00,
0x00,0x00,0x80,0x66,0x00,0x00,0x00,0x00,
0x00,0x08,0x14,0x22,0x41,0x00,0x00,0x00,
0x00,0x24,0x24,0x24,0x24,0x24,0x24,0x00,
0x00,0x00,0x00,0x41,0x22,0x14,0x08,0x00,
0x00,0x02,0x01,0x01,0x51,0x09,0x06,0x00,
0x00,0x3E,0x41,0x5D,0x55,0x55,0x1E,0x00,
0x00,0x7C,0x12,0x11,0x11,0x12,0x7C,0x00,
0x00,0x41,0x7F,0x49,0x49,0x49,0x36,0x00,
0x00,0x1C,0x22,0x41,0x41,0x41,0x22,0x00,
0x00,0x41,0x7F,0x41,0x41,0x22,0x1C,0x00,
0x00,0x41,0x7F,0x49,0x5D,0x41,0x63,0x00,
0x00,0x41,0x7F,0x49,0x1D,0x01,0x03,0x00,
0x00,0x1C,0x22,0x41,0x51,0x51,0x72,0x00,
0x00,0x7F,0x08,0x08,0x08,0x08,0x7F,0x00,
0x00,0x00,0x41,0x7F,0x41,0x00,0x00,0x00,
0x00,0x30,0x40,0x40,0x41,0x3F,0x01,0x00,
0x00,0x41,0x7F,0x08,0x14,0x22,0x41,0x40,
0x00,0x41,0x7F,0x41,0x40,0x40,0x60,0x00,
0x00,0x7F,0x01,0x02,0x04,0x02,0x01,0x7F,
0x00,0x7F,0x01,0x02,0x04,0x08,0x7F,0x00,
0x00,0x3E,0x41,0x41,0x41,0x41,0x3E,0x00,
0x00,0x41,0x7F,0x49,0x09,0x09,0x06,0x00,
0x00,0x1E,0x21,0x21,0x31,0x21,0x5E,0x40,
0x00,0x41,0x7F,0x49,0x19,0x29,0x46,0x00,
0x00,0x26,0x49,0x49,0x49,0x49,0x32,0x00,
0x00,0x03,0x01,0x41,0x7F,0x41,0x01,0x03,
0x00,0x3F,0x40,0x40,0x40,0x40,0x3F,0x00,
0x00,0x0F,0x10,0x20,0x40,0x20,0x10,0x0F,
0x00,0x3F,0x40,0x40,0x38,0x40,0x40,0x3F,
0x00,0x41,0x22,0x14,0x08,0x14,0x22,0x41,
0x00,0x01,0x02,0x44,0x78,0x44,0x02,0x01,
0x00,0x43,0x61,0x51,0x49,0x45,0x43,0x61,
0x00,0x7F,0x41,0x41,0x41,0x00,0x00,0x00,
0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x00,
0x00,0x41,0x41,0x41,0x7F,0x00,0x00,0x00,
0x08,0x04,0x02,0x01,0x02,0x04,0x08,0x00,
0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
0x00,0x00,0x00,0x03,0x04,0x00,0x00,0x00,
0x00,0x20,0x54,0x54,0x54,0x54,0x78,0x40,
0x00,0x01,0x7F,0x30,0x48,0x48,0x48,0x30,
0x00,0x38,0x44,0x44,0x44,0x44,0x28,0x00,
0x00,0x30,0x48,0x48,0x48,0x31,0x7F,0x40,
0x00,0x38,0x54,0x54,0x54,0x54,0x18,0x00,
0x00,0x00,0x48,0x7E,0x49,0x01,0x02,0x00,
0x00,0x98,0xA4,0xA4,0xA4,0xA4,0x78,0x04,
0x00,0x41,0x7F,0x08,0x04,0x04,0x78,0x00,
0x00,0x00,0x44,0x7D,0x40,0x00,0x00,0x00,
0x00,0x60,0x80,0x80,0x80,0x84,0x7D,0x00,
0x00,0x01,0x7F,0x10,0x28,0x44,0x40,0x00,
0x00,0x00,0x41,0x7F,0x40,0x00,0x00,0x00,
0x00,0x7C,0x04,0x04,0x78,0x04,0x04,0x78,
0x00,0x7C,0x08,0x04,0x04,0x04,0x78,0x00,
0x00,0x38,0x44,0x44,0x44,0x44,0x38,0x00,
0x00,0x84,0xFC,0x98,0x24,0x24,0x18,0x00,
0x00,0x18,0x24,0x24,0x98,0xFC,0x84,0x00,
0x00,0x44,0x7C,0x48,0x04,0x04,0x18,0x00,
0x00,0x48,0x54,0x54,0x54,0x54,0x24,0x00,
0x00,0x04,0x04,0x3F,0x44,0x44,0x20,0x00,
0x00,0x3C,0x40,0x40,0x40,0x20,0x7C,0x00,
0x00,0x0C,0x10,0x20,0x40,0x20,0x10,0x0C,
0x00,0x3C,0x40,0x40,0x38,0x40,0x40,0x3C,
0x00,0x44,0x28,0x10,0x28,0x44,0x00,0x00,
0x00,0x9C,0xA0,0xA0,0xA0,0xA0,0x7C,0x00,
0x00,0x44,0x64,0x54,0x4C,0x44,0x00,0x00,
0x00,0x08,0x08,0x36,0x41,0x41,0x00,0x00,
0x00,0x00,0x00,0x77,0x00,0x00,0x00,0x00,
0x00,0x00,0x41,0x41,0x36,0x08,0x08,0x00,
0x00,0x02,0x01,0x01,0x02,0x02,0x01,0x00,
0x00,0x70,0x48,0x44,0x42,0x44,0x48,0x70,
0x00,0x0E,0x91,0x91,0xB1,0xB1,0x4A,0x00,
0x00,0x3A,0x40,0x40,0x40,0x7A,0x40,0x00,
0x00,0x38,0x54,0x54,0x55,0x55,0x18,0x00,
0x00,0x22,0x55,0x55,0x55,0x79,0x42,0x00,
0x00,0x21,0x54,0x54,0x54,0x78,0x41,0x00,
0x00,0x20,0x55,0x55,0x54,0x78,0x40,0x00,
0x00,0x20,0x54,0x55,0x54,0x78,0x40,0x00,
0x00,0x18,0x24,0xA4,0xA4,0xE4,0x40,0x00,
0x00,0x3A,0x55,0x55,0x55,0x55,0x1A,0x00,
0x00,0x39,0x54,0x54,0x54,0x54,0x19,0x00,
0x00,0x38,0x55,0x55,0x54,0x54,0x18,0x00,
0x00,0x00,0x01,0x44,0x7C,0x41,0x00,0x00,
0x02,0x01,0x45,0x7D,0x41,0x01,0x02,0x00,
0x00,0x00,0x01,0x45,0x7C,0x40,0x00,0x00,
0x00,0x79,0x14,0x12,0x12,0x14,0x79,0x00,
0x00,0x70,0x28,0x2B,0x2B,0x28,0x70,0x00,
0x00,0x44,0x7C,0x54,0x55,0x45,0x00,0x00,
0x00,0x20,0x54,0x54,0x58,0x38,0x54,0x54,
0x00,0x7C,0x0A,0x09,0x09,0x7F,0x49,0x49,
0x00,0x30,0x4A,0x49,0x49,0x4A,0x30,0x00,
0x00,0x32,0x48,0x48,0x48,0x48,0x32,0x00,
0x00,0x30,0x49,0x4A,0x48,0x48,0x30,0x00,
0x00,0x38,0x42,0x41,0x41,0x42,0x38,0x00,
0x00,0x38,0x41,0x42,0x40,0x40,0x38,0x00,
0x00,0x1A,0xA0,0xA0,0xA0,0xA0,0x7A,0x00,
0x00,0x19,0x24,0x42,0x42,0x24,0x19,0x00,
0x00,0x3D,0x40,0x40,0x40,0x40,0x3D,0x00,
0x00,0x18,0x24,0x24,0xE7,0x24,0x24,0x00,
0x00,0x68,0x5E,0x49,0x41,0x42,0x20,0x00,
0x00,0x15,0x16,0x7C,0x16,0x15,0x00,0x00,
0x81,0xFF,0x85,0x05,0x17,0xFA,0x90,0x50,
0x40,0x88,0x88,0x7F,0x09,0x09,0x02,0x00,
0x00,0x20,0x54,0x54,0x55,0x79,0x40,0x00,
};
/* Global variables */
const struct FONT_DEF Font_3x6 = {3, 6, 32, 96, au8Font3x6, NULL,NULL};
const struct FONT_DEF Font_5x8 = {5, 8, 32, 128, au8Font5x8, NULL,NULL};
const struct FONT_DEF Font_7x8 = {7, 8, 32, 128, au8Font7x8, NULL,NULL};
const struct FONT_DEF Font_8x8 = {8, 8, 32, 128, au8Font8x8, NULL,NULL};
const struct FONT_DEF Font_8x8Thin = {8, 8, 32, 128, au8Font8x8Thin,NULL,NULL};

55
firmware/common/rad1o_smallfonts.h Normal file
View File

@ -0,0 +1,55 @@
/**************************************************************************/
/*!
@file smallfonts.h
@author K. Townsend (microBuilder.eu)
@date 22 March 2010
@version 0.10
@section LICENSE
Software License Agreement (BSD License)
Copyright (c) 2010, microBuilder SARL
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the copyright holders nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/**************************************************************************/
#ifndef __SMALLFONTS_H_
#define __SMALLFONTS_H_
#include "rad1o_fonts.h"
#include <stdint.h>
#include <stddef.h>
/* Partially based on original code for the KS0108 by Stephane Rey */
/* Current version by Kevin Townsend */
extern const struct FONT_DEF Font_3x6;
extern const struct FONT_DEF Font_5x8;
extern const struct FONT_DEF Font_7x8;
extern const struct FONT_DEF Font_8x8;
extern const struct FONT_DEF Font_8x8Thin;
#endif

1722
firmware/common/rad1o_ubuntu18.c Normal file
View File

File diff suppressed because it is too large Load Diff

3
firmware/common/rad1o_ubuntu18.h Normal file
View File

@ -0,0 +1,3 @@
#include "rad1o_fonts.h"
extern const struct FONT_DEF Font_Ubuntu18pt;

205
firmware/common/ui_rad1o.c
View File

@ -19,8 +19,17 @@
* Boston, MA 02110-1301, USA.
*/
#include "rad1o_display.h"
#include "rad1o_print.h"
#include "rad1o_draw.h"
#include "rad1o_render.h"
#include "rad1o_smallfonts.h"
#include "rad1o_ubuntu18.h"
#include "ui_rad1o.h"
#include <stdio.h>
/* Weak functions from rad1o app */
void hackrf_ui_init(void) __attribute__((weak));
void hackrf_ui_setFrequency(uint64_t _freq) __attribute__((weak));
@ -36,44 +45,214 @@ void hackrf_ui_setFilter(const rf_path_filter_t filter) __attribute__((weak));
void hackrf_ui_setAntennaBias(bool antenna_bias) __attribute__((weak));
void hackrf_ui_setClockSource(clock_source_t source) __attribute__((weak));
uint64_t freq = 0;
uint32_t sample_rate = 0;
uint32_t filter_bw = 0;
rf_path_direction_t direction;
uint32_t bblna_gain = 0;
uint32_t bbvga_gain = 0;
uint32_t bbtxvga_gain = 0;
bool lna_on = false;
bool enabled = false;
#define BLACK 0b00000000
#define RED 0b11100000
#define RED_DARK 0b01100000
#define GREEN 0b00011100
#define GREEN_DARK 0b00001100
#define BLUE 0b00000011
#define WHITE 0b11111111
#define GREY 0b01001101
void draw_frequency(void)
{
char tmp[100];
uint32_t mhz;
uint32_t khz;
mhz = freq/1e6;
khz = (freq - mhz * 1e6) / 1000;
setTextColor(BLACK, GREEN);
setIntFont(&Font_Ubuntu18pt);
sprintf(tmp, "%4u.%03u", (unsigned int)mhz, (unsigned int)khz); lcdPrint(tmp);
setIntFont(&Font_7x8);
lcdMoveCrsr(1, 18-7);
lcdPrint("MHz");
}
void draw_tx_rx(void)
{
uint8_t bg, fg;
setIntFont(&Font_Ubuntu18pt);
bg = BLACK;
fg = GREY;
if(direction == RF_PATH_DIRECTION_OFF) {
fg = WHITE;
}
setTextColor(bg, fg);
lcdPrint("OFF ");
fg = GREY;
if(direction == RF_PATH_DIRECTION_RX) {
fg = GREEN;
}
setTextColor(bg, fg);
lcdPrint("RX ");
fg = GREY;
if(direction == RF_PATH_DIRECTION_TX) {
fg = RED;
}
setTextColor(bg, fg);
lcdPrint("TX");
setIntFont(&Font_7x8);
}
void hackrf_ui_update(void)
{
char tmp[100];
uint32_t mhz;
uint32_t khz;
if(!enabled) {
return;
}
lcdClear();
lcdFill(0x00);
drawHLine(0, 0, RESX - 1, WHITE);
drawVLine(0, 0, RESY - 1, WHITE);
drawHLine(RESY - 1, 0, RESX - 1, WHITE);
drawVLine(RESX - 1, 0, RESY - 1, WHITE);
lcdSetCrsr(25, 2);
setTextColor(BLACK, GREEN);
lcdPrint("HackRF Mode");lcdNl();
drawHLine(11, 0, RESX - 1, WHITE);
lcdSetCrsr(2, 12);
draw_frequency();
drawHLine(40, 0, RESX - 1, WHITE);
lcdSetCrsr(6, 41);
draw_tx_rx();
drawHLine(69, 0, RESX - 1, WHITE);
setTextColor(BLACK, WHITE);
lcdSetCrsr(2, 71);
lcdPrint("Rate: ");
mhz = sample_rate/1e6;
khz = (sample_rate - mhz * 1e6) / 1000;
sprintf(tmp, "%2u.%03u MHz", (unsigned int)mhz, (unsigned int)khz); lcdPrint(tmp); lcdNl();
lcdMoveCrsr(2, 0);
lcdPrint("Filter: ");
mhz = filter_bw/1e6;
khz = (filter_bw - mhz * 1e6) / 1000;
sprintf(tmp, "%2u.%03u MHz", (unsigned int)mhz, (unsigned int)khz); lcdPrint(tmp); lcdNl();
drawHLine(88, 0, RESX - 1, WHITE);
setTextColor(BLACK, WHITE);
lcdSetCrsr(2, 90);
lcdPrint(" Gains"); lcdNl();
setTextColor(BLACK, GREEN);
lcdMoveCrsr(2, 2);
lcdPrint("AMP: ");
if(lna_on) {
setTextColor(BLACK, RED);
lcdPrint("ON ");
} else {
lcdPrint("OFF");
}
setTextColor(BLACK, RED_DARK);
if(direction == RF_PATH_DIRECTION_TX) {
setTextColor(BLACK, RED);
}
sprintf(tmp, " TX: %u dB", (unsigned int)bbtxvga_gain); lcdPrint(tmp); lcdNl();
lcdMoveCrsr(2, 0);
setTextColor(BLACK, GREEN_DARK);
if(direction == RF_PATH_DIRECTION_RX) {
setTextColor(BLACK, GREEN);
}
sprintf(tmp, "LNA: %2u dB", (unsigned int)bblna_gain); lcdPrint(tmp); lcdNl();
lcdMoveCrsr(2, 0);
sprintf(tmp, "VGA: %2u dB", (unsigned int)bbvga_gain); lcdPrint(tmp); lcdNl();
lcdDisplay();
// Don't ask...
ssp1_set_mode_max2837();
}
static void rad1o_ui_init(void) {
hackrf_ui_init();
lcdInit();
enabled = true;
hackrf_ui_update();
}
static void rad1o_ui_deinit(void) {
lcdDeInit();
enabled = false;
// Don't ask...
ssp1_set_mode_max2837();
}
static void rad1o_ui_set_frequency(uint64_t frequency) {
hackrf_ui_setFrequency(frequency);
freq = frequency;
hackrf_ui_update();
}
static void rad1o_ui_set_sample_rate(uint32_t sample_rate) {
hackrf_ui_setSampleRate(sample_rate);
static void rad1o_ui_set_sample_rate(uint32_t _sample_rate) {
sample_rate = _sample_rate;
hackrf_ui_update();
}
static void rad1o_ui_set_direction(const rf_path_direction_t direction) {
hackrf_ui_setDirection(direction);
static void rad1o_ui_set_direction(const rf_path_direction_t _direction) {
direction = _direction;
hackrf_ui_update();
}
static void rad1o_ui_set_filter_bw(uint32_t bandwidth) {
hackrf_ui_setFilterBW(bandwidth);
filter_bw = bandwidth;
hackrf_ui_update();
}
static void rad1o_ui_set_lna_power(bool lna_on) {
hackrf_ui_setLNAPower(lna_on);
static void rad1o_ui_set_lna_power(bool _lna_on) {
lna_on = _lna_on;
hackrf_ui_update();
}
static void rad1o_ui_set_bb_lna_gain(const uint32_t gain_db) {
hackrf_ui_setBBLNAGain(gain_db);
bblna_gain = gain_db;
hackrf_ui_update();
}
static void rad1o_ui_set_bb_vga_gain(const uint32_t gain_db) {
hackrf_ui_setBBVGAGain(gain_db);
bbvga_gain = gain_db;
hackrf_ui_update();
}
static void rad1o_ui_set_bb_tx_vga_gain(const uint32_t gain_db) {
hackrf_ui_setBBTXVGAGain(gain_db);
bbtxvga_gain = gain_db;
hackrf_ui_update();
}
static void rad1o_ui_set_first_if_frequency(const uint64_t frequency) {

8
firmware/hackrf_usb/CMakeLists.txt
View File

@ -77,6 +77,14 @@ endif()
if(BOARD STREQUAL "RAD1O")
SET(SRC_M4
${SRC_M4}
"${PATH_HACKRF_FIRMWARE_COMMON}/rad1o_display.c"
"${PATH_HACKRF_FIRMWARE_COMMON}/rad1o_print.c"
"${PATH_HACKRF_FIRMWARE_COMMON}/rad1o_render.c"
"${PATH_HACKRF_FIRMWARE_COMMON}/rad1o_decoder.c"
"${PATH_HACKRF_FIRMWARE_COMMON}/rad1o_itoa.c"
"${PATH_HACKRF_FIRMWARE_COMMON}/rad1o_smallfonts.c"
"${PATH_HACKRF_FIRMWARE_COMMON}/rad1o_draw.c"
"${PATH_HACKRF_FIRMWARE_COMMON}/rad1o_ubuntu18.c"
"${PATH_HACKRF_FIRMWARE_COMMON}/ui_rad1o.c"
)
endif()