Subversion Repositories ChibiGauge

/*

 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 <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <math.h>

#include "ch.h"

#include "hal.h"

// #include "test.h"

#include "shell.h"

#include "evtimer.h"

#include "chprintf.h"

#include "shellCmds.h"

#include "ap_math.h"

#include "spiInterface.h"

#include "SSD1306.h"

#include "Font.h"

static MUTEX_DECL(mutexDisplay);

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

/* Command line related.                                                     */

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

#define SHELL_WA_SIZE THD_WORKING_AREA_SIZE(1024)

#define TEST_WA_SIZE THD_WORKING_AREA_SIZE(256)

#define RPM_ID 0x10d

// 1 megabit CAN 

#define CAN_CONFIG1000

/*

 * Internal loopback mode, 500KBaud, automatic wakeup, automatic recover

 * from abort mode.

 */

// CAN_BTR_SJW(n), where n = SJW - 1

// CAN_BTR_BRP(n), where n = prescaler - 1

// CAN_BTR_TS1(n), where n = Seg 1 - 1

// CAN_BTR_TS2(n), where n = Seg 2 - 1

#if defined CAN_CONFIG500

static const CANConfig cancfg500 = {

        CAN_MCR_ABOM | CAN_MCR_AWUM | CAN_MCR_TXFP,

        CAN_BTR_LBKM | CAN_BTR_SJW(0) | CAN_BTR_TS2(2) |

                CAN_BTR_TS1(3) | CAN_BTR_BRP(8)};

#elif defined CAN_CONFIG1000

static const CANConfig cancfg1000 = {

        CAN_MCR_ABOM | CAN_MCR_AWUM | CAN_MCR_TXFP,

        CAN_BTR_LBKM | CAN_BTR_SJW(0) | CAN_BTR_TS2(2) |

                CAN_BTR_TS1(4) | CAN_BTR_BRP(3)};

#endif

static const ShellConfig shell_cfg1 = {

        (BaseSequentialStream *)&SD1,

        shellCommands};

////////

// end of shell stuff

uint16_t sampIndex;

void setDriveA(uint8_t bit)

{

        if (bit)

        {

                palSetPad(GPIOA, GPIOA_A1);

                palClearPad(GPIOA, GPIOA_A2);

        }

        else

        {

                palClearPad(GPIOA, GPIOA_A1);

                palSetPad(GPIOA, GPIOA_A2);

        }

}

void setDriveB(uint8_t bit)

{

        if (bit)

        {

                palSetPad(GPIOA, GPIOA_B1);

                palClearPad(GPIOA, GPIOA_B2);

        }

        else

        {

                palClearPad(GPIOA, GPIOA_B1);

                palSetPad(GPIOA, GPIOA_B2);

        }

}

// dial settings

volatile int origin = 0;

;

volatile int target = 0;

volatile int count = 0;

volatile bool pause;

//

void setPause(bool p)

{

        pause = p;

}

static THD_WORKING_AREA(waGaugeThread, 512);

static THD_FUNCTION(gaugeThread, p) {

        (void)p;

        unsigned const fast = 10;

        unsigned const slow = 30;

        unsigned const range = slow - fast;

        unsigned del = fast;

        int step = 1;

        chRegSetThreadName("Step");

        while (TRUE)

        {

                while (pause)

                        chThdSleep(1000);

                switch (count % 4)

                {

                case 0:

                        setDriveA(1);

                        setDriveB(0);

                        break;

                case 1:

                        setDriveA(1);

                        setDriveB(1);

                        break;

                case 2:

                        setDriveA(0);

                        setDriveB(1);

                        break;

                case 3:

                        setDriveA(0);

                        setDriveB(0);

                        break;

                }

                // all this calculates minimum distance from

                // target or origin

                int d1 = abs(count - origin);

                int d2 = abs(count - target);

                // finally, minimum distance

                int dist = d1<d2 ? d1 : d2;

                del = fast;

                if (dist < range) // inside lower bound of distance

                {

                        del = slow - dist;

                }

                chThdSleep(del);

                if (count < target)

                {

                        step = 1;

                }

                if (count > target)

                {

                        step = -1;

                }

                if (count == target)

                {

                        step = 0;

                }

                count = count + step;

        }

}

/*

 * Command Shell Thread

 */

static THD_WORKING_AREA(waShell, 512);

static THD_FUNCTION(shell, p) {

        (void) p;

        thread_t *shelltp = NULL;

        chRegSetThreadName("Shell ");

        /*

         * in this demo it just performs

         * a shell respawn upon its termination.

         */

        while (true)

        {

                if (!shelltp)

                {

                        shelltp = chThdCreateFromHeap(NULL, SHELL_WA_SIZE, "shell", NORMALPRIO, shellThread, (void *)&shell_cfg1);

                }

                else

                {

                        /* If the previous shell exited.*/

                        if (chThdTerminatedX(shelltp))

                        {

                                /* Recovers memory of the previous shell.*/

                                chThdRelease(shelltp);

                                shelltp = NULL;

                        }

                }

                chThdSleepMilliseconds(500);

        }

}

        static THD_WORKING_AREA(waCanRx, 1024);

static THD_FUNCTION(canRx, p) {

        (void) p;

        // initialize can bus hardware

        event_listener_t el;

        CANRxFrame rxmsg;

        canStart(&CAND1, &cancfg1000);

        chRegSetThreadName("CAN receiver");

        chEvtRegister(&CAND1.rxfull_event, &el, 0);

        while (true)

        {

                if (chEvtWaitAnyTimeout(ALL_EVENTS, TIME_MS2I(100)) == 0)

                        continue;

                while (canReceive(&CAND1, CAN_ANY_MAILBOX, &rxmsg, TIME_IMMEDIATE) == MSG_OK)

                {

                        /* Process message.*/

                }

        }

        chEvtUnregister(&CAND1.rxfull_event, &el);

}

/*

 * Application entry point.

 */

int main(void)

{

        //  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();

        /*

         * Initializes serial port.

         */

        sdStart(&SD1, NULL);

        /*

         * Shell manager initialization.

         */

        //      shellInit();

        /*

         * initialise approximate maths

         */

        ap_init();

        chMtxLock(&mutexDisplay);

        /* start the SPI hardware for display */

        ssd1306spiInit();

        ssd1306_begin(SSD1306_SWITCHCAPVCC, 0);

        clearDisplay();

        display();

        chMtxUnlock(&mutexDisplay);

        /*

         * Creates the PLL thread

         */

        chThdCreateStatic(waGaugeThread, sizeof(waGaugeThread), NORMALPRIO, gaugeThread, NULL);

        chThdCreateStatic(waCanRx, sizeof(waCanRx), NORMALPRIO, canRx, NULL);

        chThdCreateStatic(waShell, sizeof(waShell), NORMALPRIO, shell, NULL);

        // reset gauge

        origin = 540;

        count = 540;

        target = 0;

        chThdSleepMilliseconds(1000);

        target = 0;

        int frac = 0;

        /* start the SPI hardware for display */

        while (1)

        {

                chThdSleepMilliseconds(100);

                unsigned const SCALE = frac * 32 + 16;

                ++frac ;

                frac %= 10;

                // read the dial

                origin = count;

                target = target + 1;

                // target = lidar * 630L / 2000L;

                if (target > 540)

                        target = 0;

                chMtxLock(&mutexDisplay);

                font_gotoxy(0, 0);

                clearDisplay();

                //    print_scaled_string("cm:",0,16,4,SCALE);

                print_digits(0, 0, 4, 1, target, SCALE);

                chMtxUnlock(&mutexDisplay);

                display();

        }

}