application.c

Go to the documentation of this file.

/***
 * This file is part of OpenHome, an open source home automation system.
 * Copyright (C) 2003 Jan Klötzke
 *
 * This program 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 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <avr/io.h>
#include <avr/pgmspace.h>
#include <avr/eeprom.h>
#include <inttypes.h>
#include <stddef.h>
#include "net/application.h"
#include "net/network.h"
#include "net/link.h"
#include "net/buffers.h"
#include "net.h"
#include "utils.h"

// local type definitions
typedef struct {
                net_addr_t addr;                
                enum tsp_service_e service;     
                uint8_t assoc;                  
        } event_desc_t;

typedef struct {
                uint8_t id;     
                uint8_t obj;    
                uint8_t method; 
        } assoc_t;

typedef struct {
                uint8_t obj;
                uint8_t event;
        } event_t;

// forward definitions for local object functions
static void __sys_obj_method(void *self, uint8_t property, uint8_t *buf, uint8_t *result, uint8_t repeated);
static param_desc_t __sys_obj_prop[];

#ifdef APP_STATIC
        #define READ_WORD(x)    pgm_read_word(&(x))
        
        // system object
        static struct AppObject PROGMEM __sys_obj = {__sys_obj_prop, NULL, __sys_obj_method};

        // generate list of external object references
        #define OBJECT(x, y)    extern struct AppObject PROGMEM x;
        APP_OBJECTS
        #undef OBJECT

        // allocate eeprom for events
        #define OBJECT(x, y)    event_desc_t x##_ev[y] EEPROM;
        APP_OBJECTS
        #undef OBJECT

        // generate application object table
        #define OBJECT(x, y)    ,&x
        static const struct AppObject *  PROGMEM app_object_table[] = {&__sys_obj APP_OBJECTS};
        #undef OBJECT
        
        // generate event table
        #define OBJECT(x, y)    ,x##_ev
        static event_desc_t * PROGMEM events_table[] = {NULL APP_OBJECTS};
        #undef OBJECT
#else
        #define READ_WORD(x)    (x)
        extern char __eeprom_end;

        // system object
        static struct AppObject __sys_obj = {__sys_obj_prop, NULL, __sys_obj_method};
        
        // tables
        static struct AppObject * app_object_table[16];
        static event_desc_t *events_table[16];
        
        static uint8_t next_obj = 1;
        void *next_eeprom_addr = &__eeprom_end;
#endif

// assiciation table
assoc_t ee_assoc[APP_MAX_ASSOC] EEPROM;

// sending network buffer
static net_buf_t buffer_info;
static struct main_buf_t {
                uint8_t header[13];
                uint8_t data[APP_BUFFER_SIZE];
        } buffer;
static uint8_t lock;

// event ring buffer (pre increment)
static event_t  event_buffer[APP_MAX_EVENTS];
static uint8_t event_rd, event_wr;
static net_addr_t dest;

/***
 * System network management object.
 */

#define SYS_ADDR_LOGIC_SET      0
#define SYS_ADDR_LOGIC_GET      1
#define SYS_ADDR_GROUP_SET      2
#define SYS_ADDR_GROUP_GET      3
#define SYS_SIZE_SEGMENT_SET    4
#define SYS_SIZE_SEGMENT_GET    5
#define SYS_SIZE_GROUP_SET      6
#define SYS_SIZE_GROUP_GET      7
#define SYS_ASSOC_SET           8
#define SYS_ASSOC_GET           9
#define SYS_GET_ERROR_STATS     10

static param_desc_t __sys_obj_prop[] = {{2,0}, {0,2}, {3,0}, {1,2}, {1,0},
        {0,1}, {2,0}, {1,1}, {4,0}, {1,3}, {0,8}};

static void __sys_obj_method(void *self, uint8_t method, uint8_t *buf, uint8_t *result, uint8_t repeated)
{
        switch (method) {
                case SYS_ADDR_LOGIC_SET:
                        net_set_logic_addr(*((uint16_t*)buf));
                        break;
                case SYS_ADDR_LOGIC_GET:
                        *(uint16_t*)result = net_get_logic_addr();
                        break;
                case SYS_ADDR_GROUP_SET:
                        net_set_group_addr(buf[0], *((uint16_t*)(buf+1)));
                        break;
                case SYS_ADDR_GROUP_GET:
                        *((uint16_t*)result) = net_get_group_addr(buf[0]);
                        break;
                case SYS_SIZE_SEGMENT_SET:
                        tsp_set_segment_size(buf[0]);
                        break;
                case SYS_SIZE_SEGMENT_GET:
                        *result = tsp_get_segment_size();
                        break;
                case SYS_SIZE_GROUP_SET:
                        tsp_set_group_size(buf[0], buf[1]);
                        break;
                case SYS_SIZE_GROUP_GET:
                        *result = tsp_get_group_size(buf[0]);
                        break;
                case SYS_ASSOC_SET:
                        eeprom_write_byte(&ee_assoc[buf[0]].obj, buf[1]);
                        eeprom_write_byte(&ee_assoc[buf[0]].method, buf[2]);
                        // FIXME
                        break;
                case SYS_ASSOC_GET:
                        result[0] = eeprom_read_byte(&ee_assoc[buf[0]].obj);
                        result[1] = eeprom_read_byte(&ee_assoc[buf[0]].method);
                        // FIXME
                        break;
                case SYS_GET_ERROR_STATS:
                        lnk_get_error_stats((struct lnk_err_t *)result);
                        break;
        }
}

static void call_method(uint8_t obj, uint8_t method, uint8_t *buf, uint8_t len, uint8_t session)
{
        struct AppObject *app;
        appObjCallback_t *obj_method;
        param_desc_t *params;
        event_desc_t *event;

        // event or method?
        if ((method&0x80) != 0) {
                event = (event_desc_t*)READ_WORD(events_table[obj]);
                // event written?
                if ((session != 2) && (len == sizeof(event_desc_t))) {
                        eeprom_write_block(&event[method&0x7f], buf, sizeof(event_desc_t));
                }
                // event read?
                if (session) {
                        lock = 1;
                        buf_init(buffer_info, &buffer.data, sizeof(event_desc_t));
                        eeprom_read_block(&buffer.data, &event[method&0x7f], sizeof(event_desc_t));
                }
        } else {
                app = (struct AppObject*)READ_WORD(app_object_table[obj]);
                params = (param_desc_t*)READ_WORD(app->method_sizes);
                if (len != PRG_RDB(&params[method].in)) return;
                
                obj_method = (appObjCallback_t*)READ_WORD(app->Callback);
                if (session) {
                        lock = 1;
                        buf_init(buffer_info, &buffer.data, PRG_RDB(&params[method].out));
                        obj_method(app, method, buf, buffer.data, session==2);
                } else {
                        obj_method(app, method, buf, NULL, 0); 
                }
        }
}

/********************************************************************************
 * functions called from transport layer
 */

net_buf_t *tsp_ind(uint8_t *buf, uint8_t len, uint8_t session)
{
        uint8_t obj, method, cnt, id;
        
        // can we fulfill request?
        if ((session) && (lock != 0)) return NULL;
        
        // examine object id
        if (buf[0] < 32) {
                // direct object addressing
                obj = buf[0];
                method = buf[1];
                call_method(obj, method, buf+2, len-2, session);
        } else {
                // association, look up association table
                len--;
                cnt = 0;
                do {
                        id = eeprom_read_byte(&ee_assoc[cnt].id);
                        if (id == buf[0]) {
                                obj = eeprom_read_byte(&ee_assoc[cnt].obj);
                                method = eeprom_read_byte(&ee_assoc[cnt].method);
                                call_method(obj, method, buf+1, len, session);
                        }
                        cnt++;
                } while ((cnt < APP_MAX_ASSOC) && (id <= buf[0]));
        }
        
        return &buffer_info;
}

void tsp_con(uint8_t *buf, uint8_t len)
{
        uint8_t obj, event;
        struct AppObject *app;
        appObjCallback_t *obj_method;

        // get active event     
        obj = event_buffer[event_rd].obj;
        event = event_buffer[event_rd].event;
        
        // set data
        app = (struct AppObject*)READ_WORD(app_object_table[obj]);
        obj_method = (appObjCallback_t*)READ_WORD(app->Callback);
        obj_method(app, event|0x80, buf, NULL, 0);
}

void tsp_con_fin(uint8_t status)
{
        lock = 0;
}

/********************************************************************************
 * Public functions
 */

void app_init(void)
{
        #ifndef APP_STATIC
        app_object_table[0] = &__sys_obj;
        #endif
}

void app_process(void)
{
        struct AppObject *app;
        appObjCallback_t *obj_method;
        param_desc_t *params;
        event_desc_t *ed;
        uint8_t len, obj, event;
        enum tsp_service_e service;

        // can we send at all?
        if (!tsp_clear_to_send() || (lock != 0)) return;
        
        // process pending events
        if (event_rd != event_wr) {
                // get event
                obj = event_buffer[(event_rd+1)&(APP_MAX_EVENTS-1)].obj;
                event = event_buffer[(event_rd+1)&(APP_MAX_EVENTS-1)].event;
                
                // prepare buffer
                app = (struct AppObject*)READ_WORD(app_object_table[obj]);
                params = (param_desc_t*)READ_WORD(app->event_sizes);
                len = PRG_RDB(&params[event].out);
                buf_init(buffer_info, &buffer.data, len);
                
                // get data
                obj_method = (appObjCallback_t*)READ_WORD(app->Callback);
                obj_method(app, event|0x80, NULL, buffer.data, 0);
                
                // add header, get destination info
                ed = (event_desc_t*)READ_WORD(events_table[obj]);
                eeprom_read_block(&dest, &ed[event].addr, sizeof(net_addr_t));
                service = (enum tsp_service_e)eeprom_read_byte(&ed[event].service);
                buf_prep_char(&buffer_info, eeprom_read_byte(&ed[event].assoc));
                
                // send...
                switch (tsp_requ(&buffer_info, &dest, service)) {
                        case 1:
                                lock = 1;
                        case -1: 
                                event_rd = (event_rd+1)&(APP_MAX_EVENTS-1);
                        default:
                                break;
                }
        }
}

void app_trigger_event(uint8_t obj, uint8_t event)
{
        event_wr = (event_wr+1)&(APP_MAX_EVENTS-1);
        event_buffer[event_wr].obj = obj;
        event_buffer[event_wr].event = event;
}

#ifndef APP_STATIC

uint8_t app_register_obj(struct AppObject *obj, uint8_t events)
{
        app_object_table[next_obj] = obj;
        events_table[next_obj] = next_eeprom_addr;
        (uint8_t*)next_eeprom_addr += events*sizeof(event_desc_t);
        return next_obj++;
}

#endif

---