Talk:RoboTower

All the code for the project is hosted on github. The repository can be browsed here.

TODO

1. Implement remaining RFID actions
2. Fixup and enhance GUI (sounds, bug fix, pics, ...)
3. Build new and final towers\factories (more resistant)
4. Bugfix LED switching on firmware side
5. Fixup fuzzy rules, distance estimation, ... (also wrt the new towers)
6. Enhance error conditions management (sonar timeout, configuration file malformed, ...)

STM32F4 Discovery: notes

To manage the devices added to the robot, we used a STM32F4 Discovery Board. We built the firmware with the chibiOS/RT Operating System.

The board is equipped with an ST-Link v2 programmer, that seems to be officially supported on Windows only. It works on Linux with two methods: using the stlink utility (https://github.com/texane/stlink) or using OpenOCD (you need to build it from git, as stlink support is experimental).

OpenOCD configuration

As stlink support provided by openOCD is still experimental, it has to be explicitly enabled while compiling the sources. After downloading the latest sources from the git repository (the URL should be http://sourceforge.net/scm/?type=git&group_id=274635), compile and install issuing:

    $ ./configure --enable-maintainer-mode --enable-stlink
    $ make
    # make install    (this is needed only to install the binaries system-wide, and must be performed by root)

Starting OpenOCD

When openOCD is correctly configure, it can be started with the command

    $ openocd -f board/stm32f4discovery.cfg

(assuming that the board is connected to the computer).

NB: sometimes the board is not recognized (it happens to me frequently when chibiOS is flashed on the board), and neither openocd nor texane's stlink can connect to the board. In this case, keeping the "reset" button on the board pressed while launching openocd should solve this issue. If this doesn't solve, use the ST Visual Programmer utility (windows only, sorry) to erase the FLASH memory.

Connecting to the board

You now can flash the firmware, run and debug the code from within gdb (an arm version of gdb!). To connect to the openocd gdb server (assuming that firmware.elf is the binary file to be flashed and\or debugged):

   $ arm-none-eabi-gdb filename.elf
   (gdb) target extended-remote localhost:3333

Now that gdb is connected, typing the following commands will erase the FLASH memory, load the new firmware, and - finally - run the firmware!

   (gdb) monitor reset halt
   (gdb) monitor flash probe 0
   (gdb) monitor stm32f2x mass_erase 0
   (gdb) load
   (gdb) monitor reset halt
   (gdb) continue

Ideas for the development

Ostacoli "attivi"

Tag da riconoscere tramite visione (tutte le soluzioni provate hanno dato scarsi risultati in termini di velocità e\o qualità del riconoscimento)

• 'DataMatrix': riconosciuti bene se fermi nell'immagine, ma troppo lentamente e non riconosciuti in movimento. L'algoritmo è lento (anche 3 secondi se non si impone un timeout)
• 'Scacchiera (openCV cvFindChessboardCorners)': viene riconosciuta molto male
• 'ARToolKitPlus': i frame vengono riconosciuti molto velocemente. Problema: l'algoritmo che utilizza dipende enormemente dalle condizioni di luce. In movimento i risultati sono deludenti, anche a velocità moderate. La documentazione è scarsa.

RFID: 'Radio Frequency IDentification

Abbiamo effettuato alcune prove con il lettore ID-12 della ID Innovations (tag a 125 KHz), e possiamo confermare dei risultati abbastanza buoni.

il riconoscimento avviene a una distanza apparentemente sufficiente (anche se di poco) agli scopi del gioco, e a una velocità abbastanza sostenuta da rendere l'esperienza sufficientemente dinamica.

Problematiche: Posizionamento del lettore. Il fatto che l'ID-12 sia dotato di antenna interna rende piuttosto difficoltoso il posizionamento verso il fondo del robot.

E' stata scelta questa soluzione. Il lettore ID-12 trasmette tramite un collegamento seriale a 9600 bps gli id dei tag ricevuti (per dettagli del formato vedi datasheet ID12). La board presente sul robot ritrasmette l'ID tramite connessione wireless (zigbee) al PC.

Ostacoli invisibili

gli ostacoli invisibili sono ostacoli che il sonar non riesce a rivelare perchè, ad esempio troppo bassi (gambe delle sedie) o troppo alti (caloriferi)

idee:

• Aumento hardware robot (più sonar)
• Logica

la prima opzione è abbastanza da scartare... complicata e probabili problemi di interferenza. inoltre il sonar sarebbe sottoutilizzato se piazzato per riconoscere ostacoli bassi, e inutile per quelli alti

La seconda opzione è passare al controllore fuzzy (brian) il tempo in cui l'ingresso del sonar non varia significativamente. questo significa che il robot, con buona probabilità, è bloccato. Con un fuzzy set Triangle_or (TOR) si dovrebbe ottenere un comportamento decente.

TOR fuzzy set

idea su come gestire il "tempo di blocco"

1. calcolo la deviazione standard degli ultimi 20 dati (ossia ultimo secondo circa, poichè il ciclo di controllo è a 20 Hz)
2. impongo che la stddev sia minore dell'errore accettabile (scelto, ora, fisso)
3. se l'errore è minore, allora aumenta il tempo di "blocco"
4. se è invece maggiore, azzeralo.
5. dai in pasto a brian il tempo, e fuzzyfica.

problemi:

• Falsi negativi
• Falsi positivi
• Comandi a volte troppo brevi

soluzioni:

• filtraggio passa-basso della varianza
• Aumento soglie tempo/varianza

Considerazioni La maggior parte dei falsi positivi è dovuta al fatto che il sonar, oltre una certa distanza, tende a non rilevare con precisione le variazioni di distanza delle pareti e di altri ostacoli, senza contare la dispersione possibile del segnale sonoro. si può evitare gran parte dei falsi positivi, introducendo un controllo sull'attuazione della regola, per distanze nel range di buona affidabilità del sonar (si può introdurre la possibilità di introdure l'affidabilità dell'imput??). Sicuramente così, si introducono potenziali falsi negativi, ma, poichè il controllo non può essere perfetto, si può considerare buona l'approssimazione.

Idea per migliorare ulteriormente: considerare anche il sonar sud (e/o i sonar laterali)

Vittoria

Rilevazione abbattimento torri e fabbriche: con interruttori a pressione che scattano quando la torre cade, e trasmettono via radio il segnale di "torre abbattuta" al computer. Per la trasmissione del segnale: telecomandi e ricevitore Aurel RX-4MHCS (datasheet). la soluzione sembra valida!

Riconoscere la distanza da un oggetto "visto"

Come capire se l'oggetto che sto vedendo si trova davantti a me e non dietro a qualche ostacolo?

• Correlando ciò che Vedo a ciò che Sento

ossia correlando una distanza data dalla visione a una distanza data dal sonar.

Problema: ciò che vedo è un segnale rumoroso, la larghezza del segnale non è affidabile, e la telecamera scatta.

Ostacoli laterali

Un problema della logica e dell'infrastruttura del robot, sono gli "ostacoli laterali" Sebbene dotato di sonar a est e ovest, per ora non sono "molto" utilizzati dalla logica attuale del gioco, in quanto vengono utilizzati solamente per indurre comportamenti intelligenti di uscita dalle situazioni di blocco frontale (ad esempio a causa di un ostacolo), a supporto della scelta casuale, che è necessaria quando non si hanno altre indicazioni.

Un'idea per sfruttare più pienamente le potenzialità del sonar, e indurre un comportamento più "conscio" del campo di gioco da parte del robot, è quello di cercare di mantenere una distanza di sicurezza da ostacoli laterali, se possibile.

problema possibile: il robot potrebbe non essere in grado di attraversare strettoie

Considerazioni:

• Il robot è già in grado di attraversare strettoie? se si, si può evitare il problema? bastano i due predicati contrapposti?
• Queste regole sono utili davvero? o possono influire sul normale comportamento del robot negativamente?
• Se il robot non fosse in grado d afttraversare strettoie, è possibile indurlo a farlo?
• Si riesce a supplire la mancanza di una ulteriore coppia di sonar obliqui? il cono d'ombra attuale del robot è accettabile?

Working notes about some of the used tools

Uso di MrBrian

File di configurazione

• behaviour.txt: lista dei possibili comportamenti, dei loro livelli di priorità, e di dove trovarli nel filesystem.
• file .rul: definiscono i comportamenti possibili del robot, mettendo in relazione a una condizione logica espressa coi predicati fuzzy in ingresso, i predicati fuzzy in uscita che verranno poi defuzzyficati secondo il loro peso (cando, want e antecedente)
• ctof.txt: Associa al dato crisp in ingresso (oppure in uscita da un livello di MrBrian) una "forma", ossia un'insieme di funzioni e etichette per trasformare il dato crisp in dato fuzzy.
• s_ftoc.txt: definisce quali sono i dati in uscita e che insieme di valori possono utilizzare
• shape_ctof.txt: definisce le possibii "forme" che possono essere utilizzate per fuzzyficare un determinato dato in ingresso, ossia un insieme di funzioni e relative etichette in modo da poter associare un valore di "verità" fuzzy l dato in ingresso.
• s_shape.txt: definisce gli insiemi di valori che possono usare i dati in uscita (solitamente singleton)
• Predicate.ini: Definisce i predicati Fuzzy semplici, a partire dai dati in ingressso, processati dal fuzzyficatore, oppure i predicati complessi a partire da altri predicati e dati fuzzyficati
• PredicateActions.ini: Contiene i predicati che sono definiti dai dati fuzzy presi in uscita da ogni livello.
• Cando.ini: Questo file definisce quando un determinato comportamento può essere eseguito, ossia rappresenta le condizioni necessarie per cui uncomportamento sia "sensato" da eseguire.
• want.txt: Questo file definisce quando è oppurtuno attivare un determinato comportamento, ossia rappresenta la parte "propositiva" e "strategica" del controllore fuzzy. L'obbiettivo del want è pesare quale delle scelte possibili è la migliore scelta effettuabile, nel determinato caso.

I livelli

Lo scopo della gestione a livelli è rendere indipendente la condizione di attivazione delle regole da possibili condizioni negative che invece ne evitino l'attivazione, rendendo di fatto indipendente la regola da condizioni che esulano il suo contesto. se non ci fossero i livelli, ogni regola dovrebbe considerare dunque le condzioni per cui la sua attivazione potrebbe causare conflitti con comportamenti più critici.

Ad esempio una regola che impone di avanzare al robot è sicuramente meno critica di una regola che gli impone di evitare un ostacolo, e senza i livelli l'avanzata sarebbe condizionata sempre al controllo di eventuali ostacoli di fronte a se.

I livelli funzionano nel seguente modo:

1) Mr Brian comincerà a calcolare i predicati fuzzy a partire dai dati "crisp" in ingresso, ossia applica una "forma" ai dati ricevuti dall'applicazione, che possono essere dati dei sensori, oppure dati elaborati dal programma.

2) Mr Brian calcola il Cando di ogni regola, se è sotto una determinata soglia, la regola non viene attivata.

4) Mr Brian calcola il peso da dare a ciascuna regola con il want

A questo punto entrano in gioco i livelli

5) Mr Brian inizia a calcolare le uscite imposte dalle regole di livelli 1, pesandole con il Cando e il Want (probabile che scelga il minimo dei due come peso)

6) Se si definisce una shape per il dato Fuzzy con etichetta Proposed<nome dato fuzzy in uscita> questo potrà essere utilizzato per definire predicati in predicateActions, in modo da condizionare il comportamento dei livelli superiori, in parte a quello dei livelli inferiori, ove necessario. Ad esempio se a livello 1 abbiamo TanSpeed = 40, avremo a disposizione un dato crisp ProposedTanSpeed, che potremo, se necessario, rifuzzyficare e usare come pre condizione dei livelli successsivi. Non è necessario che TanSpeed e ProposedtanSpeed abbiano la stessa shape: concettualmente sono una uscita il primo (e quindi conviene utilizzare una shape puntuale) e un ingresso il secondo (e quindi teoricamente conviene utilizzare una shape a aree trapezioidali/triangolari).

7) Se presenti regole a livello n+1 attive, esse possono:

• Leggere i dati fuzzy definiti in predicate.ini, che avranno il medesimo valore rispetto ai dati fuzzy letti dalle regole di livello n
• Leggere i dati fuzzy in uscita ai livelli precedenti definiti in PredicateActions.ini . Il valore di questi predicati dipende dall'ultimo livello attivo che gli setta e eventualmente da quelli precedenti se il dato non fosse stato cancellato.
• Cancellare le uscite impostate precedentemente con (&DEL.<nome predicato in uscita> ANY)
• Imporre nuove uscite al predicato (che i precedenti siano stati cancellati dunque fa sì che la regola sia l'unica a essere applicata)

8) i Dati vengono dunque presi, defuzzyficati e passati al livello successivo, finchè non si raggiungono le regole attive di livello massimo.

9) Il dato fuzzy così prodotto viene mandato in uscita da brian.

ROS

Qui c'è una nostra mini-guida\cheatsheet con i comandi principali e il codice di nodi di esempio (presi dai tutorial), sia per C++ che per Python

Progettazione del gioco

1. Come abbiamo progettato il gioco (linee guida, idee scartate, etc) https://docs.google.com/document/d/1uODOTOVbayhVzQwIU1lLKIQu3Wq_uJgjkT_por5xa_o/edit
2. Una prima bozza dello storyboard: