bertos/net/pocketcmd.c

   1 /**
   2  * \file
   3  * <!--
   4  * This file is part of BeRTOS.
   5  *
   6  * Bertos is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  *
  20  * As a special exception, you may use this file as part of a free software
  21  * library without restriction.  Specifically, if other files instantiate
  22  * templates or use macros or inline functions from this file, or you compile
  23  * this file and link it with other files to produce an executable, this
  24  * file does not by itself cause the resulting executable to be covered by
  25  * the GNU General Public License.  This exception does not however
  26  * invalidate any other reasons why the executable file might be covered by
  27  * the GNU General Public License.
  28  *
  29  * Copyright 2007 Develer S.r.l. (http://www.develer.com/)
  30  * -->
  31  *
  32  * \brief pocketBus protocol Command layer implementation.
  33  *
  34  * This module implements command layer over pocketBus
  35  * protocol.
  36  * Payload packets received by pocketBus are first checked for
  37  * address matching.
  38  * If a packet is addressed to us we look for a suitable
  39  * callback function to call.
  40  *
  41  * The received payload format is as follows:
  42  * <pre>
  43  * +----------------------------------------+
  44  * |  CMD |            DATA                 |
  45  * +----------------------------------------+
  46  * |      |                                 |
  47  * +  2B  +           0..N Byte             +
  48  * </pre>
  49  *
  50  * The CMD ID used is the same supplied by the master when
  51  * the command was sent.
  52  *
  53  * \version $Id: pocketcmd.c 16587 2007-10-02 14:31:02Z batt $
  54  *
  55  * \author Francesco Sacchi <batt@develer.com>
  56  */
  57
  58 #include "pocketcmd.h"
  59 #include "pocketbus.h"
  60
  61 #include <cfg/macros.h>
  62 #include <cfg/debug.h>
  63 #include <cfg/module.h>
  64
  65 #include <drv/timer.h>
  66
  67 #include <mware/byteorder.h>
  68
  69 #include <string.h>
  70
  71 /**
  72  * pocketBus Command poll function.
  73  * Call it to read and process pocketBus commands.
  74  */
  75 void pocketcmd_poll(struct PocketCmdCtx *ctx)
  76 {
  77         PocketMsg msg;
  78
  79         /* Try to read a packet from pocketBus */
  80         while (pocketbus_recv(ctx->bus_ctx, &msg))
  81         {
  82                 /* Check address */
  83                 if (msg.addr == ctx->addr ||
  84                     msg.addr == POCKETBUS_BROADCAST_ADDR)
  85                 {
  86                         const PocketCmdHdr *hdr = (const PocketCmdHdr *)msg.payload;
  87                         pocketcmd_t cmd = be16_to_cpu(hdr->cmd);
  88
  89                         /* We're no longer waiting for a reply (in case we were) */
  90                         if (cmd == ctx->waiting)
  91                                 ctx->waiting = PKTCMD_NULL;
  92
  93                         /* Check for command callback */
  94                         pocketcmd_hook_t callback = ctx->search(cmd);
  95
  96                         /* Call it if exists */
  97                         if (callback)
  98                         {
  99                                 PocketCmdMsg cmd_msg;
 100
 101                                 cmd_msg.cmd_ctx = ctx;
 102                                 cmd_msg.cmd = cmd;
 103                                 cmd_msg.len = msg.len - sizeof(PocketCmdHdr);
 104                                 cmd_msg.buf = msg.payload + sizeof(PocketCmdHdr);
 105
 106                                 callback(&cmd_msg);
 107                         }
 108                 }
 109         }
 110 }
 111
 112 /**
 113  * Send command \a cmd to/from slave adding \a len arguments in \a buf.
 114  * Address used is contained in \a ctx->addr .
 115  * If we are master and the message has a reply, you must set \a wait_reply to true.
 116  * \return true if all is ok, false if we are already waiting a replay from another slave.
 117  */
 118 bool pocketcmd_send(struct PocketCmdCtx *ctx, pocketcmd_t cmd, const void *buf, size_t len, bool wait_reply)
 119 {
 120         /* Check if we are waiting a reply from someone */
 121         if (ctx->waiting != PKTCMD_NULL)
 122         {
 123                 /* Check is reply timeout is elapsed */
 124                 if (timer_clock() - ctx->reply_timer < ms_to_ticks(PKTCMD_REPLY_TIMEOUT))
 125                 {
 126                         TRACEMSG("Pkt discard! waiting cmd[%04X]\n", ctx->waiting);
 127                         return false;
 128                 }
 129                 else
 130                 {
 131                         TRACEMSG("Timeout waiting cmd[%04X]\n", ctx->waiting);
 132                         ctx->waiting = PKTCMD_NULL;
 133                 }
 134         }
 135
 136         /* Endianess! */
 137         cmd = cpu_to_be16(cmd);
 138
 139         /* Send packet */
 140         pocketbus_begin(ctx->bus_ctx, ctx->addr);
 141         pocketbus_write(ctx->bus_ctx, &cmd, sizeof(cmd));
 142         pocketbus_write(ctx->bus_ctx, buf, len);
 143         pocketbus_end(ctx->bus_ctx);
 144
 145         if (wait_reply)
 146         {
 147                 ctx->waiting = cmd;
 148                 ctx->reply_timer = timer_clock();
 149         }
 150         return true;
 151 }
 152
 153 /**
 154  * Init pocketBus command layer.
 155  * \a ctx is pocketBus command layer context.
 156  * \a bus_ctx is pocketBus context.
 157  * \a addr is slave address (see pocketcmd_setAddr for details.)
 158  * \a search is the lookup function used to search command ID callbacks.
 159  */
 160 void pocketcmd_init(struct PocketCmdCtx *ctx, struct PocketBusCtx *bus_ctx, pocketbus_addr_t addr, pocketcmd_lookup_t search)
 161 {
 162         ASSERT(ctx);
 163         ASSERT(bus_ctx);
 164         ASSERT(search);
 165         MOD_CHECK(timer);
 166
 167         memset(ctx, 0, sizeof(*ctx));
 168         ctx->bus_ctx = bus_ctx;
 169         ctx->search = search;
 170         pocketcmd_setAddr(ctx, addr);
 171 }
 172
 173 /**
 174  * Helper function used to reply to master with an ACK.
 175  */
 176 void pocketcmd_replyAck(struct PocketCmdMsg *msg)
 177 {
 178         uint8_t ack[] = { POCKETBUS_ACK };
 179
 180         pocketcmd_slaveReply(msg->cmd_ctx, msg->cmd, ack, sizeof(ack));
 181 }
 182
 183 /**
 184  * Helper function used to reply to master with a NAK.
 185  */
 186 void pocketcmd_replyNak(struct PocketCmdMsg *msg)
 187 {
 188         uint8_t nak[] = { POCKETBUS_NAK };
 189
 190         pocketcmd_slaveReply(msg->cmd_ctx, msg->cmd, nak, sizeof(nak));
 191 }
 192