main.c 37.1 KB
Newer Older
1
#include <stdio.h>
Damien's avatar
Damien committed
2
3
#include <stm32f4xx.h>
#include <stm32f4xx_rcc.h>
4
#include <stm32f4xx_syscfg.h>
5
#include <stm32f4xx_gpio.h>
6
#include <stm32f4xx_exti.h>
7
#include <stm32f4xx_tim.h>
Damien's avatar
Damien committed
8
#include <stm32f4xx_pwr.h>
9
#include <stm32f4xx_rtc.h>
10
#include <stm32f4xx_usart.h>
11
#include <stm32f4xx_rng.h>
12
#include <stm_misc.h>
Damien's avatar
Damien committed
13
14
#include "std.h"

15
#include "misc.h"
16
17
18
19
20
21
22
23
24
25
26
27
#include "ff.h"
#include "mpconfig.h"
#include "nlr.h"
#include "misc.h"
#include "lexer.h"
#include "lexerstm.h"
#include "parse.h"
#include "compile.h"
#include "obj.h"
#include "runtime0.h"
#include "runtime.h"
#include "repl.h"
Damien's avatar
Damien committed
28
#include "gc.h"
29
#include "systick.h"
30
#include "led.h"
31
#include "servo.h"
32
#include "lcd.h"
33
#include "storage.h"
34
#include "mma.h"
35
#include "usart.h"
Damien's avatar
Damien committed
36
#include "usb.h"
37
#include "timer.h"
38
#include "audio.h"
39
#include "pybwlan.h"
40
#include "i2c.h"
41
42

int errno;
Damien's avatar
Damien committed
43

Damien's avatar
Damien committed
44
45
extern uint32_t _heap_start;

46
47
static FATFS fatfs0;

48
49
50
51
52
53
54
55
56
57
58
59
void flash_error(int n) {
    for (int i = 0; i < n; i++) {
        led_state(PYB_LED_R1, 1);
        led_state(PYB_LED_R2, 0);
        sys_tick_delay_ms(250);
        led_state(PYB_LED_R1, 0);
        led_state(PYB_LED_R2, 1);
        sys_tick_delay_ms(250);
    }
    led_state(PYB_LED_R2, 0);
}

60
static void impl02_c_version(void) {
Damien's avatar
Damien committed
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
    int x = 0;
    while (x < 400) {
        int y = 0;
        while (y < 400) {
            volatile int z = 0;
            while (z < 400) {
                z = z + 1;
            }
            y = y + 1;
        }
        x = x + 1;
    }
}

#define PYB_USRSW_PORT (GPIOA)
76
#define PYB_USRSW_PIN (GPIO_Pin_13)
Damien's avatar
Damien committed
77

78
void sw_init(void) {
Damien's avatar
Damien committed
79
    // make it an input with pull-up
80
81
82
83
84
    GPIO_InitTypeDef GPIO_InitStructure;
    GPIO_InitStructure.GPIO_Pin = PYB_USRSW_PIN;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    GPIO_Init(PYB_USRSW_PORT, &GPIO_InitStructure);
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

    // the rest does the EXTI interrupt

    /* Enable SYSCFG clock */
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);

    /* Connect EXTI Line13 to PA13 pin */
    SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOA, EXTI_PinSource13);

    /* Configure EXTI Line13, rising edge */
    EXTI_InitTypeDef EXTI_InitStructure;
    EXTI_InitStructure.EXTI_Line = EXTI_Line13;
    EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
    EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
    EXTI_InitStructure.EXTI_LineCmd = ENABLE;
    EXTI_Init(&EXTI_InitStructure);

    /* Enable and set EXTI15_10 Interrupt to the lowest priority */
    NVIC_InitTypeDef NVIC_InitStructure;
    NVIC_InitStructure.NVIC_IRQChannel = EXTI15_10_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x0F;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0F;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
Damien's avatar
Damien committed
109
110
}

111
int sw_get(void) {
112
    if (PYB_USRSW_PORT->IDR & PYB_USRSW_PIN) {
Damien's avatar
Damien committed
113
114
115
116
117
118
119
120
121
122
123
124
        // pulled high, so switch is not pressed
        return 0;
    } else {
        // pulled low, so switch is pressed
        return 1;
    }
}

void __fatal_error(const char *msg) {
    lcd_print_strn("\nFATAL ERROR:\n", 14);
    lcd_print_strn(msg, strlen(msg));
    for (;;) {
125
        flash_error(1);
Damien's avatar
Damien committed
126
127
128
    }
}

129
130
131
static qstr pyb_config_source_dir = 0;
static qstr pyb_config_main = 0;

132
133
134
mp_obj_t pyb_source_dir(mp_obj_t source_dir) {
    pyb_config_source_dir = mp_obj_get_qstr(source_dir);
    return mp_const_none;
135
136
}

137
138
139
mp_obj_t pyb_main(mp_obj_t main) {
    pyb_config_main = mp_obj_get_qstr(main);
    return mp_const_none;
140
141
142
}

// sync all file systems
143
mp_obj_t pyb_sync(void) {
144
    storage_flush();
145
    return mp_const_none;
146
}
Damien's avatar
Damien committed
147

148
149
150
mp_obj_t pyb_delay(mp_obj_t count) {
    sys_tick_delay_ms(mp_obj_get_int(count));
    return mp_const_none;
Damien's avatar
Damien committed
151
152
}

153
mp_obj_t pyb_led(mp_obj_t state) {
154
    led_state(PYB_LED_G1, rt_is_true(state));
Damien's avatar
Damien committed
155
156
157
    return state;
}

158
mp_obj_t pyb_sw(void) {
Damien's avatar
Damien committed
159
    if (sw_get()) {
160
        return mp_const_true;
Damien's avatar
Damien committed
161
    } else {
162
        return mp_const_false;
Damien's avatar
Damien committed
163
164
165
    }
}

166
/*
167
168
169
170
171
172
void g(uint i) {
    printf("g:%d\n", i);
    if (i & 1) {
        nlr_jump((void*)(42 + i));
    }
}
173
void f(void) {
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
    nlr_buf_t nlr;
    int i;
    for (i = 0; i < 4; i++) {
        printf("f:loop:%d:%p\n", i, &nlr);
        if (nlr_push(&nlr) == 0) {
            // normal
            //printf("a:%p:%p %p %p %u\n", &nlr, nlr.ip, nlr.sp, nlr.prev, nlr.ret_val);
            g(i);
            printf("f:lp:%d:nrm\n", i);
            nlr_pop();
        } else {
            // nlr
            //printf("b:%p:%p %p %p %u\n", &nlr, nlr.ip, nlr.sp, nlr.prev, nlr.ret_val);
            printf("f:lp:%d:nlr:%d\n", i, (int)nlr.ret_val);
        }
    }
}
191
void nlr_test(void) {
192
193
    f(1);
}
194
195
*/

196
void fatality(void) {
197
198
199
200
201
202
    led_state(PYB_LED_R1, 1);
    led_state(PYB_LED_G1, 1);
    led_state(PYB_LED_R2, 1);
    led_state(PYB_LED_G2, 1);
}

203
static const char fresh_boot_py[] =
204
205
206
207
208
209
210
211
212
213
214
"# boot.py -- run on boot-up\n"
"# can run arbitrary Python, but best to keep it minimal\n"
"\n"
"pyb.source_dir('/src')\n"
"pyb.main('main.py')\n"
"#pyb.usb_usr('VCP')\n"
"#pyb.usb_msd(True, 'dual partition')\n"
"#pyb.flush_cache(False)\n"
"#pyb.error_log('error.txt')\n"
;

215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
static const char fresh_main_py[] =
"# main.py -- put your code here!\n"
;

static const char *help_text =
"Welcome to Micro Python!\n\n"
"This is a *very* early version of Micro Python and has minimal functionality.\n\n"
"Specific commands for the board:\n"
"    pyb.info()     -- print some general information\n"
"    pyb.gc()       -- run the garbage collector\n"
"    pyb.delay(<n>) -- wait for n milliseconds\n"
"    pyb.Led(<n>)   -- create Led object for LED n (n=1,2)\n"
"                      Led methods: on(), off()\n"
"    pyb.Servo(<n>) -- create Servo object for servo n (n=1,2,3,4)\n"
"                      Servo methods: angle(<x>)\n"
"    pyb.switch()   -- return True/False if switch pressed or not\n"
"    pyb.accel()    -- get accelerometer values\n"
"    pyb.rand()     -- get a 16-bit random number\n"
;

// get some help about available functions
236
static mp_obj_t pyb_help(void) {
237
    printf("%s", help_text);
238
    return mp_const_none;
239
240
}

241
// get lots of info about the board
242
static mp_obj_t pyb_info(void) {
243
244
245
246
247
248
    // get and print unique id; 96 bits
    {
        byte *id = (byte*)0x1fff7a10;
        printf("ID=%02x%02x%02x%02x:%02x%02x%02x%02x:%02x%02x%02x%02x\n", id[0], id[1], id[2], id[3], id[4], id[5], id[6], id[7], id[8], id[9], id[10], id[11]);
    }

249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
    // get and print clock speeds
    // SYSCLK=168MHz, HCLK=168MHz, PCLK1=42MHz, PCLK2=84MHz
    {
        RCC_ClocksTypeDef rcc_clocks;
        RCC_GetClocksFreq(&rcc_clocks);
        printf("S=%lu\nH=%lu\nP1=%lu\nP2=%lu\n", rcc_clocks.SYSCLK_Frequency, rcc_clocks.HCLK_Frequency, rcc_clocks.PCLK1_Frequency, rcc_clocks.PCLK2_Frequency);
    }

    // to print info about memory
    {
        extern void *_sidata;
        extern void *_sdata;
        extern void *_edata;
        extern void *_sbss;
        extern void *_ebss;
        extern void *_estack;
        extern void *_etext;
        printf("_sidata=%p\n", &_sidata);
        printf("_sdata=%p\n", &_sdata);
        printf("_edata=%p\n", &_edata);
        printf("_sbss=%p\n", &_sbss);
        printf("_ebss=%p\n", &_ebss);
        printf("_estack=%p\n", &_estack);
        printf("_etext=%p\n", &_etext);
        printf("_heap_start=%p\n", &_heap_start);
    }

276
277
278
279
280
281
282
283
284
285
    // GC info
    {
        gc_info_t info;
        gc_info(&info);
        printf("GC:\n");
        printf("  %lu total\n", info.total);
        printf("  %lu : %lu\n", info.used, info.free);
        printf("  1=%lu 2=%lu m=%lu\n", info.num_1block, info.num_2block, info.max_block);
    }

286
287
288
289
290
    // free space on flash
    {
        DWORD nclst;
        FATFS *fatfs;
        f_getfree("0:", &nclst, &fatfs);
291
        printf("LFS free: %u bytes\n", (uint)(nclst * fatfs->csize * 512));
292
    }
293

294
    return mp_const_none;
295
296
}

297
// SD card test
298
static mp_obj_t pyb_sd_test(void) {
299
300
    extern void sdio_init(void);
    sdio_init();
301
    return mp_const_none;
302
303
}

304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
static void SYSCLKConfig_STOP(void) {
    /* After wake-up from STOP reconfigure the system clock */
    /* Enable HSE */
    RCC_HSEConfig(RCC_HSE_ON);

    /* Wait till HSE is ready */
    while (RCC_GetFlagStatus(RCC_FLAG_HSERDY) == RESET) {
    }

    /* Enable PLL */
    RCC_PLLCmd(ENABLE);

    /* Wait till PLL is ready */
    while (RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET) {
    }

    /* Select PLL as system clock source */
    RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);

    /* Wait till PLL is used as system clock source */
    while (RCC_GetSYSCLKSource() != 0x08) {
    }
}

328
static mp_obj_t pyb_stop(void) {
329
330
331
332
333
334
335
336
337
338
339
340
    PWR_EnterSTANDBYMode();
    //PWR_FlashPowerDownCmd(ENABLE); don't know what the logic is with this

    /* Enter Stop Mode */
    PWR_EnterSTOPMode(PWR_Regulator_LowPower, PWR_STOPEntry_WFI);

    /* Configures system clock after wake-up from STOP: enable HSE, PLL and select 
     *        PLL as system clock source (HSE and PLL are disabled in STOP mode) */
    SYSCLKConfig_STOP();

    //PWR_FlashPowerDownCmd(DISABLE);

341
    return mp_const_none;
342
343
}

344
static mp_obj_t pyb_standby(void) {
345
    PWR_EnterSTANDBYMode();
346
    return mp_const_none;
347
348
}

349
350
351
mp_obj_t pyb_usart_send(mp_obj_t data) {
    usart_tx_char(mp_obj_get_int(data));
    return mp_const_none;
352
353
}

354
355
mp_obj_t pyb_usart_receive(void) {
    return mp_obj_new_int(usart_rx_char());
356
357
}

358
mp_obj_t pyb_usart_status(void) {
359
    if (usart_rx_any()) {
360
        return mp_const_true;
361
    } else {
362
        return mp_const_false;
363
364
365
    }
}

Damien's avatar
Damien committed
366
367
368
369
370
371
372
373
374
375
376
377
char *strdup(const char *str) {
    uint32_t len = strlen(str);
    char *s2 = m_new(char, len + 1);
    memcpy(s2, str, len);
    s2[len] = 0;
    return s2;
}

#define READLINE_HIST_SIZE (8)

static const char *readline_hist[READLINE_HIST_SIZE] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL};

378
379
380
381
382
void stdout_tx_str(const char *str) {
    usart_tx_str(str);
    usb_vcp_send_str(str);
}

383
int readline(vstr_t *line, const char *prompt) {
384
    stdout_tx_str(prompt);
385
    int len = vstr_len(line);
Damien's avatar
Damien committed
386
387
    int escape = 0;
    int hist_num = 0;
388
    for (;;) {
389
390
391
392
393
394
395
396
397
        char c;
        for (;;) {
            if (usb_vcp_rx_any() != 0) {
                c = usb_vcp_rx_get();
                break;
            } else if (usart_rx_any()) {
                c = usart_rx_char();
                break;
            }
Damien's avatar
Damien committed
398
            sys_tick_delay_ms(1);
399
400
401
            if (storage_needs_flush()) {
                storage_flush();
            }
402
        }
Damien's avatar
Damien committed
403
404
405
406
        if (escape == 0) {
            if (c == 4 && vstr_len(line) == len) {
                return 0;
            } else if (c == '\r') {
407
                stdout_tx_str("\r\n");
Damien's avatar
Damien committed
408
409
410
411
412
413
414
415
416
417
                for (int i = READLINE_HIST_SIZE - 1; i > 0; i--) {
                    readline_hist[i] = readline_hist[i - 1];
                }
                readline_hist[0] = strdup(vstr_str(line));
                return 1;
            } else if (c == 27) {
                escape = true;
            } else if (c == 127) {
                if (vstr_len(line) > len) {
                    vstr_cut_tail(line, 1);
418
                    stdout_tx_str("\b \b");
Damien's avatar
Damien committed
419
420
421
                }
            } else if (32 <= c && c <= 126) {
                vstr_add_char(line, c);
422
                stdout_tx_str(line->buf + line->len - 1);
423
            }
Damien's avatar
Damien committed
424
425
426
427
428
429
430
431
432
433
434
435
436
        } else if (escape == 1) {
            if (c == '[') {
                escape = 2;
            } else {
                escape = 0;
            }
        } else if (escape == 2) {
            escape = 0;
            if (c == 'A') {
                // up arrow
                if (hist_num < READLINE_HIST_SIZE && readline_hist[hist_num] != NULL) {
                    // erase line
                    for (int i = line->len - len; i > 0; i--) {
437
                        stdout_tx_str("\b \b");
Damien's avatar
Damien committed
438
439
440
441
442
                    }
                    // set line to history
                    line->len = len;
                    vstr_add_str(line, readline_hist[hist_num]);
                    // draw line
443
                    stdout_tx_str(readline_hist[hist_num]);
Damien's avatar
Damien committed
444
445
446
447
448
449
                    // increase hist num
                    hist_num += 1;
                }
            }
        } else {
            escape = 0;
450
        }
Damien's avatar
Damien committed
451
        sys_tick_delay_ms(10);
452
    }
453
454
}

455
void do_repl(void) {
456
457
    stdout_tx_str("Micro Python 0.1; STM32F405RG; PYBv3\r\n");
    stdout_tx_str("Type \"help()\" for more information.\r\n");
458
459
460

    vstr_t line;
    vstr_init(&line);
461
462

    for (;;) {
463
464
465
        vstr_reset(&line);
        int ret = readline(&line, ">>> ");
        if (ret == 0) {
466
            // EOF
467
468
469
470
471
            break;
        }

        if (vstr_len(&line) == 0) {
            continue;
472
        }
473

474
        if (mp_repl_is_compound_stmt(vstr_str(&line))) {
475
            for (;;) {
476
477
478
479
480
                vstr_add_char(&line, '\n');
                int len = vstr_len(&line);
                int ret = readline(&line, "... ");
                if (ret == 0 || vstr_len(&line) == len) {
                    // done entering compound statement
481
482
483
484
485
                    break;
                }
            }
        }

486
487
488
489
        mp_lexer_str_buf_t sb;
        mp_lexer_t *lex = mp_lexer_new_from_str_len("<stdin>", vstr_str(&line), vstr_len(&line), false, &sb);
        mp_parse_node_t pn = mp_parse(lex, MP_PARSE_SINGLE_INPUT);
        mp_lexer_free(lex);
490

491
492
        if (pn != MP_PARSE_NODE_NULL) {
            bool comp_ok = mp_compile(pn, true);
493
            if (comp_ok) {
494
495
                mp_obj_t module_fun = rt_make_function_from_id(1);
                if (module_fun != mp_const_none) {
496
                    nlr_buf_t nlr;
497
                    uint32_t start = sys_tick_counter;
498
499
500
                    if (nlr_push(&nlr) == 0) {
                        rt_call_function_0(module_fun);
                        nlr_pop();
501
502
503
504
505
                        // optional timing
                        if (0) {
                            uint32_t ticks = sys_tick_counter - start; // TODO implement a function that does this properly
                            printf("(took %lu ms)\n", ticks);
                        }
506
507
                    } else {
                        // uncaught exception
508
                        mp_obj_print((mp_obj_t)nlr.ret_val);
509
510
511
512
513
514
                        printf("\n");
                    }
                }
            }
        }
    }
515

516
    stdout_tx_str("\r\n");
517
518
519
}

bool do_file(const char *filename) {
520
521
    mp_lexer_file_buf_t fb;
    mp_lexer_t *lex = mp_lexer_new_from_file(filename, &fb);
522
523
524
525
526
527

    if (lex == NULL) {
        printf("could not open file '%s' for reading\n", filename);
        return false;
    }

528
529
    mp_parse_node_t pn = mp_parse(lex, MP_PARSE_FILE_INPUT);
    mp_lexer_free(lex);
530

531
    if (pn == MP_PARSE_NODE_NULL) {
532
533
534
        return false;
    }

535
    bool comp_ok = mp_compile(pn, false);
536
537
538
539
    if (!comp_ok) {
        return false;
    }

540
541
    mp_obj_t module_fun = rt_make_function_from_id(1);
    if (module_fun == mp_const_none) {
542
543
544
545
546
547
548
549
550
551
        return false;
    }

    nlr_buf_t nlr;
    if (nlr_push(&nlr) == 0) {
        rt_call_function_0(module_fun);
        nlr_pop();
        return true;
    } else {
        // uncaught exception
552
        mp_obj_print((mp_obj_t)nlr.ret_val);
553
554
555
        printf("\n");
        return false;
    }
556
557
}

558
559
560
561
562
563
#define RAM_START (0x20000000) // fixed for chip
#define HEAP_END  (0x2001c000) // tunable
#define RAM_END   (0x20020000) // fixed for chip

void gc_helper_get_regs_and_clean_stack(machine_uint_t *regs, machine_uint_t heap_end);

564
void gc_collect(void) {
565
    uint32_t start = sys_tick_counter;
Damien's avatar
Damien committed
566
    gc_collect_start();
567
568
569
570
    gc_collect_root((void**)RAM_START, (((uint32_t)&_heap_start) - RAM_START) / 4);
    machine_uint_t regs[10];
    gc_helper_get_regs_and_clean_stack(regs, HEAP_END);
    gc_collect_root((void**)HEAP_END, (RAM_END - HEAP_END) / 4); // will trace regs since they now live in this function on the stack
Damien's avatar
Damien committed
571
    gc_collect_end();
572
    uint32_t ticks = sys_tick_counter - start; // TODO implement a function that does this properly
573
574
575
576
577
578
579
580
581
582

    if (0) {
        // print GC info
        gc_info_t info;
        gc_info(&info);
        printf("GC@%lu %lums\n", start, ticks);
        printf(" %lu total\n", info.total);
        printf(" %lu : %lu\n", info.used, info.free);
        printf(" 1=%lu 2=%lu m=%lu\n", info.num_1block, info.num_2block, info.max_block);
    }
583
584
}

585
mp_obj_t pyb_gc(void) {
586
    gc_collect();
587
    return mp_const_none;
588
589
}

Damien's avatar
Damien committed
590
591
#define MMA_ADDR (0x4c)

592
593
int mma_buf[12];

594
mp_obj_t pyb_mma_read(void) {
595
596
597
598
599
600
    for (int i = 0; i <= 6; i += 3) {
        mma_buf[0 + i] = mma_buf[0 + i + 3];
        mma_buf[1 + i] = mma_buf[1 + i + 3];
        mma_buf[2 + i] = mma_buf[2 + i + 3];
    }

Damien's avatar
Damien committed
601
602
603
    mma_start(MMA_ADDR, 1);
    mma_send_byte(0);
    mma_restart(MMA_ADDR, 0);
604
    for (int i = 0; i <= 2; i++) {
Damien's avatar
Damien committed
605
606
607
608
        int v = mma_read_ack() & 0x3f;
        if (v & 0x20) {
            v |= ~0x1f;
        }
609
        mma_buf[9 + i] = v;
Damien's avatar
Damien committed
610
    }
611
612
    int jolt_info = mma_read_nack();

613
614
615
616
617
    mp_obj_t data[4];
    data[0] = mp_obj_new_int(jolt_info);
    data[1] = mp_obj_new_int(mma_buf[2] + mma_buf[5] + mma_buf[8] + mma_buf[11]);
    data[2] = mp_obj_new_int(mma_buf[1] + mma_buf[4] + mma_buf[7] + mma_buf[10]);
    data[3] = mp_obj_new_int(mma_buf[0] + mma_buf[3] + mma_buf[6] + mma_buf[9]);
618

Damien's avatar
Damien committed
619
620
621
    return rt_build_tuple(4, data); // items in reverse order in data
}

622
623
mp_obj_t pyb_hid_send_report(mp_obj_t arg) {
    mp_obj_t *items = mp_obj_get_array_fixed_n(arg, 4);
624
    uint8_t data[4];
625
626
627
628
    data[0] = mp_obj_get_int(items[0]);
    data[1] = mp_obj_get_int(items[1]);
    data[2] = mp_obj_get_int(items[2]);
    data[3] = mp_obj_get_int(items[3]);
629
    usb_hid_send_report(data);
630
    return mp_const_none;
631
632
}

633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
static void rtc_init(void) {
    /* Enable the PWR clock */
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);

    /* Allow access to RTC */
    PWR_BackupAccessCmd(ENABLE);

    /* Enable the LSE OSC */
    RCC_LSEConfig(RCC_LSE_ON);

    /* Wait till LSE is ready */
    while(RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET) {
    }

    /* Select the RTC Clock Source */
    RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
    /* ck_spre(1Hz) = RTCCLK(LSE) /(uwAsynchPrediv + 1)*(uwSynchPrediv + 1)*/
    uint32_t uwSynchPrediv = 0xFF;
    uint32_t uwAsynchPrediv = 0x7F;

    /* Enable the RTC Clock */
    RCC_RTCCLKCmd(ENABLE);

    /* Wait for RTC APB registers synchronisation */
    RTC_WaitForSynchro();

    /* Configure the RTC data register and RTC prescaler */
    RTC_InitTypeDef RTC_InitStructure;
    RTC_InitStructure.RTC_AsynchPrediv = uwAsynchPrediv;
    RTC_InitStructure.RTC_SynchPrediv = uwSynchPrediv;
    RTC_InitStructure.RTC_HourFormat = RTC_HourFormat_24;
    RTC_Init(&RTC_InitStructure);

    // Set the date (BCD)
    RTC_DateTypeDef RTC_DateStructure;
    RTC_DateStructure.RTC_Year = 0x13;
    RTC_DateStructure.RTC_Month = RTC_Month_October;
    RTC_DateStructure.RTC_Date = 0x26;
    RTC_DateStructure.RTC_WeekDay = RTC_Weekday_Saturday;
    RTC_SetDate(RTC_Format_BCD, &RTC_DateStructure);

    // Set the time (BCD)
    RTC_TimeTypeDef RTC_TimeStructure;
    RTC_TimeStructure.RTC_H12     = RTC_H12_AM;
    RTC_TimeStructure.RTC_Hours   = 0x01;
    RTC_TimeStructure.RTC_Minutes = 0x53;
    RTC_TimeStructure.RTC_Seconds = 0x00;
    RTC_SetTime(RTC_Format_BCD, &RTC_TimeStructure);

    // Indicator for the RTC configuration
    //RTC_WriteBackupRegister(RTC_BKP_DR0, 0x32F2);
}

686
mp_obj_t pyb_rtc_read(void) {
687
688
689
    RTC_TimeTypeDef RTC_TimeStructure;
    RTC_GetTime(RTC_Format_BIN, &RTC_TimeStructure);
    printf("%02d:%02d:%02d\n", RTC_TimeStructure.RTC_Hours, RTC_TimeStructure.RTC_Minutes, RTC_TimeStructure.RTC_Seconds);
690
    return mp_const_none;
691
692
}

693
694
695
696
697
698
699
typedef struct _pyb_file_obj_t {
    mp_obj_base_t base;
    FIL fp;
} pyb_file_obj_t;

void file_obj_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in) {
    printf("<file %p>", self_in);
Damien's avatar
Damien committed
700
701
}

702
703
704
mp_obj_t file_obj_read(mp_obj_t self_in, mp_obj_t arg) {
    pyb_file_obj_t *self = self_in;
    int n = mp_obj_get_int(arg);
Damien's avatar
Damien committed
705
706
    char *buf = m_new(char, n + 1);
    UINT n_out;
707
    f_read(&self->fp, buf, n, &n_out);
Damien's avatar
Damien committed
708
    buf[n_out] = 0;
709
    return mp_obj_new_str(qstr_from_str_take(buf));
Damien's avatar
Damien committed
710
711
}

712
713
714
mp_obj_t file_obj_write(mp_obj_t self_in, mp_obj_t arg) {
    pyb_file_obj_t *self = self_in;
    const char *s = qstr_str(mp_obj_get_qstr(arg));
Damien's avatar
Damien committed
715
    UINT n_out;
716
    FRESULT res = f_write(&self->fp, s, strlen(s), &n_out);
Damien's avatar
Damien committed
717
718
719
720
721
    if (res != FR_OK) {
        printf("File error: could not write to file; error code %d\n", res);
    } else if (n_out != strlen(s)) {
        printf("File error: could not write all data to file; wrote %d / %d bytes\n", n_out, strlen(s));
    }
722
    return mp_const_none;
Damien's avatar
Damien committed
723
724
}

725
726
727
728
mp_obj_t file_obj_close(mp_obj_t self_in) {
    pyb_file_obj_t *self = self_in;
    f_close(&self->fp);
    return mp_const_none;
Damien's avatar
Damien committed
729
730
}

731
732
733
734
static MP_DEFINE_CONST_FUN_OBJ_2(file_obj_read_obj, file_obj_read);
static MP_DEFINE_CONST_FUN_OBJ_2(file_obj_write_obj, file_obj_write);
static MP_DEFINE_CONST_FUN_OBJ_1(file_obj_close_obj, file_obj_close);

Damien's avatar
Damien committed
735
// TODO gc hook to close the file if not already closed
736
737
738

static const mp_obj_type_t file_obj_type = {
    { &mp_const_type },
Damien's avatar
Damien committed
739
    "File",
740
741
742
743
744
745
746
747
748
749
750
    file_obj_print, // print
    NULL, // call_n
    NULL, // unary_op
    NULL, // binary_op
    NULL, // getiter
    NULL, // iternext
    { // method list
        { "read", &file_obj_read_obj },
        { "write", &file_obj_write_obj },
        { "close", &file_obj_close_obj },
        {NULL, NULL},
Damien's avatar
Damien committed
751
752
753
    }
};

754
755
756
757
758
mp_obj_t pyb_io_open(mp_obj_t o_filename, mp_obj_t o_mode) {
    const char *filename = qstr_str(mp_obj_get_qstr(o_filename));
    const char *mode = qstr_str(mp_obj_get_qstr(o_mode));
    pyb_file_obj_t *self = m_new_obj(pyb_file_obj_t);
    self->base.type = &file_obj_type;
Damien's avatar
Damien committed
759
760
    if (mode[0] == 'r') {
        // open for reading
761
        FRESULT res = f_open(&self->fp, filename, FA_READ);
Damien's avatar
Damien committed
762
763
        if (res != FR_OK) {
            printf("FileNotFoundError: [Errno 2] No such file or directory: '%s'\n", filename);
764
            return mp_const_none;
Damien's avatar
Damien committed
765
766
767
        }
    } else if (mode[0] == 'w') {
        // open for writing, truncate the file first
768
        FRESULT res = f_open(&self->fp, filename, FA_WRITE | FA_CREATE_ALWAYS);
Damien's avatar
Damien committed
769
770
        if (res != FR_OK) {
            printf("?FileError: could not create file: '%s'\n", filename);
771
            return mp_const_none;
Damien's avatar
Damien committed
772
773
774
        }
    } else {
        printf("ValueError: invalid mode: '%s'\n", mode);
775
        return mp_const_none;
Damien's avatar
Damien committed
776
    }
777
    return self;
Damien's avatar
Damien committed
778
779
}

780
781
mp_obj_t pyb_rng_get(void) {
    return mp_obj_new_int(RNG_GetRandomNumber() >> 16);
782
783
}

784
int main(void) {
785
    // TODO disable JTAG
Damien's avatar
Damien committed
786

787
788
789
    // update the SystemCoreClock variable
    SystemCoreClockUpdate();

790
791
792
793
794
795
    // set interrupt priority config to use all 4 bits for pre-empting
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);

    // enable the CCM RAM and the GPIO's
    RCC->AHB1ENR |= RCC_AHB1ENR_CCMDATARAMEN | RCC_AHB1ENR_GPIOAEN | RCC_AHB1ENR_GPIOBEN | RCC_AHB1ENR_GPIOCEN;

796
    // configure SDIO pins to be high to start with (apparently makes it more robust)
797
798
799
800
801
802
803
804
805
806
807
808
809
810
    {
      GPIO_InitTypeDef GPIO_InitStructure;
      GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8 | GPIO_Pin_9 | GPIO_Pin_10 | GPIO_Pin_11 | GPIO_Pin_12;
      GPIO_InitStructure.GPIO_Speed = GPIO_Speed_25MHz;
      GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
      GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
      GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
      GPIO_Init(GPIOC, &GPIO_InitStructure);

      // Configure PD.02 CMD line
      GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
      GPIO_Init(GPIOD, &GPIO_InitStructure);
    }

811
812
    // basic sub-system init
    sys_tick_init();
Damien's avatar
Damien committed
813
    led_init();
814
    rtc_init();
815
816
817
818
819

    // turn on LED to indicate bootup
    led_state(PYB_LED_G1, 1);

    // more sub-system init
Damien's avatar
Damien committed
820
    sw_init();
821
    storage_init();
822
823

    //usart_init(); disabled while wi-fi is enabled
Damien's avatar
Damien committed
824

825
826
    int first_soft_reset = true;

827
828
soft_reset:

Damien's avatar
Damien committed
829
    // GC init
830
    gc_init(&_heap_start, (void*)HEAP_END);
Damien's avatar
Damien committed
831

832
    // Micro Python init
833
834
    qstr_init();
    rt_init();
835

836
    // LCD init
837
    //lcd_init(); disabled while servos on PA0 PA1
838

839
840
841
    // servo
    servo_init();

842
    // audio
843
    //audio_init();
844

845
846
847
    // timer
    timer_init();

848
    // RNG
849
    if (1) {
850
851
852
853
        RCC_AHB2PeriphClockCmd(RCC_AHB2Periph_RNG, ENABLE);
        RNG_Cmd(ENABLE);
    }

854
    // add some functions to the python namespace
855
    {
856
857
        rt_store_name(qstr_from_str_static("help"), rt_make_function_0(pyb_help));

858
        mp_obj_t m = mp_module_new();
859
        rt_store_attr(m, qstr_from_str_static("info"), rt_make_function_0(pyb_info));
860
        rt_store_attr(m, qstr_from_str_static("sd_test"), rt_make_function_0(pyb_sd_test));
861
862
        rt_store_attr(m, qstr_from_str_static("stop"), rt_make_function_0(pyb_stop));
        rt_store_attr(m, qstr_from_str_static("standby"), rt_make_function_0(pyb_standby));
863
864
        rt_store_attr(m, qstr_from_str_static("source_dir"), rt_make_function_1(pyb_source_dir));
        rt_store_attr(m, qstr_from_str_static("main"), rt_make_function_1(pyb_main));
865
        rt_store_attr(m, qstr_from_str_static("sync"), rt_make_function_0(pyb_sync));
866
867
868
        rt_store_attr(m, qstr_from_str_static("gc"), rt_make_function_0(pyb_gc));
        rt_store_attr(m, qstr_from_str_static("delay"), rt_make_function_1(pyb_delay));
        rt_store_attr(m, qstr_from_str_static("led"), rt_make_function_1(pyb_led));
869
        rt_store_attr(m, qstr_from_str_static("switch"), rt_make_function_0(pyb_sw));
870
        rt_store_attr(m, qstr_from_str_static("servo"), rt_make_function_2(pyb_servo_set));
871
        rt_store_attr(m, qstr_from_str_static("pwm"), rt_make_function_2(pyb_pwm_set));
872
        rt_store_attr(m, qstr_from_str_static("accel"), rt_make_function_0(pyb_mma_read));
873
        rt_store_attr(m, qstr_from_str_static("hid"), rt_make_function_1(pyb_hid_send_report));
874
        rt_store_attr(m, qstr_from_str_static("time"), rt_make_function_0(pyb_rtc_read));
875
876
877
        rt_store_attr(m, qstr_from_str_static("uout"), rt_make_function_1(pyb_usart_send));
        rt_store_attr(m, qstr_from_str_static("uin"), rt_make_function_0(pyb_usart_receive));
        rt_store_attr(m, qstr_from_str_static("ustat"), rt_make_function_0(pyb_usart_status));
878
        rt_store_attr(m, qstr_from_str_static("rand"), rt_make_function_0(pyb_rng_get));
879
        rt_store_attr(m, qstr_from_str_static("Led"), rt_make_function_1(pyb_Led));
880
        rt_store_attr(m, qstr_from_str_static("Servo"), rt_make_function_1(pyb_Servo));
881
	rt_store_attr(m, qstr_from_str_static("I2C"), rt_make_function_2(pyb_I2C));
882
        rt_store_name(qstr_from_str_static("pyb"), m);
Damien's avatar
Damien committed
883
884

        rt_store_name(qstr_from_str_static("open"), rt_make_function_2(pyb_io_open));
885
    }
886

887
888
    // print a message to the LCD
    lcd_print_str(" micro py board\n");
Damien's avatar
Damien committed
889

890
891
892
893
894
895
896
897
898
899
900
901
902
    // check if user switch held (initiates reset of filesystem)
    bool reset_filesystem = false;
    if (sw_get()) {
        reset_filesystem = true;
        for (int i = 0; i < 50; i++) {
            if (!sw_get()) {
                reset_filesystem = false;
                break;
            }
            sys_tick_delay_ms(10);
        }
    }

903
904
905
906
    // local filesystem init
    {
        // try to mount the flash
        FRESULT res = f_mount(&fatfs0, "0:", 1);
907
        if (!reset_filesystem && res == FR_OK) {
908
            // mount sucessful
909
        } else if (reset_filesystem || res == FR_NO_FILESYSTEM) {
910
            // no filesystem, so create a fresh one
911
            // TODO doesn't seem to work correctly when reset_filesystem is true...
912
913
914
915
916
917
918
919
920
921
922
923

            // LED on to indicate creation of LFS
            led_state(PYB_LED_R2, 1);
            uint32_t stc = sys_tick_counter;

            res = f_mkfs("0:", 0, 0);
            if (res == FR_OK) {
                // success creating fresh LFS
            } else {
                __fatal_error("could not create LFS");
            }

924
925
926
927
928
929
930
931
932
933
934
935
            // create src directory
            res = f_mkdir("0:/src");
            // ignore result from mkdir

            // create empty main.py
            FIL fp;
            f_open(&fp, "0:/src/main.py", FA_WRITE | FA_CREATE_ALWAYS);
            UINT n;
            f_write(&fp, fresh_main_py, sizeof(fresh_main_py) - 1 /* don't count null terminator */, &n);
            // TODO check we could write n bytes
            f_close(&fp);

936
937
            // keep LED on for at least 200ms
            sys_tick_wait_at_least(stc, 200);
938
939
940
941
            led_state(PYB_LED_R2, 0);
        } else {
            __fatal_error("could not access LFS");
        }
Damien's avatar
Damien committed
942
943
    }

944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
    // make sure we have a /boot.py
    {
        FILINFO fno;
        FRESULT res = f_stat("0:/boot.py", &fno);
        if (res == FR_OK) {
            if (fno.fattrib & AM_DIR) {
                // exists as a directory
                // TODO handle this case
                // see http://elm-chan.org/fsw/ff/img/app2.c for a "rm -rf" implementation
            } else {
                // exists as a file, good!
            }
        } else {
            // doesn't exist, create fresh file

            // LED on to indicate creation of boot.py
            led_state(PYB_LED_R2, 1);
            uint32_t stc = sys_tick_counter;

            FIL fp;
            f_open(&fp, "0:/boot.py", FA_WRITE | FA_CREATE_ALWAYS);
            UINT n;
966
            f_write(&fp, fresh_boot_py, sizeof(fresh_boot_py) - 1 /* don't count null terminator */, &n);
967
968
969
            // TODO check we could write n bytes
            f_close(&fp);

970
971
            // keep LED on for at least 200ms
            sys_tick_wait_at_least(stc, 200);
972
973
974
975
            led_state(PYB_LED_R2, 0);
        }
    }

976
977
978
979
980
    // run /boot.py
    if (!do_file("0:/boot.py")) {
        flash_error(4);
    }

981
982
983
    // USB
    usb_init();

Damien's avatar
Damien committed
984
    // MMA
985
    if (first_soft_reset) {
Damien's avatar
Damien committed
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
        // init and reset address to zero
        mma_init();
        mma_start(MMA_ADDR, 1);
        mma_send_byte(0);
        mma_stop();

        /*
        // read and print all 11 registers
        mma_start(MMA_ADDR, 1);
        mma_send_byte(0);
        mma_restart(MMA_ADDR, 0);
        for (int i = 0; i <= 0xa; i++) {
            int data;
            if (i == 0xa) {
                data = mma_read_nack();