/opt/ros/diamondback/stacks/ethzasl_aseba/asebaros/aseba/svn/targets/dspic33/skel.c

Go to the documentation of this file.

/*
        Aseba - an event-based framework for distributed robot control
        Copyright (C) 2006 - 2009:
                Philippe Rétornaz <philippe.retornaz at epfl dot ch>
                and other contributors, see authors.txt for details
                Mobots group, Laboratory of Robotics Systems, EPFL, Lausanne

        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 3 of the License, or
        any other version as decided by the two original authors
        Stephane Magnenat and Valentin Longchamp.

        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, see <http://www.gnu.org/licenses/>.
*/


#include <string.h>

// Molole includes
#include <can/can.h>
#include <dma/dma.h>
#include <gpio/gpio.h>
#include <types/types.h>
#include <error/error.h>
#include <flash/flash.h>

// Aseba includes 
#include <transport/can/can-net.h>
#include <vm/natives.h>
#include <vm/vm.h>
#include <common/consts.h>
#include <transport/buffer/vm-buffer.h>

#include "skel.h"


static AsebaNativeFunctionDescription AsebaNativeDescription__system_reboot =
{
        "_system.reboot",
        "Reboot the microcontroller",
        {
                { 0, 0 }
        }
};

void AsebaResetIntoBootloader(AsebaVMState *vm) {
        asm __volatile__ ("reset");
}

static AsebaNativeFunctionDescription AsebaNativeDescription__system_settings_read =
{
        "_system.settings.read",
        "Read a setting",
        {
                { 1, "address"},
                { 1, "value"},
                { 0, 0 }
        }
};

static void AsebaNative__system_settings_read(AsebaVMState *vm) {
        uint16 address = vm->variables[AsebaNativePopArg(vm)];
        uint16 destidx = AsebaNativePopArg(vm);

        if(address > sizeof(settings)/2 - 1) {
                AsebaVMEmitNodeSpecificError(vm, "Address out of settings");
                return;
        }
        vm->variables[destidx] = ((unsigned int *) &settings)[address];
}

static AsebaNativeFunctionDescription AsebaNativeDescription__system_settings_write =
{
        "_system.settings.write",
        "Write a setting",
        {
                { 1, "address"},
                { 1, "value"},
                { 0, 0 }
        }
};

static void AsebaNative__system_settings_write(AsebaVMState *vm) {
        uint16 address = vm->variables[AsebaNativePopArg(vm)];
        uint16 sourceidx = AsebaNativePopArg(vm);
        if(address > sizeof(settings)/2 - 1) {
                AsebaVMEmitNodeSpecificError(vm, "Address out of settings");
                return;
        }
        ((unsigned int *) &settings)[address] = vm->variables[sourceidx];
}


static AsebaNativeFunctionDescription AsebaNativeDescription__system_settings_flash =
{
        "_system.settings.flash",
        "Write the settings into flash",
        {
                { 0, 0 }
        }
};

static void AsebaNative__system_settings_flash(AsebaVMState *vm);



#include <skel-user.c>


unsigned int events_flags = 0;



struct private_settings __attribute__((aligned(2))) settings;
// Nice hack to do a compilation assert with 
#define COMPILATION_ASSERT(e) do { enum { assert_static__ = 1/(e) };} while(0)

const AsebaLocalEventDescription * AsebaGetLocalEventsDescriptions(AsebaVMState *vm)
{
        return localEvents;
}








/* buffers for can-net */
static __attribute((far)) CanFrame sendQueue[SEND_QUEUE_SIZE];

static __attribute((far)) CanFrame recvQueue[RECV_QUEUE_SIZE];


/* VM */
struct __attribute((far)) _vmVariables vmVariables;

static __attribute((far))  uint16 vmBytecode[VM_BYTECODE_SIZE];

static __attribute((far))  sint16 vmStack[VM_STACK_SIZE];

AsebaVMState vmState = {
        0,
        
        VM_BYTECODE_SIZE,
        vmBytecode,
        
        sizeof(vmVariables) / sizeof(sint16),
        (sint16*)&vmVariables,

        VM_STACK_SIZE,
        vmStack
};



/* Callbacks */

void AsebaIdle(void) {
        Idle();
}

void AsebaPutVmToSleep(AsebaVMState *vm) {
}

void AsebaNativeFunction(AsebaVMState *vm, uint16 id)
{
        nativeFunctions[id](vm);
}


static void received_packet_dropped(void)
{
        /* ---- PUT HERE SOME LED STATE OUTPUT ----- */
}

static void sent_packet_dropped(void)
{
        /* ---- PUT HERE SOME LED STATE OUTPUT ----- */
}

const AsebaVMDescription * AsebaGetVMDescription(AsebaVMState *vm) {
        return &vmDescription;
}

uint16 AsebaShouldDropPacket(uint16 source, const uint8* data) {
        return AsebaVMShouldDropPacket(&vmState, source, data);
}

        
const AsebaNativeFunctionDescription * const * AsebaGetNativeFunctionsDescriptions(AsebaVMState *vm) {
        return nativeFunctionsDescription;
}


// START of Bytecode into Flash section -----

// A chunk is a bytecode image 
#define PAGE_PER_CHUNK ((VM_BYTECODE_SIZE*2+3 + INSTRUCTIONS_PER_PAGE*3 - 1) / (INSTRUCTIONS_PER_PAGE*3))
#if PAGE_PER_CHUNK == 0
#undef PAGE_PER_CHUNK
#define PAGE_PER_CHUNK 1
#endif

/* noload will tell the linker to allocate the space but NOT to initialise it. (left unprogrammed)*/
/* I cannot delare it as an array since it's too large ( > 65535 ) */

// Put everything in the same section, so we are 100% sure that the linker will put them contiguously.
// Force the address, since the linker sometimes put it in the middle of the code 
#define NUMBER_OF_CHUNK 26
unsigned char  aseba_flash[PAGE_PER_CHUNK][INSTRUCTIONS_PER_PAGE * 2] __attribute__ ((space(prog), aligned(INSTRUCTIONS_PER_PAGE * 2), section(".aseba_bytecode"), address(0x15800 - 0x800 /* bootloader */ - 0x400 /* settings */ - NUMBER_OF_CHUNK*0x400L*PAGE_PER_CHUNK)/*, noload*/));
unsigned char aseba_flash1[PAGE_PER_CHUNK][INSTRUCTIONS_PER_PAGE * 2] __attribute__ ((space(prog), aligned(INSTRUCTIONS_PER_PAGE * 2), section(".aseba_bytecode")/*, noload*/));
unsigned char aseba_flash2[PAGE_PER_CHUNK][INSTRUCTIONS_PER_PAGE * 2] __attribute__ ((space(prog), aligned(INSTRUCTIONS_PER_PAGE * 2), section(".aseba_bytecode")/*, noload*/));
unsigned char aseba_flash3[PAGE_PER_CHUNK][INSTRUCTIONS_PER_PAGE * 2] __attribute__ ((space(prog), aligned(INSTRUCTIONS_PER_PAGE * 2), section(".aseba_bytecode")/*, noload*/));
unsigned char aseba_flash4[PAGE_PER_CHUNK][INSTRUCTIONS_PER_PAGE * 2] __attribute__ ((space(prog), aligned(INSTRUCTIONS_PER_PAGE * 2), section(".aseba_bytecode")/*, noload*/));
unsigned char aseba_flash5[PAGE_PER_CHUNK][INSTRUCTIONS_PER_PAGE * 2] __attribute__ ((space(prog), aligned(INSTRUCTIONS_PER_PAGE * 2), section(".aseba_bytecode")/*, noload*/));
unsigned char aseba_flash6[PAGE_PER_CHUNK][INSTRUCTIONS_PER_PAGE * 2] __attribute__ ((space(prog), aligned(INSTRUCTIONS_PER_PAGE * 2), section(".aseba_bytecode")/*, noload*/));
unsigned char aseba_flash7[PAGE_PER_CHUNK][INSTRUCTIONS_PER_PAGE * 2] __attribute__ ((space(prog), aligned(INSTRUCTIONS_PER_PAGE * 2), section(".aseba_bytecode")/*, noload*/));
unsigned char aseba_flash8[PAGE_PER_CHUNK][INSTRUCTIONS_PER_PAGE * 2] __attribute__ ((space(prog), aligned(INSTRUCTIONS_PER_PAGE * 2), section(".aseba_bytecode")/*, noload*/));
unsigned char aseba_flash9[PAGE_PER_CHUNK][INSTRUCTIONS_PER_PAGE * 2] __attribute__ ((space(prog), aligned(INSTRUCTIONS_PER_PAGE * 2), section(".aseba_bytecode")/*, noload*/));
unsigned char aseba_flash10[PAGE_PER_CHUNK][INSTRUCTIONS_PER_PAGE * 2] __attribute__ ((space(prog), aligned(INSTRUCTIONS_PER_PAGE * 2), section(".aseba_bytecode")/*, noload*/));
unsigned char aseba_flash11[PAGE_PER_CHUNK][INSTRUCTIONS_PER_PAGE * 2] __attribute__ ((space(prog), aligned(INSTRUCTIONS_PER_PAGE * 2), section(".aseba_bytecode")/*, noload*/));
unsigned char aseba_flash12[PAGE_PER_CHUNK][INSTRUCTIONS_PER_PAGE * 2] __attribute__ ((space(prog), aligned(INSTRUCTIONS_PER_PAGE * 2), section(".aseba_bytecode")/*, noload*/));
unsigned char aseba_flash13[PAGE_PER_CHUNK][INSTRUCTIONS_PER_PAGE * 2] __attribute__ ((space(prog), aligned(INSTRUCTIONS_PER_PAGE * 2), section(".aseba_bytecode")/*, noload*/));
unsigned char aseba_flash14[PAGE_PER_CHUNK][INSTRUCTIONS_PER_PAGE * 2] __attribute__ ((space(prog), aligned(INSTRUCTIONS_PER_PAGE * 2), section(".aseba_bytecode")/*, noload*/)); 
unsigned char aseba_flash15[PAGE_PER_CHUNK][INSTRUCTIONS_PER_PAGE * 2] __attribute__ ((space(prog), aligned(INSTRUCTIONS_PER_PAGE * 2), section(".aseba_bytecode")/*, noload*/));
unsigned char aseba_flash16[PAGE_PER_CHUNK][INSTRUCTIONS_PER_PAGE * 2] __attribute__ ((space(prog), aligned(INSTRUCTIONS_PER_PAGE * 2), section(".aseba_bytecode")/*, noload*/));
unsigned char aseba_flash17[PAGE_PER_CHUNK][INSTRUCTIONS_PER_PAGE * 2] __attribute__ ((space(prog), aligned(INSTRUCTIONS_PER_PAGE * 2), section(".aseba_bytecode")/*, noload*/));
unsigned char aseba_flash18[PAGE_PER_CHUNK][INSTRUCTIONS_PER_PAGE * 2] __attribute__ ((space(prog), aligned(INSTRUCTIONS_PER_PAGE * 2), section(".aseba_bytecode")/*, noload*/));
unsigned char aseba_flash19[PAGE_PER_CHUNK][INSTRUCTIONS_PER_PAGE * 2] __attribute__ ((space(prog), aligned(INSTRUCTIONS_PER_PAGE * 2), section(".aseba_bytecode")/*, noload*/));
unsigned char aseba_flash20[PAGE_PER_CHUNK][INSTRUCTIONS_PER_PAGE * 2] __attribute__ ((space(prog), aligned(INSTRUCTIONS_PER_PAGE * 2), section(".aseba_bytecode")/*, noload*/));
unsigned char aseba_flash21[PAGE_PER_CHUNK][INSTRUCTIONS_PER_PAGE * 2] __attribute__ ((space(prog), aligned(INSTRUCTIONS_PER_PAGE * 2), section(".aseba_bytecode")/*, noload*/));
unsigned char aseba_flash22[PAGE_PER_CHUNK][INSTRUCTIONS_PER_PAGE * 2] __attribute__ ((space(prog), aligned(INSTRUCTIONS_PER_PAGE * 2), section(".aseba_bytecode")/*, noload*/));
unsigned char aseba_flash23[PAGE_PER_CHUNK][INSTRUCTIONS_PER_PAGE * 2] __attribute__ ((space(prog), aligned(INSTRUCTIONS_PER_PAGE * 2), section(".aseba_bytecode")/*, noload*/));
unsigned char aseba_flash24[PAGE_PER_CHUNK][INSTRUCTIONS_PER_PAGE * 2] __attribute__ ((space(prog), aligned(INSTRUCTIONS_PER_PAGE * 2), section(".aseba_bytecode")/*, noload*/));
unsigned char aseba_flash25[PAGE_PER_CHUNK][INSTRUCTIONS_PER_PAGE * 2] __attribute__ ((space(prog), aligned(INSTRUCTIONS_PER_PAGE * 2), section(".aseba_bytecode")/*, noload*/));

// Saveguard the bootloader (2 pages)
unsigned char __bootloader[INSTRUCTIONS_PER_PAGE * 2 * 2] __attribute((space(prog), section(".boot"), noload, address(0x15800 - 0x800)));

// Put the settings page at a fixed position so it's independant of linker mood. 
unsigned char aseba_settings_flash[INSTRUCTIONS_PER_PAGE * 2] __attribute__ ((space(prog), section(".aseba_settings"), noload, address(0x15800 - 0x800 - 0x400)));
#warning "the settings page is NOT initialised"


unsigned long aseba_flash_ptr;
unsigned long aseba_settings_ptr;

void AsebaWriteBytecode(AsebaVMState *vm) {
        // Look for the lowest number of use
        unsigned long min = 0xFFFFFFFF;
        unsigned long min_addr = 0;
        unsigned long count;
        unsigned int i;
        unsigned long temp_addr = aseba_flash_ptr;
        unsigned int instr_count;
        unsigned char * bcptr = (unsigned char *) vm->bytecode;
        // take the first minimum value
        for (i = 0; i < NUMBER_OF_CHUNK; i++, temp_addr += INSTRUCTIONS_PER_PAGE * 2 * PAGE_PER_CHUNK) {
                count = flash_read_instr(temp_addr);
                if(count < min) {
                        min = count;
                        min_addr = temp_addr;
                }
        }
        if(min == 0xFFFFFFFF) {
                AsebaVMEmitNodeSpecificError(vm, "Error: min == 0xFFFFFFFF !");
                return;
        }
        min++;
        
        // Now erase the pages
        for(i = 0; i < PAGE_PER_CHUNK; i++) 
                flash_erase_page(min_addr + i*INSTRUCTIONS_PER_PAGE * 2);
                
        // Then write the usage count and the bytecode
        flash_prepare_write(min_addr);
        flash_write_instruction(min);
        flash_write_buffer((unsigned char *) vm->bytecode, VM_BYTECODE_SIZE*2);
        flash_complete_write();
        
        
        // Now, check the data
        
        if(min != flash_read_instr(min_addr)) {
                AsebaVMEmitNodeSpecificError(vm, "Error: Unable to flash bytecode (1) !");
                return;
        }       
        min_addr += 2;
        instr_count = (VM_BYTECODE_SIZE*2) / 3;

        for(i = 0; i < instr_count; i++) {
                unsigned char data[3];
                flash_read_chunk(min_addr, 3, data);

                if(memcmp(data, bcptr, 3)) {
                        AsebaVMEmitNodeSpecificError(vm, "Error: Unable to flash bytecode (2) !");
                        return;
                }
                bcptr += 3;
                min_addr += 2;
        }
        
        i = (VM_BYTECODE_SIZE * 2) % 3;
        
        if(i != 0) {
                unsigned char data[2];
                flash_read_chunk(min_addr, i, data);
                if(memcmp(data, bcptr, i)) {
                        AsebaVMEmitNodeSpecificError(vm, "Error: Unable to flash bytecode (3) !");
                        return;
                }
        }
        
        AsebaVMEmitNodeSpecificError(vm, "Flashing OK");
        
}

const static unsigned int _magic_[8] = {0xDE, 0xAD, 0xCA, 0xFE, 0xBE, 0xEF, 0x04, 0x02};
static void AsebaNative__system_settings_flash(AsebaVMState *vm) {
        // Look for the last "Magic" we know, this is the most up to date conf
        // Then write the next row with the correct magic.
        // If no magic is found, erase the page, and then write the first one
        // If the last magic is found, erase the page and then write the first one
        
        unsigned long setting_addr = aseba_settings_ptr;
        int i = 0;
        unsigned int mag;
        unsigned long temp;
        for(i = 0; i < 8; i++) { 
                mag = flash_read_low(setting_addr + INSTRUCTIONS_PER_ROW * 2 * i);
                if(mag != _magic_[i]) 
                        break;
        }
        
        if(i == 0 || i == 8) {
                flash_erase_page(setting_addr);
                i = 0;
        }
        
        setting_addr += INSTRUCTIONS_PER_ROW * 2 * i;
        
        flash_prepare_write(setting_addr);
        temp = (((unsigned long) *((unsigned char * ) &settings)) << 16) | _magic_[i];
        
        flash_write_instruction(temp);
        flash_write_buffer(((unsigned char *) &settings) + 1, sizeof(settings) - 1);
        flash_complete_write();
}

static void load_code_from_flash(AsebaVMState *vm) {
        // Find the last maximum value
        unsigned long max = 0;
        unsigned long max_addr = 0;
        unsigned long temp_addr = aseba_flash_ptr;
        unsigned long count;
        unsigned int i;
        // take the last maximum value
        for (i = 0; i < NUMBER_OF_CHUNK; i++, temp_addr += INSTRUCTIONS_PER_PAGE * 2 * PAGE_PER_CHUNK) {
                count = flash_read_instr(temp_addr);
                if(count >= max) {
                        max = count;
                        max_addr = temp_addr;
                }
        }
        if(!max)  
                // Nothing to load
                return;
                
        flash_read_chunk(max_addr + 2, VM_BYTECODE_SIZE*2, (unsigned char *) vm->bytecode);
        
        // Tell the VM to init
        AsebaVMSetupEvent(vm, ASEBA_EVENT_INIT);
}

int load_settings_from_flash(void) {
        
        // Max size 95 int, min 1 int
        COMPILATION_ASSERT(sizeof(settings) < ((INSTRUCTIONS_PER_ROW*3) - 2));
        COMPILATION_ASSERT(sizeof(settings) > 1);
        
        // The the last "known" magic found
        unsigned long temp = aseba_settings_ptr;
        int i = 0;
        unsigned int mag;


        
        for(i = 0; i < 8; i++) { 
                mag = flash_read_low(temp + INSTRUCTIONS_PER_ROW * 2 * i);
                if(mag != _magic_[i]) 
                        break;
        }
        if(i == 0)
                // No settings found 
                return -1;
        i--;
        temp += INSTRUCTIONS_PER_ROW * 2 * i;
        *((unsigned char *) &settings) = (unsigned char) (flash_read_high(temp) & 0xFF);
        flash_read_chunk(temp + 2, sizeof(settings) - 1, ((unsigned char *) &settings) + 1);
        
        return 0;       
}
// END of bytecode into flash section


#ifdef ASEBA_ASSERT
void AsebaAssert(AsebaVMState *vm, AsebaAssertReason reason) {
        AsebaVMEmitNodeSpecificError(vm, "VM ASSERT !");
}
#endif

static unsigned int ui2str(char *str, unsigned int value) {
        unsigned div;
        unsigned int i = 0;
        bool hasSent = false;
        for (div = 10000; div > 0; div /= 10)
        {
                unsigned disp = value / div;
                value %= div;

                if ((disp != 0) || (hasSent) || (div == 1))
                {
                        hasSent = true;
                        str[i++] =  '0' + disp;
                }
        }
        str[i] = 0;
        return i;
}

static unsigned int ui2strhex(char * str, unsigned int id) {
        int shift;
        bool hasSent = false;
        unsigned int i = 0;
        for (shift = 12; shift >= 0; shift -= 4)
        {
                unsigned disp = ((id & (0xF << shift)) >> shift);

                if ((disp != 0) || (hasSent) || (shift == 0))
                {
                        hasSent = true;
                        if(disp > 9) 
                                str[i++] = 'A' + disp - 0xA;
                        else
                                str[i++] = '0' + disp;
                }
        }
        str[i] = 0;
        return i;
}

static void __attribute__((noreturn)) error_handler(const char * file, int line, int id, void* __attribute((unused)) arg) {
        char error_string[255];
        char number[10];
        strcpy(error_string, "Molole error 0x");
        ui2strhex(number, (unsigned int) id);
        strcat(error_string, number);
        strcat(error_string, " in file: ");
        strncat(error_string, file, 200);
        strcat(error_string, ":");
        ui2str(number, line);
        strcat(error_string, number);
        
        
        AsebaVMEmitNodeSpecificError(&vmState, error_string);
        
        AsebaCanFlushQueue();
        
        asm __volatile__ ("reset");
        
        for(;;); // Shutup GCC 
}

#define FUID3 0xF80016

void init_aseba_and_can(void) {
        unsigned int low, high;
        // Read the Device ID at _FUID3

        vmState.nodeId = flash_read_low(FUID3);
        
        // Get the section start pointer. Cannot get it in C, so use the assember-style
        asm ("mov #tbloffset(.startof.(.aseba_bytecode)), %[l]" : [l] "=r" (low));
        asm ("mov #tblpage(.startof.(.aseba_bytecode)), %[h]" : [h] "=r" (high));
        aseba_flash_ptr = (unsigned long) high << 16 | low;
        
        asm ("mov #tbloffset(.startof.(.aseba_settings)), %[l]" : [l] "=r" (low));
        asm ("mov #tblpage(.startof.(.aseba_settings)), %[h]" : [h] "=r" (high));
        aseba_settings_ptr = (unsigned long) high << 16 | low;



        can_init((can_frame_received_callback)AsebaCanFrameReceived, AsebaCanFrameSent, DMA_CAN_RX, DMA_CAN_TX, CAN_SELECT_MODE, 1000, PRIO_CAN);
        AsebaCanInit(vmState.nodeId, (AsebaCanSendFrameFP)can_send_frame, can_is_frame_room, received_packet_dropped, sent_packet_dropped, sendQueue, SEND_QUEUE_SIZE, recvQueue, RECV_QUEUE_SIZE);
        AsebaVMInit(&vmState);
        vmVariables.id = vmState.nodeId;
        
        load_code_from_flash(&vmState);
        
        error_register_callback(error_handler);

}

void __attribute((noreturn)) run_aseba_main_loop(void) {
        while(1)
        {
                update_aseba_variables_read();
                
                AsebaVMRun(&vmState, 1000);
                
                AsebaProcessIncomingEvents(&vmState);
                
                update_aseba_variables_write();

                // Either we are in step by step, so we go to sleep until further commands, or we are not executing an event,
                // and so we have nothing to do.
                if (AsebaMaskIsSet(vmState.flags, ASEBA_VM_STEP_BY_STEP_MASK) || AsebaMaskIsClear(vmState.flags, ASEBA_VM_EVENT_ACTIVE_MASK))
                {
                        unsigned i;
                        // Find first bit from right (LSB), check if some CAN packets are pending
                        // Atomically, do an Idle() if nothing is found
                        // Warning, I'm doing some nasty things with the IPL bits (forcing the value, without safeguard)
                        // Second warning: It doesn't disable level 7 interrupt. So if you set an event inside a level 7 interrupt
                        // It may get delayed until next interrupt
                        asm __volatile__ ("mov #SR, w0 \r\n"
                                                        "mov #0xC0, w1\r\n"
                                                        "ior.b w1, [w0], [w0]\r\n" // Disable all interrupts
                                                        "ff1r [%[word]], %[b]\r\n"
                                                        "bra nc, 1f\r\n"
                                                        "rcall _AsebaCanRecvBufferEmpty\r\n"
                                                        "cp0 w0\r\n"
                                                        "bra z, 1f \r\n"
                                                        "rcall _clock_idle\r\n"  // Powersave WITH interrupt disabled. It works, read section 6.2.5 of dsPIC manual
                                                        "1: \r\n"
                                                        "mov #SR, w0 \r\n"
                                                        "mov #0x1F, w1\r\n"
                                                        "and.b w1, [w0],[w0] \r\n" // enable interrupts
                                                         : [b] "=x" (i) : [word] "r" (&events_flags) : "cc", "w0", "w1", "w2", "w3", "w4", "w5", "w6", "w7");
                                                        // Why putting "x" as constrain register. Because it's w8-w9, so it's preserved accross function call
                                                        // we do a rcall, so we must clobber w0-w7
                                                        
                        // If a local event is pending, then execute it.
                        // Else, we waked up from idle because of an interrupt, so re-execute the whole thing
                        // FIXME: do we want to kill execution upon local events? that would be consistant so Steph votes yes, but
                        // we may discuss further
                        if(i && !(AsebaMaskIsSet(vmState.flags, ASEBA_VM_STEP_BY_STEP_MASK) &&  AsebaMaskIsSet(vmState.flags, ASEBA_VM_EVENT_ACTIVE_MASK))) {
                        // that is the same as (thx de Morgan)
                        //if(i && (AsebaMaskIsClear(vmState.flags, ASEBA_VM_STEP_BY_STEP_MASK) ||  AsebaMaskIsClear(vmState.flags, ASEBA_VM_EVENT_ACTIVE_MASK))) {
                                i--;
                                CLEAR_EVENT(i);
                                vmVariables.source = vmState.nodeId;
                                AsebaVMSetupEvent(&vmState, ASEBA_EVENT_LOCAL_EVENTS_START - i);
                        }
                }
        }
}

        

---

asebaros
Author(s): $author
autogenerated on Mon Sep 5 08:41:53 2011