Traduzione automatica di un middleware su ZigBee Andrea Brazzarola vr luglio 2008

Introduzione Lo sviluppo di una applicazione per reti di sensori comporta un elevato sforzo di progettazione a causa delle limitate risorse disponibili e delle forti limitazioni date dallo standard ZigBee/IEEE Lo scopo di questo progetto è quello di fornire un tool per il mapping automatico dell'applicazione SystemC sullo Z-Stack di Texas Instrument, lasciando allo sviluppatore libertà di progetto.

Traduzione automatica su ZigBee Tre concetti fondamentali: Conversione dal linguaggio SystemC a C; Implementazione dei servizi ZigBee OOM; Modifica dell'applicazione per rispettare le specifiche dello Z-Stack.

Traduzione automatica su ZigBee

Creazione della macchina a stati finiti Nella slide precedente si può notare che il corpo principale dell'applicazione ZigBee è dato dalla trasformazione del codice in una FSM, ciò è stato fatto per evitare il rischio di deadlock sulle invocazioni remote. La creazione di una FSM implica la suddivisione del codice in stati e quindi l'implementazione di un algoritmo che riconosca nel codice dell'applicazione AME i punti nel quale creare un nuovo stato.

Creazione della macchina a stati finiti Un nuovo stato deve essere creato quando si incontra un'operazione potenzialmente bloccante, come una chiamata a servizio o un operazione di register/lookup di un nodo. Esiste anche il problema che se la chiamata si trova annidata in un blocco iterativo o condizionale, questi non possone essere interrotti e poi ripresi. Quindi c'è bisogno di dividere in stati anche questi blocchi.

Creazione della macchina a stati finiti La trasformazione inizia con la visita di ogni funzione e procedura, per ognuna di queste viene effettuato il parsing delle sue istruzioni attraverso il metodo parseCode() e nel caso venga trovata una chiamata bloccante verrà creato un nuovo stato; Allo stesso modo, se vengono trovati blocchi iterativi o condizionali verrà creato uno stato ma, in questo caso, si andrà ad analizzare ricorsivamente il codice al loro interno utilizzando il metodo parseIf() o il metodo parseWhile(), mentre i blocchi di istruzioni sequenziali verranno copiati nello stato corrente.

codeToFsm(){ newState = create_newFSM_state(); parseCode(AMECode->INSTRUCTIONS, newState) for each(state) addStatement(return); } parse_Code(instr, newState){ for each (instr) { if(instr.type == CASE_STATEMENT){ newState = create_new_FSM_state(); parse_if(caseObjects, newState) }else if(instr.type == WHILE_STATEMENT){ newState = create_new_FSM_state(); parse_while(whileObject, newState) }else if(instr.type == PCALL_STATEMENT){ newState = create_new_FSM_state(); newState ->AddInstruction_to_FSM_state(instr); newState ->AddStatement(step=step+1); }else if(instr.type == ASSIGN_STATEMENT){ if(instr.type == FCALL_STATEMENT){ newState = create_new_FSM_state(); newState -> addInstruction_to_FSM_state(instr); newState -> addStatement(step=step+1); }else newState -> addInstruction_to_FSM_state(instr); }

parse_if(caseObjects, newState){ for each (caseObjects) { newCaseObject = create_CaseObject(); parseCode(caseObject->INSTRUCTIONS, newCaseObject); newCaseObject -> setCondition(caseObject->CONDITION) newCaseObject -> addStatement(step=step+1); newCaseObject -> addStatement(else{step=counter}); newState -> addStatement(newCaseObject); } parse_while(whileObject, newState){ newCaseObject = create_CaseObject(); parseCode(whileObject->INSTRUCTIONS, newCaseObject); newCaseObject -> setCondition(whileObject->CONDITION) newCaseObject -> addStatement(else{step=counter}); newState -> addStatement(newCaseObject); } create_new_FSM_state(){ newState = newState(); newState -> addStatement(if (step==[counter]){}); counter++; return newState; }

Creazione della macchina a stati finiti Il codice necessario per la costruzione della FSM è situato nei file: CodeToFsm.cpp e CodeToFsm.h Esso è stato implementato in modo da poter modificare un albero HIF ridefinendo il metodo VisitStateObject() di guideVisitor. Ecco come viene trasformato un blocco while: while (COND){if (step == n){ \\Codiceif (COND) { }\\Codice }else step++ }

FINE