led.c 11.8 KB
Newer Older
1
/*
2
 * This file is part of the MicroPython project, http://micropython.org/
3
4
5
 *
 * The MIT License (MIT)
 *
6
 * Copyright (c) 2013-2016 Damien P. George
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

27
28
#include <stdio.h>

29
30
#include "py/nlr.h"
#include "py/runtime.h"
31
#include "py/mphal.h"
32
#include "timer.h"
33
34
#include "led.h"
#include "pin.h"
35
#include "genhdr/pins.h"
36

37
38
#if defined(MICROPY_HW_LED1)

39
40
41
42
43
/// \moduleref pyb
/// \class LED - LED object
///
/// The LED object controls an individual LED (Light Emitting Diode).

44
45
46
47
48
// the default is that LEDs are not inverted, and pin driven high turns them on
#ifndef MICROPY_HW_LED_INVERTED
#define MICROPY_HW_LED_INVERTED (0)
#endif

49
50
typedef struct _pyb_led_obj_t {
    mp_obj_base_t base;
51
    mp_uint_t led_id;
52
53
54
55
56
    const pin_obj_t *led_pin;
} pyb_led_obj_t;

STATIC const pyb_led_obj_t pyb_led_obj[] = {
    {{&pyb_led_type}, 1, &MICROPY_HW_LED1},
57
#if defined(MICROPY_HW_LED2)
58
    {{&pyb_led_type}, 2, &MICROPY_HW_LED2},
59
#if defined(MICROPY_HW_LED3)
60
    {{&pyb_led_type}, 3, &MICROPY_HW_LED3},
61
#if defined(MICROPY_HW_LED4)
62
    {{&pyb_led_type}, 4, &MICROPY_HW_LED4},
63
64
65
66
#endif
#endif
#endif
};
67
#define NUM_LEDS MP_ARRAY_SIZE(pyb_led_obj)
68
69
70
71

void led_init(void) {
    /* Turn off LEDs and initialize */
    for (int led = 0; led < NUM_LEDS; led++) {
72
        const pin_obj_t *led_pin = pyb_led_obj[led].led_pin;
73
        mp_hal_gpio_clock_enable(led_pin->gpio);
74
        MICROPY_HW_LED_OFF(led_pin);
75
        mp_hal_pin_output(led_pin);
76
77
78
    }
}

79
80
81
82
83
84
#if defined(MICROPY_HW_LED1_PWM) \
    || defined(MICROPY_HW_LED2_PWM) \
    || defined(MICROPY_HW_LED3_PWM) \
    || defined(MICROPY_HW_LED4_PWM)

// The following is semi-generic code to control LEDs using PWM.
85
// It currently supports TIM1, TIM2 and TIM3, channels 1-4.
86
87
88
89
90
91
// Configure by defining the relevant MICROPY_HW_LEDx_PWM macros in mpconfigboard.h.
// If they are not defined then PWM will not be available for that LED.

#define LED_PWM_ENABLED (1)

#ifndef MICROPY_HW_LED1_PWM
92
#define MICROPY_HW_LED1_PWM { NULL, 0, 0, 0 }
93
94
#endif
#ifndef MICROPY_HW_LED2_PWM
95
#define MICROPY_HW_LED2_PWM { NULL, 0, 0, 0 }
96
97
#endif
#ifndef MICROPY_HW_LED3_PWM
98
#define MICROPY_HW_LED3_PWM { NULL, 0, 0, 0 }
99
100
#endif
#ifndef MICROPY_HW_LED4_PWM
101
#define MICROPY_HW_LED4_PWM { NULL, 0, 0, 0 }
102
103
104
105
#endif

#define LED_PWM_TIM_PERIOD (10000) // TIM runs at 1MHz and fires every 10ms

106
107
108
// this gives the address of the CCR register for channels 1-4
#define LED_PWM_CCR(pwm_cfg) ((volatile uint32_t*)&(pwm_cfg)->tim->CCR1 + ((pwm_cfg)->tim_channel >> 2))

109
110
111
typedef struct _led_pwm_config_t {
    TIM_TypeDef *tim;
    uint8_t tim_id;
112
    uint8_t tim_channel;
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
    uint8_t alt_func;
} led_pwm_config_t;

STATIC const led_pwm_config_t led_pwm_config[] = {
    MICROPY_HW_LED1_PWM,
    MICROPY_HW_LED2_PWM,
    MICROPY_HW_LED3_PWM,
    MICROPY_HW_LED4_PWM,
};

STATIC uint8_t led_pwm_state = 0;

static inline bool led_pwm_is_enabled(int led) {
    return (led_pwm_state & (1 << led)) != 0;
}

// this function has a large stack so it should not be inlined
STATIC void led_pwm_init(int led) __attribute__((noinline));
STATIC void led_pwm_init(int led) {
    const pin_obj_t *led_pin = pyb_led_obj[led - 1].led_pin;
    const led_pwm_config_t *pwm_cfg = &led_pwm_config[led - 1];

    // GPIO configuration
    GPIO_InitTypeDef gpio_init;
    gpio_init.Pin = led_pin->pin_mask;
    gpio_init.Mode = GPIO_MODE_AF_PP;
    gpio_init.Speed = GPIO_SPEED_FAST;
    gpio_init.Pull = GPIO_NOPULL;
    gpio_init.Alternate = pwm_cfg->alt_func;
    HAL_GPIO_Init(led_pin->gpio, &gpio_init);

    // TIM configuration
    switch (pwm_cfg->tim_id) {
146
        case 1: __TIM1_CLK_ENABLE(); break;
147
148
149
150
        case 2: __TIM2_CLK_ENABLE(); break;
        case 3: __TIM3_CLK_ENABLE(); break;
        default: assert(0);
    }
151
    TIM_HandleTypeDef tim = {0};
152
153
154
155
156
    tim.Instance = pwm_cfg->tim;
    tim.Init.Period = LED_PWM_TIM_PERIOD - 1;
    tim.Init.Prescaler = timer_get_source_freq(pwm_cfg->tim_id) / 1000000 - 1; // TIM runs at 1MHz
    tim.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    tim.Init.CounterMode = TIM_COUNTERMODE_UP;
157
    tim.Init.RepetitionCounter = 0;
158
159
    HAL_TIM_PWM_Init(&tim);

160
    // PWM configuration
161
162
163
    TIM_OC_InitTypeDef oc_init;
    oc_init.OCMode = TIM_OCMODE_PWM1;
    oc_init.Pulse = 0; // off
164
    oc_init.OCPolarity = MICROPY_HW_LED_INVERTED ? TIM_OCPOLARITY_LOW : TIM_OCPOLARITY_HIGH;
165
    oc_init.OCFastMode = TIM_OCFAST_DISABLE;
166
167
168
169
170
    oc_init.OCNPolarity = TIM_OCNPOLARITY_HIGH; // needed for TIM1 and TIM8
    oc_init.OCIdleState = TIM_OCIDLESTATE_SET; // needed for TIM1 and TIM8
    oc_init.OCNIdleState = TIM_OCNIDLESTATE_SET; // needed for TIM1 and TIM8
    HAL_TIM_PWM_ConfigChannel(&tim, &oc_init, pwm_cfg->tim_channel);
    HAL_TIM_PWM_Start(&tim, pwm_cfg->tim_channel);
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191

    // indicate that this LED is using PWM
    led_pwm_state |= 1 << led;
}

STATIC void led_pwm_deinit(int led) {
    // make the LED's pin a standard GPIO output pin
    const pin_obj_t *led_pin = pyb_led_obj[led - 1].led_pin;
    GPIO_TypeDef *g = led_pin->gpio;
    uint32_t pin = led_pin->pin;
    static const int mode = 1; // output
    static const int alt = 0; // no alt func
    g->MODER = (g->MODER & ~(3 << (2 * pin))) | (mode << (2 * pin));
    g->AFR[pin >> 3] = (g->AFR[pin >> 3] & ~(15 << (4 * (pin & 7)))) | (alt << (4 * (pin & 7)));
    led_pwm_state &= ~(1 << led);
}

#else
#define LED_PWM_ENABLED (0)
#endif

192
193
194
195
void led_state(pyb_led_t led, int state) {
    if (led < 1 || led > NUM_LEDS) {
        return;
    }
196

197
    const pin_obj_t *led_pin = pyb_led_obj[led - 1].led_pin;
198
    //printf("led_state(%d,%d)\n", led, state);
199
200
    if (state == 0) {
        // turn LED off
201
        MICROPY_HW_LED_OFF(led_pin);
202
203
    } else {
        // turn LED on
204
        MICROPY_HW_LED_ON(led_pin);
205
    }
206
207
208
209
210
211

    #if LED_PWM_ENABLED
    if (led_pwm_is_enabled(led)) {
        led_pwm_deinit(led);
    }
    #endif
212
213
214
215
216
217
}

void led_toggle(pyb_led_t led) {
    if (led < 1 || led > NUM_LEDS) {
        return;
    }
218

219
220
221
222
223
224
225
226
    #if LED_PWM_ENABLED
    if (led_pwm_is_enabled(led)) {
        // if PWM is enabled then LED has non-zero intensity, so turn it off
        led_state(led, 0);
        return;
    }
    #endif

227
    // toggle the output data register to toggle the LED state
228
    const pin_obj_t *led_pin = pyb_led_obj[led - 1].led_pin;
229
    led_pin->gpio->ODR ^= led_pin->pin_mask;
230
231
}

232
int led_get_intensity(pyb_led_t led) {
233
234
235
    if (led < 1 || led > NUM_LEDS) {
        return 0;
    }
236

237
238
    #if LED_PWM_ENABLED
    if (led_pwm_is_enabled(led)) {
239
240
        const led_pwm_config_t *pwm_cfg = &led_pwm_config[led - 1];
        mp_uint_t i = (*LED_PWM_CCR(pwm_cfg) * 255 + LED_PWM_TIM_PERIOD - 2) / (LED_PWM_TIM_PERIOD - 1);
241
242
243
244
245
246
247
        if (i > 255) {
            i = 255;
        }
        return i;
    }
    #endif

248
    const pin_obj_t *led_pin = pyb_led_obj[led - 1].led_pin;
249
250
251
252
    GPIO_TypeDef *gpio = led_pin->gpio;

    if (gpio->ODR & led_pin->pin_mask) {
        // pin is high
253
        return MICROPY_HW_LED_INVERTED ? 0 : 255;
254
255
    } else {
        // pin is low
256
        return MICROPY_HW_LED_INVERTED ? 255 : 0;
257
258
259
    }
}

260
void led_set_intensity(pyb_led_t led, mp_int_t intensity) {
261
262
    #if LED_PWM_ENABLED
    if (intensity > 0 && intensity < 255) {
263
264
        const led_pwm_config_t *pwm_cfg = &led_pwm_config[led - 1];
        if (pwm_cfg->tim != NULL) {
265
266
267
268
            // set intensity using PWM pulse width
            if (!led_pwm_is_enabled(led)) {
                led_pwm_init(led);
            }
269
            *LED_PWM_CCR(pwm_cfg) = intensity * (LED_PWM_TIM_PERIOD - 1) / 255;
270
271
272
273
274
            return;
        }
    }
    #endif

275
276
277
278
    // intensity not supported for this LED; just turn it on/off
    led_state(led, intensity > 0);
}

279
280
281
282
283
284
285
286
void led_debug(int n, int delay) {
    led_state(1, n & 1);
    led_state(2, n & 2);
    led_state(3, n & 4);
    led_state(4, n & 8);
    HAL_Delay(delay);
}

287
288
289
/******************************************************************************/
/* Micro Python bindings                                                      */

290
void led_obj_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
291
    pyb_led_obj_t *self = self_in;
292
    mp_printf(print, "LED(%lu)", self->led_id);
293
294
}

295
296
297
298
/// \classmethod \constructor(id)
/// Create an LED object associated with the given LED:
///
///   - `id` is the LED number, 1-4.
299
STATIC mp_obj_t led_obj_make_new(const mp_obj_type_t *type, mp_uint_t n_args, mp_uint_t n_kw, const mp_obj_t *args) {
300
    // check arguments
Damien George's avatar
Damien George committed
301
    mp_arg_check_num(n_args, n_kw, 1, 1, false);
302
303

    // get led number
304
    mp_int_t led_id = mp_obj_get_int(args[0]);
305
306

    // check led number
307
    if (!(1 <= led_id && led_id <= NUM_LEDS)) {
308
        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "LED(%d) does not exist", led_id));
309
310
311
    }

    // return static led object
312
    return (mp_obj_t)&pyb_led_obj[led_id - 1];
313
314
}

315
316
/// \method on()
/// Turn the LED on.
317
318
319
320
321
322
mp_obj_t led_obj_on(mp_obj_t self_in) {
    pyb_led_obj_t *self = self_in;
    led_state(self->led_id, 1);
    return mp_const_none;
}

323
324
/// \method off()
/// Turn the LED off.
325
326
327
328
329
330
mp_obj_t led_obj_off(mp_obj_t self_in) {
    pyb_led_obj_t *self = self_in;
    led_state(self->led_id, 0);
    return mp_const_none;
}

331
332
/// \method toggle()
/// Toggle the LED between on and off.
333
334
335
336
337
338
mp_obj_t led_obj_toggle(mp_obj_t self_in) {
    pyb_led_obj_t *self = self_in;
    led_toggle(self->led_id);
    return mp_const_none;
}

339
340
341
342
/// \method intensity([value])
/// Get or set the LED intensity.  Intensity ranges between 0 (off) and 255 (full on).
/// If no argument is given, return the LED intensity.
/// If an argument is given, set the LED intensity and return `None`.
343
mp_obj_t led_obj_intensity(mp_uint_t n_args, const mp_obj_t *args) {
344
    pyb_led_obj_t *self = args[0];
345
346
    if (n_args == 1) {
        return mp_obj_new_int(led_get_intensity(self->led_id));
347
    } else {
348
        led_set_intensity(self->led_id, mp_obj_get_int(args[1]));
349
350
351
352
353
354
355
        return mp_const_none;
    }
}

STATIC MP_DEFINE_CONST_FUN_OBJ_1(led_obj_on_obj, led_obj_on);
STATIC MP_DEFINE_CONST_FUN_OBJ_1(led_obj_off_obj, led_obj_off);
STATIC MP_DEFINE_CONST_FUN_OBJ_1(led_obj_toggle_obj, led_obj_toggle);
356
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(led_obj_intensity_obj, 1, 2, led_obj_intensity);
357

358
359
360
361
362
STATIC const mp_map_elem_t led_locals_dict_table[] = {
    { MP_OBJ_NEW_QSTR(MP_QSTR_on), (mp_obj_t)&led_obj_on_obj },
    { MP_OBJ_NEW_QSTR(MP_QSTR_off), (mp_obj_t)&led_obj_off_obj },
    { MP_OBJ_NEW_QSTR(MP_QSTR_toggle), (mp_obj_t)&led_obj_toggle_obj },
    { MP_OBJ_NEW_QSTR(MP_QSTR_intensity), (mp_obj_t)&led_obj_intensity_obj },
363
364
};

365
366
STATIC MP_DEFINE_CONST_DICT(led_locals_dict, led_locals_dict_table);

367
const mp_obj_type_t pyb_led_type = {
368
    { &mp_type_type },
369
    .name = MP_QSTR_LED,
370
    .print = led_obj_print,
371
    .make_new = led_obj_make_new,
372
    .locals_dict = (mp_obj_t)&led_locals_dict,
373
};
374
375
376
377
378
379
380
381
382
383
384

#else
// For boards with no LEDs, we leave an empty function here so that we don't
// have to put conditionals everywhere.
void led_init(void) {
}
void led_state(pyb_led_t led, int state) {
}
void led_toggle(pyb_led_t led) {
}
#endif  // defined(MICROPY_HW_LED1)