Subversion Repositories chibiosIgnition

/*

 ChibiOS/RT - Copyright (C) 2006,2007,2008,2009,2010,

 2011,2012 Giovanni Di Sirio.

 This file is part of ChibiOS/RT.

 ChibiOS/RT is free software; you can redistribute it and/or modify

 it under the terms of the GNU General Public License as published by

 the Free Software Foundation; either version 3 of the License, or

 (at your option) any later version.

 ChibiOS/RT is distributed in the hope that it will be useful,

 but WITHOUT ANY WARRANTY; without even the implied warranty of

 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License

 along with this program.  If not, see <http://www.gnu.org/licenses/>.

 ---

 A special exception to the GPL can be applied should you wish to distribute

 a combined work that includes ChibiOS/RT, without being obliged to provide

 the source code for any proprietary components. See the file exception.txt

 for full details of how and when the exception can be applied.

 */

#include <string.h>

#include "ch.h"

#include "hal.h"

#include "test.h"

#include "shell.h"

#include "evtimer.h"

#include "chprintf.h"

#include "ap_math.h"

#include "hardware.h"

#include "useAdc.h"

#include "spiInterface.h"

#include "SSD1306.h"

#include "timer2.h"

static MUTEX_DECL(mutexDisplay);

/*===========================================================================*/

/* Command line related.                                                     */

/*===========================================================================*/

#define SHELL_WA_SIZE   THD_WA_SIZE(2048)

#define TEST_WA_SIZE    THD_WA_SIZE(256)

static void cmd_mem(BaseChannel *chp, int argc, char *argv[]) {

        size_t n, size;

        (void) argv;

        if (argc > 0) {

                chprintf(chp, "Usage: mem\r\n");

                return;

        }

        n = chHeapStatus(NULL, &size);

        chprintf(chp, "core free memory : %u bytes\r\n", chCoreStatus());

        chprintf(chp, "heap fragments   : %u\r\n", n);

        chprintf(chp, "heap free total  : %u bytes\r\n", size);

}

static void cmd_threads(BaseChannel *chp, int argc, char *argv[]) {

        static const char *states[] = { THD_STATE_NAMES };

        Thread *tp;

        (void) argv;

        if (argc > 0) {

                chprintf(chp, "Usage: threads\r\n");

                return;

        }

        chprintf(chp, "    addr    stack prio refs     state time\r\n");

        tp = chRegFirstThread();

        do {

                chprintf(chp, "%.8lx %.8lx %4lu %4lu %9s %lu\r\n", (uint32_t) tp,

                                (uint32_t) tp->p_ctx.r13, (uint32_t) tp->p_prio,

                                (uint32_t)(tp->p_refs - 1), states[tp->p_state],

                                (uint32_t) tp->p_time);

                tp = chRegNextThread(tp);

        } while (tp != NULL);

}

static void cmd_test(BaseChannel *chp, int argc, char *argv[]) {

        Thread *tp;

        (void) argv;

        if (argc > 0) {

                chprintf(chp, "Usage: test\r\n");

                return;

        }

        tp = chThdCreateFromHeap(NULL, TEST_WA_SIZE, chThdGetPriority(), TestThread,

                        chp);

        if (tp == NULL) {

                chprintf(chp, "out of memory\r\n");

                return;

        }

        chThdWait(tp);

}

static const ShellCommand commands[] = { { "mem", cmd_mem }, { "threads",

                cmd_threads }, { "test", cmd_test }, { NULL, NULL } };

static const ShellConfig shell_cfg1 = { (BaseChannel *) &SD2, commands };

/*

 * Red LEDs blinker thread, times are in milliseconds.

 */

uint16_t sampleVal;

static WORKING_AREA(waThread1, 128);

static msg_t Thread1(void *arg) {

        (void) arg;

        chRegSetThreadName("PLL ");

        while (TRUE) {

                sampleVal = getNextPulse();

        chThdSleep(1);

        }

        return 0;

}

/*

 * Application entry point.

 */

int main(void) {

        Thread *shelltp = NULL;

//  struct EventListener el0, el1;

        /*

         * System initializations.

         * - HAL initialization, this also initializes the configured device drivers

         *   and performs the board-specific initializations.

         * - Kernel initialization, the main() function becomes a thread and the

         *   RTOS is active.

         */

        halInit();

        chSysInit();

        initTimer2();

 useAdc();

        /*

         * Activates the serial driver 2 using the driver default configuration.

         */

        sdStart(&SD2, NULL);

        /*

         * Shell manager initialization.

         */

        shellInit();

        ap_init();

         /*

         * Creates the PLL thread

         */

        chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);

        /* start the SPI hardware for display */

        ssd1306spiInit();

        ssd1306_begin( SSD1306_SWITCHCAPVCC, 0) ;

        int spd  = 800;

    int adv = 0;

        setRPM(spd);

        while(1)

{

        spd = getRPM();

        adv = getAdc(0) * 1200 / 4096 - 300;

        /* initialise the display */

        chMtxLock(&mutexDisplay);

        clearDisplay();

    font_gotoxy(0,0);

    print_digits(64, 16, 4, 1, adv);

    print_digits(64, 32, 4,-1, spd);

    print_large_string("RPM:",0,32,4);

    print_large_string("ADV:",0,16,4);

    font_puts("count");

    font_sig_digits(12, 0,1,-1, sampleVal);

         display();

         chMtxUnlock();

         //

//       invertDisplay(x & 32);

         chThdSleep(MS2ST(10));

}

        /*

         * Normal main() thread activity, in this demo it does nothing except

         * sleeping in a loop and listen for events.

         */

        while (TRUE) {

                if (!shelltp)

                        shelltp = shellCreate(&shell_cfg1, SHELL_WA_SIZE, NORMALPRIO);

                else if (chThdTerminated(shelltp)) {

                        chThdRelease(shelltp); /* Recovers memory of the previous shell.   */

                        shelltp = NULL; /* Triggers spawning of a new shell.        */

                }

                chThdSleep(MS2ST(100));

                //   chEvtDispatch(evhndl, chEvtWaitOne(ALL_EVENTS));

        }

        return 0;

}