Use kfile interface.

git-svn-id: https://src.develer.com/svnoss/bertos/trunk@1193 38d2e660-2303-0410-9eaa-f027e97ec537

diff --git a/app/triface/protocol.c b/app/triface/protocol.c
index 7dc434e64e901687cacbc0a36ffa375ca2662920..6a415118cf076d38d0a5ab44ee47ab188482487d 100644 (file)
--- a/app/triface/protocol.c
+++ b/app/triface/protocol.c
@@ -39,30 +39,35 @@
  * \author Giovanni Bajo <rasky@develer.com>
  * \author Marco Benelli <marco@develer.com>
  * \author Bernardo Innocenti <bernie@develer.com>
+ * \author Daniele Basile <asterix@develer.com>
  */
 
 #include "protocol.h"
-
+#include "cmd_ctor.h"  // MAKE_CMD, REGISTER_CMD
+#include "verstag.h"
 
 #include <drv/timer.h>
 #include <drv/ser.h>
+#include <drv/sipo.h>
+#include <drv/wdt.h>
+#include <drv/buzzer.h>
+
 #include <mware/readline.h>
 #include <mware/parser.h>
+
 #include <cfg/compiler.h>
 #include <cfg/debug.h>
-#include <drv/sipo.h>
-#include <drv/wdt.h>
+
+#include <kern/kfile.h>
+
 #include "hw_adc.h"
+#include "hw_input.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 //#include <cmd_hunk.h>
 
-#include "cmd_ctor.h"  // MAKE_CMD, REGISTER_CMD
-#include "hw_input.h"
-#include "verstag.h"
-#include <drv/buzzer.h>
 
 // Define the format string for ADC
 #define ADC_FORMAT_STR "dddd"
@@ -88,25 +93,25 @@ uint8_t reg_status_dout;
  *
  * \param err  human-readable description of the error for debug purposes.
  */
-INLINE void NAK(Serial *ser, const char *err)
+INLINE void NAK(KFile *fd, const char *err)
 {
 #ifdef _DEBUG
-       ser_printf(ser, "NAK \"%s\"\r\n", err);
+       kfile_printf(fd, "NAK \"%s\"\r\n", err);
 #else
-       ser_printf(ser, "NAK\r\n");
+       kfile_printf(fd, "NAK\r\n");
 #endif
 }
 
-static void protocol_prompt(Serial *ser)
+static void protocol_prompt(KFile *fd)
 {
-       ser_print(ser, ">> ");
+       kfile_print(fd, ">> ");
 }
 
 /*
  * Print args on s, with format specified in t->result_fmt.
  * Return number of valid arguments or -1 in case of error.
  */
-static bool protocol_reply(Serial *s, const struct CmdTemplate *t,
+static bool protocol_reply(KFile *fd, const struct CmdTemplate *t,
                          const parms *args)
 {
        unsigned short offset = strlen(t->arg_fmt) + 1;
@@ -116,11 +121,11 @@ static bool protocol_reply(Serial *s, const struct CmdTemplate *t,
        {
                if (t->result_fmt[i] == 'd')
                {
-                       ser_printf(s, " %ld", args[offset+i].l);
+                       kfile_printf(fd, " %ld", args[offset+i].l);
                }
                else if (t->result_fmt[i] == 's')
                {
-                       ser_printf(s, " %s", args[offset+i].s);
+                       kfile_printf(fd, " %s", args[offset+i].s);
                }
 
                else
@@ -128,11 +133,11 @@ static bool protocol_reply(Serial *s, const struct CmdTemplate *t,
                        abort();
                }
        }
-       ser_printf(s, "\r\n");
+       kfile_printf(fd, "\r\n");
        return true;
 }
 
-static void protocol_parse(Serial *ser, const char *buf)
+static void protocol_parse(KFile *fd, const char *buf)
 {
        const struct CmdTemplate *templ;
 
@@ -140,8 +145,8 @@ static void protocol_parse(Serial *ser, const char *buf)
        templ = parser_get_cmd_template(buf);
        if (!templ)
        {
-               ser_print(ser, "-1 Invalid command.\r\n");
-               protocol_prompt(ser);
+               kfile_print(fd, "-1 Invalid command.\r\n");
+               protocol_prompt(fd);
                return;
        }
 
@@ -150,26 +155,26 @@ static void protocol_parse(Serial *ser, const char *buf)
        /* Args Check.  TODO: Handle different case. see doc/PROTOCOL .  */
        if (!parser_get_cmd_arguments(buf, templ, args))
        {
-               ser_print(ser, "-2 Invalid arguments.\r\n");
-               protocol_prompt(ser);
+               kfile_print(fd, "-2 Invalid arguments.\r\n");
+               protocol_prompt(fd);
                return;
        }
 
        /* Execute. */
        if(!parser_execute_cmd(templ, args))
        {
-               NAK(ser, "Error in executing command.");
+               NAK(fd, "Error in executing command.");
        }
-       if (!protocol_reply(ser, templ, args))
+       if (!protocol_reply(fd, templ, args))
        {
-               NAK(ser, "Invalid return format.");
+               NAK(fd, "Invalid return format.");
        }
 
-       protocol_prompt(ser);
+       protocol_prompt(fd);
        return;
 }
 
-void protocol_run(Serial *ser)
+void protocol_run(KFile *fd)
 {
        /**
         * \todo to be removed, we could probably access the serial FIFO
@@ -179,10 +184,10 @@ void protocol_run(Serial *ser)
 
        if (!interactive)
        {
-               ser_gets(ser, linebuf, sizeof(linebuf));
+               kfile_gets(fd, linebuf, sizeof(linebuf));
 
                // reset serial port error anyway
-               ser_setstatus(ser, 0);
+               kfile_clearerr(fd);
 
                // check message minimum length
                if (linebuf[0])
@@ -194,12 +199,11 @@ void protocol_run(Serial *ser)
                                if (linebuf[0] == 0x1B && linebuf[1] == 0x1B)  // ESC
                                {
                                        interactive = true;
-                                       ser_printf(ser,
-                                               "Entering interactive mode\r\n");
+                                       kfile_printf(fd, "Entering interactive mode\r\n");
                                }
                                else
                                {
-                                       protocol_parse(ser, linebuf);
+                                       protocol_parse(fd, linebuf);
                                }
                        }
                }
@@ -228,8 +232,7 @@ void protocol_run(Serial *ser)
                                if (!strcmp(buf, "exit") || !strcmp(buf, "quit"))
                                {
                                        rl_clear_history(&rl_ctx);
-                                       ser_printf(ser,
-                                               "Leaving interactive mode...\r\n");
+                                       kfile_printf(fd, "Leaving interactive mode...\r\n");
                                        interactive = FORCE_INTERACTIVE;
                                }
                                else
@@ -240,7 +243,7 @@ void protocol_run(Serial *ser)
 
                                        strncpy(linebuf + 2, buf, sizeof(linebuf) - 3);
                                        linebuf[sizeof(linebuf) - 1] = '\0';
-                                       protocol_parse(ser, linebuf);
+                                       protocol_parse(fd, linebuf);
                                }
                        }
                }
@@ -358,20 +361,20 @@ static void protocol_registerCmds(void)
 }
 
 /* Initialization: readline context, parser and register commands.  */
-void protocol_init(Serial *ser)
+void protocol_init(KFile *fd)
 {
        interactive = FORCE_INTERACTIVE;
 
        rl_init_ctx(&rl_ctx);
        //rl_setprompt(&rl_ctx, ">> ");
-       rl_sethook_get(&rl_ctx, (getc_hook)ser_getchar, ser);
-       rl_sethook_put(&rl_ctx, (putc_hook)ser_putchar, ser);
+       rl_sethook_get(&rl_ctx, (getc_hook)kfile_getc, fd);
+       rl_sethook_put(&rl_ctx, (putc_hook)kfile_putc, fd);
        rl_sethook_match(&rl_ctx, parser_rl_match, NULL);
-       rl_sethook_clear(&rl_ctx, (clear_hook)ser_clearstatus,ser);
+       rl_sethook_clear(&rl_ctx, (clear_hook)kfile_clearerr,fd);
 
        parser_init();
 
        protocol_registerCmds();
 
-       protocol_prompt(ser);
+       protocol_prompt(fd);
 }

diff --git a/app/triface/protocol.h b/app/triface/protocol.h
index ee758555b4dcf3d0b008c6e21b6894438bbbd97e..a752ee827f47ddcd78bf42b0a5f3c47a92b54a0d 100644 (file)
--- a/app/triface/protocol.h
+++ b/app/triface/protocol.h
@@ -42,10 +42,9 @@
 #ifndef PROTOCOL_H
 #define PROTOCOL_H
 
-// fwd decl
-struct Serial;
+#include <kern/kfile.h>
 
-void protocol_init(struct Serial *ser);
-void protocol_run(struct Serial *ser);
+void protocol_init(KFile *fd);
+void protocol_run(KFile *fd);
 
 #endif // PROTOOCOL_H

diff --git a/app/triface/triface.c b/app/triface/triface.c
index 00c1a58025fa3ca2d1f0077c51ef553946598431..eb47d8fad0f5c67f77c31de895c0d67ff506b62b 100644 (file)
--- a/app/triface/triface.c
+++ b/app/triface/triface.c
@@ -26,7 +26,7 @@
  * invalidate any other reasons why the executable file might be covered by
  * the GNU General Public License.
  *
- * Copyright 2003, 2004, 2006 Develer S.r.l. (http://www.develer.com/)
+ * Copyright 2003, 2004, 2006, 2008 Develer S.r.l. (http://www.develer.com/)
  * Copyright 2000 Bernardo Innocenti <bernie@codewiz.org>
  *
  * -->
@@ -35,6 +35,7 @@
  *
  * \author Marco Benelli <marco@develer.com>
  * \author Bernardo Innocenti <bernie@develer.com>
+ * \author Daniele Basile <asterix@develer.com>
  *
  * \brief Windowing system test.
  */
@@ -43,15 +44,19 @@
 #include <drv/timer.h>
 #include <drv/buzzer.h>
 #include <drv/ser.h>
+#include <drv/sipo.h>
+
 #include <cfg/macros.h>
 #include <mware/parser.h>
 #include <net/keytag.h>
-#include <drv/sipo.h>
 
 #include "protocol.h"
 #include "hw_input.h"
 #include "hw_adc.h"
 
+
+static KFileSerial fd_ser;
+
 int main(void)
 {
        /* SPI Port Initialization */
@@ -69,24 +74,25 @@ int main(void)
        TagPacket pkt;
 
        /* Open the main communication port */
-       Serial *host_port = ser_open(CONFIG_SER_HOSTPORT);
-       ser_setbaudrate(host_port, CONFIG_SER_HOSTPORTBAUDRATE);
+       ser_init(&fd_ser, CONFIG_SER_HOSTPORT);
+       ser_setbaudrate(&fd_ser, CONFIG_SER_HOSTPORTBAUDRATE);
 
-       pkt.tag_ser = ser_open(TAG_SER_PORT);
+       ser_init(pkt.tag_ser, TAG_SER_PORT);
        ser_setbaudrate(pkt.tag_ser, TAG_SER_BAUDRATE);
-       pkt.comm_ser = host_port;
-       keytag_init(&pkt);
-
 
+       pkt.comm_ser = &fd_ser;
+       keytag_init(&pkt);
 
-       protocol_init(host_port);
+       protocol_init(&fd_ser.fd);
 
        // Main loop
        for(;;)
        {
-               protocol_run(host_port);
+               protocol_run(&fd_ser.fd);
                keytag_poll(&pkt);
        }
 
        return 0;
 }
+
+

diff --git a/app/triface/triface.mk b/app/triface/triface.mk
index b7c19cc41968a156bff22fe71fa5f5f104645e6d..887acc8a1f1032b42739ccaa0dc9fa62045d8732 100644 (file)
--- a/app/triface/triface.mk
+++ b/app/triface/triface.mk
@@ -40,10 +40,11 @@ triface_CSRC = \
 triface_PCSRC += mware/formatwr.c
 
 
-triface_CFLAGS = -O2 -D'ARCH=0' -Iapp/triface/hw -Iapp/triface -Icpu/avr
+triface_CFLAGS = -O2 -D'ARCH=0' -fno-strict-aliasing -Iapp/triface/hw -Iapp/triface -Icpu/avr
 triface_LDFLAGS = -Wl
 
 triface_MCU = atmega64
+triface_CROSS = avr-
 
 # Debug stuff
 ifeq ($(triface_DEBUG),1)

diff --git a/net/keytag.c b/net/keytag.c
index afc21b183ed2e0ebf7632f834b2d80727c449b93..3542aafde4d92aff569c3f44af57f1f6bdfe0d84 100644 (file)
--- a/net/keytag.c
+++ b/net/keytag.c
@@ -56,12 +56,12 @@ static void keytag_clearPkt(struct TagPacket *pkt)
        pkt->len = 0;
 }
 
-void keytag_init(struct TagPacket *pkt)
-{
-       keytag_clearPkt(pkt);
-}
+       void keytag_init(struct TagPacket *pkt)
+       {
+               keytag_clearPkt(pkt);
+       }
 
-void keytag_poll(struct TagPacket *pkt)
+       void keytag_poll(struct TagPacket *pkt)
 {
        int c;
 

diff --git a/net/keytag.h b/net/keytag.h
index 651f134c16b2201711bc473a5299ceae97a50442..ab87be21797458253a199bc9aa67b16f25ff971c 100644 (file)
--- a/net/keytag.h
+++ b/net/keytag.h
@@ -61,15 +61,15 @@
  */
 #define TAG_MAX_PRINT_CHARS 12
 
-#include <drv/ser.h>
+#include <kern/kfile.h>
 
 /**
  * Structure of a Tag packet
  */
 typedef struct TagPacket
 {
-       struct Serial *tag_ser;         // Tag serial
-       struct Serial *comm_ser;        // Communication serial
+       KFileSerial *tag_ser;           // Tag serial
+       KFileSerial *comm_ser;        // Communication serial
        bool sync;                      // Status flag: true if we find an STX
        uint16_t len;                   // Packet lenght
        uint8_t buf[TAG_MAX_LEN];       // Reception buffer