git-svn-id: svn://svn.code.sf.net/p/chibios/svn/trunk@1074 35acf78f-673a-0410-8e92-d51de3d6d3f4
gdisirio
parent
1ea7355d85
commit
de11519219
|
|
@ -1 +1,3 @@
|
|||
ChibiOS/RT I/O abstraction code
|
||||
ChibiOS/RT I/O abstraction code, available modules:
|
||||
- PAL, digital I/O ports abstraction layer.
|
||||
- serial, abstract serial communication port using channels and events.
|
||||
|
|
|
|||
|
|
@ -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 <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file serial.c
|
||||
* @brief Serial Driver code.
|
||||
* @addtogroup SERIAL
|
||||
* @{
|
||||
*/
|
||||
|
||||
#include <ch.h>
|
||||
|
||||
#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 */
|
||||
|
||||
/** @} */
|
||||
|
|
@ -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 <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @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_ */
|
||||
|
||||
/** @} */
|
||||
Loading…
Reference in New Issue