Subversion Repositories chibiosIgnition

Rev

Rev 9 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /*
  2.  * Font.c
  3.  
  4.  *
  5.  *  Created on: 20 Dec 2015
  6.  *      Author: Mike
  7.  */
  8. #include <stdint.h>
  9. #include <string.h>
  10. #include "ap_math.h"
  11. #include "SSD1306.h"
  12.  
  13.  
  14.  
  15. #include "ascii-lucida.h"
  16.  
  17.  
  18. uint8_t cursor_x;
  19. uint8_t cursor_y;
  20.  
  21.  
  22. #include "Font.h"
  23. /*
  24.  * display text using a 5x7 bitmap font in ASCII letters
  25.  */
  26. static const unsigned char font [] [5] = {
  27.         { 0x00,0x00,0x00,0x00,0x00 },   //   0x20 32
  28.         { 0x00,0x00,0x6f,0x00,0x00 },   // ! 0x21 33
  29.         { 0x00,0x07,0x00,0x07,0x00 },   // " 0x22 34
  30.         { 0x14,0x7f,0x14,0x7f,0x14 },   // # 0x23 35
  31.   //      { 0x00,0x07,0x04,0x1e,0x00 },   // $ 0x24 36
  32.                 {0x2e, 0x2a, 0xff, 0x2a, 0x3a},
  33.                 { 0x23,0x13,0x08,0x64,0x62 },   // % 0x25 37
  34.         { 0x36,0x49,0x56,0x20,0x50 },   // & 0x26 38
  35.         { 0x00,0x00,0x07,0x00,0x00 },   // ' 0x27 39
  36.         { 0x00,0x1c,0x22,0x41,0x00 },   // ( 0x28 40
  37.         { 0x00,0x41,0x22,0x1c,0x00 },   // ) 0x29 41
  38.         { 0x14,0x08,0x3e,0x08,0x14 },   // * 0x2a 42
  39.         { 0x08,0x08,0x3e,0x08,0x08 },   // + 0x2b 43
  40.         { 0x00,0x50,0x30,0x00,0x00 },   // , 0x2c 44
  41.         { 0x08,0x08,0x08,0x08,0x08 },   // - 0x2d 45
  42.         { 0x00,0x60,0x60,0x00,0x00 },   // . 0x2e 46
  43.         { 0x20,0x10,0x08,0x04,0x02 },   // / 0x2f 47
  44.         { 0x3e,0x51,0x49,0x45,0x3e },   // 0 0x30 48
  45.         { 0x00,0x42,0x7f,0x40,0x00 },   // 1 0x31 49
  46.         { 0x42,0x61,0x51,0x49,0x46 },   // 2 0x32 50
  47.         { 0x21,0x41,0x45,0x4b,0x31 },   // 3 0x33 51
  48.         { 0x18,0x14,0x12,0x7f,0x10 },   // 4 0x34 52
  49.         { 0x27,0x45,0x45,0x45,0x39 },   // 5 0x35 53
  50.         { 0x3c,0x4a,0x49,0x49,0x30 },   // 6 0x36 54
  51.         { 0x01,0x71,0x09,0x05,0x03 },   // 7 0x37 55
  52.         { 0x36,0x49,0x49,0x49,0x36 },   // 8 0x38 56
  53.         { 0x06,0x49,0x49,0x29,0x1e },   // 9 0x39 57
  54.         { 0x00,0x36,0x36,0x00,0x00 },   // : 0x3a 58
  55.         { 0x00,0x56,0x36,0x00,0x00 },   // ; 0x3b 59
  56.         { 0x08,0x14,0x22,0x41,0x00 },   // < 0x3c 60
  57.         { 0x14,0x14,0x14,0x14,0x14 },   // = 0x3d 61
  58.         { 0x00,0x41,0x22,0x14,0x08 },   // > 0x3e 62
  59.         { 0x02,0x01,0x51,0x09,0x06 },   // ? 0x3f 63
  60.         { 0x3e,0x41,0x5d,0x49,0x4e },   // @ 0x40 64
  61.         { 0x7e,0x09,0x09,0x09,0x7e },   // A 0x41 65
  62.         { 0x7f,0x49,0x49,0x49,0x36 },   // B 0x42 66
  63.         { 0x3e,0x41,0x41,0x41,0x22 },   // C 0x43 67
  64.         { 0x7f,0x41,0x41,0x41,0x3e },   // D 0x44 68
  65.         { 0x7f,0x49,0x49,0x49,0x41 },   // E 0x45 69
  66.         { 0x7f,0x09,0x09,0x09,0x01 },   // F 0x46 70
  67.         { 0x3e,0x41,0x49,0x49,0x7a },   // G 0x47 71
  68.         { 0x7f,0x08,0x08,0x08,0x7f },   // H 0x48 72
  69.         { 0x00,0x41,0x7f,0x41,0x00 },   // I 0x49 73
  70.         { 0x20,0x40,0x41,0x3f,0x01 },   // J 0x4a 74
  71.         { 0x7f,0x08,0x14,0x22,0x41 },   // K 0x4b 75
  72.         { 0x7f,0x40,0x40,0x40,0x40 },   // L 0x4c 76
  73.         { 0x7f,0x02,0x0c,0x02,0x7f },   // M 0x4d 77
  74.         { 0x7f,0x04,0x08,0x10,0x7f },   // N 0x4e 78
  75.         { 0x3e,0x41,0x41,0x41,0x3e },   // O 0x4f 79
  76.         { 0x7f,0x09,0x09,0x09,0x06 },   // P 0x50 80
  77.         { 0x3e,0x41,0x51,0x21,0x5e },   // Q 0x51 81
  78.         { 0x7f,0x09,0x19,0x29,0x46 },   // R 0x52 82
  79.         { 0x46,0x49,0x49,0x49,0x31 },   // S 0x53 83
  80.         { 0x01,0x01,0x7f,0x01,0x01 },   // T 0x54 84
  81.         { 0x3f,0x40,0x40,0x40,0x3f },   // U 0x55 85
  82.         { 0x0f,0x30,0x40,0x30,0x0f },   // V 0x56 86
  83.         { 0x3f,0x40,0x30,0x40,0x3f },   // W 0x57 87
  84.         { 0x63,0x14,0x08,0x14,0x63 },   // X 0x58 88
  85.         { 0x07,0x08,0x70,0x08,0x07 },   // Y 0x59 89
  86.         { 0x61,0x51,0x49,0x45,0x43 },   // Z 0x5a 90
  87. //        { 0x3c,0x4a,0x49,0x29,0x1e },   // [ 0x5b 91
  88.             { 0x00,0x00,0x7f,0x41,0x00 },
  89.         { 0x02,0x04,0x08,0x10,0x20 },   // \ 0x5c 92
  90.         { 0x00,0x41,0x7f,0x00,0x00 },   // ] 0x5d 93
  91.         { 0x04,0x02,0x01,0x02,0x04 },   // ^ 0x5e 94
  92.         { 0x40,0x40,0x40,0x40,0x40 },   // _ 0x5f 95
  93.         { 0x00,0x00,0x03,0x04,0x00 },   // ` 0x60 96
  94.         { 0x20,0x54,0x54,0x54,0x78 },   // a 0x61 97
  95.         { 0x7f,0x48,0x44,0x44,0x38 },   // b 0x62 98
  96. //        { 0x38,0x44,0x44,0x44,0x20 },   // c 0x63 99
  97.                  { 0x38,0x44,0x44,0x44,0x44 },
  98.                 { 0x38,0x44,0x44,0x48,0x7f },   // d 0x64 100
  99.         { 0x38,0x54,0x54,0x54,0x18 },   // e 0x65 101
  100.         { 0x08,0x7e,0x09,0x01,0x02 },   // f 0x66 102
  101.         { 0x0c,0x52,0x52,0x52,0x3e },   // g 0x67 103
  102.         { 0x7f,0x08,0x04,0x04,0x78 },   // h 0x68 104
  103.         { 0x00,0x44,0x7d,0x40,0x00 },   // i 0x69 105
  104.         { 0x20,0x40,0x44,0x3d,0x00 },   // j 0x6a 106
  105.         { 0x00,0x7f,0x10,0x28,0x44 },   // k 0x6b 107
  106.         { 0x00,0x41,0x7f,0x40,0x00 },   // l 0x6c 108
  107.         { 0x7c,0x04,0x18,0x04,0x78 },   // m 0x6d 109
  108.         { 0x7c,0x08,0x04,0x04,0x78 },   // n 0x6e 110
  109.         { 0x38,0x44,0x44,0x44,0x38 },   // o 0x6f 111
  110.         { 0x7c,0x14,0x14,0x14,0x08 },   // p 0x70 112
  111. //        { 0x08,0x14,0x14,0x18,0x7c },   // q 0x71 113
  112.             { 0x08,0x14,0x14,0x14,0x7c },
  113.         { 0x7c,0x08,0x04,0x04,0x08 },   // r 0x72 114
  114.         { 0x48,0x54,0x54,0x54,0x20 },   // s 0x73 115
  115.         { 0x04,0x3f,0x44,0x40,0x20 },   // t 0x74 116
  116.         { 0x3c,0x40,0x40,0x20,0x7c },   // u 0x75 117
  117.         { 0x1c,0x20,0x40,0x20,0x1c },   // v 0x76 118
  118.         { 0x3c,0x40,0x30,0x40,0x3c },   // w 0x77 119
  119.         { 0x44,0x28,0x10,0x28,0x44 },   // x 0x78 120
  120.         { 0x0c,0x50,0x50,0x50,0x3c },   // y 0x79 121
  121.         { 0x44,0x64,0x54,0x4c,0x44 },   // z 0x7a 122
  122.         { 0x00,0x08,0x36,0x41,0x41 },   // { 0x7b 123
  123.         { 0x00,0x00,0x7f,0x00,0x00 },   // | 0x7c 124
  124.         { 0x41,0x41,0x36,0x08,0x00 },   // } 0x7d 125
  125. //        { 0x04,0x02,0x04,0x08,0x04 },   // ~ 0x7e 126
  126.             { 0x08,0x0c,0x08,0x18,0x08 },
  127.  
  128.  
  129.  
  130. };
  131.  
  132. #define extDegrees 0
  133.  
  134. static const unsigned char font_ext[] [5] =
  135. {
  136.  
  137. [extDegrees] =    { 0x00,0x06,0x09,0x06,0x00 }, // a ° sign
  138.  
  139. };
  140.  
  141.  
  142.  
  143.  
  144. void font_gotoxy(uint8_t x,uint8_t y)
  145. {
  146.         cursor_x=x;
  147.         cursor_y=y;
  148. }
  149.  
  150. void font_putchar(uint8_t c)
  151. {
  152.         uint8_t * ptr = &display_buffer[0] + cursor_x*6 + cursor_y * WIDTH;
  153.         int i;
  154.         if('\r'==c)
  155.         {
  156.                 cursor_x = 0;
  157.                 cursor_y++;
  158.                 if(cursor_y >= HEIGHT/8)
  159.                 {
  160.                         cursor_y = 0;
  161.                 }
  162.                 return;
  163.         }
  164.  
  165.  
  166.         for(i=0;i<5;i++)
  167.         {
  168.                 if(c>' ' && c<0x80)
  169.                 {
  170.                   *ptr++ = font[c-' '][i];
  171.                 }
  172.                 else if(c=='°')
  173.                 {
  174.                    *ptr++ = font_ext[extDegrees][i];
  175.                 }
  176.                 else
  177.                 {
  178.                    *ptr++ = 0;
  179.                 }
  180.         }
  181.         *ptr++=0;
  182.  
  183.         // move cursor
  184.         cursor_x++;
  185.         if(cursor_x >= WIDTH/6)
  186.         {
  187.           cursor_x=0;
  188.           cursor_y++;
  189.           if(cursor_y==HEIGHT/8)
  190.           {
  191.                   cursor_y = 0;
  192.           }
  193.         }
  194.  
  195. }
  196.  
  197.  
  198.  
  199. void font_puts(uint8_t * s)
  200. {
  201.         while(s && *s)
  202.         {
  203.                 font_putchar(*(s++));
  204.         }
  205. }
  206.  
  207.  
  208. uint8_t get_digits(uint16_t x, uint16_t y)
  209. {
  210.         return ((ascii_lucida_bits[(y*ascii_lucida_width)/8+(x/8)])>>(x&7)) & 1 ;
  211. }
  212.  
  213.  
  214. static uint8_t format_num(char * buff, uint8_t digits,uint8_t dp_pos,int val)
  215. {
  216.   digits++;
  217.   uint8_t pos = digits;
  218.   uint8_t dp_loc = pos - dp_pos;
  219.   uint8_t sign = 0;
  220.   if(val<0)
  221.   {
  222.         sign = 1;
  223.         val = -val;
  224.   }
  225.  
  226.   buff[pos]=0;
  227.   while (pos)
  228.   {
  229.         if(pos == dp_loc )
  230.         {
  231.                 buff[--pos]='.';
  232.         }
  233.         else
  234.         {
  235.            buff[--pos] = val%10 + '0';
  236.            val/=10;
  237.            if(val==0 && pos< dp_loc)
  238.                  break;
  239.         }
  240.   }
  241.   if(sign)
  242.  {
  243.         buff[--pos] =  '-';
  244.  }
  245.  return digits;
  246. }
  247.  
  248.  
  249. void font_digits( uint8_t digits,uint8_t dp_pos,  int val)
  250. {
  251.         char buff[10] = "        ";
  252.         uint8_t len = format_num(buff, digits,dp_pos,val);
  253.         font_puts(buff);
  254. }
  255.  
  256.  
  257. void font_sig_digits(uint8_t x, uint8_t y,uint8_t right_justify,uint8_t dp_pos, int val)
  258. {
  259.   char digits;
  260.   char sign = 0;
  261.   int uval;
  262.   if (val < 0)
  263.   {
  264.           uval = -val;
  265.           sign = 1; // mark as negative
  266.   }
  267.   else
  268.   {
  269.           uval = val;
  270.   }
  271.   if(uval<10) // always one digit for a sign or space, one for a digit
  272.   {
  273.           digits = 1;
  274.   }
  275.   if(uval>=10 && uval <100)
  276.   {
  277.           digits = 2;
  278.   }
  279.   if(uval>=100 && uval < 1000)
  280.   {
  281.          digits =3;
  282.   }
  283.   if(uval>=1000)
  284.   {
  285.          digits=4;
  286.   }
  287.   // backup for the - sign if right justified
  288.   if(right_justify)
  289.   {
  290.          if(dp_pos<10)
  291.      {
  292.            digits+=2;
  293.      }
  294.          else
  295.          {
  296.                  digits+=1;
  297.          }
  298.      x-=(digits);
  299.   }
  300.  
  301.  
  302.   font_gotoxy(x,y);
  303.   font_digits(digits,dp_pos,val);
  304. }
  305.  
  306.  
  307. #define FONTX 10
  308. #define FONTY 18
  309.  
  310.  
  311. void scan_xbm(void)
  312. {
  313.  
  314.         int i,j;
  315.  
  316.         for(i=0; i< FONTY;i++)
  317.         {
  318.                 for(j=0;j<FONTX*6;j++)
  319.                 {
  320.                          drawPixel(j, i, get_digits(j,i)) ;
  321.                 }
  322.         }
  323. }
  324.  
  325. void print_large_string(char * string, int x, int y, int digits)
  326. {
  327.  int xt,yt,j;
  328.  for(yt=0;yt<FONTY;yt++) // iterate down scan lines
  329.     {
  330.         for(xt=0;xt<digits;xt++)
  331.         {
  332.                 for(j=0;j<FONTX;j++)
  333.                 {
  334.                         unsigned char c = (string[xt] & 0x7F);
  335.                         if(c<32)
  336.                                 c= 32;
  337.  
  338.                         drawPixel(x+j+xt*FONTX, y+yt, get_digits(j+(c-32)*FONTX,yt)) ;
  339.                 }
  340.         }
  341.         }
  342.  
  343. }
  344.  
  345. void print_digits(uint8_t x, uint8_t y, uint8_t digits,uint8_t dp_pos,  int val)
  346. {
  347.  
  348.  
  349.         char buff[10] = "        ";
  350.         uint8_t len = format_num(buff, digits,dp_pos,val);
  351.     print_large_string(buff,x,y,len);
  352. }
  353.  
  354.  
  355.  
  356.  
  357.  
  358.  
  359. /* print a digit value 0 to 9 (not ASCII)  rotated by ang */
  360. void print_rotated(uint8_t x, uint8_t y, int ang, uint8_t val)
  361. {
  362.         int co=ap_cos(ang);
  363.         int si=ap_sin(ang);
  364.  
  365.         int xt,yt;
  366.  
  367.     for(yt=0;yt<FONTY;yt++) // iterate down scan lines
  368.     {
  369.                 for(xt=0;xt<FONTX;xt++)
  370.                 {
  371.                         if(get_digits(xt+(val+16)*FONTX,yt))
  372.                         {
  373.                            int cx = xt-FONTX/2;
  374.                            int cy = yt-FONTY/2;
  375.  
  376.                            int px = AP_SCALE(cx*co - cy*si);
  377.                            int py = AP_SCALE(cx*si + cy*co);
  378.  
  379.                            drawPixel(x+px, y+py,WHITE) ;
  380.                         }
  381.                 }
  382.    }
  383.  
  384.  
  385.  
  386.  
  387.  
  388. }
  389.  
  390.  
  391.  
  392.  
  393.