File content as of revision 8:18e86eb228ca:

/**
 * @file   main.cpp
 * @brief  Abstract
 * @copyright (c) Salem TANG
 */
// -----------------------------------------------------------------------------
//  note
// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------
//  include files
// -----------------------------------------------------------------------------
#include "main.h"
#if (defined RTC_CLOCK_TEST) || (defined LED_BLINK_TEST)
#include "mbed.h"
#endif  // RTC_CLOCK_TEST || LED_BLINK_TEST
#if (defined RTC_CLOCK_TEST) || (defined SLCD_BLINKING_TEST)
#include "SLCD.h"
#endif  // RTC_CLOCK_TEST || SLCD_BLINKING_TEST
#ifdef SLCD_BLINKING_TEST
#include "MAG3110.h"
#include "MMA8451Q.h"
#include "TSISensor.h"
#endif  // SLCD_BLINKING_TEST

// -----------------------------------------------------------------------------
//  general define
// -----------------------------------------------------------------------------
#ifdef SLCD_BLINKING_TEST
#define LED_ON  0
#define LED_OFF 1
#define PRESS_ON  0
#define PRESS_OFF 1
#define MMA8451_I2C_ADDRESS (0x1d<<1)
#endif  // SLCD_BLINKING_TEST

// -----------------------------------------------------------------------------
//  struct define
// -----------------------------------------------------------------------------
#ifdef SLCD_BLINKING_TEST
struct KL46_SENSOR_DATA {
    int   sw1State;
    int   sw3State;
    float accValX;
    float accValY;
    float accValZ;
    float slider;
    float light;
    int   magValX;
    int   magValY;
    int   magValZ;
} sensorData;
#endif  // SLCD_BLINKING_TEST

// -----------------------------------------------------------------------------
//  external function
// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------
//  function prototype
// -----------------------------------------------------------------------------
#if (defined RTC_CLOCK_TEST) || (defined LED_BLINK_TEST) || (defined SLCD_BLINKING_TEST)
void initializeSetting (void);
#endif  // RTC_CLOCK_TEST || LED_BLINK_TEST || SLCD_BLINKING_TEST
#ifdef LED_BLINK_TEST
void ledBlink (float dutyfactor);
#endif  // LED_BLINK_TEST
#ifdef RTC_CLOCK_TEST
void rtcClock (void);
void scrollMessage (void);
void switchinput1_INTIRQ (void);
void switchinput3_INTIRQ (void);
#endif  // LED_BLINK_TEST
#ifdef SLCD_BLINKING_TEST
void SLCD_blinking_msg_wait (char *slcd_msg1, char *slcd_msg2);
#endif  // SLCD_BLINKING_TEST

// -----------------------------------------------------------------------------
//  external variable
// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------
//  global variable
// -----------------------------------------------------------------------------
#if (defined LED_BLINK_TEST) || (defined SLCD_BLINKING_TEST)
PwmOut greenled_PO(LED1);
PwmOut redled_PO(LED2);
DigitalIn switchinput1_DI(SW1);
DigitalIn switchinput3_DI(SW3);
float defaultdutyfactor = 0.0;
#endif  // LED_BLINK_TEST || SLCD_BLINKING_TEST
#if (defined RTC_CLOCK_TEST) || (defined SLCD_BLINKING_TEST)
DigitalOut greenled_DO(LED1);
DigitalOut redled_DO(LED2);
InterruptIn switchinput1_INT(SW1);
InterruptIn switchinput3_INT(SW3);
SLCD slcd;
Timer scroll;
struct tm t;
int i, j, k, lastscroll, display_timer, minute, hour, colon, dp;
char message[60];
char buffer[32];
#endif  // RTC_CLOCK_TEST || SLCD_BLINKING_TEST
#ifdef SLCD_BLINKING_TEST
AnalogIn  light(PTE22);  // analog-light input
TSISensor slider;  // Capacitive Touch Slider
MAG3110 mag(PTE25, PTE24);  // Magnetometer
MMA8451Q acc(PTE25, PTE24, MMA8451_I2C_ADDRESS);
Serial usb_osda(USBTX, USBRX);  // OpenSDA Terminal
#endif  // SLCD_BLINKING_TEST

// -----------------------------------------------------------------------------
//  function
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//! @brief  Main Function
//! @param  [in] nil
//! @retval int
// -----------------------------------------------------------------------------
int main (void)
{
#if (defined RTC_CLOCK_TEST) || (defined LED_BLINK_TEST) || (defined SLCD_BLINKING_TEST)
    initializeSetting();
#endif  // RTC_CLOCK_TEST || LED_BLINK_TEST || SLCD_BLINKING_TEST

    while (true) {
#ifdef RTC_CLOCK_TEST
        rtcClock();
#endif  // RTC_CLOCK_TEST

#ifdef LED_BLINK_TEST
        if (!switchinput1_DI) {
            ledBlink(0.5);
        } else if (!switchinput3_DI) {
            ledBlink(1.0);
        } else {
            ledBlink(2.0);
        }
#endif  // LED_BLINK_TEST

#ifdef SLCD_BLINKING_TEST
        // disable all SLCD DPs
        slcd.DP(0, false); slcd.DP(1, false); slcd.DP(2, false);

        // MAIN/Loop/Sensing and Storing data -----------------//
        sensorData.sw1State = switchinput1_DI; sensorData.sw3State = switchinput3_DI;
        sensorData.accValX = acc.getAccX();  // accX[-1..1]->mouse (Lab1)
        sensorData.accValY = acc.getAccY();  // accY[-1..1]->mouse (Lab1)
        sensorData.accValZ = acc.getAccZ();  // accZ[-1..1]->rLED
        sensorData.slider = slider.readPercentage() * 100;
        sensorData.light = light;
        sensorData.magValX = mag.readVal(MAG_OUT_X_MSB);
        sensorData.magValY = mag.readVal(MAG_OUT_Y_MSB);
        sensorData.magValZ = mag.readVal(MAG_OUT_Z_MSB);

        // MAIN/Loop/Processing and Actions -------------------//
        // sensor -> terminal
        if (sensorData.sw1State != PRESS_OFF) {
            greenled_DO = !greenled_DO; //blinking 
            usb_osda.printf(" \r\n");
            usb_osda.printf(" Switches. Light . Slider . Accelerometer       . Magnetometer      . Compass\r\n");
            usb_osda.printf("  SW1:SW2|  LUX  |  TSI   |  accX : accY : accZ |  magX: magY: maxZ | Heading\r\n");
            usb_osda.printf("  %d : %d  | %1.3f |  %2.0f %%  | %+1.3f:%+1.3f:%+1.3f| %5d:%5d:%5d |  Lab3 \r\n", 
                sensorData.sw1State, sensorData.sw3State, sensorData.light, sensorData.slider, 
                sensorData.accValX, sensorData.accValY, sensorData.accValZ, 
                (short)sensorData.magValX, (short)sensorData.magValY, (short)sensorData.magValZ);
        } greenled_DO = LED_OFF;

        // acc: z-axis 1g min-blinking//acc: z-axis 1g min-blinking
        redled_PO = abs(sensorData.accValZ);

        if (sensorData.slider) {
            slcd.printf(" %3.0f", sensorData.slider);  // night->light .. 1->0
        } else {
            slcd.printf("%1.3f", sensorData.light);  // left->right .. 0->100%
        }
        wait(0.05);  // wait 50ms
#endif  // SLCD_BLINKING_TEST
    }
}

// -----------------------------------------------------------------------------
//! @brief  Initialize Setting
//! @param  [in] nil
//! @retval nil
// -----------------------------------------------------------------------------
#if (defined RTC_CLOCK_TEST) || (defined LED_BLINK_TEST) || (defined SLCD_BLINKING_TEST)
void initializeSetting (void)
{
#if (defined LED_BLINK_TEST) || (defined SLCD_BLINKING_TEST)
    switchinput1_DI.mode(PullUp);
    switchinput3_DI.mode(PullUp);
#endif  // LED_BLINK_TEST || SLCD_BLINKING_TEST

#ifdef RTC_CLOCK_TEST
    time_t seconds = time(NULL);

    slcd.All_Segments(1);
    wait(2);
    slcd.All_Segments(0);
    wait(1);    

    greenled_DO = 1;
    redled_DO = 1;

    sprintf(message, "    rtc clock    sw3 sets the hours    sw1 sets the minutes");

    // scrolling message    
    scroll.start();
    while (i < 58) {
        while (i < 58) {
            scrollMessage();
         }
    }
    wait(1);
    
    switchinput1_INT.rise(switchinput1_INTIRQ);
    switchinput3_INT.rise(switchinput3_INTIRQ);
#endif  // RTC_CLOCK_TEST
    
#ifdef SLCD_BLINKING_TEST
    greenled_DO = LED_ON;  // Green LED ON to indicate running/writing
    redled_PO = LED_OFF;  // Red LED OFF
    redled_PO.period (150);
    
    //---- MAIN/Inits (Wait4SW1) -> Start! --------------------//  
    // wait for Press SW1 - e.g. for HID/CDC/MsensorData Windows install.
    SLCD_blinking_msg_wait("   o","PrES");  // Lab1=Hid; 2=cdc; 3=MsensorData

    //---- MAIN/Inits Interface -------------------------------//
    usb_osda.baud (115200);
    usb_osda.printf ("\n___________________________________\r\n");
    usb_osda.printf ("\nFRDM-KL46Z_Lab\r\n \r\n I am a CDC serial port @OpensensorDataA/mUSB. Baud=115200 \r\n");

    //---- MAIN/Inits Done! (Wait4SW1) -> MANI/Loop -----------//
    greenled_DO = LED_OFF;  // Inits are done
#endif  // SLCD_BLINKING_TEST
}
#endif  // RTC_CLOCK_TEST || LED_BLINK_TEST || SLCD_BLINKING_TEST

// -----------------------------------------------------------------------------
//! @brief  LED Blink
//! @param  [in] dutyfactor Duty Factor Integer
//! @retval nil
// -----------------------------------------------------------------------------
#ifdef LED_BLINK_TEST
void ledBlink (float dutyfactor)
{
        redled_PO.write(defaultdutyfactor);
        greenled_PO.write(dutyfactor - defaultdutyfactor);
        defaultdutyfactor += 0.01;
        if (defaultdutyfactor >= dutyfactor) defaultdutyfactor = 0.0;
        wait(0.5);
}
#endif

// -----------------------------------------------------------------------------
//! @brief  RTC Clock
//! @param  [in] nil
//! @retval nil
// -----------------------------------------------------------------------------
#ifdef RTC_CLOCK_TEST
void rtcClock (void)
{
    time_t seconds = time(NULL);

    if (display_timer > 6) {
        // display Hours,Minutes for 2 seconds
        strftime(buffer, 4, "%H%M", localtime(&seconds));
        slcd.Colon(1);
        redled_DO = 0;
        slcd.DP2(0);
        greenled_DO = 1;
    } else {
        // display Minutes,Seconds for 8 seconds
        strftime(buffer, 4, "%M%S", localtime(&seconds));
        slcd.Colon(0);
        redled_DO = 1;
        slcd.DP2(1);
        greenled_DO = 0;
    }

    slcd.printf(buffer);
    wait(0.5);
    slcd.DP2(0);
    greenled_DO = 1;
    display_timer++;
    if (display_timer > 9) display_timer = 0;
    wait(0.5);
}
#endif  // RTC_CLOCK_TEST

// -----------------------------------------------------------------------------
//! @brief  Scroll Message
//! @param  [in] nil
//! @retval nil
// -----------------------------------------------------------------------------
#ifdef RTC_CLOCK_TEST
void scrollMessage (void)
{
    if (scroll.read_ms() > lastscroll + 350) {
        scroll.reset();
        if (i > 58) {
            i = 0;
        }
        int j, k = i;
        for (j = 0; j < 4; j++) {
            if (message[k+j]) {
                slcd.putc(message[k+j]);
            } else {
                slcd.putc(' ');
                k--;
            }
        }
        i++;
        lastscroll = scroll.read_ms();
    }
}
#endif  // RTC_CLOCK_TEST

// -----------------------------------------------------------------------------
//! @brief  Set Minutes ISR
//! @param  [in] nil
//! @retval nil
// -----------------------------------------------------------------------------
#ifdef RTC_CLOCK_TEST
void switchinput1_INTIRQ (void)
{
    display_timer = 7;
    time_t seconds = time(NULL);
    char buffer[2];
    strftime(buffer, 2,"%H", localtime(&seconds));
    hour = atoi(buffer);  // get Hour integer
    strftime(buffer, 2,"%M", localtime(&seconds));
    minute = atoi(buffer);  // get Minutes integer
    minute++;
    if (minute > 59) minute = 0;
    t.tm_sec = 0;  // Seconds reset to zero
    t.tm_min = minute;
    t.tm_hour = hour;
    t.tm_mday = 1;
    t.tm_mon = 2;
    t.tm_year = 114;
    set_time(mktime(&t));
}
#endif  // RTC_CLOCK_TEST

// -----------------------------------------------------------------------------
//! @brief  Set Hours ISR
//! @param  [in] nil
//! @retval nil
// -----------------------------------------------------------------------------
#ifdef RTC_CLOCK_TEST
void switchinput3_INTIRQ (void)
{
    display_timer = 7;
    time_t seconds = time(NULL);
    char buffer[2];
    strftime(buffer, 2,"%H", localtime(&seconds));
    hour = atoi(buffer);  // get Hour integer
    strftime(buffer, 2,"%M", localtime(&seconds));
    minute = atoi(buffer);  // get Minutes integer
    hour++;
    if (hour > 23) hour = 0;
    t.tm_sec = 0;  // Seconds reset to zero
    t.tm_min = minute;
    t.tm_hour = hour;
    t.tm_mday = 1;
    t.tm_mon = 2;
    t.tm_year = 114;
    set_time(mktime(&t));
}
#endif  //RTC_CLOCK_TEST

// -----------------------------------------------------------------------------
//! @brief  SLCD Blinking Massage
//! @param  [in] *slcd_msg1 Massage 1
//! @param  [in] *slcd_msg2 Massage 2
//! @retval nil
// -----------------------------------------------------------------------------
#ifdef SLCD_BLINKING_TEST
void SLCD_blinking_msg_wait (char *slcd_msg1, char *slcd_msg2)
{
    char wait4sw1 = 0;  // 500ms blinking
    slcd.CharPosition = 0;
    // wait for Press SW1 - to start mag calibration
    while (switchinput1_DI == PRESS_ON);  // wait for release
    while (switchinput1_DI == PRESS_OFF) {  // wait for press
        if (++wait4sw1 < 150) {  // 300ms
            slcd.printf(slcd_msg1);
        } else {  //200ms
            slcd.printf (slcd_msg2);
            wait (0.002);
            slcd.CharPosition = 0;
        }
    }
    while (switchinput1_DI == PRESS_ON);  // wait for release
}
#endif  // SLCD_BLINKING_TEST