led.c

Go to the documentation of this file.

/*
 * Copyright (C) 2009 by Rittal GmbH & Co. KG,
 * Ulrich Prinz <prinz.u@rittal.de> All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the copyright holders nor the names of
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY EMBEDDED IT AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL EMBEDDED IT
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * For additional information see http://www.ethernut.de/
 *
 */


#include <cfg/os.h>

#include <compiler.h>
#include <dev/board.h>
#include <dev/gpio.h>

#include <stdlib.h>
#include <string.h>
#include <sys/heap.h>
#include <sys/event.h>
#include <sys/timer.h>
#include <sys/atom.h>

#include <sys/nutdebug.h>

#include <cfg/pca9555.h>
#ifdef LED_SUPPORT_IOEXP
#include <dev/pca9555.h>
#endif
#include "cfg/led.h"
#include "dev/led.h"


/* define inverted LED states as LEDs are driven by low side switching */

#ifdef LED_ON_HIGH
#define LED_IS_ON  1
#define LED_IS_OFF 0
#else
#define LED_IS_ON  0
#define LED_IS_OFF 1
#endif

typedef struct
{
    void         *next;     
        uint32_t     timOn;     
    uint32_t     timOff;    
        uint32_t     tim;           
    int          bank;      
    int          pin;       
        int          state;             
    uint_fast8_t fx;        
} LEDEventT;

/* Pointer to first led registered */
LEDEventT *first_led = NULL;

/* Timer- and Timer-Event-Handler */
HANDLE led_tmr = NULL;
HANDLE led_evt = NULL;

int InitLED(LEDEventT *led)
{
#ifdef LED_SUPPORT_IOEXP
    if( led->bank >= IOXP_PORT0) {
        IOExpPinConfigSet(led->bank, led->pin, GPIO_CFG_OUTPUT);
        IOExpSetBitHigh( led->bank, led->pin);
        return 0;
    }
    else
#else
    {
        GpioPinConfigSet( led->bank, led->pin, GPIO_CFG_OUTPUT);
        GpioPinSetHigh( led->bank, led->pin);
        return 0;
    }
#endif
    return -1;
}

static void LedTimerCb(HANDLE timer, void *arg)
{
    NutEventPostAsync( arg);
}

/****************************************************************************/
THREAD( sys_led, arg)
/****************************************************************************/
{
    LEDEventT *led;
    uint32_t now, last, dur;

    NUTASSERT( arg != NULL);

    last = NutGetMillis();
    NutThreadSetPriority(16);
    for(;;) {
        if (NutEventWait(arg, NUT_WAIT_INFINITE)==0) {
            now = NutGetMillis();
            dur = now-last;
            last = now;
            led = first_led;

            while( led)
            {
                switch( led->fx) {
                    case LED_ON:
                        if( led->timOn > 0) {
                            if( led->tim >= dur) led->tim -= dur;
                            else
                                NutSetLed( led, LED_OFF, 0, 0);
                        }
                        break;
                    case LED_OFF:
                        if( led->timOff > 0) {
                            if( led->tim >= dur) led->tim -= dur;
                            else
                                NutSetLed( led, LED_ON, 0, 0);
                        }
                        break;
                    case LED_BLINK:
                        if( led->tim >= dur) led->tim -= dur;
                        else {
                            NutSetLed( led, LED_FLIP, 0, 0);
                            led->fx = LED_BLINK;
                            if( led->state)
                                led->tim = led->timOff;
                            else
                                led->tim = led->timOn;
                        }
                        break;
                }

                led = led->next;
            }
        }
    }
}

void NutSetLed( HANDLE ledh, uint_fast8_t fxin, uint32_t timOn, uint32_t timOff)
{
    LEDEventT *led = (LEDEventT *)ledh;

    NUTASSERT( ledh != NULL);

    led->fx = fxin;

    switch( fxin) {
        case LED_BLINK:
            led->state ^= 1;
            led->timOn = timOn;
            led->timOff = timOff;
            if( led->state==LED_IS_ON)
                led->tim = timOff;
            else
                led->tim = timOn;
            break;
        case LED_FLIP:
            led->state ^= 1;
            break;
        case LED_ON:
            led->state = LED_IS_ON;
            led->timOn = led->tim = timOn;
            break;
        case LED_OFF:
        default:
            led->state = LED_IS_OFF;
            led->timOff = led->tim = timOff;
            break;
    }

#ifdef LED_SUPPORT_IOEXP
    if( led->bank < IOXP_PORT0)
        GpioPinSet( led->bank, led->pin, led->state);
    else
        IOExpSetBit( led->bank, led->pin, led->state);
#else
        GpioPinSet( led->bank, led->pin, led->state);
#endif

}

int NutRegisterLed( HANDLE * ledh, int bank, int pin)
{
    LEDEventT *led;

    /* Check memory constraints and assign memory to new led struct */
    led = malloc(sizeof( LEDEventT));
    *ledh = (void*)led;

    if( led == NULL) {
        return -1;
    }

    /* Preset new led struct */
    memset( led, 0, sizeof( LEDEventT));
    led->bank = bank;
    led->pin = pin;
    led->state = LED_IS_OFF;

    /* Assign the led to the chain */
    NutEnterCritical();
    if( first_led == NULL) {
        /* it is the first led */
        first_led = led;
    }
    else {
        /* if not first, put it into the chain at first position */
        led->next = first_led;
        first_led = led;
    }
    NutExitCritical();

    /* Start timer for LED effects, but only one timer for all */
    if( led_tmr == NULL) {
        NutThreadCreate("sys_led", sys_led, &led_evt, 192);
        led_tmr = NutTimerStart(10, LedTimerCb, &led_evt, 0);
    }

    return InitLED( led);
}