andreika-git
/
ChibiOS
mirror of https://github.com/andreika-git/ChibiOS.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

New serial driver for Win32 demo. 

git-svn-id: svn://svn.code.sf.net/p/chibios/svn/trunk@1142 35acf78f-673a-0410-8e92-d51de3d6d3f4
This commit is contained in:
gdisirio 2009-08-30 14:14:09 +00:00
parent 58f6aa17ff
commit 68a37ee345
5 changed files with 490 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
demos/Win32-MinGW/Makefile
View File

@ -63,14 +63,17 @@ include ../../test/test.mk
SRC = ${KERNSRC} \
${TESTSRC} \
chcore.c \
../../os/ports/GCC/win32/simcom.c \
../../os/io/serial.c \
../../os/io/platforms/Win32/serial_lld.c \
main.c
# List ASM source files here
ASRC =
# List all user directories here
UINCDIR = $(KERNINC) $(TESTINC)
UINCDIR = $(KERNINC) $(TESTINC) \
../../os/io \
../../os/io/platforms/Win32
# List the user directory to look for the libraries here
ULIBDIR =

17
demos/Win32-MinGW/chcore.c
View File

@ -28,19 +28,11 @@
*/
#include <ch.h>
#include <serial.h>
static LARGE_INTEGER nextcnt;
static LARGE_INTEGER slice;
void InitSimCom1(void);
void InitSimCom2(void);
BOOL Com1ConnInterruptSimCom(void);
BOOL Com2ConnInterruptSimCom(void);
BOOL Com1InInterruptSimCom(void);
BOOL Com2InInterruptSimCom(void);
BOOL Com1OutInterruptSimCom(void);
BOOL Com2OutInterruptSimCom(void);
/*
* Simulated HW initialization.
*/
@ -64,8 +56,7 @@ void InitCore(void) {
QueryPerformanceCounter(&nextcnt);
nextcnt.QuadPart += slice.QuadPart;
InitSimCom1();
InitSimCom2();
sdInit();
fflush(stdout);
}
@ -75,9 +66,7 @@ void InitCore(void) {
void ChkIntSources(void) {
LARGE_INTEGER n;
if (Com1InInterruptSimCom() || Com2InInterruptSimCom() ||
Com1OutInterruptSimCom() || Com2OutInterruptSimCom() ||
Com1ConnInterruptSimCom() || Com2ConnInterruptSimCom()) {
if (sd_lld_interrupt_pending()) {
if (chSchRescRequiredI())
chSchDoRescheduleI();
return;

108
demos/Win32-MinGW/main.c
View File

@ -21,6 +21,7 @@
#include <stdio.h>
#include <ch.h>
#include <serial.h>
static uint32_t wdguard;
static WORKING_AREA(wdarea, 2048);
@ -34,8 +35,6 @@ static msg_t ConsoleThread(void *arg);
msg_t TestThread(void *p);
extern FullDuplexDriver COM1, COM2;
#define cprint(msg) chMsgSend(cdtp, (msg_t)msg)
/*
@ -73,13 +72,13 @@ static msg_t ConsoleThread(void *arg) {
return 0;
}
static void PrintLineFDD(FullDuplexDriver *sd, char *msg) {
static void PrintLineSD(SerialDriver *sd, char *msg) {
while (*msg)
chFDDPut(sd, *msg++);
sdPut(sd, *msg++);
}
static bool_t GetLineFDD(FullDuplexDriver *sd, char *line, int size) {
static bool_t GetLineFDD(SerialDriver *sd, char *line, int size) {
char *p = line;
while (TRUE) {
@ -87,27 +86,27 @@ static bool_t GetLineFDD(FullDuplexDriver *sd, char *line, int size) {
if (c < 0)
return TRUE;
if (c == 4) {
PrintLineFDD(sd, "^D\r\n");
PrintLineSD(sd, "^D\r\n");
return TRUE;
}
if (c == 8) {
if (p != line) {
chFDDPut(sd, (uint8_t)c);
chFDDPut(sd, 0x20);
chFDDPut(sd, (uint8_t)c);
sdPut(sd, (uint8_t)c);
sdPut(sd, 0x20);
sdPut(sd, (uint8_t)c);
p--;
}
continue;
}
if (c == '\r') {
PrintLineFDD(sd, "\r\n");
PrintLineSD(sd, "\r\n");
*p = 0;
return FALSE;
}
if (c < 0x20)
continue;
if (p < line + size - 1) {
chFDDPut(sd, (uint8_t)c);
sdPut(sd, (uint8_t)c);
*p++ = (uint8_t)c;
}
}
@ -120,19 +119,19 @@ static bool_t GetLineFDD(FullDuplexDriver *sd, char *line, int size) {
static msg_t HelloWorldThread(void *arg) {
int i;
short c;
FullDuplexDriver *sd = (FullDuplexDriver *)arg;
SerialDriver *sd = (SerialDriver *)arg;
for (i = 0; i < 10; i++) {
PrintLineFDD(sd, "Hello World\r\n");
c = chFDDGetTimeout(sd, 333);
PrintLineSD(sd, "Hello World\r\n");
c = sdGetTimeout(sd, 333);
switch (c) {
case Q_TIMEOUT:
continue;
case Q_RESET:
return 1;
case 3:
PrintLineFDD(sd, "^C\r\n");
PrintLineSD(sd, "^C\r\n");
return 0;
default:
chThdSleep(333);
@ -141,12 +140,12 @@ static msg_t HelloWorldThread(void *arg) {
return 0;
}
static bool_t checkend(FullDuplexDriver *sd) {
static bool_t checkend(SerialDriver *sd) {
char * lp = strtok(NULL, " \009"); /* It is not thread safe but this is a demo.*/
if (lp) {
PrintLineFDD(sd, lp);
PrintLineFDD(sd, " ?\r\n");
PrintLineSD(sd, lp);
PrintLineSD(sd, " ?\r\n");
return TRUE;
}
return FALSE;
@ -157,7 +156,7 @@ static bool_t checkend(FullDuplexDriver *sd) {
* standard input and output. It recognizes few simple commands.
*/
static msg_t ShellThread(void *arg) {
FullDuplexDriver *sd = (FullDuplexDriver *)arg;
SerialDriver *sd = (SerialDriver *)arg;
char *lp, line[64];
Thread *tp;
WORKING_AREA(tarea, 2048);
@ -166,11 +165,11 @@ static msg_t ShellThread(void *arg) {
chIQResetI(&sd->d2.iqueue);
chOQResetI(&sd->d2.oqueue);
chSysUnlock();
PrintLineFDD(sd, "ChibiOS/RT Command Shell\r\n\n");
PrintLineSD(sd, "ChibiOS/RT Command Shell\r\n\n");
while (TRUE) {
PrintLineFDD(sd, "ch> ");
PrintLineSD(sd, "ch> ");
if (GetLineFDD(sd, line, sizeof(line))) {
PrintLineFDD(sd, "\nlogout");
PrintLineSD(sd, "\nlogout");
break;
}
lp = strtok(line, " \009"); // Note: not thread safe but it is just a demo.
@ -180,24 +179,24 @@ static msg_t ShellThread(void *arg) {
(stricmp(lp, "?") == 0)) {
if (checkend(sd))
continue;
PrintLineFDD(sd, "Commands:\r\n");
PrintLineFDD(sd, " help,h,? - This help\r\n");
PrintLineFDD(sd, " exit - Logout from ChibiOS/RT\r\n");
PrintLineFDD(sd, " time - Prints the system timer value\r\n");
PrintLineFDD(sd, " hello - Runs the Hello World demo thread\r\n");
PrintLineFDD(sd, " test - Runs the System Test thread\r\n");
PrintLineSD(sd, "Commands:\r\n");
PrintLineSD(sd, " help,h,? - This help\r\n");
PrintLineSD(sd, " exit - Logout from ChibiOS/RT\r\n");
PrintLineSD(sd, " time - Prints the system timer value\r\n");
PrintLineSD(sd, " hello - Runs the Hello World demo thread\r\n");
PrintLineSD(sd, " test - Runs the System Test thread\r\n");
}
else if (stricmp(lp, "exit") == 0) {
if (checkend(sd))
continue;
PrintLineFDD(sd, "\nlogout");
PrintLineSD(sd, "\nlogout");
break;
}
else if (stricmp(lp, "time") == 0) {
if (checkend(sd))
continue;
sprintf(line, "Time: %d\r\n", chTimeNow());
PrintLineFDD(sd, line);
PrintLineSD(sd, line);
}
else if (stricmp(lp, "hello") == 0) {
if (checkend(sd))
@ -216,8 +215,8 @@ static msg_t ShellThread(void *arg) {
break; // Lost connection while executing the hello thread.
}
else {
PrintLineFDD(sd, lp);
PrintLineFDD(sd, " ?\r\n");
PrintLineSD(sd, lp);
PrintLineSD(sd, " ?\r\n");
}
}
}
@ -229,23 +228,23 @@ static Thread *s1;
EventListener s1tel;
static void COM1Handler(eventid_t id) {
dflags_t flags;
sdflags_t flags;
if (s1 && chThdTerminated(s1)) {
s1 = NULL;
cprint("Init: disconnection on COM1\n");
cprint("Init: disconnection on SD1\n");
}
flags = chFDDGetAndClearFlags(&COM1);
flags = sdGetAndClearFlags(&SD1);
if ((flags & SD_CONNECTED) && (s1 == NULL)) {
cprint("Init: connection on COM1\n");
cprint("Init: connection on SD1\n");
s1 = chThdInit(s1area, sizeof(s1area),
NORMALPRIO, ShellThread, &COM1);
NORMALPRIO, ShellThread, &SD1);
chEvtRegister(chThdGetExitEventSource(s1), &s1tel, 0);
chThdResume(s1);
}
if ((flags & SD_DISCONNECTED) && (s1 != NULL)) {
chSysLock();
chIQResetI(&COM1.d2.iqueue);
chIQResetI(&SD1.d2.iqueue);
chSysUnlock();
}
}
@ -255,23 +254,23 @@ static Thread *s2;
EventListener s2tel;
static void COM2Handler(eventid_t id) {
dflags_t flags;
sdflags_t flags;
if (s2 && chThdTerminated(s2)) {
s2 = NULL;
cprint("Init: disconnection on COM2\n");
cprint("Init: disconnection on SD2\n");
}
flags = chFDDGetAndClearFlags(&COM2);
flags = sdGetAndClearFlags(&SD2);
if ((flags & SD_CONNECTED) && (s2 == NULL)) {
cprint("Init: connection on COM2\n");
cprint("Init: connection on SD2\n");
s2 = chThdInit(s2area, sizeof(s1area),
NORMALPRIO, ShellThread, &COM2);
NORMALPRIO, ShellThread, &SD2);
chEvtRegister(chThdGetExitEventSource(s2), &s2tel, 1);
chThdResume(s2);
}
if ((flags & SD_DISCONNECTED) && (s2 != NULL)) {
chSysLock();
chIQResetI(&COM2.d2.iqueue);
chIQResetI(&SD2.d2.iqueue);
chSysUnlock();
}
}
@ -290,19 +289,22 @@ int main(void) {
// Startup ChibiOS/RT.
chSysInit();
sdStart(&SD1, NULL);
sdStart(&SD2, NULL);
chThdCreateStatic(wdarea, sizeof(wdarea), NORMALPRIO + 2, WatchdogThread, NULL);
cdtp = chThdCreateStatic(cdarea, sizeof(cdarea), NORMALPRIO + 1, ConsoleThread, NULL);
cprint("Console service started on COM1, COM2\n");
cprint(" - Listening for connections on COM1\n");
chFDDGetAndClearFlags(&COM1);
chEvtRegister(&COM1.d2.sevent, &c1fel, 0);
cprint(" - Listening for connections on COM2\n");
chFDDGetAndClearFlags(&COM2);
chEvtRegister(&COM2.d2.sevent, &c2fel, 1);
cprint("Console service started on SD1, SD2\n");
cprint(" - Listening for connections on SD1\n");
sdGetAndClearFlags(&SD1);
chEvtRegister(&SD1.d2.sevent, &c1fel, 0);
cprint(" - Listening for connections on SD2\n");
sdGetAndClearFlags(&SD2);
chEvtRegister(&SD2.d2.sevent, &c2fel, 1);
while (!chThdShouldTerminate())
chEvtDispatch(fhandlers, chEvtWaitOne(ALL_EVENTS));
chEvtUnregister(&COM2.d2.sevent, &c2fel); // Never invoked but this is an example...
chEvtUnregister(&COM1.d2.sevent, &c1fel); // Never invoked but this is an example...
chEvtUnregister(&SD1.d2.sevent, &c2fel); // Never invoked but this is an example...
chEvtUnregister(&SD2.d2.sevent, &c1fel); // Never invoked but this is an example...
return 0;
}

253
os/io/platforms/Win32/serial_lld.c Normal file
View File

@ -0,0 +1,253 @@
/*
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 Win32/serial_lld.c
* @brief Win32 low level simulated serial driver code
* @addtogroup WIN32_SERIAL
* @{
*/
#include <windows.h>
#include <stdio.h>
#include <ch.h>
#include <serial.h>
/** @brief USART0 serial driver identifier.*/
#if USE_WIN32_SERIAL1 || defined(__DOXYGEN__)
SerialDriver SD1;
#endif
/** @brief USART1 serial driver identifier.*/
#if USE_WIN32_SERIAL2 || defined(__DOXYGEN__)
SerialDriver SD2;
#endif
/** @brief Driver default configuration.*/
static const SerialDriverConfig default_config = {
};
static u_long nb = 1;
/*===========================================================================*/
/* Low Level Driver local functions. */
/*===========================================================================*/
static void init(SerialDriver *sdp, uint16_t port) {
struct sockaddr_in sad;
struct protoent *prtp;
if ((prtp = getprotobyname("tcp")) == NULL) {
printf("%s: Error mapping protocol name to protocol number\n", sdp->d2.com_name);
goto abort;
}
sdp->d2.com_listen = socket(PF_INET, SOCK_STREAM, prtp->p_proto);
if (sdp->d2.com_listen == INVALID_SOCKET) {
printf("%s: Error creating simulator socket\n", sdp->d2.com_name);
goto abort;
}
if (ioctlsocket(sdp->d2.com_listen, FIONBIO, &nb) != 0) {
printf("%s: Unable to setup non blocking mode on socket\n", sdp->d2.com_name);
goto abort;
}
memset(&sad, 0, sizeof(sad));
sad.sin_family = AF_INET;
sad.sin_addr.s_addr = INADDR_ANY;
sad.sin_port = htons(port);
if (bind(sdp->d2.com_listen, (struct sockaddr *)&sad, sizeof(sad))) {
printf("%s: Error binding socket\n", sdp->d2.com_name);
goto abort;
}
if (listen(sdp->d2.com_listen, 1) != 0) {
printf("%s: Error listening socket\n", sdp->d2.com_name);
goto abort;
}
printf("Full Duplex Channel %s listening on port %d\n", sdp->d2.com_name, port);
return;
abort:
if (sdp->d2.com_listen != INVALID_SOCKET)
closesocket(sdp->d2.com_listen);
WSACleanup();
exit(1);
}
static bool_t connint(SerialDriver *sdp) {
if (sdp->d2.com_data == INVALID_SOCKET) {
struct sockaddr addr;
int addrlen = sizeof(addr);
if ((sdp->d2.com_data = accept(sdp->d2.com_listen, &addr, &addrlen)) == INVALID_SOCKET)
return FALSE;
if (ioctlsocket(sdp->d2.com_data, FIONBIO, &nb) != 0) {
printf("%s: Unable to setup non blocking mode on data socket\n", sdp->d2.com_name);
goto abort;
}
sdAddFlagsI(sdp, SD_CONNECTED);
return TRUE;
}
return FALSE;
abort:
if (sdp->d2.com_listen != INVALID_SOCKET)
closesocket(sdp->d2.com_listen);
if (sdp->d2.com_data != INVALID_SOCKET)
closesocket(sdp->d2.com_data);
WSACleanup();
exit(1);
}
static bool_t inint(SerialDriver *sdp) {
if (sdp->d2.com_data != INVALID_SOCKET) {
int i;
uint8_t data[32];
/*
* Input.
*/
int n = recv(sdp->d2.com_data, data, sizeof(data), 0);
switch (n) {
case 0:
closesocket(sdp->d2.com_data);
sdp->d2.com_data = INVALID_SOCKET;
sdAddFlagsI(sdp, SD_DISCONNECTED);
return FALSE;
case SOCKET_ERROR:
if (WSAGetLastError() == WSAEWOULDBLOCK)
return FALSE;
closesocket(sdp->d2.com_data);
sdp->d2.com_data = INVALID_SOCKET;
return FALSE;
}
for (i = 0; i < n; i++)
sdIncomingDataI(sdp, data[i]);
return TRUE;
}
return FALSE;
}
static bool_t outint(SerialDriver *sdp) {
if (sdp->d2.com_data != INVALID_SOCKET) {
int n;
uint8_t data[1];
/*
* Input.
*/
n = sdRequestDataI(sdp);
if (n < 0)
return FALSE;
data[0] = (uint8_t)n;
n = send(sdp->d2.com_data, data, sizeof(data), 0);
switch (n) {
case 0:
closesocket(sdp->d2.com_data);
sdp->d2.com_data = INVALID_SOCKET;
sdAddFlagsI(sdp, SD_DISCONNECTED);
return FALSE;
case SOCKET_ERROR:
if (WSAGetLastError() == WSAEWOULDBLOCK)
return FALSE;
closesocket(sdp->d2.com_data);
sdp->d2.com_data = INVALID_SOCKET;
return FALSE;
}
return TRUE;
}
return FALSE;
}
/*===========================================================================*/
/* Low Level Driver interrupt handlers. */
/*===========================================================================*/
/*===========================================================================*/
/* Low Level Driver exported functions. */
/*===========================================================================*/
/**
* Low level serial driver initialization.
*/
void sd_lld_init(void) {
#if USE_WIN32_SERIAL1
sdObjectInit(&SD1, NULL, NULL);
SD1.d2.com_listen = INVALID_SOCKET;
SD1.d2.com_data = INVALID_SOCKET;
SD1.d2.com_name = "SD1";
#endif
#if USE_WIN32_SERIAL1
sdObjectInit(&SD2, NULL, NULL);
SD2.d2.com_listen = INVALID_SOCKET;
SD2.d2.com_data = INVALID_SOCKET;
SD2.d2.com_name = "SD2";
#endif
}
/**
* @brief Low level serial driver configuration and (re)start.
*
* @param[in] sdp pointer to a @p SerialDriver object
* @param[in] config the architecture-dependent serial driver configuration.
* If this parameter is set to @p NULL then a default
* configuration is used.
*/
void sd_lld_start(SerialDriver *sdp, const SerialDriverConfig *config) {
if (config == NULL)
config = &default_config;
#if USE_WIN32_SERIAL1
if (sdp == &SD1)
init(&SD1, SD1_PORT);
#endif
#if USE_WIN32_SERIAL1
if (sdp == &SD2)
init(&SD2, SD2_PORT);
#endif
}
/**
* @brief Low level serial driver stop.
* @details De-initializes the USART, stops the associated clock, resets the
* interrupt vector.
*
* @param[in] sdp pointer to a @p SerialDriver object
*/
void sd_lld_stop(SerialDriver *sdp) {
}
bool_t sd_lld_interrupt_pending(void) {
return connint(&SD1) || connint(&SD2) ||
inint(&SD1) || inint(&SD2) ||
outint(&SD1) || outint(&SD2);
}
/** @} */

174
os/io/platforms/Win32/serial_lld.h Normal file
View File

@ -0,0 +1,174 @@
/*
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 Win32/serial_lld.h
* @brief Win32 low level simulated serial driver header
* @addtogroup WIN32_SERIAL
* @{
*/
#ifndef _SERIAL_LLD_H_
#define _SERIAL_LLD_H_
#include <windows.h>
/*===========================================================================*/
/* Driver pre-compile time settings. */
/*===========================================================================*/
/**
* @brief Serial buffers size.
* @details Configuration parameter, you can change the depth of the queue
* buffers depending on the requirements of your application.
*/
#if !defined(SERIAL_BUFFERS_SIZE) || defined(__DOXYGEN__)
#define SERIAL_BUFFERS_SIZE 1024
#endif
/**
* @brief SD1 driver enable switch.
* @details If set to @p TRUE the support for SD1 is included.
* @note The default is @p TRUE.
*/
#if !defined(USE_WIN32_SERIAL1) || defined(__DOXYGEN__)
#define USE_WIN32_SERIAL1 TRUE
#endif
/**
* @brief SD2 driver enable switch.
* @details If set to @p TRUE the support for SD2 is included.
* @note The default is @p TRUE.
*/
#if !defined(USE_WIN32_SERIAL2) || defined(__DOXYGEN__)
#define USE_WIN32_SERIAL2 TRUE
#endif
/**
* @brief Listen port for SD1.
*/
#if !defined(SD1_PORT) || defined(__DOXYGEN__)
#define SD1_PORT 29001
#endif
/**
* @brief Listen port for SD2.
*/
#if !defined(SD2_PORT) || defined(__DOXYGEN__)
#define SD2_PORT 29002
#endif
/*===========================================================================*/
/* Unsupported event flags and custom events. */
/*===========================================================================*/
/*===========================================================================*/
/* Driver data structures and types. */
/*===========================================================================*/
/**
* Serial Driver condition flags type.
*/
typedef uint32_t sdflags_t;
/**
* @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;
/**
* Input circular buffer.
*/
uint8_t ib[SERIAL_BUFFERS_SIZE];
/**
* Output circular buffer.
*/
uint8_t ob[SERIAL_BUFFERS_SIZE];
/**
* Listen socket for simulated serial port.
*/
SOCKET com_listen;
/**
* Data socket for simulated serial port.
*/
SOCKET com_data;
/**
* Port readable name.
*/
const char *com_name;
};
/**
* @brief Generic Serial Driver configuration structure.
* @details An instance of this structure must be passed to @p sdStart()
* in order to configure and start a serial driver operations.
*
* @note This structure content is architecture dependent, each driver
* implementation defines its own version and the custom static
* initializers.
*/
typedef struct {
uint16_t port;
} SerialDriverConfig;
/*===========================================================================*/
/* External declarations. */
/*===========================================================================*/
/** @cond never*/
#if USE_WIN32_SERIAL1
extern SerialDriver SD1;
#endif
#if USE_WIN32_SERIAL2
extern SerialDriver SD2;
#endif
#ifdef __cplusplus
extern "C" {
#endif
void sd_lld_init(void);
void sd_lld_start(SerialDriver *sdp, const SerialDriverConfig *config);
void sd_lld_stop(SerialDriver *sdp);
bool_t sd_lld_interrupt_pending(void);
#ifdef __cplusplus
}
#endif
/** @endcond*/
#endif /* _SERIAL_LLD_H_ */
/** @} */