From de1151921960d485fd46a211a228e469185a21da Mon Sep 17 00:00:00 2001 From: gdisirio Date: Wed, 19 Aug 2009 06:23:42 +0000 Subject: [PATCH] git-svn-id: svn://svn.code.sf.net/p/chibios/svn/trunk@1074 35acf78f-673a-0410-8e92-d51de3d6d3f4 --- os/io/readme.txt | 4 +- os/io/serial.c | 168 ++++++++++++++++++++++++++++++++++++ os/io/serial.h | 217 +++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 388 insertions(+), 1 deletion(-) create mode 100644 os/io/serial.c create mode 100644 os/io/serial.h diff --git a/os/io/readme.txt b/os/io/readme.txt index 18bd93b20..2f13a937f 100644 --- a/os/io/readme.txt +++ b/os/io/readme.txt @@ -1 +1,3 @@ -ChibiOS/RT I/O abstraction code \ No newline at end of file +ChibiOS/RT I/O abstraction code, available modules: +- PAL, digital I/O ports abstraction layer. +- serial, abstract serial communication port using channels and events. diff --git a/os/io/serial.c b/os/io/serial.c new file mode 100644 index 000000000..b513938b8 --- /dev/null +++ b/os/io/serial.c @@ -0,0 +1,168 @@ +/* + ChibiOS/RT - Copyright (C) 2006-2007 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 serial.c + * @brief Serial Driver code. + * @addtogroup SERIAL + * @{ + */ + +#include + +#if CH_USE_SERIAL_FULLDUPLEX + +/* + * Interface implementation, the following functions just invoke the equivalent + * queue-level function or macro. + */ +static bool_t putwouldblock(void *instance) { + + return chOQIsFull(&((FullDuplexDriver *)instance)->d2.oqueue); +} + +static bool_t getwouldblock(void *instance) { + + return chIQIsEmpty(&((FullDuplexDriver *)instance)->d2.iqueue); +} + +static msg_t put(void *instance, uint8_t b, systime_t timeout) { + + return chOQPutTimeout(&((FullDuplexDriver *)instance)->d2.oqueue, b, timeout); +} + +static msg_t get(void *instance, systime_t timeout) { + + return chIQGetTimeout(&((FullDuplexDriver *)instance)->d2.iqueue, timeout); +} + +static size_t write(void *instance, uint8_t *buffer, size_t n) { + + return chOQWrite(&((FullDuplexDriver *)instance)->d2.oqueue, buffer, n); +} + +static size_t read(void *instance, uint8_t *buffer, size_t n) { + + return chIQRead(&((FullDuplexDriver *)instance)->d2.iqueue, buffer, n); +} + +static const struct FullDuplexDriverVMT vmt = { + {putwouldblock, getwouldblock, put, get}, + {write, read}, + {} +}; + +/** + * @brief Initializes a generic full duplex driver. + * @details The HW dependent part of the initialization has to be performed + * outside, usually in the hardware initialization code. + * + * @param[out] sd pointer to a @p FullDuplexDriver structure + * @param[in] ib pointer to a memory area allocated for the Input Queue buffer + * @param[in] isize size of the Input Queue buffer + * @param[in] inotify pointer to a callback function that is invoked when + * some data is read from the Queue. The value can be + * @p NULL. + * @param[in] ob pointer to a memory area allocated for the Output Queue buffer + * @param[in] osize size of the Output Queue buffer + * @param[in] onotify pointer to a callback function that is invoked when + * some data is written in the Queue. The value can be + * @p NULL. + */ +void chFDDInit(FullDuplexDriver *sd, + uint8_t *ib, size_t isize, qnotify_t inotify, + uint8_t *ob, size_t osize, qnotify_t onotify) { + + chDbgCheck((sd != NULL) && (ib != NULL) && (ob != NULL) && + (isize > 0) && (osize > 0), "chFDDInit"); + + sd->vmt = &vmt; + chEvtInit(&sd->d1.ievent); + chEvtInit(&sd->d1.oevent); + chEvtInit(&sd->d2.sevent); + sd->d2.flags = SD_NO_ERROR; + chIQInit(&sd->d2.iqueue, ib, isize, inotify); + chOQInit(&sd->d2.oqueue, ob, osize, onotify); +} + +/** + * @brief Handles incoming data. + * @details This function must be called from the input interrupt service + * routine in order to enqueue incoming data and generate the + * related events. + * @param[in] sd pointer to a @p FullDuplexDriver structure + * @param[in] b the byte to be written in the driver's Input Queue + */ +void sdIncomingDataI(FullDuplexDriver *sd, uint8_t b) { + + if (chIQPutI(&sd->d2.iqueue, b) < Q_OK) + chFDDAddFlagsI(sd, SD_OVERRUN_ERROR); + else + chEvtBroadcastI(&sd->d1.ievent); +} + +/** + * @brief Handles outgoing data. + * @details Must be called from the output interrupt service routine in order + * to get the next byte to be transmitted. + * + * @param[in] sd pointer to a @p FullDuplexDriver structure + * @return The byte value read from the driver's output queue. + * @retval Q_EMPTY if the queue is empty (the lower driver usually disables + * the interrupt source when this happens). + */ +msg_t sdRequestDataI(FullDuplexDriver *sd) { + + msg_t b = chOQGetI(&sd->d2.oqueue); + if (b < Q_OK) + chEvtBroadcastI(&sd->d1.oevent); + return b; +} + +/** + * @brief Handles communication events/errors. + * @details Must be called from the I/O interrupt service routine in order to + * notify I/O conditions as errors, signals change etc. + * + * @param[in] sd pointer to a @p FullDuplexDriver structure + * @param[in] mask condition flags to be added to the mask + */ +void sdAddFlagsI(FullDuplexDriver *sd, dflags_t mask) { + + sd->d2.flags |= mask; + chEvtBroadcastI(&sd->d2.sevent); +} + +/** + * @brief Returns and clears the errors mask associated to the driver. + * + * @param[in] sd pointer to a @p FullDuplexDriver structure + * @return The condition flags modified since last time this function was + * invoked. + */ +dflags_t sdGetAndClearFlags(FullDuplexDriver *sd) { + dflags_t mask; + + mask = sd->d2.flags; + sd->d2.flags = SD_NO_ERROR; + return mask; +} +#endif /* CH_USE_SERIAL_FULLDUPLEX */ + +/** @} */ diff --git a/os/io/serial.h b/os/io/serial.h new file mode 100644 index 000000000..ef6b7f742 --- /dev/null +++ b/os/io/serial.h @@ -0,0 +1,217 @@ +/* + ChibiOS/RT - Copyright (C) 2006-2007 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 serial.h + * @brief Serial Driver macros and structures. + * @addtogroup SERIAL + * @{ + */ + +#ifndef _SERIAL_H_ +#define _SERIAL_H_ + +/** No pending conditions.*/ +#define SD_NO_ERROR 0 +/** Connection happened.*/ +#define SD_CONNECTED 1 +/** Disconnection happened.*/ +#define SD_DISCONNECTED 2 +/** Parity error happened.*/ +#define SD_PARITY_ERROR 4 +/** Framing error happened.*/ +#define SD_FRAMING_ERROR 8 +/** Overflow happened.*/ +#define SD_OVERRUN_ERROR 16 +/** Break detected.*/ +#define SD_BREAK_DETECTED 32 + +#include "serial_lld.h" + +/** Serial Driver condition flags type.*/ +typedef uint8_t sdflags_t; + +/** + * @brief @p FullDuplexDriver specific methods. + */ +struct _serial_driver_methods { + void (*start)(SerialDriver *sd, const SerialDriverConfig *config); + void (*stop)(SerialDriver *sd); +}; + +/** + * @brief @p SerialDriver specific data. + */ +struct _serial_driver_data { + /** + * Input queue, incoming data can be read from this input queue by + * using the queues APIs. + */ + InputQueue iqueue; + /** + * Output queue, outgoing data can be written to this output queue by + * using the queues APIs. + */ + OutputQueue oqueue; + /** + * Status Change @p EventSource. This event is generated when one or more + * condition flags change. + */ + EventSource sevent; + /** + * I/O driver status flags. + */ + sdflags_t flags; +}; + +/** + * @brief @p SerialDriver virtual methods table. + */ +struct SerialDriverVMT { + /** + * @p BaseChannel class inherited methods. + */ + struct _base_channel_methods m0; + /** + * @p BaseAsynchronousChannel class inherited methods. + */ + struct _base_asynchronous_channel_methods m1; + /** + * @p SerialDriver specific methods. + */ + struct _serial_driver_methods m2; +}; + +/** + * @extends BaseAsynchronousChannel + * + * @brief Full duplex serial driver class. + * @details This class extends @p BaseAsynchronousChannel by adding physical + * I/O queues. + */ +typedef struct { + /** + * Virtual Methods Table. + */ + const struct SerialDriverVMT *vmt; + /** + * @p BaseChannel class inherited data. + */ + struct _base_channel_data d0; + /** + * @p BaseAsynchronousChannel class inherited data. + */ + struct _base_asynchronous_channel_data d1; + /** + * @p SerialDriver specific data. + */ + struct _serial_driver_data d2; +} SerialDriver; + +#ifdef __cplusplus +extern "C" { +#endif + void sdInit(SerialDriver *sd, + uint8_t *ib, size_t isize, qnotify_t inotify, + uint8_t *ob, size_t osize, qnotify_t onotify); + void sdIncomingDataI(SerialDriver *sd, uint8_t b); + msg_t sdRequestDataI(SerialDriver *sd); + void sdAddFlagsI(SerialDriver *sd, sdflags_t mask); + sdflags_t sdGetAndClearFlags(SerialDriver *sd); +#ifdef __cplusplus +} +#endif + +/** + * @brief Direct output check on a @p SerialDriver. + * @details This function bypasses the indirect access to the channel and + * checks directly the output queue. This is faster but cannot + * be used to check different channels implementations. + * @see chIOPutWouldBlock() + */ +#define sdPutWouldBlock(sd) chOQIsFull(&(sd)->d2.oqueue) + +/** + * @brief Direct input check on a @p SerialDriver. + * @details This function bypasses the indirect access to the channel and + * checks directly the input queue. This is faster but cannot + * be used to check different channels implementations. + * @see chIOGetWouldBlock() + */ +#define sdGetWouldBlock(sd) chIQIsEmpty(&(sd)->d2.iqueue) + +/** + * @brief Direct blocking write to a @p SerialDriver. + * @details This function bypasses the indirect access to the channel and + * writes directly on the output queue. This is faster but cannot + * be used to write to different channels implementations. + * @see chIOPut() + */ +#define sdPut(sd, b) chOQPut(&(sd)->d2.oqueue, b) + +/** + * @brief Direct blocking write on a @p SerialDriver with timeout + * specification. + * @details This function bypasses the indirect access to the channel and + * writes directly on the output queue. This is faster but cannot + * be used to write to different channels implementations. + * @see chIOPutTimeout() + */ +#define sdPutTimeout(sd, b, t) chOQPutTimeout(&(sd)->d2.iqueue, b, t) + +/** + * @brief Direct blocking read from a @p SerialDriver. + * @details This function bypasses the indirect access to the channel and + * reads directly from the input queue. This is faster but cannot + * be used to read from different channels implementations. + * @see chIOGet() + */ +#define sdGet(sd) chIQGet(&(sd)->d2.iqueue) + +/** + * @brief Direct blocking read from a @p SerialDriver with timeout + * specification. + * @details This function bypasses the indirect access to the channel and + * reads directly from the input queue. This is faster but cannot + * be used to read from different channels implementations. + * @see chIOGetTimeout() + */ +#define sdGetTimeout(sd, t) chIQGetTimeout(&(sd)->d2.iqueue, t) + +/** + * @brief Direct non-blocking write to a @p SerialDriver. + * @details This function bypasses the indirect access to the channel and + * writes directly to the output queue. This is faster but cannot + * be used to write from different channels implementations. + * @see chIOWrite() + */ +#define sdWrite(sd, b, n) chOQWrite(&(sd)->d2.oqueue, b, n) + +/** + * @brief Direct non-blocking read on a @p SerialDriver. + * @details This function bypasses the indirect access to the channel and + * reads directly from the input queue. This is faster but cannot + * be used to read from different channels implementations. + * @see chIORead() + */ +#define sdRead(sd, b, n) chIQRead(&(sd)->d2.iqueue, b, n) + +#endif /* _SERIAL_H_ */ + +/** @} */