Comply the demo project to new spi dma interface.
[bertos.git] / boards / sam3n-ek / examples / display / main.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 Atmel SAM3N-EK testcase
34  *
35  * \author Stefano Fedrigo <aleph@develer.com>
36  */
37
38 #include "bitmaps.h"
39
40 #include "hw/hw_led.h"
41 #include "hw/hw_lcd.h"
42
43 #include <cfg/debug.h>
44
45 #include <cpu/irq.h>
46
47 #include <drv/timer.h>
48 #include <drv/kbd.h>
49 #include <drv/lcd_ili9225.h>
50
51 #include <drv/spi_dma.h>
52
53 #include <gfx/gfx.h>
54 #include <gfx/font.h>
55 #include <gfx/text.h>
56
57 #include <gui/menu.h>
58
59 #include <icons/logo.h>
60
61 #include <io/kfile.h>
62
63 #include <kern/signal.h>
64 #include <kern/proc.h>
65
66 // Keyboard
67 #define KEY_MASK (K_LEFT | K_RIGHT)
68
69 // Kernel
70 #define PROC_STACK_SIZE KERN_MINSTACKSIZE * 2
71
72 #if CONFIG_KERN_HEAP
73         #define hp_stack NULL
74         #define lp_stack NULL
75         #define led_stack NULL
76 #else
77         static PROC_DEFINE_STACK(hp_stack, PROC_STACK_SIZE);
78         static PROC_DEFINE_STACK(lp_stack, PROC_STACK_SIZE);
79         static PROC_DEFINE_STACK(led_stack, PROC_STACK_SIZE);
80 #endif
81
82 struct SpiDma spi;
83 static uint8_t raster[RAST_SIZE(LCD_WIDTH, LCD_HEIGHT)];
84 static Bitmap lcd_bitmap;
85 extern Font font_gohu;
86 static int lcd_brightness = LCD_BACKLIGHT_MAX;
87 static Process *hp_proc, *lp_proc, *led_proc;
88 static hptime_t start, end;
89
90
91 static bool led_blinking;
92
93 static void NORETURN led_process(void)
94 {
95         unsigned i;
96
97         for (i = 0; ; i++)
98         {
99                 if (!led_blinking)
100                 {
101                         LED_OFF(0);
102                         LED_OFF(1);
103                         LED_OFF(2);
104                         sig_wait(SIG_USER0);
105                 }
106                 LED_ON(i % 3);
107                 LED_OFF((i-1) % 3);
108                 timer_delay(200);
109         }
110 }
111
112 static void led_test(UNUSED_ARG(Bitmap *, bm))
113 {
114         led_blinking = !led_blinking;
115         sig_send(led_proc, SIG_USER0);
116 }
117
118 static void bouncing_logo(Bitmap *bm)
119 {
120         const long SPEED_SCALE = 1000;
121         const long GRAVITY_ACCEL = 100;
122         const long BOUNCE_ELASTICITY = 1;
123         long h = (long)(-bertos_logo.height) * SPEED_SCALE;
124         long speed = 0, i;
125
126         for (i = 0; ; i++)
127         {
128                 /* Move */
129                 h += speed;
130
131                 /* Gravity acceleration */
132                 speed += GRAVITY_ACCEL;
133
134                 if (h > 0 && speed > 0)
135                 {
136                         /* Bounce */
137                         speed = -(speed / BOUNCE_ELASTICITY);
138
139                 }
140                 /* Update graphics */
141                 gfx_bitmapClear(bm);
142                 gfx_blitImage(bm,
143                         (LCD_WIDTH - bertos_logo.width) / 2,
144                         (LCD_HEIGHT - bertos_logo.height) / 2 + h / SPEED_SCALE,
145                         &bertos_logo);
146                 text_xprintf(bm, 13, 0, TEXT_FILL | TEXT_CENTER, "Press any key to quit");
147                 lcd_ili9225_blitBitmap(bm);
148                 timer_delay(15);
149                 if (kbd_peek() & KEY_MASK)
150                         break;
151         }
152 }
153
154 static void screen_saver(Bitmap *bm)
155 {
156         int x1, y1, x2, y2;
157         int i;
158
159         for (i = 0; ; i++)
160         {
161                 x1 = i % LCD_WIDTH;
162                 y1 = i % LCD_HEIGHT;
163
164                 x2 = LCD_WIDTH - i % LCD_WIDTH;
165                 y2 = LCD_HEIGHT - i % LCD_HEIGHT;
166
167                 gfx_bitmapClear(bm);
168                 gfx_rectDraw(bm, x1, y1, x2, y2);
169                 lcd_ili9225_blitBitmap(bm);
170                 if (kbd_peek() & KEY_MASK)
171                         break;
172         }
173 }
174
175 static void robot_logo(UNUSED_ARG(Bitmap *, bm))
176 {
177         lcd_ili9225_blitBitmap24(0, 0, BMP_THINKING_WIDTH, BMP_THINKING_HEIGHT, bmp_thinking);
178
179         while (!(kbd_peek() & KEY_MASK))
180                 timer_delay(50);
181 }
182
183
184 INLINE hptime_t get_hp_ticks(void)
185 {
186         return (timer_clock_unlocked() * TIMER_HW_CNT) + timer_hw_hpread();
187 }
188
189 static void NORETURN hp_process(void)
190 {
191         while (1)
192         {
193                 sig_wait(SIG_USER0);
194                 end = get_hp_ticks();
195                 timer_delay(100);
196                 sig_send(lp_proc, SIG_USER0);
197         }
198 }
199
200 static void NORETURN lp_process(void)
201 {
202         while (1)
203         {
204                 start = get_hp_ticks();
205                 sig_send(hp_proc, SIG_USER0);
206                 sig_wait(SIG_USER0);
207         }
208 }
209
210 static void res_process(void)
211 {
212         const char spinner[] = {'/', '-', '\\', '|'};
213         int i;
214         char c;
215
216         for (i = 0; ; i++)
217         {
218                 /* Show context switch (in clock cycles) */
219                 c = spinner[i % countof(spinner)];
220                 text_xprintf(&lcd_bitmap, 3, 0, TEXT_CENTER | TEXT_FILL, "%c Context switch %c", c, c);
221                 text_xprintf(&lcd_bitmap, 5, 0, TEXT_FILL, " %lu clock cycles", end - start);
222                 /* Show context switch (in usec) */
223                 text_xprintf(&lcd_bitmap, 6, 0, TEXT_FILL,
224                         " %lu.%lu usec",
225                                 ((end - start) * 1000000) / CPU_FREQ,
226                                 ((end - start) * (100000000 / CPU_FREQ)) % 100);
227                 lcd_ili9225_blitBitmap(&lcd_bitmap);
228                 timer_delay(5);
229                 if (kbd_peek() & KEY_MASK)
230                         break;
231         }
232 }
233
234 static void context_switch_test(Bitmap *bm)
235 {
236         const Font *old_font = bm->font;
237         gfx_setFont(&lcd_bitmap, &font_gohu);
238
239         gfx_bitmapClear(bm);
240         text_xprintf(bm, 0, 0, TEXT_FILL,
241                         "CPU: Cortex-M3 %luMHz", CPU_FREQ / 1000000);
242         text_xprintf(bm, 1, 0, TEXT_FILL, "Board: SAM3N-EK EVB");
243
244         res_process();
245
246         gfx_setFont(&lcd_bitmap, old_font);
247 }
248
249 static void uptime(Bitmap *bm)
250 {
251         gfx_bitmapClear(bm);
252         text_xprintf(bm, 0, 0, TEXT_FILL | TEXT_CENTER, "Uptime");
253         while (1)
254         {
255                 ticks_t clock = ticks_to_ms(timer_clock_unlocked());
256
257                 /* Display uptime (in ticks) */
258                 text_xprintf(&lcd_bitmap, 2, 0, TEXT_FILL | TEXT_CENTER,
259                                 "seconds: %lu", clock / 1000);
260                 lcd_ili9225_blitBitmap(bm);
261                 timer_delay(5);
262                 if (kbd_peek() & KEY_MASK)
263                         break;
264         }
265 }
266
267 /*
268  * Lcd
269  */
270 static void setBrightness(Bitmap *bm)
271 {
272         while (1)
273         {
274                 gfx_bitmapClear(bm);
275                 text_xprintf(bm, 1, 0, TEXT_FILL | TEXT_CENTER, "Brightness: %d", lcd_brightness);
276                 text_xprintf(bm, 3, 0, TEXT_FILL | TEXT_CENTER, "RIGHT key: change");
277                 text_xprintf(bm, 4, 0, TEXT_FILL | TEXT_CENTER, "LEFT  key: back  ");
278                 lcd_ili9225_blitBitmap(bm);
279
280                 keymask_t mask = kbd_get();
281
282                 if (mask & K_LEFT)
283                         break;
284                 else if (mask & K_RIGHT)
285                 {
286                         if (++lcd_brightness > LCD_BACKLIGHT_MAX)
287                                 lcd_brightness = 0;
288                         lcd_setBacklight(lcd_brightness);
289                 }
290         }
291 }
292
293
294 static void NORETURN soft_reset(Bitmap * bm)
295 {
296         int i;
297
298         gfx_bitmapClear(bm);
299         for (i = 5; i; --i)
300         {
301                 text_xprintf(bm, 2, 0, TEXT_FILL | TEXT_CENTER, "%d", i);
302                 lcd_ili9225_blitBitmap(bm);
303                 timer_delay(1000);
304         }
305         text_xprintf(bm, 2, 0, TEXT_FILL | TEXT_CENTER, "REBOOT");
306         lcd_ili9225_blitBitmap(bm);
307         timer_delay(1000);
308
309         /* Perform a software reset request */
310         HWREG(NVIC_APINT) = NVIC_APINT_VECTKEY | NVIC_APINT_SYSRESETREQ;
311         UNREACHABLE();
312 }
313
314
315 static struct MenuItem main_items[] =
316 {
317         { (const_iptr_t)"LED blinking", 0, (MenuHook)led_test, (iptr_t)&lcd_bitmap },
318         { (const_iptr_t)"Graphics demo", 0, (MenuHook)robot_logo, (iptr_t)&lcd_bitmap },
319         { (const_iptr_t)"Bouncing logo", 0, (MenuHook)bouncing_logo, (iptr_t)&lcd_bitmap },
320         { (const_iptr_t)"Screen saver demo", 0, (MenuHook)screen_saver, (iptr_t)&lcd_bitmap },
321         { (const_iptr_t)"Scheduling test", 0, (MenuHook)context_switch_test, (iptr_t)&lcd_bitmap },
322         { (const_iptr_t)"Show uptime", 0, (MenuHook)uptime, (iptr_t)&lcd_bitmap },
323         { (const_iptr_t)"Display brightness", 0, (MenuHook)setBrightness, (iptr_t)&lcd_bitmap },
324         { (const_iptr_t)"Reboot", 0, (MenuHook)soft_reset, (iptr_t)&lcd_bitmap },
325         { (const_iptr_t)0, 0, NULL, (iptr_t)0 }
326 };
327 static struct Menu main_menu = { main_items, "BeRTOS", MF_STICKY | MF_SAVESEL, &lcd_bitmap, 0, lcd_ili9225_blitBitmap };
328
329
330 int main(void)
331 {
332         IRQ_ENABLE;
333
334         kdbg_init();
335         LED_INIT();
336         timer_init();
337         proc_init();
338
339         spi_dma_init(&spi);
340         spi_dma_setclock(LCD_SPICLOCK);
341         lcd_ili9225_init(&spi.fd);
342         LCD_BACKLIGHT_INIT();
343         lcd_setBacklight(lcd_brightness);
344
345         gfx_bitmapInit(&lcd_bitmap, raster, LCD_WIDTH, LCD_HEIGHT);
346         gfx_setFont(&lcd_bitmap, &font_luBS14);
347         lcd_ili9225_blitBitmap(&lcd_bitmap);
348
349         kbd_init();
350
351         hp_proc = proc_new(hp_process, NULL, PROC_STACK_SIZE, hp_stack);
352         lp_proc = proc_new(lp_process, NULL, PROC_STACK_SIZE, lp_stack);
353         led_proc = proc_new(led_process, NULL, PROC_STACK_SIZE, led_stack);
354
355         proc_setPri(hp_proc, 2);
356         proc_setPri(lp_proc, 1);
357
358         lcd_ili9225_blitBitmap24(0, 50, BMP_LOGO_WIDTH, BMP_LOGO_HEIGHT, bmp_logo);
359         timer_delay(3000);
360
361         while (1)
362         {
363                 menu_handle(&main_menu);
364                 cpu_relax();
365         }
366 }