/* ChibiOS/RT - Copyright (C) 2006,2007,2008,2009,2010 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 . */ /** * @file can.c * @brief CAN Driver code. * * @addtogroup CAN * @{ */ #include "ch.h" #include "hal.h" #if HAL_USE_CAN || defined(__DOXYGEN__) /*===========================================================================*/ /* Driver exported variables. */ /*===========================================================================*/ /*===========================================================================*/ /* Driver local variables. */ /*===========================================================================*/ /*===========================================================================*/ /* Driver local functions. */ /*===========================================================================*/ /*===========================================================================*/ /* Driver exported functions. */ /*===========================================================================*/ /** * @brief CAN Driver initialization. * @note This function is implicitly invoked by @p halInit(), there is * no need to explicitly initialize the driver. * * @init */ void canInit(void) { can_lld_init(); } /** * @brief Initializes the standard part of a @p CANDriver structure. * * @param[out] canp pointer to the @p CANDriver object * * @init */ void canObjectInit(CANDriver *canp) { canp->cd_state = CAN_STOP; canp->cd_config = NULL; chSemInit(&canp->cd_txsem, 0); chSemInit(&canp->cd_rxsem, 0); chEvtInit(&canp->cd_rxfull_event); chEvtInit(&canp->cd_txempty_event); chEvtInit(&canp->cd_error_event); canp->cd_status = 0; #if CAN_USE_SLEEP_MODE chEvtInit(&canp->cd_sleep_event); chEvtInit(&canp->cd_wakeup_event); #endif /* CAN_USE_SLEEP_MODE */ } /** * @brief Configures and activates the CAN peripheral. * @note Activating the CAN bus can be a slow operation this this function * is not atomic, it waits internally for the initialization to * complete. * * @param[in] canp pointer to the @p CANDriver object * @param[in] config pointer to the @p CANConfig object. Depending on * the implementation the value can be @p NULL. * * @api */ void canStart(CANDriver *canp, const CANConfig *config) { chDbgCheck(canp != NULL, "canStart"); chSysLock(); chDbgAssert((canp->cd_state == CAN_STOP) || (canp->cd_state == CAN_STARTING) || (canp->cd_state == CAN_READY), "canStart(), #1", "invalid state"); while (canp->cd_state == CAN_STARTING) chThdSleepS(1); if (canp->cd_state == CAN_STOP) { canp->cd_config = config; can_lld_start(canp); canp->cd_state = CAN_READY; } chSysUnlock(); } /** * @brief Deactivates the CAN peripheral. * * @param[in] canp pointer to the @p CANDriver object * * @api */ void canStop(CANDriver *canp) { chDbgCheck(canp != NULL, "canStop"); chSysLock(); chDbgAssert((canp->cd_state == CAN_STOP) || (canp->cd_state == CAN_READY), "canStop(), #1", "invalid state"); can_lld_stop(canp); chSemResetI(&canp->cd_rxsem, 0); chSemResetI(&canp->cd_txsem, 0); chSchRescheduleS(); canp->cd_state = CAN_STOP; canp->cd_status = 0; chSysUnlock(); } /** * @brief Can frame transmission. * @details The specified frame is queued for transmission, if the hardware * queue is full then the invoking thread is queued. * @note Trying to transmit while in sleep mode simply enqueues the thread. * * @param[in] canp pointer to the @p CANDriver object * @param[in] ctfp pointer to the CAN frame to be transmitted * @param[in] timeout the number of ticks before the operation timeouts, * the following special values are allowed: * - @a TIME_IMMEDIATE immediate timeout. * - @a TIME_INFINITE no timeout. * . * @return The operation result. * @retval RDY_OK the frame has been queued for transmission. * @retval RDY_TIMEOUT The operation has timed out. * @retval RDY_RESET The driver has been stopped while waiting. * * @api */ msg_t canTransmit(CANDriver *canp, const CANTxFrame *ctfp, systime_t timeout) { chDbgCheck((canp != NULL) && (ctfp != NULL), "canTransmit"); chSysLock(); chDbgAssert((canp->cd_state == CAN_READY) || (canp->cd_state == CAN_SLEEP), "canTransmit(), #1", "invalid state"); while ((canp->cd_state == CAN_SLEEP) || !can_lld_can_transmit(canp)) { msg_t msg = chSemWaitTimeoutS(&canp->cd_txsem, timeout); if (msg != RDY_OK) { chSysUnlock(); return msg; } } can_lld_transmit(canp, ctfp); chSysUnlock(); return RDY_OK; } /** * @brief Can frame receive. * @details The function waits until a frame is received. * @note Trying to receive while in sleep mode simply enqueues the thread. * * @param[in] canp pointer to the @p CANDriver object * @param[out] crfp pointer to the buffer where the CAN frame is copied * @param[in] timeout the number of ticks before the operation timeouts, * the following special va
/*
    ChibiOS/RT - Copyright (C) 2006-2013 Giovanni Di Sirio
    LPC122x PWM driver - Copyright (C) 2013 Marcin Jokel

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

        http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
*/

#include "ch.h"
#include "hal.h"

static void pwm2pcb(PWMDriver *pwmp) {

  (void)pwmp;
  palSetPad(GPIO1, GPIO1_LED2);
}

static void pwm2c0cb(PWMDriver *pwmp) {

  (void)pwmp;
  palClearPad(GPIO1, GPIO1_LED2);
}

static PWMConfig pwmcfg = {
  10000,                                    /* 100kHz PWM clock frequency.   */
  1000,                                     /* PWM 10 Hz    */
  pwm2pcb,
  {
   {PWM_OUTPUT_ACTIVE_LOW, pwm2c0cb},
   {PWM_OUTPUT_ACTIVE_LOW, NULL}
  }
};

/*
 * Application entry point.
 */
int main(void) {

  /*
   * 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 the PWM driver 2.
   */
  pwmStart(&PWMD2, &pwmcfg);
  chThdSleepMilliseconds(2000);

  /*
   * Starts the PWM channel 1 using 75% duty cycle.
   */
  pwmEnableChannel(&PWMD2, 0, 250);
  chThdSleepMilliseconds(5000);

  /*
   * Changes the PWM channel 1 to 50% duty cycle.
   */
  pwmEnableChannel(&PWMD2, 0, 500);
  chThdSleepMilliseconds(5000);

  /*
   * Changes the PWM channel 0 to 75% duty cycle.
   */
  pwmEnableChannel(&PWMD2, 0, 250);
  chThdSleepMilliseconds(5000);

  /*
   * Changes PWM period to half second the duty cycle becomes 50%
   * implicitly.
   */
  pwmChangePeriod(&PWMD2, 500);
  chThdSleepMilliseconds(5000);

  /*
   * Normal main() thread activity, in this demo it does nothing.
   */
  while (TRUE) {
    chThdSleepMilliseconds(500);
  }
  return 0;
}