examples/lm3s1968/lm3s1968.c

   1 /**
   2  * \file
   3  * <!--
   4  * This file is part of BeRTOS.
   5  *
   6  * Bertos is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  *
  20  * As a special exception, you may use this file as part of a free software
  21  * library without restriction.  Specifically, if other files instantiate
  22  * templates or use macros or inline functions from this file, or you compile
  23  * this file and link it with other files to produce an executable, this
  24  * file does not by itself cause the resulting executable to be covered by
  25  * the GNU General Public License.  This exception does not however
  26  * invalidate any other reasons why the executable file might be covered by
  27  * the GNU General Public License.
  28  *
  29  * Copyright 2010 Develer S.r.l. (http://www.develer.com/)
  30  *
  31  * -->
  32  *
  33  * \brief LM3S1968 Cortex-M3 testcase
  34  *
  35  * \author Andrea Righi <arighi@develer.com>
  36  */
  37
  38 #include <cpu/irq.h>
  39 #include <drv/timer.h>
  40 #include <drv/ser.h>
  41 #include <drv/lcd_rit128x96.h>
  42 #include <gfx/gfx.h>
  43 #include <gfx/font.h>
  44 #include <gfx/text.h>
  45 #include <icons/logo.h>
  46 #include <stdio.h>
  47
  48 #include "cfg/compiler.h"
  49 #include "cfg/cfg_gfx.h"
  50
  51 #include "hw/hw_rit128x96.h"
  52
  53 #define PROC_STACK_SIZE KERN_MINSTACKSIZE * 2
  54
  55 #if CONFIG_KERN_HEAP
  56 #define hp_stack NULL
  57 #define lp_stack NULL
  58 #define ser_stack NULL
  59 #define led_stack NULL
  60 #else
  61 static PROC_DEFINE_STACK(hp_stack, PROC_STACK_SIZE);
  62 static PROC_DEFINE_STACK(lp_stack, PROC_STACK_SIZE);
  63 static PROC_DEFINE_STACK(ser_stack, PROC_STACK_SIZE);
  64 static PROC_DEFINE_STACK(led_stack, PROC_STACK_SIZE);
  65 #endif
  66
  67 extern Font font_helvB10;
  68 static uint8_t raster[RAST_SIZE(LCD_WIDTH, LCD_HEIGHT)];
  69 static Bitmap bm;
  70
  71 static Process *hp_proc, *lp_proc, *res_proc;
  72 static hptime_t start, end;
  73
  74 static Serial ser_port;
  75
  76 static void led_init(void)
  77 {
  78         /* Enable the GPIO port that is used for the on-board LED */
  79         SYSCTL_RCGC2_R = SYSCTL_RCGC2_GPIOG;
  80         /*
  81          * Perform a dummy read to insert a few cycles delay before enabling
  82          * the peripheral.
  83          */
  84         (void)SYSCTL_RCGC2_R;
  85         /* Enable the GPIO pin for the LED */
  86         GPIO_PORTG_DIR_R = 0x04;
  87         GPIO_PORTG_DEN_R = 0x04;
  88 }
  89
  90 INLINE void led_on(void)
  91 {
  92         GPIO_PORTG_DATA_R |= 0x04;
  93 }
  94
  95 INLINE void led_off(void)
  96 {
  97         GPIO_PORTG_DATA_R &= ~0x04;
  98 }
  99
 100 static void NORETURN led_process(void)
 101 {
 102         int i;
 103
 104         for (i = 0; ; i++)
 105         {
 106                 if (i & 1)
 107                         led_on();
 108                 else
 109                         led_off();
 110                 timer_delay(50);
 111         }
 112 }
 113
 114 static void NORETURN ser_process(void)
 115 {
 116         char buf[32];
 117         int i;
 118
 119         ser_init(&ser_port, SER_UART0);
 120         ser_setbaudrate(&ser_port, 115200);
 121
 122         /* BeRTOS terminal */
 123         for (i = 0; ; i++)
 124         {
 125                 kfile_printf(&ser_port.fd, "\n\r[%03d] BeRTOS:~$ ", i);
 126                 kfile_gets_echo(&ser_port.fd, buf, sizeof(buf), true);
 127                 kfile_printf(&ser_port.fd, "%s", buf);
 128         }
 129 }
 130
 131 INLINE hptime_t get_hp_ticks(void)
 132 {
 133         return (TIMER_HW_CNT - timer_hw_hpread()) +
 134                         timer_clock_unlocked() * TIMER_HW_CNT;
 135 }
 136
 137 static void NORETURN res_process(void)
 138 {
 139         const char spinner[] = {'/', '-', '\\', '|'};
 140         int i;
 141         char c;
 142
 143         for (i = 0; ; i++)
 144         {
 145                 ticks_t clock;
 146
 147                 clock = timer_clock_unlocked();
 148
 149                 /* Display uptime (in ticks) */
 150                 text_xprintf(&bm, 2, 0, TEXT_FILL, "uptime: %lu sec", clock / 1000);
 151
 152                 /* Show context switch (in clock cycles) */
 153                 c = spinner[i % countof(spinner)];
 154                 text_xprintf(&bm, 4, 0, TEXT_CENTER | TEXT_FILL, "%c Context switch %c", c, c);
 155                 text_xprintf(&bm, 6, 0, TEXT_FILL, " %lu clock cycles", end - start);
 156                 /* Show context switch (in usec) */
 157                 text_xprintf(&bm, 7, 0, TEXT_FILL,
 158                         " %lu.%lu usec",
 159                                 ((end - start) * 1000000) / CPU_FREQ,
 160                                 ((end - start) * (100000000 / CPU_FREQ)) % 100);
 161                 rit128x96_lcd_blitBitmap(&bm);
 162         }
 163 }
 164
 165 static void NORETURN hp_process(void)
 166 {
 167         while (1)
 168         {
 169                 sig_wait(SIG_USER0);
 170                 end = get_hp_ticks();
 171                 timer_delay(100);
 172                 sig_send(lp_proc, SIG_USER0);
 173         }
 174 }
 175
 176 static void NORETURN lp_process(void)
 177 {
 178         while (1)
 179         {
 180                 start = get_hp_ticks();
 181                 sig_send(hp_proc, SIG_USER0);
 182                 sig_wait(SIG_USER0);
 183         }
 184 }
 185
 186 /**
 187  * Show the splash screen
 188  */
 189 static void bouncing_logo(Bitmap *bm)
 190 {
 191         const long SPEED_SCALE = 1000;
 192         const long GRAVITY_ACCEL = 100;
 193         const long BOUNCE_ELASTICITY = 2;
 194         const long TOT_FRAMES = 100;
 195         long h = (long)(-bertos_logo.height) * SPEED_SCALE;
 196         long speed = 0, i;
 197
 198         for (i = 0; i < TOT_FRAMES; i++)
 199         {
 200                 /* Move */
 201                 h += speed;
 202
 203                 /* Gravity acceleration */
 204                 speed += GRAVITY_ACCEL;
 205
 206                 if (h > 0 && speed > 0)
 207                 {
 208                         /* Bounce */
 209                         speed = -(speed / BOUNCE_ELASTICITY);
 210
 211                 }
 212                 /* Update graphics */
 213                 gfx_bitmapClear(bm);
 214                 gfx_blitImage(bm,
 215                         (LCD_WIDTH - bertos_logo.width) / 2,
 216                         (LCD_HEIGHT - bertos_logo.height) / 2 + h / SPEED_SCALE,
 217                         &bertos_logo);
 218                 rit128x96_lcd_blitBitmap(bm);
 219                 timer_delay(5);
 220         }
 221 }
 222
 223 int main(void)
 224 {
 225         IRQ_ENABLE;
 226         kdbg_init();
 227
 228         kputs("Init LED..");
 229         led_init();
 230         kputs("Done.\n");
 231         kputs("Init Timer..");
 232         timer_init();
 233         kputs("Done.\n");
 234         kputs("Init Process..");
 235         proc_init();
 236         kputs("Done.\n");
 237         kputs("Init OLED display..");
 238         rit128x96_lcd_init();
 239         gfx_bitmapInit(&bm, raster, LCD_WIDTH, LCD_HEIGHT);
 240         gfx_setFont(&bm, &font_helvB10);
 241         rit128x96_lcd_blitBitmap(&bm);
 242         kputs("Done.\n");
 243
 244         bouncing_logo(&bm);
 245         gfx_bitmapClear(&bm);
 246 #ifdef _DEBUG
 247         text_xprintf(&bm, 4, 0, TEXT_CENTER | TEXT_FILL, "BeRTOS up & running!");
 248         rit128x96_lcd_blitBitmap(&bm);
 249         proc_testRun();
 250 #endif
 251         text_xprintf(&bm, 0, 0, TEXT_FILL,
 252                         "CPU: Cortex-M3 %luMHz", CPU_FREQ / 1000000);
 253         rit128x96_lcd_blitBitmap(&bm);
 254         text_xprintf(&bm, 1, 0, TEXT_FILL, "Board: LM3S1968 EVB");
 255         rit128x96_lcd_blitBitmap(&bm);
 256
 257         hp_proc = proc_new(hp_process, NULL, PROC_STACK_SIZE, hp_stack);
 258         lp_proc = proc_new(lp_process, NULL, PROC_STACK_SIZE, lp_stack);
 259         proc_new(led_process, NULL, PROC_STACK_SIZE, led_stack);
 260         proc_new(ser_process, NULL, PROC_STACK_SIZE, ser_stack);
 261
 262         res_proc = proc_current();
 263
 264         proc_setPri(hp_proc, 2);
 265         proc_setPri(lp_proc, 1);
 266
 267         res_process();
 268 }