Abb Manuale Applicativo Sdk Con Flex Pendant

Machine Translated by Google
ABB Robotica
Manuale applicativo
SDK FlexPendant
Rintracciare le informazioni:
Area di lavoro RW 5-15-01 versione a2
Controllato nel 15-03-2013
Skribenta versione 1184
Manuale applicativo
SDK FlexPendant
RobotWare 5.15
ID documento: 3HAC036958-001
Revisione: B
©Copyright 2010-2013 ABB. Tutti i diritti riservati.

Le informazioni contenute in questo manuale sono soggette a modifiche senza preavviso e non devono
essere interpretate come un impegno da parte di ABB. ABB non si assume alcuna responsabilità per
eventuali errori presenti nel presente manuale.
Fatto salvo quanto espressamente indicato in qualsiasi parte del presente manuale, nulla di quanto
contenuto nel presente documento dovrà essere interpretato come alcun tipo di garanzia da parte di
ABB per perdite, danni a persone o proprietà, idoneità per uno scopo specifico o simili.
In nessun caso ABB sarà responsabile per danni incidentali o consequenziali derivanti dall'uso del presente
manuale e dei prodotti in esso descritti.
Questo manuale e parti di esso non possono essere riprodotti o copiati senza il consenso scritto di
ABB.
Ulteriori copie di questo manuale possono essere ottenute da ABB.
La lingua originale di questa pubblicazione è l'inglese. Tutte le altre lingue fornite sono state tradotte
dall'inglese.

ABB AB
Prodotti di robotica
SE-721 68 Västerås
Svezia
Sommario
Sommario
Panoramica di questo manuale................................................ .................................................... ....................
7 Documentazione del prodotto, M2004 .................... .................................................... ....................9
Sicurezza.................. .................................................... .................................................... .................... 11
1. Introduzione 13
1.1 Informazioni sulla creazione di applicazioni controller................................ .................. 13 1.2
Documentazione e aiuto .................. .................................................... .............. 15 1.3
Terminologia .................................... .................................................... ..............17
2 Ambiente di installazione e sviluppo 19

2.1 Panoramica dell'installazione .................................... .................................... 19 2.2 Come ottenere e
installare una chiave di licenza per RAB 5.09 o precedente .................................. 22 2.3 Come configurare
il PC per comunicare con il robot................................................ ....... 23 2.4 Ambiente di
sviluppo .................................... .................................... 25 2.5 Due modelli di sviluppo: virtuale e
vero ................................................. ........... 27 2.6 Conversione di progetti Visual Studio 2005 in Visual
Studio 2008 ........................... .....29
3 Ambiente di esecuzione 31
3.1 Panoramica................................................ .................................................... .... 31 3.2 Esecuzione
delle applicazioni FlexPendant .................................... .............................. 33 3.2.1 Componenti, assiemi
e dll .................. .................................................... .... 33 3.2.2 Distribuzione dell'applicazione
FlexPendant a un sistema robotico ................ 34 3.2.3 Comunicazione tra FlexPendant e
controller............................................. 37 3.2.4 Comprensione dell'applicazione FlexPendant ciclo
di vita .................................... 38 3.2.5 Attributo FlexPendant
TpsView .... .................................................... ............ 40 3.2.6 ITpsViewSetup e
ITpsViewActivation ............................. ............................ 44 3.3 Aggiornamenti delle release e
compatibilità ................ .................................... 46
4 Sviluppo di applicazioni del controller 47

4.1 Introduzione .................................................... .................................................... .... 47 4.2 Analisi e
progettazione .................................... .................................................... 48 4.3 Eventi e thread del
controller ................................................ .............................. 51 4.4 Sistema di autorizzazione degli
utenti .................. .................................................... .................... 54 4.5 Gestione delle
eccezioni ............................ .................................................... .............. 56 4.6 Come utilizzare la guida in
linea ............................ .................................................... .......59
5 Utilizzo dell'SDK FlexPendant 61

5.1 Introduzione................................................ .................................................... .... 61 5.1.1 Informazioni
su questo capitolo .................................. .................................... 61 5.1.2 Caratteristiche del
sistema supporto all'utilizzo di schermate personalizzate .................. 62 5.2 Impostazione di un
nuovo progetto .... .................................................... ........................ 64 5.2.1 Utilizzo del modello di
progetto in Visual Studio .................... .................................... 64 5.2.2 Impostazione del supporto
di progettazione per i controlli FlexPendant .. .................................... 67 5.3 Costruire l'interfaccia
utente.... .................................................... ............................ 68 5.3.1 Introduzione al supporto del visual
design .............. .................................... 68 5.3.2 Controlli GUI e memoria
gestione ................................................. ....... 77 5.3.3 Stile del
contenitore .................................. .................................... 81 5.3.4 Barra dei
comandi............................................ .................................... 85 5.3.5 Caratteri
FlexPendant .................................................... ............................ 87 5.3.6 L'uso delle
icone .............. .................................................... .................... 88 5.3.7
TabControl .................... .................................................... .................... 90 5.3.8 Pulsanti, TextBox
e ComboBox .............. .................................... 93 5.3. 9
AlphaPad.................................................. .................................... 94 5.3. 10 Visualizzazione
elenco................................................ .................................... 97 5.3 .11 CompactAlphaPad e
NumPad............................................ ....................99
3HAC036958-001 Revisione: B 5
Sommario
5.3.12 GTPUMessageBox ............................................ .................................... 101 5.3.13 Finestra di

dialogo FileGTPU.... .................................................... ............................ 103 5.3.14 Dati RAPID e segnali
IO .................. .................................... 107 5.4 Avvio di altre
visualizzazioni .................................. .................................... 113 5.4.1 Utilizzo del servizio di
lancio .. .................................................... ............................ 113 5.4.2 Utilizzo della finestra di dialogo
standard per modificare i dati .................. .................................... 116 5.5 Utilizzo dell'API del
controller .... .................................................... .................. 118 5.5.1
ABB.Robotics.Controller.... .................................................... .............. 118 5.5.2 Accesso al
controllore ............................ .................................... 121 5.5.3 Dominio
rapido................................................ .................................... 124 5.5.3.1 Lavorare con i dati
RAPID . .................................................... .............. 124 5.5.3.2 Gestione degli array
RAPID ................................ ............................ 131 5.5.3.3 Metodi ReadItem e
WriteItem .. .................................... 134 5.5.3.4 Dati definiti
dall'utente .. .................................................... ..................... 135 5.5.3.5 Ricerca RAPIDA
simboli .................... .................................... 139 5.5.3.6 Esecuzione
RAPIDA .................................................... .................... 144 5.5.3.7 Modifica di moduli e
programmi .................... .................. 146 5.5.4 Dominio del sistema
IO.................. .................................................... ...................... 149 5.5.5 Dominio registro
eventi................. .................................................... ............ 155 5.5.6 Dominio del
movimento.............................. .................................................... ....... 157 5.5.7 Dominio del file
system ................................... .................................... 160 5.5.8 Sistema dominio
informativo................................................ .................... 162
6 robuste applicazioni FlexPendant 165

6.1 Introduzione .................................................... .................................................... .... 165 6.2 Gestione della
memoria .................................... .............................. 167 6.3
Prestazioni . .................................................... .................................... 171 6.4
Affidabilità .............................................. .................................................... .......176
7 FlexPendant - Debug e risoluzione dei problemi 181
7.1 Debug.................................................... .................................................... .... 181 7.2 Uscite di

debug .................................... .................................................... ....... 185 7.3 Debug della FlexPendant
virtuale .................................. .................... 188 7.4 Debug del dispositivo
FlexPendant .............. .................................................... .... 192 7.5 Risoluzione dei problemi delle applicazioni
FlexPendant ................................... ........................195
8 Localizzazione di un'applicazione FlexPendant 197
8.1 Aggiunta del supporto per più lingue............................................ ....................197
9 Distribuzione di un'applicazione SDK FlexPendant 207

9.1 Panoramica................................................ .................................................... ....... 207 9.2 Distribuzione di
un'applicazione senza licenza .................................. .................. 209 9.3 Distribuzione di un'applicazione con
licenza .................. .............................. 212 9.4 Distribuzione utilizzando
FTP............................................... ...................................... 215
Indice 217
6 3HAC036958-001 Revisione: B
Panoramica di questo manuale

Di questo manuale
FlexPendant - Software Development Kit (FlexPendant SDK) è uno strumento software che consente
ai programmatori di sviluppare interfacce operatore FlexPendant personalizzate per il controller del robot
IRC5.
Lo scopo di questo manuale è aiutare gli sviluppatori di software a iniziare con lo sviluppo di
applicazioni SDK FlexPendant.
Utilizzo
Il manuale dell'applicazione FlexPendant SDK copre lo sviluppo dell'applicazione utilizzando FlexPendant
SDK. FlexPendant SDK è destinato allo sviluppo di applicazioni per l'utente finale basate su FlexPendant.
PC SDK è uno strumento per lo sviluppo di applicazioni per l'utente finale basate su PC (PC implica una
macchina Windows in questo contesto). Per ulteriori informazioni su PC SDK, consultare il manuale
dell'applicazione PC SDK. Il processo di sviluppo effettivo dell'applicazione prevede l'utilizzo di un PC
con Visual Studio sia per le applicazioni PC SDK che per quelle FlexPendant SDK.
Chi dovrebbe leggere questo manuale?
Questo manuale è destinato principalmente agli sviluppatori che utilizzano FlexPendant SDK per creare
applicazioni robot adatte alle esigenze dell'utente finale. È utile anche per chiunque abbia bisogno di
una panoramica delle applicazioni del controller.
Prerequisiti
Il lettore dovrebbe
• avere familiarità con IRC5, FlexPendant e RobotStudio. • essere utilizzato
per Microsoft Visual Studio e programmazione Windows. • avere familiarità con uno
dei linguaggi di programmazione .NET C# o Visual

Basic.NET sono i linguaggi preferiti. È possibile utilizzare anche Visual J# e Visual C++.
• essere utilizzato per la programmazione orientata agli oggetti.
Organizzazione dei capitoli

Il manuale è organizzato come segue:
Contenuto del capitolo
1 Introduzione. Terminologia. Sicurezza.
2 Installazione e configurazione. Sviluppo dell'ambiente . Tecnologia dei robot virtuali.
3 Architettura software: ambiente runtime per applicazioni FlexPendant. Ciclo di vita di un'applicazione
FlexPendant. Aggiornamenti e compatibilità.
4 Sviluppo di applicazioni SDK FlexPendant. Analisi e progettazione. Importanti questioni di

programmazione: eventi e thread del controller, UAS, gestione delle eccezioni.
Aiuto online.
5 Utilizzando l'SDK FlexPendant. Supporto alla progettazione visiva. Controlli della GUI. Avvio delle
visualizzazioni standard. . Come aggiungere funzionalità del controller utilizzando l'API Controller.
Problemi di programmazione ed esempi di codice in VB e C#.
Continua nella pagina successiva


Continua
Contenuto del capitolo
6 Come sviluppare applicazioni FlexPendant robuste e performanti. Memoria

gestione, prestazioni e affidabilità. La gestione delle eccezioni.
7 Test, debug e risoluzione dei problemi delle applicazioni SDK FlexPendant. Utilizzando
stampe, codici di errore nelle eccezioni e così via. Lista di controllo per contattare un servizio
organizzazione.
8 Come aggiungere il supporto per diverse lingue a un'applicazione FlexPendant personalizzata.
9 Come creare un'opzione aggiuntiva e come realizzare un prodotto da una FlexPendant

applicazione.
Riferimenti
Riferimento Documento d'identità
Manuale operativo - IRC5 con FlexPendant 3HAC16590-1
Manuale operativo - RobotStudio 3HAC032104-001
Manuale operativo - Per iniziare, IRC5 e RobotStudio 3HAC027097-001
Manuale tecnico di riferimento - Istruzioni RAPID, Funzioni e 3HAC16581-1

Tipi di dati
Manuale dell'applicazione: SDK per PC 3HAC036957-001
Revisioni
Revisione Descrizione
- Prima edizione
Da FlexPendant SDK 5.13 in poi questo manuale sostituisce:

Manuale dell'applicazione - Generatore di applicazioni robot (3HAC028083-001)
Per informazioni su PC SDK consultare il Manuale applicativo PC SDK (3HAC036957-
001)
UN Modifiche editoriali
B Aggiornato il valore della RAM nella tabella delle risorse di memoria FlexPendant . Vedere
Quanto può essere grande un'applicazione personalizzata? a pagina 166.

Documentazione del prodotto, M2004

Categorie per la documentazione del manipolatore
La documentazione del manipolatore è divisa in una serie di categorie. Questo elenco si basa sul tipo di
informazioni contenute nei documenti, indipendentemente dal fatto che i prodotti siano standard o
opzionali.
Tutti i documenti elencati possono essere ordinati presso ABB su DVD. I documenti elencati
sono validi per i sistemi manipolatori M2004.
Manuali dei prodotti
Manipolatori, controller, DressPack/SpotPack e la maggior parte degli altri componenti hardware

verranno consegnati con un manuale del prodotto che generalmente contiene:
• Informazioni sulla
sicurezza. • Installazione e messa in servizio (descrizioni dell'installazione meccanica o dei

collegamenti elettrici).
• Manutenzione (descrizione di tutte le procedure di manutenzione preventiva richieste

compresi gli intervalli e la durata prevista delle parti).
• Riparazione (descrizioni di tutte le procedure di riparazione consigliate, compresi i pezzi di ricambio

parti).
• Calibrazione.
• Smantellamento. •
Informazioni di riferimento (norme di sicurezza, conversioni di unità, giunzioni a vite, elenchi

di strumenti).
• Elenco parti di ricambio con viste esplose (o riferimenti a parti di ricambio separate
elenchi).
• Schemi elettrici (o riferimenti agli schemi elettrici).
Manuali tecnici di riferimento

I manuali di riferimento tecnico descrivono le informazioni di riferimento per i prodotti di robotica.
• Manuale tecnico di riferimento - Lubrificazione nei riduttori: Descrizione delle tipologie

e volumi di lubrificazione per i riduttori del manipolatore.
• Manuale tecnico di riferimento - Panoramica RAPID: una panoramica di RAPID
linguaggio di programmazione.
• Manuale tecnico di riferimento - Istruzioni, funzioni e tipi di dati RAPID: descrizione e sintassi per
tutte le istruzioni, funzioni e tipi di dati RAPID.
• Manuale tecnico di riferimento - Kernel RAPID: una descrizione formale del linguaggio di
programmazione RAPID. • Manuale
tecnico di riferimento - Parametri di sistema: Descrizione del sistema

parametri e flussi di lavoro di configurazione.
Manuali delle applicazioni

Applicazioni specifiche (ad esempio opzioni software o hardware) sono descritte nei Manuali delle
applicazioni. Un manuale applicativo può descrivere una o più applicazioni.

Continua
Un manuale applicativo generalmente contiene informazioni su:

• Lo scopo dell'applicazione (cosa fa e quando è utile). • Cosa è incluso
(ad esempio cavi, schede I/O, istruzioni RAPID, parametri di sistema, DVD con
software per PC). • Come installare
l'hardware incluso o richiesto. • Come utilizzare
l'applicazione. • Esempi di come
utilizzare l'applicazione.
Manuali operativi
I manuali operativi descrivono la manipolazione pratica dei prodotti. I manuali sono
rivolti a chi ha un contatto operativo diretto con il prodotto, ovvero operatori di celle di
produzione, programmatori e problem solving.
Il gruppo dei manuali comprende (tra gli altri):
• Manuale operativo - Informazioni di emergenza sulla
sicurezza • Manuale operativo - Informazioni generali
sulla sicurezza • Manuale operativo - Nozioni di base, IRC5 e
RobotStudio • Manuale operativo - Introduzione
a RAPID • Manuale operativo - IRC5 con
FlexPendant • Manuale operativo -
RobotStudio • Manuale operativo - Risoluzione dei problemi IRC5 , per il controller e il manipolatore.
Sicurezza
Sicurezza
Sicurezza del personale

Un robot è pesante ed estremamente potente indipendentemente dalla sua velocità. Una pausa o un
arresto prolungato del movimento possono essere seguiti da un movimento rapido e pericoloso. Anche
se si prevede uno schema di movimento, un cambiamento nel funzionamento può essere innescato da
un segnale esterno che determina un movimento inaspettato.
Pertanto, è importante seguire tutte le norme di sicurezza quando si entra nello spazio protetto.
Norme di sicurezza
Prima di iniziare a lavorare con il robot, assicurarsi di conoscere le norme di sicurezza descritte nel
manuale Manuale operativo - Informazioni generali sulla sicurezza.
Questa pagina è stata lasciata vuota intenzionalmente

1. Introduzione
1.1 Informazioni sulla creazione di applicazioni controller
1. Introduzione
Interfacce utente flessibili
I robot vengono generalmente forniti con un'interfaccia operatore generale. Tuttavia, processi diversi
richiedono una gestione diversa da parte dell'operatore e i clienti necessitano di soluzioni flessibili in cui
l'interfaccia utente sia adattata alle esigenze specifiche dell'utente.
FlexPendant SDK consente agli integratori di sistema, a terze parti o agli utenti finali di aggiungere le proprie
interfacce operatore personalizzate per il controller IRC5. Tali applicazioni personalizzate possono
essere aggiunte alle visualizzazioni standard della FlexPendant.
Per le applicazioni basate su PC, vedere Manuale dell'applicazione - PC SDK.
Nota
Le applicazioni del controller non sono indipendenti dalla piattaforma. È necessario scegliere di sviluppare
l'applicazione per FlexPendant o per la piattaforma PC (per ulteriori informazioni, vedere
Manuale dell'applicazione - PC SDK).
Client locale o remoto
La differenza tra le due piattaforme è che un'applicazione FlexPendant è un client locale, mentre
un'applicazione PC è un client remoto.
I client remoti non dispongono di tutti i privilegi di un client locale. Ad esempio, sia le applicazioni PC che
quelle FlexPendant possono reimpostare il puntatore del programma e avviare l'esecuzione RAPID, ma per
un'applicazione PC SDK che può eseguire questa operazione esistono alcune restrizioni. La padronanza
del dominio Rapid deve essere richiesta esplicitamente dal programmatore dell'applicazione e il controller
IRC5 deve essere in modalità operativa automatica.
Un vantaggio di un client remoto, invece, è la possibilità di monitorare e accedere a più controller di robot
da un'unica posizione. Per quanto riguarda le applicazioni di grandi dimensioni, anche la piattaforma PC è
meno limitata della FlexPendant per quanto riguarda le risorse di memoria e la potenza di processo.
Nota
Si prevede che un tempo di risposta minimo per un controller reale sia nell'ordine di 10-100 millisecondi,
il che significa che le difficili richieste di tempo reale non possono essere soddisfatte su nessuna
piattaforma. Per ulteriori informazioni, vedere Comunicazione tra FlexPendant e controller a pagina
37.
Facilità d'uso in fabbrica

Un'interfaccia utente ben progettata presenta informazioni e funzionalità rilevanti al momento giusto. A
questo proposito, le interfacce utente personalizzate sono chiaramente molto desiderabili per l'utente finale.
Poiché le soluzioni su misura sono più facili da utilizzare, ottimizzano anche l'investimento dell'utente
nell'automazione.
FlexPendant SDK consente interfacce utente personalizzate per IRC5. È importante tenere presente, tuttavia,
che lo stesso FlexPendant SDK non garantisce un aumento

1. Introduzione
Continua
valore per il consumatore. Per raggiungere questo obiettivo, le applicazioni SDK FlexPendant
dovrebbero essere sviluppate con cura e ponendo una forte enfasi sulla facilità d'uso.
Comprendere le esigenze degli utenti finali è infatti fondamentale per realizzare i vantaggi delle
interfacce personalizzate.
.NET e Visual Studio

FlexPendant SDK utilizza Microsoft .NET e Microsoft Visual Studio. Si presuppone quindi che tu
sappia programmare per piattaforme .NET utilizzando Visual Studio.

Tra i programmatori .NET si distingue per il modello di programmazione fornito da Microsoft .NET Framework.
Una caratteristica è l'indipendenza dal linguaggio di programmazione, lasciando allo sviluppatore la scelta
di utilizzare qualsiasi linguaggio fornito dall'ambiente di sviluppo integrato Visual Studio. La maggior parte
preferisce C# o Visual Basic, che offrono entrambi uno sviluppo sicuro ed efficiente.
Per un programmatore Windows che ha familiarità con Visual Studio e .NET, lo sviluppo di una vista
operatore personalizzata è piuttosto semplice. FlexPendant SDK è completamente integrato con Visual
Studio, il che significa che un programmatore .NET riconoscerà le procedure guidate per l'impostazione del
progetto e gli strumenti per il supporto della progettazione visiva, il debug e così via.
Sono stati compiuti sforzi considerevoli per consentire agli sviluppatori di applicazioni controller di iniziare a
lavorare senza dover superare una ripida curva di apprendimento. Per accelerare ulteriormente il processo
di sviluppo, è possibile utilizzare l'IRC5 virtuale di RobotStudio per testare ed eseguire il debug delle
applicazioni del controller.
Nota
La conoscenza della programmazione Windows, dell'orientamento agli oggetti e della programmazione .NET
sono i prerequisiti per utilizzare FlexPendant SDK.
Robustezza e prestazioni
Lo sviluppo di un'applicazione per FlexPendant, un dispositivo con risorse di memoria e processo limitate,
può essere piuttosto impegnativo. È necessario affrontare problemi come le prestazioni e la gestione
della memoria.
Si consiglia vivamente di leggere questo manuale per conoscere le problematiche specifiche dell'SDK
FlexPendant durante il passaggio allo sviluppo dell'SDK FlexPendant.
Nota
Prendetevi il tempo necessario per studiare questo manuale insieme alle note di rilascio ed evitare di
affrettarvi a scrivere codice.
1. Introduzione
1.2 Documentazione e aiuto
introduzione
FlexPendant SDK include un ampio modulo di guida in linea, fornito con l'installazione del
prodotto. Dopo aver installato RobotStudio, facendo clic sul menu Start di Windows ,
quindi selezionando Programmi > ABB Industrial IT > Robotics IT > RobotStudio 5.xx >
SDK troverai:
• Manuale dell'applicazione SDK FlexPendant
• Manuale di riferimento SDK FlexPendant
• Guida allo stile FlexPendant
Manuale applicativo
Questo manuale dell'applicazione - FlexPendant SDK, è il modo consigliato per iniziare se
si è nuovi allo sviluppo di FlexPendant SDK. Spiega come funziona l'SDK FlexPendant.
Contiene esempi di codice in C# e VB e fornisce esercizi pratici.
Il manuale dell'applicazione è fornito in due formati, Guida HTML e PDF. HTML è il formato
consigliato per lo schermo del PC e PDF è la scelta migliore se desideri delle stampe.
Nota
Il PDF del manuale dell'applicazione è reperibile nella directory di installazione, in

C:\Programmi\ABB Industrial IT\Robotics IT\SDK\FlexPendant SDK 5.xx.
Guida di riferimento
dell'SDK Durante la programmazione è necessario utilizzare il Manuale di riferimento
dell'SDK FlexPendant. Costituisce il riferimento completo alle librerie di classi SDK
FlexPendant. Le firme dei metodi vengono fornite in C# e Visual Basic.
Tieni presente che non sono integrati con la funzione della Guida di Visual Studio.
Facendo clic su F1 quando si punta al codice, ad esempio, si aprirà il riferimento per
programmatori di Visual Studio o la libreria di classi .NET Framework per il linguaggio e
l'argomento specifici. Molte volte questo è ciò che desideri, ma se il tuo problema è
correlato all'SDK FlexPendant, devi aprire la Guida di riferimento dell'SDK appropriata per
trovare una soluzione.
Nota
Si consiglia di mantenere aperti i file della guida durante la programmazione, poiché ne

saranno spesso necessari per problemi relativi a FlexPendant SDK.
Guida allo stile FlexPendant

Una buona usabilità si ottiene quando il programma stesso comunica le possibili azioni e
come eseguirle. Per incoraggiare un'attenta progettazione dell'aspetto visivo, anche la
FlexPendant StyleGuide fa parte dell'installazione. Si tratta delle migliori pratiche di ABB
Robotics per la progettazione visiva dell'interfaccia utente FlexPendant.

1. Introduzione
Continua
Comunità RobotStudio
ABB Robotics ha lanciato una comunità denominata RobotStudio Community, per i suoi utenti di
software per PC. Gli Strumenti per sviluppatori nella sezione Sviluppatori della community
RobotStudio contengono informazioni e alcuni video sulla programmazione con FlexPendant
SDK. In Content Sharing è disponibile per il download un'applicazione SDK FlexPendant
completa. È consigliato agli utenti medi e ai principianti.
ABB incoraggia conversazioni aperte e crede che tutti abbiano qualcosa da dare. Il
forum degli utenti della comunità RobotStudio dispone di una sezione dedicata allo
sviluppo di applicazioni robot. Qui sia i principianti che gli esperti discutono online di codici
e soluzioni. Se stai affrontando un problema di codifica, il forum degli utenti dovrebbe
essere la tua prima scelta, poiché ci sono buone probabilità che qualcuno ti dia l'aiuto di
cui hai bisogno per procedere.
RobotStudio Community fornisce inoltre i mezzi per condividere codice e video. Il tuo
contributo sarà apprezzato. Lavorare insieme è molte volte la chiave del successo.
Mancia
Provalo su www.abb.com/robotics > RobotStudio Community.
MSDN
MSDN (Microsoft Developer Network) all'indirizzo http://www.msdn.com è una delle
numerose fonti di informazioni per problemi generali di programmazione relativi a .NET e
Visual Studio.
1. Introduzione
1.3 Terminologia
1.3 Terminologia
Informazioni su termini e acronimi

Alcuni termini utilizzati in questo manuale sono specifici del prodotto e fondamentali per la comprensione.
Inoltre, al posto dei termini lunghi vengono talvolta utilizzati acronimi, parole formate da lettere iniziali.
Per evitare confusione, la terminologia importante è chiarita nella tabella seguente.
Definizioni
Termine Definizione
.NET Compact Framework Versione del framework .NET di Microsoft che fornisce l'ambiente runtime per le
(.NET CF) applicazioni eseguite su dispositivi incorporati, come FlexPendant. Include una
libreria di classi, che è quasi un sottoinsieme del ricco framework .NET per desktop.
Linguaggi di programmazione C# e Visual Basic.NET .NET.
Linguaggio comune Il motore di runtime principale in .NET Framework per l'esecuzione del codice
Durata gestito. Fornisce servizi come l'integrazione di più linguaggi, la sicurezza
dall'accesso di codice, la gestione della durata degli oggetti e il supporto per il
debug e la profilazione.
Applicazione del controller Le librerie di classi pubbliche dell'SDK FlexPendant, che offrono funzionalità del
Interfaccia di programmazione controller del robot. Noto anche come CAPI.
Dispositivo La FlexPendant è un "dispositivo intelligente" nel vocabolario .NET, ovvero un

computer completo in sé con il proprio processore, sistema operativo e così via.
FlexPendant Dispositivo portatile di ABB, utilizzato con il controller robot IRC5. È sviluppato
con la tecnologia Microsoft per sistemi embedded, Windows CE e .NET Compact
Framework.
Programmatore SDK Un programmatore che utilizza FlexPendant SDK per sviluppare applicazioni
FlexPendant personalizzate.
Applicazione FlexPendant SDK: un'applicazione personalizzata sviluppata con FlexPendant SDK. azione
IRC5 Il controllore robot di ABB.
Compilatore JIT Durante la compilazione del codice gestito, il compilatore traduce il codice
sorgente in Microsoft Intermediate Language (MSIL), che è un set di istruzioni
indipendente dalla CPU. Prima che il codice possa essere eseguito, MSIL deve
essere convertito in codice specifico della CPU, in genere da un compilatore just-in-
time (JIT).
codice gestito Codice eseguito e gestito dal Common Language Runtime di Microsoft .NET
Framework. Tutto il codice prodotto da Visual Studio viene eseguito come codice
gestito.
Microsoft Visual Studio L'ambiente di sviluppo integrato in cui lavorano gli sviluppatori quando
utilizzano .NET Framework.
Microsoft .NET Framework Un componente integrale di Windows che supporta la creazione e l'esecuzione
di applicazioni.
Presa di rete Un punto finale di comunicazione unico per una macchina che comunica su una
rete basata sul protocollo Internet.


1. Introduzione
1.3 Terminologia
Continua
Termine Definizione
Creazione di applicazioni robotiche Strumento software ABB, che ha consentito lo sviluppo di prodotti personalizzati
ehm interfacce operatore per IRC5. Spesso indicato come RAB. Il RAB
è suddiviso in FlexPendant SDK e PC SDK. Applicazione robotica
Builder (RAB) era uno strumento software che consentiva ai programmatori
per sviluppare FlexPendant o interfacce PC personalizzate per IRC5
controllore del robot.
Comunicazione robotica Il livello di comunicazione utilizzato dall'API Controller per comunicare

Durata sulla rete con un controller IRC5.
codice non gestito Codice che viene eseguito direttamente dal sistema operativo, all'esterno
il .NET Framework. Il codice non gestito deve fornire il proprio codice
gestione della memoria, controllo del tipo e supporto di sicurezza, a differenza di
codice gestito, che riceve questi servizi dal comune
tempo di esecuzione del linguaggio. Tutto il codice in esecuzione nel controller del robot, come
così come parte del codice in esecuzione nella FlexPendant non è gestito.
IRC5 virtuale La tecnologia dei robot virtuali consente di eseguire un IRC5 virtuale
controller, unità meccaniche virtuali e una FlexPendant virtuale attiva
la scrivania. Incluso come freeware in RobotStudio di ABB.
Windows CE Il sistema operativo incorporato in esecuzione sulla FlexPendant

dispositivo.
Acronimo Definizione
CAPI Interfaccia di programmazione dell'applicazione del controller
CLR Runtime del linguaggio comune
SDK FlexPendant Kit di sviluppo software FlexPendant
GUI Interfaccia grafica utente
MSDN Microsoft Developer Network, fonte di informazioni per .NET

sviluppatori all'indirizzo: http://www.msdn.com.
SDK Kit di sviluppo software
TAF Insegnare ciondolo Application Framework, tutte le applicazioni che utilizzano

l'SDK FlexPendant deve essere eseguito come client TAF. Per ulteriori
informazioni, vedere TAF - Framework host dell'applicazione a pagina 38.
TCP/IP Protocollo di controllo della trasmissione (TCP) e protocollo Internet (IP)
V.B Visual Basic
VS Studio visivo

2 Ambiente di installazione e sviluppo
2.1 Panoramica dell'installazione

Informazioni su questa sezione
Questa sezione descrive come installare FlexPendant SDK. Quando l'installazione è
completato, è possibile programmare, compilare e testare le applicazioni FlexPendant per il controller

IRC5.
Piattaforme supportate
Devono essere soddisfatti i seguenti requisiti software:
• Sistema operativo: Microsoft Windows XP + SP2, Windows Vista +SP2 o

Windows 7
• Microsoft Visual Studio: VS 2005 (Standard Edition o superiore) o VS 2008 (Professional Edition
o superiore). • .NET Compact Framework
2.0 Service Pack 1 o 2
Devono essere soddisfatti i seguenti requisiti hardware: • 50 MB di
spazio libero sul disco di installazione
Sono supportate entrambe le generazioni FlexPendant:
• SxTPU-1, che viene eseguito con .NET CF 2.0 e WinCE 4.2. • SxTPU-2, che
viene eseguito con .NET CF 2.0 e WinCE 5.0. • SxTPU3, che viene eseguito con
NET CF 3.5 e Windows CE 6.0.
Nota
Il sistema controller deve disporre dell'interfaccia FlexPendant opzionale RobotWare
Nota
FlexPendant SDK è sviluppato e testato per la versione inglese di Visual Studio.

Se esegui Visual Studio in un'altra lingua, ti consigliamo di passare alla versione inglese.
Requisiti per l'installazione e l'utilizzo dell'SDK FlexPendant

FlexPendant SDK viene installato durante l'installazione di RobotStudio. Per ulteriori informazioni
sull'installazione di RobotStudio, vedere Installazione e licenza di RobotStudio nel Manuale operativo -
RobotStudio. Per utilizzare FlexPendant SDK, è necessario soddisfare i seguenti requisiti. Assicurati inoltre
di disporre delle autorizzazioni di amministratore sul computer che stai utilizzando.
Prima... devi...
installazione di RobotStudio installare Microsoft Visual Studio 2005 o 2008.
debug utilizzando un virtual scopri come eseguire l'IRC5 virtuale in RobotStudio.

IRC5

Continua
Prima... devi...
debug utilizzando il real installare .NET Compact Framework 2.0 Service Pack 1 o 2, che può
Dispositivo FlexPendant essere scaricato da http://www.microsoft.com.
Il forum degli utenti della comunità RobotStudio contiene informazioni
su come collegare il debugger di Visual Studio al dispositivo.
Per ulteriori informazioni, vedere anche Debug del dispositivo
FlexPendant a pagina 192.
eseguendo l'applicazione verificare che il sistema robotico disponga dell'opzione controller Flex-
targeting per un'interfaccia pendente del sistema IRC5 reale (per applicazioni FlexPendant).
Configura una connessione tra il tuo PC e il controller del robot. Per
ulteriori informazioni, vedere Come configurare il PC per
comunicare con il robot a pagina 23 per i dettagli su come eseguire
questa operazione.
Nota
L'installazione di Visual Studio installa .NET e Compact Framework 2.0.
Informazioni sull'installazione dell'SDK FlexPendant
In precedenza FlexPendant SDK faceva parte di Robot Application Builder (RAB) che includeva anche PC
SDK. RAB 5.12 è stata l'ultima versione di Robot Application Builder.
A partire da RobotStudio 5.13, sia FlexPendant SDK che PC SDK sono inclusi nell'installazione di
RobotStudio. RobotStudio installa FlexPendant SDK 5.13, parallelamente alle versioni precedentemente
installate di FlexPendant SDK.
RAB dal 5.11 al 5.12
RAB 5.11 e versioni successive installano PC SDK e FlexPendant SDK insieme a qualsiasi versione
precedentemente installata.
RAB5.10
RAB 5.10 ha aggiornato qualsiasi SDK per PC precedentemente installato alla versione 5.10 e
ha installato FlexPendant SDK 5.08,5.09 e 5.10 affiancati. Il motivo dell'installazione affiancata di diverse
versioni dell'SDK FlexPendant era quello di semplificare il processo
Gli utenti dell'SDK FlexPendant possono lavorare su applicazioni SDK FlexPendant destinate a diverse
versioni di RobotWare. Le versioni precedenti di RAB possono essere scaricate da http://
www.abb.com/robotics > RobotStudioCommunity > Strumenti per sviluppatori > Panoramica SDK
FlexPendant.
Cosa è installato?
L'installazione genera le seguenti funzionalità sul tuo PC:

• Assemblee e risorse SDK
• Manuale dell'applicazione FlexPendant SDK • Guida
allo stile FlexPendant

• Manuale di riferimento SDK FlexPendant

Continua
Lavorare con diverse versioni

Un'applicazione SDK FlexPendant normalmente è destinata a una versione specifica di RobotWare.
Supponendo che si stia sviluppando un'applicazione SDK FlexPendant per un nuovo cliente che utilizza
RobotWare 5.12 e contemporaneamente si stia mantenendo un'applicazione SDK FlexPendant
esistente per un cliente con un sistema robotico che utilizza RobotWare 5.09, sarà necessario lavorare con
due diverse versioni SDK FlexPendant sul proprio computer. Per ulteriori informazioni sulle versioni e
sulla compatibilità, vedere Aggiornamenti delle versioni e compatibilità a pagina 46.
Applicazioni FlexPendant
Se si installa FlexPendant SDK 5.13 e versioni precedenti di FlexPendant SDK fornite con PC SDK
come Robot Application Builder, le versioni precedenti saranno presenti sul PC. Scegli quale versione
dell'SDK FlexPendant utilizzare quando configuri il progetto dell'applicazione in Visual Studio. Per ulteriori
informazioni, vedere Utilizzo del modello di progetto in Visual Studio a pagina 64.
È necessario assicurarsi che i controlli della GUI dell'SDK FlexPendant utilizzati da Visual Studio Designer
siano della stessa versione. Se in precedenza hai lavorato con un'altra versione dell'SDK FlexPendant,
dovrai rimuovere i controlli GUI aggiunti a Visual Studio Toolbox e quindi aggiungerli di nuovo, indicando la
versione corretta nel browser. Per ulteriori informazioni, vedere Impostazione del supporto di
progettazione per i controlli FlexPendant a pagina 67.
Procedura di installazione
La procedura di installazione è molto semplice. Per impostazione predefinita, FlexPendant SDK viene
installato quando si installa RobotStudio. Per ulteriori informazioni, vedere Installazione di RobotStudio, in
Manuale operativo - Per iniziare, IRC5 e RobotStudio. Una procedura guidata di installazione guiderà
l'utente attraverso l'installazione. Se si desidera installare RobotStudio senza installare FlexPendant
SDK o rimuovere FlexPendant SDK da RobotStudio, selezionare Personalizzato nell'installazione guidata
di RobotStudio e selezionare o deselezionare la funzione FlexPendant SDK.
Nota
Si consiglia inoltre vivamente di leggere le note sulla versione che si trovano sul DVD RobotWare e sul
sito Web della comunità RobotStudio, poiché contengono le informazioni più aggiornate, comprese le
nuove funzionalità e le eventuali limitazioni note della versione.
2.2 Come ottenere e installare una chiave di licenza per RAB 5.09 o versioni precedenti
2.2 Come ottenere e installare una chiave di licenza per RAB 5.09 o versioni precedenti
Panoramica
In RAB 5.10, il controllo della licenza è stato rimosso dal software, consentendo a chiunque di utilizzare
Robot Application Builder gratuitamente. Ciò significa che non dovrai più preoccuparti di ottenere una
licenza o includere un file licx nell'applicazione del tuo PC.
Nota
Per RAB versione 5.09 o precedente, la licenza è la seconda parte della procedura di installazione. Nel
caso in cui sia necessario sviluppare un'applicazione RAB per RobotWare 5.09 o versioni precedenti è
necessario rivolgersi al supporto per ottenere una chiave di licenza gratuita.
Installa la chiave di licenza
Segui questi passaggi quando hai ricevuto l'e-mail con il file della chiave di licenza:
Passo Azione
1 Stacca il file della chiave di licenza dall'e-mail e salvalo in una cartella sul tuo PC.
2 Fare doppio clic sul file della chiave di licenza. Verrà aperta la procedura guidata di installazione della licenza.
3 Seguire le istruzioni nella procedura.
Nota
Per eseguire le applicazioni SDK FlexPendant verso un controller robot reale è necessario connettere
il PC al controller robot, tramite la rete o direttamente alla porta di servizio sul controller. Per
informazioni dettagliate, vedere Come configurare il PC per comunicare con il robot a pagina 23.
2.3 Come configurare il PC per comunicare con il robot
Panoramica
Questa sezione descrive come collegare il PC al controller del robot.
È possibile connettere il PC al controller tramite una rete Ethernet o direttamente alla porta di servizio
del controller. Quando si utilizza la porta di servizio del controller, è possibile ottenere automaticamente
un indirizzo IP per il PC oppure specificare un indirizzo IP fisso.
Quando il PC e il controller sono collegati correttamente, il controller viene rilevato

automaticamente da RobotStudio.
Perché è necessaria una connessione?

Il collegamento del PC al controller è necessario per tutte le attività online eseguite in RobotStudio. Ad
esempio, il download di un sistema robotico o di file sul controller, la modifica di file di configurazione,
la programmazione e così via.
La connessione viene utilizzata anche per scaricare un'applicazione FlexPendant nel file system
del controller e testarla sul dispositivo FlexPendant reale.
Consente inoltre di comunicare con il controller tramite una finestra della console sul PC e ottenere
informazioni preziose sullo stato del controller, sul consumo di memoria della FlexPendant e così via.
Connessione di rete Ethernet
Se il controller è connesso a una rete Ethernet, è possibile connettere anche il PC a quella rete. Le
impostazioni da utilizzare sul PC dipendono dalla configurazione di rete. Per sapere come
configurare il tuo PC, contatta l'amministratore di rete.
Connessione alla porta di servizio con indirizzo IP automatico

Un'alternativa alla connessione di rete consiste nell'utilizzare la porta di servizio del controller. Ha un
server DHCP che assegna automaticamente al tuo PC un indirizzo IP se è configurato per questo. Per
ulteriori informazioni sulla configurazione del PC per ottenere automaticamente un indirizzo IP,
vedere la Guida di Windows su Configurare le impostazioni TCP/IP.
Nota
L'ottenimento automatico di un indirizzo IP potrebbe non riuscire se il PC dispone già di un

indirizzo IP da un altro controller o dispositivo Ethernet. Per assicurarti di ottenere un indirizzo IP
corretto se il PC è già stato connesso a un dispositivo Ethernet, procedi in uno dei seguenti modi:
• Riavviare il PC prima di collegarlo al controller. • Successivamente
eseguire il comando "ipconfig /renew" dal prompt dei comandi

collegando il PC al controller

Continua
Connessione seriale alla porta della Console

Per utilizzare la finestra della console del controller IRC5 è possibile connettere il proprio
PC con un cavo seriale null-modem alla porta console del controller.
Nota
Il cavo deve essere un cavo intrecciato con un connettore DB-9 femmina a ciascuna estremità.
Connessione alla porta di servizio con indirizzo IP fisso

Invece di ottenere automaticamente un indirizzo IP, è possibile specificare un indirizzo IP fisso
sul PC collegato al controller.
Utilizzare le seguenti impostazioni per la connessione con un indirizzo IP fisso:
Proprietà Valore
indirizzo IP 192.168.125.2
Maschera di sottorete 255.255.255.0
Gateway predefinito 192.168.125.1
Informazioni correlate
Per informazioni su Vedere
Come configurare le connessioni di rete del PC Guida di Windows: configura le impostazioni TCP/IP.
Come collegare il PC alla porta di servizio del Collegamento di un PC alla porta di servizio in
Controller Guida di RobotStudio.
2.4 Ambiente di sviluppo
Panoramica
Questa sezione presenta una panoramica dell'ambiente di sviluppo utilizzato per creare applicazioni
SDK FlexPendant. È possibile programmare ed eseguire il debug dell'applicazione utilizzando
Microsoft Visual Studio 2005 o 2008.
Microsoft .NET e Microsoft Visual Studio Microsoft

Visual Studio è supportato da .NET Framework. Un componente fondamentale di .NET Framework
è Common Language Runtime (CLR). Gestisce l'esecuzione del codice, i thread e la memoria,
applicando anche l'indipendenza dai tipi.
Un altro componente importante è la libreria di classi base, che è una raccolta completa e
orientata agli oggetti di tipi riutilizzabili. Per diventare un abile programmatore .NET è essenziale
apprendere le funzionalità offerte dalla Base Class Library.
Non rientra nello scopo di questo manuale insegnare come utilizzare Visual Studio. A questo
scopo msdn (Microsoft Developer Network) all'indirizzo http://msdn.microsoft.com è un'utile fonte
di informazioni.
Nota
Per informazioni sull'aggiornamento di un progetto SDK FlexPendant esistente al progetto Visual

Studio 2008, vedere Conversione di progetti Visual Studio 2005 in Visual Studio 2008 a
pagina 29.
Supporto della progettazione visiva e

associazione dati .NET Compact Framework 2.0. può essere utilizzato per creare interfacce
utente avanzate. I controlli specifici di FlexPendant sono disponibili nel toolbox di Visual Studio a
partire dalla versione FlexPendant SDK 5.08.
L'associazione dati è il processo di associazione di una proprietà di un controllo GUI a un'origine

dati, in modo che la proprietà rifletta automaticamente il valore dell'origine dati.
Scelta di un linguaggio di programmazione

Insieme a Visual Basic, C# è il linguaggio .NET più utilizzato.
C# è un linguaggio orientato agli oggetti derivato dal C, con alcune funzionalità di C++, Java e
Visual Basic. È stato progettato per .NET e offre la potenza e la ricchezza del C++ insieme alla
produttività di Visual Basic. Sia il PC che l'SDK FlexPendant sono implementati utilizzando C#.
Per le applicazioni FlexPendant SDK sono supportati solo C# e Visual Basic.

Allo stesso modo, in questo manuale sono presenti esempi di codice in C# e Visual Basic, ma
nessuno in J# o Visual C++.
In fase di esecuzione non importa quale lingua hai utilizzato, poiché il codice .NET compilato è
indipendente dalla lingua. Il codice sorgente viene compilato da un linguaggio di alto livello
in Intermediate Language (IL), che viene quindi eseguito, in fase di esecuzione, da Common
Language Runtime. Ciò rende possibile l'utilizzo diverso

Continua
linguaggi di programmazione, anche all'interno della stessa applicazione. Per ulteriori informazioni
sui termini .NET, vedere Definizioni a pagina 17.
Nota
Si presume che tu sia già un programmatore .NET. In caso contrario, è necessario iniziare
imparando il linguaggio di programmazione da utilizzare. Sono disponibili numerosi libri che
insegnano C# e Visual Basic.
Integrazione con Visual Studio

Quando FlexPendant SDK è installato sul computer, è integrato con Visual Studio. Noterai quando
inizi un nuovo progetto, ad esempio, che il tipo di progetto FlexPendant è disponibile nella
finestra Nuovo progetto . Quando si utilizza la procedura guidata per creare un progetto
FlexPendant, i riferimenti SDK comuni vengono aggiunti al progetto e parte del codice viene
generato automaticamente.
Il supporto di progettazione visiva per FlexPendant sarà accessibile dalla Casella degli strumenti
in Visual Studio e funzionerà allo stesso modo del supporto di progettazione per una normale
applicazione Windows. Come vedrai, l'utilizzo di FlexPendant SDK è abbastanza intuitivo per uno
sviluppatore abituato alla programmazione di Visual Studio.
Nota
Il modulo della Guida non è integrato con la funzione della Guida di Visual Studio. Facendo clic
su F1 quando si punta al codice, ad esempio, si aprirà il riferimento per programmatori di Visual
Studio o la libreria di classi .NET Framework per il linguaggio e l'argomento specifici. Se il tuo
problema è correlato all'SDK FlexPendant, questo non ti aiuterà.
Mancia
Il Manuale di riferimento FlexPendant SDK è reperibile facendo clic sul menu Start , quindi
selezionando Programmi > ABB Industrial IT > Robotics IT > RobotStudio 5.xx > SDK >
Manuale di riferimento FlexPendant SDK. Mantieni aperto il file di riferimento durante la
programmazione, poiché ne avrai sempre bisogno.
2.5 Due modelli di sviluppo: virtuale e reale
Quando provi un'applicazione personalizzata, puoi utilizzare un controller robot virtuale o un sistema robot
reale. Questa sezione fornisce informazioni su come utilizzare entrambi i modelli di sviluppo.
Tecnologia dei robot virtuali

L'IRC5 virtuale di RobotStudio di ABB consente l'esecuzione del software del controller IRC5 su un
PC e supporta gli sviluppatori di applicazioni con un ambiente puramente virtuale da utilizzare

per lo sviluppo, il test e il debug.
Quando si avvia l'IRC5 virtuale in RobotStudio, sullo schermo del PC viene visualizzato un armadietto
del robot virtuale insieme a una FlexPendant virtuale.
Dato che un vero e proprio controller robot normalmente non è a portata di mano per lo sviluppo di
applicazioni, la tecnologia virtuale è molto preziosa.
Requisiti per l'ambiente virtuale

Per sviluppare, testare ed eseguire il debug utilizzando l'ambiente virtuale è necessario installare i
seguenti componenti software:
• ABB RobotStudio (completo)

• Microsoft Visual Studio 2005 o 2008
• Opzione controller Interfaccia FlexPendant
Opzione controller L'interfaccia PC non è necessaria nell'ambiente virtuale.
Nota
Per ulteriori informazioni, vedere Installazione e licenza di RobotStudio in Operativo

Manuale-RobotStudio
Requisiti per l'ambiente reale

Per sviluppare, testare ed eseguire il debug utilizzando un controller robot reale è necessario installare i
seguenti componenti software:
• ABB RobotStudio (completo o personalizzato - con RobotStudio e FlexPendant

SDK selezionato)
• Microsoft Visual Studio 2005 o 2008
• Opzione controller Interfaccia PC e interfaccia FlexPendant

• Connessione di rete tra PC e controller del robot
Per informazioni su come configurare la rete, vedere Come configurare il PC per comunicare con il
robot a pagina 23.
Test virtuale e debug

Utilizzando l'ambiente virtuale, un'applicazione FlexPendant viene eseguita sulla Virtual FlexPendant come
un assembly (dll). Si avvia l'applicazione dal menu ABB della Virtual FlexPendant come se si avviasse
sulla FlexPendant reale.

Continua
Il debug è semplice utilizzando IRC5 virtuale e Visual Studio. Si collega il processo

dell'applicazione a Visual Studio, si imposta il punto di interruzione nel codice e lo si esegue durante
l'esecuzione. Per ulteriori informazioni, consultare Debug della FlexPendant virtuale a pagina 188.
Sono necessari test reali

L'ambiente virtuale è una scelta molto conveniente, soprattutto per test e debug. Dovresti essere
consapevole, tuttavia, che la FlexPendant virtuale è più indulgente del dispositivo reale. Utilizzando
solo la FlexPendant virtuale, è molto facile trascurare le limitazioni sul consumo di memoria imposte
dal dispositivo reale.
Le immagini, ad esempio, possono facilmente consumare tutta la memoria FlexPendant disponibile
per le applicazioni personalizzate.
Ciò significa che potenziali problemi potrebbero essere difficili da rilevare finché non si testa
l'applicazione utilizzando un vero sistema robotico. È quasi altrettanto semplice eseguire il debug del
codice in esecuzione sul dispositivo FlexPendant reale. Per ulteriori informazioni, vedere Debug
del dispositivo FlexPendant a pagina 192.
È inoltre necessario tenere presente che l'applicazione condivide CPU, memoria e host dell'applicazione
con tutte le altre applicazioni FlexPendant. Ciò significa che un'applicazione personalizzata può influire
sulle prestazioni complessive della FlexPendant.
Nota
Prima di spedire un'applicazione FlexPendant, è necessario testarla adeguatamente, utilizzando un

sistema reale. Affidarsi solo all’ambiente virtuale è troppo rischioso. Per ulteriori informazioni,
vedere Due modelli di sviluppo: virtuale e reale a pagina 27.
Porting dell'applicazione da IRC5 virtuale a reale

Un'applicazione FlexPendant che funziona perfettamente sulla Virtual FlexPendant, ma non sul
dispositivo reale poiché può verificarsi un ritardo nel tempo di risposta a causa della
comunicazione TCP/IP, ma il problema principale sono le risorse limitate sul dispositivo, sia memoria
che potenza del processore.
L'SDK FlexPendant non rallenta le prestazioni. Pertanto si suppone che l'applicazione funzioni come
qualsiasi applicazione standard della FlexPendant. Per ulteriori informazioni su come velocizzare
un'applicazione FlexPendant lenta, vedere Prestazioni a pagina 171.
Distribuzione al cliente
Durante lo sviluppo, la distribuzione sul controller viene eseguita manualmente. Quando la fase di
sviluppo è terminata e l'applicazione deve essere distribuita al cliente, è necessario farlo
diversamente.
Per informazioni su come eseguire questa operazione, vedere Distribuzione di un'applicazione SDK
FlexPendant a pagina 207.
2.6 Conversione di progetti Visual Studio 2005 in Visual Studio 2008
2.6 Conversione di progetti Visual Studio 2005 in Visual Studio 2008
Panoramica
Convertire un progetto FlexPendant SDK Visual Studio 2005 esistente in Visual Studio 2008 è
semplice. Quando si apre un progetto di Visual Studio 2005 in Visual Studio 2008, la conversione
guidata di Visual Studio viene visualizzata automaticamente. La procedura per convertire il progetto
in Visual Studio 2008 è semplice da seguire. Consiste in alcune finestre di dialogo che forniscono
informazioni su ciò che accadrà.
Nota
Per i progetti SDK FlexPendant è necessario modificare manualmente l'evento post-

compilazione che crea *gtpu.dll. Trova eventi di compilazione nelle proprietà del progetto e
adatta il percorso di vcvarsall.bat al nuovo ambiente di sviluppo.

3 Ambiente di esecuzione
3.1 Panoramica
3.1 Panoramica
A proposito di questo capitolo
Questo capitolo fornisce una panoramica dell'ambiente runtime delle applicazioni personalizzate,
comprese le illustrazioni dell'architettura software dell'SDK FlexPendant.
La configurazione dell'applicazione è dettagliata così come la distribuzione di un'applicazione FlexPendant

su un controller robot. Viene inoltre spiegato il ciclo di vita di un'applicazione FlexPendant.
Architettura del software
La FlexPendant è parte integrante di IRC5, ma è di per sé un computer completo. È stato sviluppato con la
tecnologia software Microsoft per sistemi embedded, Windows CE e .NET Compact Framework, che è un
sottoinsieme dell'intero .NET Framework utilizzato dal PC.
Piattaforma FlexPendant La
seguente illustrazione mostra l'architettura software di FlexPendant SDK.
Due applicazioni FlexPendant, una che utilizza VB e l'altra C#, sviluppate su FlexPendant SDK. FlexPendant
SDK CAPI è l'API pubblica che offre funzionalità del controller. Tutta la comunicazione con il controller del
robot avviene tramite il Robot Communication Runtime interno. FlexPendant SDK fornisce controlli dell'interfaccia
utente realizzati da ABB adatti per FlexPendant.
.NET Compact
Framework 2.0 App2 SDK FlexPendant C#
FlexPendant SDK app1 VB

enoizacilppA
#Q
ordau C
SDK FlexPendant, C#,

Controlli dell'interfaccia utente e CAPI
Librerie di classi di dispositivi, C#

Adattatori, C++
API interna basata su COM verso controller

Windows CE 5.0 robot, C++
Confine di rete
TCP/IP
Controllore
FlexPendant_

3.1 Panoramica
Continua
API del controller

L'SDK FlexPendant offre la funzionalità del controller tramite l'interfaccia dell'applicazione
pubblica denominata Controller API (CAPI). L'interfaccia può essere vista come una specifica
dei servizi del controller disponibili.
3.2.1 Componenti, assiemi e DLL
3.2 Esecuzione delle applicazioni FlexPendant
3.2.1 Componenti, assiemi e DLL
Costruzioni
.NET Framework è una libreria di componenti e classi e strutture di supporto, progettata per
rendere lo sviluppo dei componenti semplice e affidabile.
I componenti sono confezionati in assiemi, chiamati anche dll.
Gli assembly sono gli elementi costitutivi delle applicazioni .NET. Un assembly è una raccolta riutilizzabile
di tipi e risorse, creati per funzionare insieme e formare un'unità logica di funzionalità. L'assembly
più semplice è un singolo eseguibile.
Una o più assemblee
Un progetto FlexPendant viene compilato in una dll, che non può essere eseguita come
applicazione indipendente, ma deve essere avviata dal Teach Pendente Application Framework (TAF),
il gestore dell'applicazione della FlexPendant. Per ulteriori informazioni, vedere Comprensione del
ciclo di vita dell'applicazione FlexPendant a pagina 38.
In un caso normale, un'applicazione personalizzata per FlexPendant viene sviluppata come un singolo
componente, ma è anche possibile separare la funzionalità in più componenti.
In questo modo l'applicazione sarà composta da più DLL. Il motivo potrebbe essere uno dei seguenti:
• La quantità di codice è notevole. Un design modulare con elementi costitutivi piccoli e ben
testati messi insieme è un modo per gestire la complessità.
• Diversi sviluppatori stanno lavorando sulla stessa applicazione personalizzata. Per ragioni di
efficienza possono suddividere la funzionalità tra loro e lavorare ciascuno su un componente.
Nota
È possibile utilizzare linguaggi di programmazione diversi per componenti diversi.
3.2.2 Distribuzione dell'applicazione FlexPendant a un sistema robotico
Assemblea per delega

Quando si compila un'applicazione SDK FlexPendant, viene creato automaticamente un assembly aggiuntivo
denominato *gtpu.dll. Questa operazione viene eseguita da uno strumento, ABB Compliance Tool, che verifica
che l'applicazione sia conforme ai requisiti FlexPendant. Questa dll proxy è necessaria per eseguire l'applicazione
sulla FlexPendant.
Per testare l'applicazione su una FlexPendant reale, entrambi i gruppi devono essere scaricati nella directory
SYSTEM o HOME del controller del robot. Successivamente è necessario riavviare la FlexPendant. All'avvio
carica gli assembly dell'applicazione dal controller.
Mancia
Un vantaggio di distribuire le DLL nella directory HOME è che verranno incluse in un backup di sistema.
Scarica sul controller reale
Per scaricare gli assiemi dell'applicazione sul controller è possibile utilizzare la funzione online Trasferimento file
di RobotStudio.
Un altro modo per scaricare l'applicazione sul controller del robot è utilizzare ABB Compliance Tool.
Fare un passo
Azione
1 Verificare che siano soddisfatti i seguenti requisiti prima di avviare la procedura: • Deve
essere connessa una connessione di rete tra il PC e il controller
immaginato, utilizzando la porta LAN del controller o la porta di servizio del controller.
Per ulteriori informazioni vedere Come configurare il PC per comunicare con il robot
a pagina 23.
• Per eseguire l'applicazione su un sistema reale è necessaria l'interfaccia FlexPendant
opzionale RobotWare. Senza l'opzione non vedrai l'applicazione nel menu ABB.
2 Apri Esplora risorse.

3 Avviare abbct.exe in C:\Programmi\ABB Industrial IT\Robotics IT\SDK\FlexPendant SDK
5.xx..
4.3.2_1Compl
4 Fare clic su Sfoglia e individuare il progetto Visual Studio e l'assembly dell'applicazione nella
sottocartella \bin\debug (o \bin\release).

Continua
Fare un passo
Azione
5 Seleziona la casella Deploy , inserisci l' indirizzo IP del controller del robot e fai clic su Esegui.
La distribuzione viene eseguita nel sistema corrente del controller.
Nota!
Se l'applicazione è composta da più assiemi è necessario ripetere la procedura per tutti questi.
6 Riavviare la FlexPendant. Per ulteriori informazioni sui diversi modi per eseguire questa operazione,
vedere Riavviare la FlexPendant a pagina 35.
Utilizzo della finestra di comando

ABB Compliance Tool può essere utilizzato tramite la finestra di comando invece che tramite
l'interfaccia grafica. Per farlo scrivi:
abbct.exe /deploy="192.168.8.192" <PATH>\TpsViewHelloWorld.dll <PATH>\TpsViewHelloWorld.gtpu.dll.
È anche possibile eseguire la creazione e la distribuzione in un unico passaggio. Per fare ciò
l'argomento deploy dovrebbe essere l'ultimo:
abbct.exe <PATH>\TpsViewHelloWorld.dll /deploy="192.168.8.192"
Sia l'applicazione che l'assembly proxy vengono distribuiti al controller dopo la compilazione.
Distribuzione FTP
Puoi anche utilizzare un client FTP per trasferire file dal tuo PC al controller del robot.
Per utilizzare FTP è necessario:
• Programma client FTP •

Connessione configurata al controller • Opzione
RobotWare Client FTP e NFS • Nome e password
Fare un passo
Azione
1 Trasferire le risorse (ad esempio le icone) e gli insiemi di applicazioni e proxy nella directory HOME
o SYSTEM del sistema attuale del controller.
2 Riavviare la FlexPendant. Consulta la sezione successiva per informazioni su come eseguire questa operazione.
Nota
Per la distribuzione a un cliente quando l'applicazione è pronta, vedere Distribuzione

dell'applicazione FlexPendant a un sistema robotico a pagina 34.
Riavviare la FlexPendant
Se si desidera riavviare il dispositivo FlexPendant senza riavviare il controller, scegliere una di
queste alternative:
Azione alternativa
1 Scrivi il comando fpcmd "-restart" nella finestra della console del controller sul tuo PC.
2 Eseguire la seguente sequenza tenendo premuto il joystick della FlexPendant: Spostare il

joystick tre volte a destra, una volta a sinistra e una volta verso il basso.
Conferma la tua volontà di reimpostare la FlexPendant nella finestra di dialogo che apparirà.

Continua
Azione alternativa
3 Scollegare e ricollegare la FlexPendant (accensione/spegnimento).

Nota! Ciò attiva l'arresto di emergenza.
Distribuisci l'applicazione su IRC5 virtuale

Seguire questi passaggi per distribuire un'applicazione sulla Virtual FlexPendant:
Fare un passo
Azione
1 Copia gli assiemi e le immagini dell'applicazione e del proxy nella directory HOME del sistema
che desideri utilizzare sul tuo PC.
Nota! Chiudere prima la FlexPendant virtuale se si stanno sostituendo gli assiemi.
2 Riavviare la FlexPendant virtuale.
Mancia
Se riscontri problemi nell'esecuzione dell'applicazione, prova a inserire tutti i file (dll, file gif e
così via) nella directory vcbin del robotware utilizzato dal tuo sistema. Questa configurazione è
quanto di più simile possibile alla configurazione reale del sistema.
3.2.3 Comunicazione tra FlexPendant e controller
3.2.3 Comunicazione tra FlexPendant e controller
tecnologia COM
FlexPendant SDK utilizza un'API del controller interno basata sulla tecnologia COM per comunicare con
il controller. Questa API utilizza socket e TCP/IP (per ulteriori informazioni, vedere Informazioni su
termini e acronimi a pagina 17) verso controller sia reali che virtuali.
Le chiamate dall'SDK FlexPendant al controller sono sincrone, ovvero vengono eseguite

immediatamente tramite i server COM. Ciò aumenta la velocità di esecuzione e provoca un minor
sovraccarico, il che è importante su un dispositivo con risorse limitate.
Identificazione delle risorse
Tutte le risorse del controller, sia reali che virtuali, sono descritte utilizzando una gerarchia basata su
oggetti. Ogni risorsa è identificata in modo univoco, comprese le informazioni su quale controller
possiede la risorsa mediante l'utilizzo dell'ID di sistema univoco o dell'indirizzo IP del controller.
Il controller è l'oggetto più alto della gerarchia:

"/<Controller>/<Dominio>/<Sottodominio1>/<Sottodominio2>/e così via"
Mancia
I messaggi di errore che includono tale percorso indicano dove cercare il problema.
Richieste difficili in tempo reale

L'SDK FlexPendant non è in grado di soddisfare le impegnative richieste in tempo reale. Questo è per molti
motivi:
• Parte dell'API viene eseguita su un sistema operativo non in tempo reale. •
Talvolta il titolare del trattamento ha compiti da svolgere che hanno un diritto più elevato
priorità.
Nota
L'SDK FlexPendant non influisce negativamente sulle prestazioni. Dovresti aspettarti che la tua
applicazione personalizzata funzioni come qualsiasi altra applicazione su ABB
menù.
3.2.4 Comprensione del ciclo di vita dell'applicazione FlexPendant
Panoramica
Comprendere il ciclo di vita dell'applicazione FlexPendant migliora la capacità di progettare ed eseguire il debug
dell'applicazione.
TAF: framework host dell'applicazione

Il Teach Pendente Application Framework (TAF) è il fornitore di servizi applicativi eseguito su FlexPendant. È
destinato a .NET CF ed è implementato in C#. Tutte le applicazioni che utilizzano FlexPendant SDK devono
essere eseguite come client TAF, poiché TAF contiene servizi per l'hosting dei controlli e per la gestione delle
applicazioni.
TAF utilizza un file di configurazione personalizzato per creare l'aspetto e il comportamento dell'applicazione
ospitata. Definisce inoltre una serie di regole che devono essere seguite.
Avvio di un'applicazione personalizzata

All'avvio della FlexPendant, TAF è già nella memoria flash. Le applicazioni che verranno eseguite nel contenitore
TAF vengono ora caricate dal controller.
Se l'applicazione FlexPendant SDK deve essere avviata manualmente dall'utente finale, l'icona e il testo
dell'applicazione vengono inseriti nel menu ABB. L'altra alternativa è avviarlo automaticamente da TAF all'avvio
di FlexPendant. Per ulteriori informazioni su come viene configurato, vedere Attributo FlexPendant TpsView a
pagina 40.
Ciclo di vita dell'applicazione

TAF gestisce il ciclo di vita di un'applicazione personalizzata, iniziando chiamando il costruttore della sua classe
TpsView. Successivamente, vengono eseguiti il metodo Install e quindi il metodo Activate nella stessa
classe.
Durante la sua vita, l'applicazione passa dallo stato attivo a quello passivo. Ogni volta viene eseguito Attiva o
Disattiva. Nello stato attivo l'applicazione è visibile nella vista client, nello stato passivo potrebbe essere stata
aperta un'altra applicazione oppure potrebbe essere stata aperta un'altra applicazione tramite la barra delle
attività FlexPendant.
Quando l'applicazione viene chiusa tramite il pulsante di chiusura, viene eseguito prima il metodo Disattiva e poi
Disinstalla. Successivamente viene chiamato il metodo Dispose della classe TpsView. Quindi l'istanza
dell'applicazione viene eliminata da TAF. Per ulteriori informazioni su come implementare questi metodi, vedere
ITpsViewSetup e ITpsViewActivation a pagina 44.

Continua
Illustrazione
La figura illustra il ciclo di vita di un'applicazione FlexPendant.
4.3.3_1TAFAp
Risorse limitate
Poiché la FlexPendant è un dispositivo con risorse molto limitate rispetto a un PC, è necessario
apprendere e utilizzare i meccanismi implementati per assistersi nella scrittura di codice
efficiente.
Sia la potenza del processo che le risorse di memoria sono limitate rispetto all'ambiente
virtuale sul desktop. Un'applicazione che funziona molto bene sulla FlexPendant virtuale
può incontrare seri problemi nell'ambiente reale a causa di queste limitazioni. Per ulteriori
informazioni, vedere Panoramica tecnica del dispositivo FlexPendant a pagina 165.
Nota
Si consiglia vivamente di leggere Comprensione del ciclo di vita dell'applicazione

FlexPendant a pagina 38 in questo manuale prima di iniziare la codifica. Tenere sempre
presenti i limiti del dispositivo quando si sviluppano applicazioni FlexPendant personalizzate.
3.2.5 Attributo FlexPendant TpsView
Panoramica
Un'applicazione FlexPendant personalizzata deve implementare l'attributo assembly TpsView.

Ad esempio, viene utilizzato per determinare l'aspetto visivo dell'applicazione nel menu ABB. L'attributo
TpsView viene generato automaticamente e posizionato prima della definizione dello spazio dei nomi nella
classe di visualizzazione dell'applicazione, ovvero la classe che visualizza la prima visualizzazione di
un'applicazione SDK FlexPendant.
In questa sezione verranno dettagliati tutti i parametri dell'attributo TpsView.
Impostazioni della procedura guidata del progetto
L'attributo TpsView viene generato automaticamente in base alle impostazioni nel file
Procedura guidata del progetto SDK FlexPendant in Visual Studio:
6.2.2_1FormT
In C# le impostazioni della figura renderanno questo codice:

[assembly: TpsView("MyApplicationName", "tpu-Operator32.gif",
"tpu-Operator16.gif", "TpsViewHelloWorld.dll",
"TpsViewHelloWorld.TpsViewHelloWorld",
StartPanelLocation.Left, TpsViewType.Static, StartupType = TpsViewStartupTypes.Manual)]
Nota
Puoi modificare le tue impostazioni direttamente nel codice generato automaticamente.

Continua
Aspetto visivo
In fase di esecuzione il risultato più ovvio di questo codice è il modo in cui l'applicazione personalizzata
viene presentata nel menu ABB. Nell'esempio seguente, il primo parametro TpsView è stato modificato da
"MyApplicationName" a "Hello World".
4.3.4_1Ciao
Nome dell'applicazione
Il primo parametro di TpsView è il nome dell'applicazione così come dovrebbe apparire nel menu ABB e
sulla barra delle applicazioni. L'esempio utilizza "HelloWorld" come applicazione
nome.
Icona dell'applicazione
Il secondo parametro è il file da utilizzare come icona dell'applicazione nel menu ABB. Solitamente per
l'applicazione viene utilizzata un'icona personalizzata. Nell'esempio viene utilizzata l'icona predefinita: "tpu-
Operator32.gif".
Icona della barra delle applicazioni
Il terzo parametro è il file da utilizzare come icona sulla barra delle applicazioni dell'applicazione.
L'esempio utilizza l'icona predefinita "tpu-Operator16.gif".
Assembly dell'applicazione
Il quarto parametro è il nome dell'assembly. Se si modifica il nome dell'assembly dell'applicazione è
necessario modificare anche questo parametro per riflettere tale modifica.
Nell'esempio, il nome dell'assembly è "TpsViewHelloWorld.dll".
Nota
Il nome dell'assembly deve iniziare con "TpsView" affinché TAF lo identifichi come applicazione
da caricare. Se lo dimentichi, lo strumento di verifica ABB genererà un errore quando tenti di costruire il
progetto.

Continua
Nome della classe
Il quinto parametro specifica il nome completo della classe della vista iniziale dell'applicazione,
che hai scelto nella finestra di dialogo Nuovo progetto. Nell'esempio, il nome completo della classe
è "TpsViewHelloWorld.TpsViewHelloWorld".
Posizione
dell'applicazione Il sesto parametro determina la posizione dell'icona e del testo dell'applicazione nel menu ABB.
Nell'esempio questi vengono visualizzati nella colonna di sinistra:
startPanelLocation.Left.
Valore del parametro Risultato
StartPanelLocation.Left applicazione visibile a sinistra nel menu ABB.
StartPanelLocation.Right applicazione visibile a destra nel menu ABB.
StartPanelLocation.None l'applicazione non è affatto visibile nel menu ABB.
Nota
StartPanelLocation.None è stato introdotto nella versione 5.11.01. Le applicazioni che lo utilizzano

NON possono quindi essere eseguite su versioni di RobotWare precedenti alla 5.11.01.
Tipo di applicazione
Come puoi vedere dalle due icone Hello World visibili nella barra delle applicazioni, sono state avviate
due istanze dell'applicazione Hello World. Per abilitare ciò, il settimo parametro viene modificato
in: TpsViewType.Dynamic. I possibili valori del tipo di vista sono mostrati nella tabella:
Valore del parametro Risultato
TpsViewType.Dynamic È possibile avviare più istanze dell'applicazione.
TpsViewType.Static È possibile avviare solo un'istanza dell'applicazione.
TpsViewType.Invisible Un'applicazione in background senza GUI e senza icona sulla barra delle
applicazioni. Può essere avviato automaticamente o manualmente. È possibile un
solo esempio.
Nota
A meno che non vi sia una necessità particolare, è necessario consentire all'utente di avviare
solo un'istanza dell'applicazione: TpsViewType.Static. Il motivo è che lavorare con più istanze
richiede preziose risorse di memoria.
Tipo di avvio
L'ottavo parametro determina la modalità di avvio dell'applicazione. Nell'esempio il tipo di avvio è
TpsViewStartupTypes.Manual e l'applicazione viene avviata dal menu ABB. Utilizzando il tipo di avvio
manuale è anche possibile avviare l'applicazione tramite RAPID o, ad esempio, passare alla modalità
operativa automatica.
Per ulteriori informazioni, vedere Funzionalità del sistema che supportano l'uso di schermate
personalizzate a pagina 62


Continua
Se si sceglie TpsViewStartupTypes.Automatic, l'applicazione viene avviata automaticamente da TAF

ogni volta che la FlexPendant viene riavviata o che un nuovo utente accede
SU.
Per informazioni sull'impostazione Stile della procedura guidata del progetto, vedere Stile contenitore a
pagina 81.
Per trovare la procedura guidata del progetto SDK FlexPendant in Visual Studio, vedere Impostazione
di un nuovo progetto a pagina 64.
3.2.6 ITpsViewSetup e ITpsViewActivation
ITpsViewSetup
Un'applicazione che TAF deve inizializzare deve avere un costruttore predefinito (vuoto) e deve
implementare l'interfaccia ITpsViewSetup, che specifica i due metodi Install e Uninstall.
Installa e disinstalla
L'installazione viene chiamata quando l'applicazione viene creata in TAF. I parametri sono utilizzati
da TAF e non devono essere modificati. Si consiglia di aggiungere codice per ulteriori avviamenti
e allocazione delle risorse di sistema in questo metodo, ad esempio caricare assembly, aprire
canali di comunicazione e così via.
Quando chiudi l'applicazione viene chiamata la disinstallazione. Ciò accade subito prima che
l'applicazione venga eliminata. Si consiglia di aggiungere codice per l'eliminazione delle risorse di
sistema in questo metodo, ad esempio scaricare assembly, chiudere socket e così via
SU.
ITpsViewAttivazione
Tutte le applicazioni personalizzate devono implementare l'interfaccia ITpsViewActivation, che
specifica i due metodi Attiva e Disattiva. Questi vengono utilizzati da TAF per avvisare le applicazioni
quando ottengono il focus e quando lo perdono.
Attiva e Disattiva
L'attivazione viene eseguita ogni volta che l'applicazione viene attivata. Ciò avviene durante
l'inizializzazione, dopo l'esecuzione del metodo ITpsViewSetup.Install e quando si fa clic sull'icona
dell'applicazione nella barra delle applicazioni.
La disattivazione, di conseguenza, viene eseguita ogni volta che l'applicazione perde il focus.
Ciò accade quando si chiude l'applicazione, prima che sia stato eseguito il metodo
ITpsViewSetup.Uninstall e quando si fa clic sull'icona di un'altra applicazione nella barra delle applicazioni.
Nota
Si consiglia di attivare e disattivare i timer con questi metodi. In questo modo i timer non verranno
eseguiti quando sono attive altre applicazioni, risparmiando così la potenza del processore. Per
lo stesso motivo, qualsiasi sottoscrizione agli eventi del controller deve essere disabilitata in
Disattiva e abilitata nuovamente in Attiva. Tieni presente che i valori correnti devono essere
letti prima di abilitare l'abbonamento.

Continua
Semplici esempi di codice

Questa tabella mostra gli elementi base per i quali vengono utilizzati i metodi ITpsView in
un'applicazione personalizzata:
Metodo Utilizzo
Installare Creare l'oggetto Controller:

V.B.:
AController = Nuovo controller
C#:
aController = nuovo Controller();
Attiva Aggiungi abbonamento all'evento del controller:

V.B.:
AddHandler AController.OperatingModeChanged, AddressOf UpdateUI C#:
AController.OperatingModeChanged += nuovo
OperatingModeChangedEventHandler(UpdateUI);
Disattiva Rimuovi l'abbonamento all'evento del controller:

V.B.:
RemoveHandler AController.OperatingModeChanged, AddressOf UpdateUI C#:
AController.OperatingModeChanged -= nuovo
OperatingModeChangedEventHandler(UpdateUI);
Disinstalla Rimuovere l'oggetto controller:

V.B.:
Se non AController non è niente, allora

AController.Dispose()
AController = Niente
Finisci se
C#:
se (aController!= null)
{
aController.Dispose();
aController = null;
}

3.3 Aggiornamenti e compatibilità delle versioni
3.3 Aggiornamenti e compatibilità delle versioni
Questa sezione affronta i problemi di compatibilità con diverse versioni di Robotware.
Versione SDK FlexPendant e RobotWare corrispondenti

È necessario tenere presente che gli SDK FlexPendant sono sviluppati e testati per una versione
specifica di RobotWare. La regola generale è quindi che si sviluppi un'applicazione per una
determinata release.
La compatibilità tra le revisioni è comunque garantita (ad esempio FlexPendant SDK 5.11.01 sarà
compatibile con FlexPendant SDK 5.11).
Aggiornamenti RobotWare
In un determinato momento durante il ciclo di vita dell'applicazione, un sistema robotico a cui è
destinata l'applicazione potrebbe essere aggiornato con una versione successiva di RobotWare.
Per quanto riguarda un'applicazione FlexPendant SDK, ciò significa che il runtime cambierà, ovvero, i
gruppi SDK FlexPendant presenti in RobotWare saranno diversi da quelli utilizzati al momento dello
sviluppo dell'applicazione. In genere, l'unico modo per essere sicuri che l'applicazione esistente funzionerà
con una versione RobotWare più recente è compilare il codice sorgente con la versione SDK
FlexPendant che corrisponde alla versione RobotWare prevista.
Nota
Puoi trovare tutti i dettagli sulla compatibilità tra le diverse versioni dell'SDK FlexPendant nelle note di
rilascio.
Mancia
Durante la compilazione del progetto, notare eventuali avvisi relativi a metodi obsoleti, poiché questi
verranno probabilmente rimossi nella prossima versione dell'SDK FlexPendant.
Preparati al cambiamento
Per riassumere, è importante mantenere il codice sorgente sicuro e disponibile per la manutenzione.
Mancia
Ildasm è uno strumento Microsoft, fornito con l'installazione di Visual Studio, che potresti trovare utile.
Ti consente di aprire il manifest di un assembly specificato e di scoprire rapidamente, ad esempio, le
dipendenze.
Scopri di più su
http://msdn2.microsoft.com/en-us/library/aa309387(Visual Studio.71).aspx
4 Sviluppo di applicazioni del controller

4.1 Introduzione

4.1 Introduzione
A proposito di questo capitolo
Questo capitolo tratta l'analisi, la progettazione e l'implementazione delle applicazioni FlexPendant

SDK.
Vengono inoltre discussi alcuni problemi di programmazione specifici importanti per gli
utenti dell'SDK FlexPendant:
• conflitti di thread e come evitarli
• eventi del controller e gestione degli eventi •

gestione degli errori e delle eccezioni •
il sistema di autorizzazione dell'utente Il
capitolo non include informazioni pratiche su come impostare il primo progetto o informazioni
dettagliate su come utilizzare le librerie di classi SDK FlexPendant, poiché questi argomenti sono
trattati in capitoli dedicati.
Approccio di base
Nella maggior parte degli aspetti, l'utilizzo di FlexPendant SDK per lo sviluppo di applicazioni non
presenta differenze sostanziali rispetto al normale sviluppo .NET. Le librerie di classi .NET
vengono utilizzate per tutto ciò che non è specifico del robot. Inoltre, utilizzi l'API Controller pubblica
degli SDK.
Nota
Quando si utilizzano le librerie di classi .Net per lo sviluppo FlexPendant, vedere Informazioni
sulla versione per assicurarsi che la classe o il metodo sia supportato su .NET Compact
Framework 2.0, che viene eseguito su FlexPendant.
Utilizzare questa procedura per programmare l'applicazione FlexPendant SDK per la prima volta:
Passo Azione
1 Prima di iniziare
Apprendere le nozioni di base sulla programmazione dell'SDK FlexPendant leggendo tutte le sezioni
pertinenti di questo manuale. Sentiti rassicurato dal fatto che questa è un'attività che fa risparmiare tempo e
non affrettarti a scrivere codice.
Se si intende sviluppare un'applicazione per la FlexPendant, un dispositivo con risorse limitate rispetto a un
PC, è fondamentale studiare il capitolo Applicazioni robuste della FlexPendant a pagina 165 .
2 Durante lo sviluppo
Testare frequentemente la funzionalità dell'applicazione.
Non attendere troppo a lungo prima di testare un'applicazione FlexPendant su un vero dispositivo FlexPendant.
3 Dopo lo sviluppo Se si
sviluppa un'applicazione FlexPendant, impostare un test a lungo termine prima dell'uso in produzione. In
caso contrario, si corre il rischio che la FlexPendant esaurisca lentamente la memoria e si blocchi a causa
dell'applicazione.
Verifica il comportamento, le prestazioni e il consumo di memoria dell'applicazione. Utilizza i servizi offerti da
ABB. Per ulteriori informazioni, consultare FlexPendant - Debug e risoluzione dei problemi a
pagina 181.

4.2 Analisi e progettazione
Lo scopo di FlexPendant SDK è fornire interfacce operatore che soddisfino le esigenze specifiche dei clienti.
Questa sezione si concentra sulle fasi di sviluppo che precedono la codifica vera e propria: analisi e progettazione.
Sviluppo software orientato agli oggetti .NET è

interamente orientato agli oggetti. I servizi della piattaforma sono suddivisi in diversi spazi dei nomi come
System.Collections, System.Data, System.IO, System.Security e così via. Ogni spazio dei nomi contiene
un insieme di classi correlate che consentono l'accesso ai servizi della piattaforma. Anche FlexPendant SDK è
completamente orientato agli oggetti. Le sue librerie di classi sono organizzate in diversi spazi dei nomi come
ABB.Robotics.Controllers.RapidDomain,ABB.Robotics.Controllers.MotionDomain e così via.
Per iniziare a sviluppare applicazioni personalizzate è necessaria una certa esperienza nell'orientamento agli
oggetti. Si presume che tu ti senta a tuo agio con concetti come oggetti, classi, metodi, ereditarietà, incapsulamento
e così via.
Analisi e progettazione orientata agli oggetti

L'analisi e la progettazione orientata agli oggetti, OOAD, è un argomento popolare nella letteratura informatica,
dove è comunemente accettata l'importanza di eseguire un'analisi e una progettazione approfondite prima di
iniziare la codifica. Un'applicazione OO ben progettata ha una rappresentazione fedele nel mondo reale. Le classi
hanno aree di responsabilità ben definite e collaborano in modo efficiente per raggiungere ciò che è richiesto.
Analisi basata sulla comunicazione e sui casi d'uso

L'idea principale di FlexPendant SDK è, come è già stato sottolineato, che le interfacce operatore personalizzate
possono essere sviluppate vicino agli utenti finali, tenendo in considerazione le loro esigenze specifiche. Inutile
quindi dire che l’analisi è cruciale.
Il risultato dell'analisi orientata agli oggetti è una descrizione di ciò che vogliamo costruire, spesso espressa come
modello concettuale. Anche qualsiasi altra documentazione necessaria per descrivere ciò che vogliamo costruire,
ad esempio le immagini dell'interfaccia utente, fa parte dell'analisi.
L'aspetto più importante per lo sviluppo dell'SDK FlexPendant è la comunicazione con gli utenti finali. Sono
fortemente raccomandate attività che supportino una visione condivisa di ciò che dovrebbe essere sviluppato.
Tali attività possono includere:
• creare e discutere insieme casi d'uso • codificare o disegnare
prototipi e ottenere feedback dagli utenti finali

Continua
In breve, coinvolgere gli utenti finali fin dalle prime fasi e mantenerli coinvolti durante tutto il progetto di
sviluppo è la strategia migliore.
Nota
La soddisfazione del cliente è ciò che ha guidato lo sviluppo di FlexPendant SDK.

Assicurati di aver veramente capito di cosa hanno bisogno gli utenti finali della tua applicazione.
Il design riguarda la gestione della complessità

Il risultato della progettazione orientata agli oggetti descrive in dettaglio come il sistema può essere
costruito, utilizzando gli oggetti. L'astrazione viene utilizzata per suddividere problemi complessi in blocchi gestibili.
Permette di comprendere il problema nel suo insieme o di studiarne parti a livelli più bassi di astrazione.
Ci vogliono anni per diventare un abile designer orientato agli oggetti. La teoria del design deve essere
trasformata in esperienza pratica e ripetuta più e più volte.
L'obiettivo è produrre codice di alta qualità, che sia economicamente vantaggioso e di facile
manutenzione. Ciò si ottiene, ad esempio, quando l'aggiunta di nuove funzionalità comporterà modifiche
minime al codice esistente e la maggior parte delle modifiche verrà gestita come nuovi metodi e
nuove classi.
Hai bisogno di fare progettazione?

C'è un'enorme differenza in termini di complessità quando si crea software come .NET Framework, ad
esempio, e una visualizzazione operatore personalizzata per IRC5. Ovviamente, più un sistema è
complesso, più è necessaria una progettazione attenta. Di conseguenza, quanto più grande e complessa
deve essere un'applicazione personalizzata, tanto più è probabile che si dedichi tempo alla progettazione.
Questa tabella presenta alcune considerazioni prima di decidere quanto bene è necessario progettare
la tua applicazione prima di iniziare a scrivere codice:
Considerazione Consiglio
Quanto codice sarà? Se sarà un'applicazione molto semplice con una vista e pochi
pulsanti non sarà nemmeno necessario dividere il codice tra
classi e file diversi.
Se ci sarà una quantità sostanziale di codice e potrebbero
esserci ulteriori estensioni in seguito, dedicare tempo alla
progettazione diventa più rilevante.
Su cosa lavoreranno i diversi sviluppatori? Se sì, dedicare tempo alla progettazione diventa più
rilevante. classi/componenti diversi?
Manterrai tu stesso il codice o il
compito sarà affidato ad altri?
L'aspetto in tempo reale Se sì, la codifica efficiente è importante. Ciò sarà molto più
dell'applicazione è importante? facile da ottenere se dedichi un po’ di tempo alla progettazione.
Nota! Si consiglia inoltre di leggere il capitolo Applicazioni
robuste FlexPendant a pagina 165 prima di iniziare la codifica.

Continua
Complesso o facile come desideri

È possibile creare una semplice applicazione personalizzata in un giorno o due utilizzando
FlexPendant SDK. Tuttavia, un'applicazione personalizzata di grandi dimensioni con numerose
visualizzazioni diverse e che offre funzionalità avanzate del sistema robotico potrebbe richiedere
mesi per essere sviluppata e richiederà notevoli capacità di programmazione. Il consiglio è di iniziare
a sviluppare un'applicazione semplice, da eseguire sulla piattaforma di destinazione, prima di
spostarsi alla programmazione avanzata dell'SDK FlexPendant.

4.3 Eventi e thread del controller
Panoramica
Un evento del controller è un messaggio inviato dal controller che informa che è successo qualcosa.
Gli eventi possono essere rilevati e gestiti dalle applicazioni FlexPendant SDK.
Gli eventi del controller utilizzano i propri thread. Ciò significa che i thread dell'interfaccia utente e i thread degli
eventi del controller possono entrare in conflitto. Questa sezione fornisce informazioni su come evitare ciò.
Eventi del controllore
Le applicazioni SDK FlexPendant possono sottoscrivere una serie di eventi del controller.
Questi sono tutti descritti nel Manuale di riferimento FlexPendant SDK.
La tabella mostra alcuni eventi esistenti nell'SDK FlexPendant.
L'evento... avviene quando...
Stato modificato lo stato del controller è cambiato.
Modalità operativa modificata la modalità operativa del controller è cambiata.
ExecutionStatusChanged lo stato di esecuzione del controller è cambiato.
Cambiato il valore o lo stato del segnale I/O è cambiato.
Messaggio scritto il EventLog ha un nuovo messaggio
Valore modificato il valore di un dato RAPID è cambiato.
Nota
Non vi è alcuna garanzia che riceverai un evento iniziale quando imposti/attivi un evento del controller. È
necessario leggere lo stato iniziale dal controller.
Thread di eventi della GUI e del controller in conflitto

È necessario tenere presente che gli eventi del controller utilizzano i propri thread sia sulla piattaforma
FlexPendant che su PC. Se un thread della GUI e un thread degli eventi del controller entrano in conflitto,
potrebbero verificarsi blocchi critici o dati sovrascritti. Ciò può verificarsi quando a un evento del controller segue
un aggiornamento dell'interfaccia utente, che è in effetti uno scenario molto comune.
È quindi necessario intervenire nel codice per controllare che l'aggiornamento dell'interfaccia utente venga
eseguito dal thread della GUI e non dal thread degli eventi del controller. Questa operazione viene eseguita
imponendo un cambio di thread utilizzando il metodo Invoke o BeginInvoke. Per ulteriori informazioni su
come eseguire questa operazione insieme ad esempi di codice, vedere Metodo Invoke a pagina 52.

Continua
D'altra parte, se l'evento del controller NON dovesse causare alcun aggiornamento dell'interfaccia utente, non
si dovrebbe intraprendere alcuna azione particolare. L'uso di Invoke/BeginInvoke richiede prestazioni elevate
e non deve essere utilizzato più del necessario.
Nota
I conflitti di thread spesso causano impiccagioni. Il touch screen della FlexPendant smette quindi di
rispondere e l'applicazione deve essere riavviata.
Esamina quale eccezione è stata generata quando ti trovi in una situazione del genere.
Le eccezioni System.NotSupportedException (piattaforma FlexPendant) e System.InvalidOperationException
(piattaforma PC) indicano conflitti di thread.
Consulta la sezione successiva per informazioni su come utilizzare Invoke per risolvere il problema.
Metodo di chiamata
Tutte le viste FlexPendant devono ereditare Control/TpsControl, che implementano Invoke e BeginInvoke.
Questi metodi eseguono il gestore delegato/evento specificato sul thread che possiede l'handle della finestra
sottostante del controllo, imponendo così il passaggio da un thread di lavoro al thread della GUI. Questo
è esattamente ciò che serve quando un evento del controller deve essere comunicato all'utente finale del
sistema.
Invoke deve essere chiamato all'interno del gestore eventi occupandosi dell'evento del controller. Nota
che devi creare un nuovo array di oggetti per gli oggetti mittente e argomento:
V.B.:
Me.Invoke(Nuovo EventHandler(AddressOf UpdateUI), Nuovo Oggetto()

{mittente, e})
C#:
this.Invoke(new EventHandler(UpdateUI), new Object[] {sender, e});
Si noti inoltre che se si utilizza EventHandler nel metodo Invoke e non la classe delegata specifica, ad
esempio DataValueChangedEventHandler, è necessario eseguire il typecast dell'argomento nel delegato che
aggiorna l'interfaccia utente. Il modo in cui ciò avviene è mostrato nel seguente esempio:
V.B.:
Private Sub UpdateUI(mittente ByVal As Object, ByVal e As System.EventArgs)
Dim Args come ExecutionStatusChangedEventArgs

Args = DirectCast(e, ExecutionStatusChangedEventArgs)
Me.Label1.Text = e.NewStatus.ToString()
Fine sott
C#:
private void UpdateUI(mittente oggetto, System.EventArgs e)

{
ExecutionStatusChangedEventArgs args; args =
(ExecutionStatusChangedEventArgs) e; this.label1.Text =
e.NewStatus.ToString();
}


Continua
Nota
La differenza tra Invoke e BeginInvoke è che il primo effettua una chiamata sincrona e
si bloccherà fino al completamento dell'operazione GUI, mentre BeginInvoke esegue
il gestore eventi specificato in modo asincrono. Il metodo che desideri utilizzare
dipende dalla logica del tuo programma. Il consiglio è di scegliere
BeginInvoke quando possibile.
Nota
Se il codice tenta di accedere a un controllo GUI da un thread in background,

Common Language Runtime .NET genererà un'eccezione
System.NotSupportedException (piattaforma FlexPendant) o un'eccezione
System.InvalidOperationException (piattaforma PC).
Mancia
Se si utilizza FlexPendant SDK sono disponibili ulteriori informazioni sui thread in

Affidabilità a pagina 176 e Affidabilità a pagina 176.
4.4 Sistema di autorizzazione degli utenti
Panoramica
Nel controller del robot è presente un sistema che controlla l'accesso degli utenti: lo User Authorization
System (UAS). Se viene utilizzata questa funzione, ogni utente necessita di un nome utente e di una password per
accedere al controller del robot tramite FlexPendant o RobotStudio.
Se per qualsiasi motivo la connessione al controller viene persa, è necessario effettuare nuovamente l'accesso.
Il titolare del trattamento conserva informazioni su quali operazioni i diversi utenti possono eseguire. La configurazione
dell'UAS viene eseguita in RobotStudio.
Mancia
Per ulteriori informazioni sull'UAS, utilizzare la funzione di guida in RobotStudio.
Accesso a UAS da applicazioni personalizzate Prima che
vengano eseguite operazioni sensibili del controller, un'applicazione SDK FlexPendant dovrebbe verificare che l'utente
sia attualmente connesso e disponga dei diritti UAS corrispondenti.
L'accesso a UAS viene effettuato utilizzando la proprietà AuthorizationSystem sull'oggetto controller:
V.B.:
Dim UAS come UserAuthorizationSystem =

Me.AController.AuthorizationSystem
C#:
UserAuthorizationSystem uas = this.aController.AuthorizationSystem;
Sovvenzioni e gruppi
I diritti UAS sono chiamati Grants. L'utente specifico appartiene a uno dei numerosi gruppi definiti, in cui ciascun gruppo
dispone di un numero di concessioni specificate.
Per garantire di disporre delle autorizzazioni necessarie per eseguire un'operazione, utilizzare il metodo
CheckDemandGrant sull'oggetto AuthorizationSystem. La concessione da verificare viene passata come argomento:
V.B.:
Se uas.CheckDemandGrant(Grant.ModifyRapidProgram) Allora
aTask.LoadModuleFromFile(localFile, RapidLoadMode.Replace)
Finisci se
C#:
if (uas.CheckDemandGrant(Grant.ModifyRapidProgram)) {
aTask.LoadModuleFromFile(localFile, RapidLoadMode.Replace);
}
Nota
L'applicazione FlexPendant SDK non può sovrascrivere la configurazione UAS. Ciò significa che il sistema alla fine
ti impedirà di eseguire un'azione non consentita.

Continua
Feedback sul MessageBox

Se manca una borsa di studio UAS dovresti ottenere informazioni a riguardo. Questo può essere fatto in un
messaggio come mostrato nel seguente esempio: msg = "Non
sei autorizzato a eseguire questa operazione, parla con il tuo
amministratore di sistema se è necessario accedere."
titolo = "Sistema di autorizzazione utente"
V.B.:
GTPUMessageBox.Show(Io, Niente, messaggio, titolo,
System.Windows.Forms.MessageBoxIcon.Asterisk,
System.Windows.Forms.MessageBoxButtons.OK)
C#:
GTPUMessageBox.Show(questo, null, msg, titolo,
System.Windows.Forms.MessageBoxIcon.Asterisk,
System.Windows.Forms.MessageBoxButtons.OK);
GetCurrentGrants e DemandGrant
Un'altra possibilità è recuperare tutte le sovvenzioni per l'utente corrente chiamando

GetCurrentGrants, quindi scorrere la raccolta delle sovvenzioni e cercare le sovvenzioni necessarie.
Ancora un'altra soluzione è chiamare DemandGrant con uno dei membri statici di Grant
come in argomento.
Se non si dispone della concessione specificata, l'SDK FlexPendant genera un'eccezione

UasRejectException e l'SDK del PC genera un'eccezione
GrantDemandRejectedException.
Mancia
Per ulteriori informazioni sui membri UAS e Grant, consultare il Manuale di riferimento
SDK FlexPendant.

4.5 Gestione delle eccezioni
Panoramica
I linguaggi di programmazione .NET forniscono supporto integrato per la gestione delle eccezioni, che consente al
programma di rilevare e ripristinare gli errori durante l'esecuzione.
Nel codice gestito, l'esecuzione non può continuare nello stesso thread dopo un'eccezione non gestita. Il thread
termina e, se si tratta del thread del programma, termina il programma stesso. Per evitare ciò, è necessario utilizzare
una gestione accurata delle eccezioni.
L'SDK FlexPendant fornisce diverse classi di eccezioni, che vengono utilizzate quando si verificano errori. Se
l'operazione viene rifiutata dal meccanismo di limitazione dell'accesso di sicurezza del controller, ad esempio, viene
generata un'eccezione RejectException.
Se si verifica un'eccezione non gestita, l'applicazione si blocca e TAF visualizza un messaggio grigio sulla FlexPendant.
Dopo la conferma la FlexPendant si riavvierà. Per evitare ciò dovresti assicurarti che qualsiasi potenziale situazione
di errore sia gestita correttamente dal tuo codice.
Il messaggio visualizzato quando si verifica una situazione di errore non gestito potrebbe essere simile al seguente.
NON contattare ABB, ma correggere la gestione degli errori della propria applicazione.
5.5_1Unhandl
Nota
Per ulteriori informazioni su come funzionano le classi di eccezione di FlexPendant SDK, consultare il Manuale
di riferimento FlexPendant SDK. Vedere anche Affidabilità a pagina 176 per ottenere informazioni più dettagliate
sulla gestione delle eccezioni per la piattaforma FlexPendant.
Prova-cattura-finalmente
Le eccezioni vengono gestite in blocchi try - catch (-finally ), che vengono eseguiti al di fuori del normale flusso di
controllo.
Continua
Il blocco try racchiude una o più istruzioni da eseguire. Se si verifica un'eccezione all'interno di
questo blocco, l'esecuzione passa al blocco catch, che gestisce l'eccezione.
Il blocco last viene eseguito quando si esce dal blocco Try, indipendentemente dal fatto che si
sia verificata un'eccezione e sia stata gestita. Viene utilizzato per pulire il sistema o il controller
risorse.
Se non si sa quali eccezioni aspettarsi o come gestirle, è possibile rilevarle e non è necessario
eseguire alcuna operazione. Ciò, tuttavia, potrebbe rendere difficile l'individuazione degli errori,
poiché le eccezioni includono informazioni sulla causa del problema.
Pertanto, provare almeno a visualizzare il messaggio di eccezione, utilizzando una finestra di
messaggio o i tipi Debug o Trace. Per ulteriori informazioni, vedere Output di debug a pagina 185
e Traccia e debug a pagina 187.
Typecasting
Quando si digitano valori Signal o RapidData, ad esempio, esiste il rischio potenziale di eccezioni di
typecast. Per evitare ciò è possibile controllare l'oggetto utilizzando l'operatore is sia per i tipi di
valore che per quelli di riferimento:
V.B.:
Se TypeOf aRapidData.Value è Num allora

Dim aNum As Num = DirectCast(aRapidData.Value, Num)
.....
C#:
se (aRapidData.Value è Num) {
Num aNum = (Num) aRapidData.Value;

....
}
In C# è anche possibile utilizzare l'operatore as per i tipi di riferimento. Viene restituito un valore null
se il tipo non è quello previsto:
C#:
DigitalSignal di = this.aController.IOSystem.GetSignal("UserSig")
come segnale digitale;
se (di == nullo)
{
MessageBox.Show(this, null, “Tipo sbagliato”);
}
Procedure consigliate per .NET
.La Guida per gli sviluppatori di .NET Framework presenta le seguenti procedure consigliate per la
gestione delle eccezioni:
• Sapere quando impostare un blocco try/catch. Ad esempio, potrebbe essere un'idea migliore
verificare a livello di codice una condizione che è probabile che si verifichi senza utilizzare la
gestione delle eccezioni. Per gli errori che si verificano di routine, questo è consigliato, poiché
le eccezioni richiedono più tempo per essere gestite.
• Utilizzare la gestione delle eccezioni per individuare errori imprevisti. Se l'evento è vero
eccezionale ed è un errore (come una fine file imprevista), la gestione delle eccezioni è la
scelta migliore poiché viene eseguito meno codice nel normale


Continua
case. Ordina sempre le eccezioni in blocchi catch dal più specifico al meno specifico.
Questa tecnica gestisce l'eccezione specifica prima che venga passata a un blocco
catch più generale.
4.6 Come utilizzare la guida in linea
4.6 Come utilizzare la guida in linea
Panoramica
La guida in linea viene fornita con l'installazione di FlexPendant SDK ed è accessibile dal menu
Start di Windows .
Si consiglia di leggere attentamente il manuale dell'applicazione durante lo sviluppo delle

applicazioni SDK FlexPendant. Manuale di riferimento FlexPendant SDK è un importante
complemento a questo manuale, poiché costituisce il riferimento completo alle librerie di classi di
FlexPendant SDK. Per ulteriori informazioni, vedere Documentazione e guida a pagina 15.
Nota
Il riferimento SDK NON è integrato in Visual Studio. È necessario aprirlo dal menu Start .
Mancia
Per ulteriori informazioni sull'indirizzo Web della RobotStudio Community, dove gli sviluppatori
dell'SDK FlexPendant discutono online problemi e soluzioni software, vedere Documentazione
e guida a pagina 15.

5 Utilizzo dell'SDK FlexPendant
5.1.1 Informazioni su questo capitolo

5.1 Introduzione
5.1.1 Informazioni su questo capitolo
Panoramica
Questo capitolo fornisce informazioni dettagliate su come utilizzare FlexPendant SDK.
Vengono trattati questi argomenti:
• Come sfruttare alcune funzionalità del sistema che supportano l'uso di schermate personalizzate.
• Come utilizzare la procedura guidata integrata di Visual Studio per configurare una FlexPendant
progetto.
• Come aggiungere i controlli GUI dell'SDK FlexPendant a Visual Studio Toolbox.
• Come costruire l'interfaccia utente utilizzando il supporto di progettazione integrato. •
Come programmare i controlli GUI dell'SDK FlexPendant. • Come
avviare altre applicazioni dalla tua applicazione. • Come implementare la
funzionalità del controller utilizzando CAPI.
Il supporto alla progettazione in Visual Studio consente di disporre visivamente l'applicazione, riducendo
la necessità di scrivere codice. Ciò accelera lo sviluppo e offre un controllo più preciso dell'aspetto
degli schermi FlexPendant.
Utilizzando FlexPendant SDK è possibile avviare diverse applicazioni FlexPendant standard

dalla propria applicazione, che spesso rappresenta un'alternativa molto pratica alla gestione
autonoma di procedure complesse, come ad esempio la lettura e la scrittura di dati RAPID.
L'API Controller (CAPI) è il nucleo dell'SDK FlexPendant. Viene utilizzato per accedere al controller
del robot a cui è collegata la FlexPendant. Innanzitutto ci sono informazioni su come è organizzata
questa API pubblica. Successivamente ciascun dominio del CAPI viene trattato separatamente. In tutto il
capitolo sono presenti esempi di codice in C# e VB.
5.1.2 Funzionalità del sistema che supportano l'uso di schermate personalizzate
Interfacce utente flessibili
La FlexPendant può essere adattata alle esigenze specifiche degli utenti finali in molti modi diversi. Può essere
utilizzato in 14 lingue diverse, comprese le lingue asiatiche basate sui caratteri come il giapponese e il cinese. Gli
operatori mancini possono adattare il dispositivo dalle impostazioni predefinite semplicemente ruotando il display di 180
gradi.
Quattro degli otto tasti sono programmabili, ovvero la loro funzione può essere assegnata dall'utente finale.
Gli schermi FlexPendant personalizzati, adattati alle esigenze degli utenti finali, rappresentano un altro modo per fornire
le soluzioni flessibili richieste da molti clienti. Per supportare l'uso di schermate personalizzate ci sono un paio di
funzionalità di cui potresti voler parlare agli utenti finali della tua applicazione.
Configurare la FlexPendant Utilizzando
le funzionalità di configurazione della FlexPendant (Pannello di controllo - FlexPendant) è possibile configurare la
FlexPendant per consentire l'esecuzione RAPID in modalità manuale da una vista SDK FlexPendant. È inoltre possibile
fare in modo che la FlexPendant visualizzi automaticamente una vista SDK quando si cambia la modalità operativa.
Visualizzazione test aggiuntiva
Impostare la proprietà di configurazione FlexPendant Visualizzazione test aggiuntiva se si desidera avviare
l'esecuzione RAPID in modalità manuale con un'applicazione personalizzata come vista attiva.
6.1.0_1AddTe


Continua
Visualizza su modifica modalità operativa

Impostare la proprietà di configurazione FlexPendant Visualizza su modifica modalità operativa se si
desidera che l'applicazione personalizzata diventi attiva quando la modalità operativa del controller
viene impostata su automatica, manuale o manuale a velocità massima.
6.1.0_2VistaO
Utilizzare l'istruzione RAPID per avviare l'applicazione FlexPendant SDK

L'istruzione RAPID UIShow (User Interface Show) viene utilizzata per comunicare con l'utente del
sistema robotico tramite un'applicazione FlexPendant. Sia le applicazioni FlexPendant SDK che le
applicazioni standard possono essere avviate utilizzando queste istruzioni.
Esempio: il
seguente codice RAPID avvia l'applicazione personalizzata TpsViewMyApp.

CONST stringa Nome:="TpsViewMyApp.gtpu.dll";CONST stringa Tipo
:="ABB.Robotics.SDK.Views.TpsViewMyApp";UIMostra nome, tipo;
Affinché ciò funzioni, il sistema robotico deve disporre dell'opzione RobotWare FlexPendant Interface.
Gli assembly TpsViewMyApp.dll e TpsViewMyApp.gtpu.dll devono trovarsi nella directory HOME del
sistema robotico attivo. (Una volta scaricati gli assiemi sul controller, è necessario riavviare la
FlexPendant per caricarli.)
Nota
Per ulteriori informazioni sulle istruzioni UIShow, consultare il Manuale tecnico di riferimento -
Istruzioni RAPID, funzioni e tipi di dati
5.2.1 Utilizzo del modello di progetto in Visual Studio
5.2 Impostazione di un nuovo progetto
Panoramica
È molto semplice impostare un nuovo progetto FlexPendant utilizzando il modello di progetto integrato.
Aggiungerà automaticamente i riferimenti SDK più comuni al progetto e genererà automaticamente del codice
sorgente per la finestra principale dell'applicazione, nel linguaggio di programmazione selezionato, C# o
Visual Basic.
Nota
Per aggiungere un'altra vista al progetto FlexPendant, non è necessario avviare un nuovo progetto. Per ulteriori
informazioni, vedere Stile contenitore a pagina 81.
Procedura di installazione
Seguire questi passaggi per creare un progetto FlexPendant:
Passo Azione
1 Nel menu File in Visual Studio scegliere Nuovo e quindi fare clic su Progetto.
2 In Visual Studio 2005, nella finestra di dialogo Nuovo progetto selezionare Visual C#/Smart
Device/FlexPendant o Altri linguaggi/Visual Basic/Smart Device/FlexPendant. In Visual
Studio 2008, selezionare Visual C#/FlexPendant o Altri linguaggi/Visual Basic/FlexPendant).
Nuovo progetto
Nota
Se sul PC sono presenti diverse installazioni dell'SDK FlexPendant, saranno disponibili diversi
modelli tra cui scegliere. Assicurati di selezionare il modello che corrisponde alla versione di
Ro-botWare a cui dovrebbe essere destinata la tua applicazione.


Continua
Passo Azione
3 Inserisci il nome dell'applicazione nel campo Nome e dove desideri che venga archiviata nel campo
Posizione . Fare clic su OK.
Nota
Il nome deve iniziare con "TpsView" . Se lo dimentichi, lo strumento di verifica ABB genererà un
errore una volta realizzato il progetto.
4 La procedura guidata del progetto FlexPendant SDK è ora avviata. Per informazioni su come
configurare l'applicazione utilizzando questa procedura guidata, vedere Attributo FlexPendant
TpsView a pagina 40 e Stile contenitore a pagina 81. Quando si è pronti, fare clic su OK.
5 È necessario impostare il supporto di progettazione per i controlli GUI FlexPendant prima di iniziare la
programmazione. La modalità di esecuzione è descritta in dettaglio in Impostazione del supporto di
Nota
Se i riferimenti all'SDK sembrano mancare nel tuo progetto FlexPendant, consulta la sezione
seguente per istruzioni su come risolvere il problema.
Aggiungere eventuali riferimenti

mancanti I riferimenti SDK necessari al progetto FlexPendant vengono aggiunti automaticamente
al completamento della procedura guidata del progetto. Tuttavia, esiste la possibilità che
Visual Studio non possa fornire il percorso di queste DLL. In questo caso dovresti aggiungere
manualmente il percorso dei riferimenti. Segui questi passi:
Passo Azione
1 Guarda Solution Explorer di Visual Studio. Se hai un progetto C#, espandi il nodo Riferimenti . I
triangoli di avviso indicano che manca il percorso delle DLL di riferimento.
6.1.1_2Impostazione
Per un progetto VB, Solution Explorer ha lo stesso aspetto, tranne per il fatto che non è presente
alcun nodo Riferimenti .


Continua
Passo Azione
2 C#: selezionare l'icona del progetto, fare clic con il pulsante destro del mouse e selezionare Proprietà. Fare clic sulla
scheda Percorsi di riferimento e aggiungere il percorso agli assembly SDK.
VB: selezionare l'icona del progetto, fare clic con il tasto destro e selezionare Proprietà. Fare
clic sulla scheda Riferimenti . Se manca il percorso dei riferimenti all'SDK, aggiungilo accedendo
alla directory in cui si trovano.
Nota
Il percorso predefinito è C:\Programmi\ABB Industrial IT\Robotics IT\SDK\FlexPendant SDK

5.xx\bin.
3 Salva il progetto. Noterai che eventuali triangoli di avviso nel nodo Riferimenti di Solution
Explorer scompariranno.
5.2.2 Impostazione del supporto di progettazione per i controlli FlexPendant
5.2.2 Impostazione del supporto di progettazione per i controlli FlexPendant
Panoramica
Questa sezione descrive come rendere accessibili i controlli della GUI FlexPendant in Visual Studio.
Procedura
Seguire questi passaggi per aggiungere i controlli FlexPendant a Visual Studio Toolbox:
Passo Azione
1 Nel menu Visualizza selezionare Casella degli strumenti.
2 Fare clic con il tasto destro nell'area Casella degli strumenti e selezionare Aggiungi scheda.
3 Assegnare un nome alla nuova scheda della casella degli strumenti, ad esempio Controlli FlexPendant.
4 Fare clic con il tasto destro nell'area della nuova scheda e selezionare Scegli elementi.
5 Nella finestra di dialogo Scegli elementi della casella degli strumenti , accedere alla directory in cui si
trovano gli assembly SDK FlexPendant e importare i seguenti assembly: •
ABB.Robotics.Tps.Windows.Forms.dll •
ABB.Robotics.GTPU.Windows.Forms.dll
• ABB.Robotics.DataBinding.dll Il percorso
predefinito è C:\Programmi\ABB Industrial IT\Robotics IT\SDK\Flex-Pendant SDK 5.xx\bin.
6 In Esplora soluzioni, fai clic con il pulsante destro del mouse su view.cs (view.vb se hai un progetto VB) e
seleziona Progettazione vista se non sei già in modalità progettazione.
Come puoi vedere, i controlli specifici della FlexPendant sono ora accessibili nella Casella degli strumenti.
Per ulteriori informazioni su come utilizzarli, vedere Introduzione al supporto della progettazione visiva a pagina
68.
Nota
Il modo in cui si utilizza Visual Studio Designer per implementare i controlli FlexPendant è molto simile
all'implementazione dei normali controlli .NET. In questo manuale vengono fornite informazioni utili
che potrebbero non essere ovvie per tutti gli utenti. Ma spesso è la Guida generale di Visual Studio a
rispondere a qualsiasi domanda tu possa avere sulle proprietà dei controlli e simili.

5.3.1 Introduzione al supporto del visual design
5.3 Costruire l'interfaccia utente
Cos'è il supporto alla progettazione visiva?
Il supporto di progettazione per i controlli utente di Compact Framework era una nuova funzionalità di Visual Studio
2005. Consenteva di includere il supporto di progettazione per i controlli FlexPendant SDK in FlexPendant SDK 5.08.
Da FlexPendant SDK 5.08 in poi si progetta visivamente l'interfaccia utente dell'applicazione FlexPendant in
Visual Studio Designer. I controlli FlexPendant vengono trascinati dalla casella degli strumenti all'area del designer,
spostati e ridimensionati facendo clic e trascinando. Applicando diverse impostazioni nella finestra Proprietà di un
controllo, puoi perfezionarne l'aspetto e il comportamento.
Per utilizzare il supporto della progettazione visiva è necessario aggiungere i controlli FlexPendant alla casella degli
strumenti di Visual Studio. Come eseguire questa operazione è descritto in dettaglio in Impostazione del supporto di
Nota
Il supporto alla progettazione per i controlli FlexPendant è da tempo nella lista dei desideri degli utenti di
FlexPendant SDK. Si tratta infatti di una funzionalità che fa risparmiare tempo, poiché la maggior parte del codice
che supporta l'interfaccia utente grafica viene ora generato automaticamente.
Perché controlli speciali per la FlexPendant?
Ci si potrebbe chiedere perché i controlli standard di Microsoft Windows non sono stati considerati sufficientemente
buoni da essere utilizzati per il touch screen FlexPendant.
La risposta è che alcuni controlli di Windows potrebbero benissimo essere utilizzati. Altri controlli Windows tuttavia non
sono altrettanto adatti per il touch screen FlexPendant. Per navigare utilizzando i controlli con le dita, in particolare,
è necessario che siano sufficientemente grandi. In altri casi i controlli di Windows semplicemente non appaiono molto
bene sul touch screen.
Nota
Nel Manuale di riferimento FlexPendant SDK, fare clic sulla scheda Contenuto e sul nodo
ABB.Robotics.Tps.Windows.Forms per ottenere una panoramica e una breve descrizione di tutti i controlli
ABB utilizzabili per creare l'interfaccia utente di un'applicazione FlexPendant.
Mancia
La modalità di programmazione di questi controlli ABB è molto simile a quella degli equivalenti controlli Windows.
Se hai bisogno di esempi di codice, la migliore fonte di informazioni è solitamente MSDN. Puoi provare http://
msdn.microsoft.com/library/
default.asp?url=/library/en-us/cpref/html/frlrfsystemwindowsformslistviewclasstopic.asp, ad esempio, per scoprire
come programmare un ListView.


Continua
Illustrazione
Lo screenshot seguente mostra Visual Studio Toolbox con tutti i controlli FlexPendant a
sinistra. Nell'area Designer a destra è in fase di sviluppo un'applicazione FlexPendant. È possibile
visualizzare parte del controllo del contenitore, insieme a una serie di controlli ABB e Windows
standard.
6.3.1_1MyFir
Vale la pena notare le seguenti funzionalità: • Un

controllo PictureBox di Windows viene utilizzato come contenitore di una foto. • Il
pulsante FlexPendant dispone di una proprietà denominata BackgroundImage, utilizzata per
visualizzare un'immagine. La libreria di immagini ABB situata nella cartella Risorse, fornita
con l'installazione di FlexPendant SDK, dispone di numerose icone che possono essere
utilizzate da applicazioni personalizzate. Naturalmente puoi anche utilizzare foto e icone
personalizzate.
• Alcuni controlli ABB, come SignalBindingSource , non hanno
rappresentazione grafica in fase di progettazione. Come vedi nella figura, sono posizionati
nel riquadro dei componenti sotto il modulo principale. Il codice viene generato in modo
simile ai controlli visualizzati nel modulo.
• Di solito per un'applicazione FlexPendant SDK viene utilizzata una combinazione di controlli
Windows e ABB. Ad esempio, poiché non sono presenti ABB RadioButton o CheckBox,
vengono utilizzati i controlli equivalenti di Windows. Nella figura viene utilizzato il CheckBox
standard di Windows.
ATTENZIONE
Non dimenticare la quantità limitata di memoria disponibile per le applicazioni

personalizzate quando aggiungi immagini o foto! Per ulteriori informazioni, vedere
Introduzione a pagina 165.


Continua
ATTENZIONE
Il codice generato automaticamente per i controlli si trova nel metodo

InitializeComponent. Non dovresti manomettere il codice all'interno di questo metodo.
Eventuali modifiche o aggiunte al codice generato automaticamente si trovano solitamente nel costruttore,
dopo la chiamata a InitializeComponent.
Hands on - Ciao mondo
Sei pronto per programmare e testare la tua prima applicazione FlexPendant? Se non è stato creato un progetto
FlexPendant e non sono stati aggiunti i controlli FlexPendant a Visual Studio Toolbox, è necessario farlo prima.
Per ulteriori informazioni, vedere Utilizzo del modello di progetto in Visual Studio a pagina 64 e Impostazione
del supporto di progettazione per i controlli FlexPendant a pagina 67.
Seguire questi passaggi per creare e testare una semplice applicazione personalizzata:
Passo Azione
1 Trascinare un pulsante FlexPendant dalla Casella degli strumenti al Designer.
2 Fare doppio clic sul pulsante nel Designer per aprire l'editor del codice.


Continua
Passo Azione
3 Come vedi è stato creato un gestore eventi per l'evento click. Aggiungi il codice per avviare il messaggio
Hello World al suo interno:
private void button1_Click(mittente oggetto, EventArgs e)
{
Tentativo
{
miaLabel1.Text = " Ciao mondo! ";
}
catch(System.Exception ex)
{
// Qui la cattura è obbligatoria!!
// Se non è presente alcun problema per risolvere l'errore causato
dalla tua candidatura,
// non solo la tua applicazione, ma l'intera FlexPend-
formica, si bloccherà, poiché tutte le applicazioni FP condividono lo stesso
thread della GUI.
// Sta a te decidere come gestire l'errore. Normalmente, potresti voler visualizzare un

messaggio di errore, qualcosa del genere:
GTPUMessageBox.Show(this.Parent
, nullo
"
, "Si è verificato un errore imprevisto\nMessaggio di errore: +ex.Message
, "Errore dell'applicazione"
, System.Windows.Forms.MessageBoxIcon.Question
, System.Windows.Forms.MessageBoxButtons.OK);
}
Finalmente
{
// il codice di pulizia va qui (se necessario) // "finalmente"
viene utilizzato per garantire la pulizia
le risorse, il rilascio di mastersip ecc. non vengono saltati a causa
dell'eccezione.
// (In questo caso, la clausola final non è necessaria, poiché non c'è nulla da
pulire.)
}
Un modo alternativo per aggiungere un gestore eventi viene mostrato nel passaggio successivo.
Nota
Un'applicazione FlexPendant da utilizzare nel settore deve avere la gestione delle eccezioni in tutti i
gestori eventi, come mostrato nell'esempio di codice precedente. La FlexPendant ha un solo thread della
GUI, condiviso da tutte le applicazioni in esecuzione sulla FlexPendant. Se l'applicazione interrompe
l'unico thread della GUI, tutte le applicazioni moriranno e la FlexPendant dovrà essere riavviata
manualmente. Per ulteriori informazioni, vedere Gestione delle eccezioni a pagina 56.



Continua
Passo Azione
4 Visualizza la finestra Proprietà del pulsante facendo clic con il pulsante destro del mouse nel
Designer e selezionando Proprietà. Fare clic sul pulsante eventi (lampeggio giallo lampeggiante) per
visualizzare gli eventi disponibili per il pulsante ABB. Come mostrato dalla figura, hai già collegato un
gestore eventi all'evento click.
6.3.1_1B_Aggiungi
Nota
È l'evento predefinito del controllo che ottieni quando fai doppio clic su di esso nel Designer. Per
aggiungere un gestore eventi per un altro evento pulsante, apri la finestra Proprietà e fai doppio clic
sull'evento per cui desideri generare un gestore, ad esempio un gestore eventi FontChanged. Entrerai
nell'editor del codice, il cursore all'interno del gestore eventi generato.
5 Nel menu Compila , fai clic su Compila soluzione e verifica di non aver ricevuto errori di compilazione.
6 Per testare l'applicazione è necessario distribuirla su un sistema robotico. Se non è disponibile alcun
sistema robotico, è necessario creare un sistema robotico utilizzando System Builder di RobotStudio.
7 Copiare l'assembly (*.dll) e l'assembly proxy (*.gtpu.dll) dalla directory bin\Debug (o bin\Release)
del progetto Visual Studio alla directory HOME creata da RobotStudio al momento della creazione del
sistema robotico.
Esempio che mostra i percorsi predefiniti per copia/incolla:
C:\Data\Visual Studio 2005\Projects\TpsViewMyApp\TpsViewMyApp\bin\Debug\ C:
\Systems\sys1_508\HOME Nota!
Se hai già avviato la FlexPendant virtuale devi chiuderla prima di incollare le dll.
8 Avviare la FlexPendant virtuale.
9 Nel menu ABB, trova la tua applicazione e aprila.


Continua
Passo Azione
10 Fare clic sul pulsante. Verrà visualizzato il messaggio Hello World.
6.3.1_2Ciao
Nota
Per ulteriori informazioni su come implementare le funzionalità aggiuntive: titolo dell'applicazione,

immagine di sfondo del pulsante, barra dei comandi con una voce di menu e un gestore eventi per
avviare una visualizzazione standard, vedere Introduzione al supporto della progettazione visiva a pagina 68.
Mancia
Quando si utilizza Virtual FlexPendant per test e debug è possibile automatizzare la procedura di copia/
incolla descritta nel passaggio sette precedente. La seguente procedura lo spiega: 1 Fare clic con il
pulsante destro del mouse
sull'icona del progetto in Esplora soluzioni e selezionare Proprietà.
2 Per un progetto C#, selezionare la scheda Eventi di compilazione . (Per un progetto VB fare clic su
Scheda Compila e quindi il pulsante Crea eventi .)
3 Fare clic sul pulsante Modifica post-costruzione e aggiungere due comandi che copieranno le DLL
prodotte nella directory del sistema robotico da eseguire. Esempio:
copia "$(TargetDir)$(TargetName).dll" "C:\Systems\sys1"
copia "$(TargetDir)$(TargetName).gtpu.dll" "C:\Systems\sys1"
Nota! Non rimuovere le righe di comando post-compilazione predefinite, che creano il proxy di
assembly (*gtpu.dll).


Continua
Pratico: passaggio 2
Questa sezione descrive in dettaglio come programmare le restanti funzionalità
dell'applicazione Hello World mostrate nel passaggio 9 precedente: titolo dell'applicazione,
immagine di sfondo del pulsante, barra dei comandi con una voce di menu. Imparerai anche
come implementare un gestore eventi per il comando Launch View .
Quando si crea un progetto FlexPendant, si sceglie Vuoto o Modulo nella procedura

guidata del progetto FlexPendant SDK. Per ulteriori informazioni per comprendere la
differenza tra loro, vedere Vuoto o Modulo? a pagina 81. Nel nostro esempio Form è
selezionato come controllo contenitore.
Passo Azione
1 Se hai selezionato Vuoto per il tuo progetto, puoi cambiarlo in Modulo scambiandolo
TpsControl con TpsForm direttamente nel codice sorgente, in questo modo:
C#:
classe pubblica TpsViewIRC5App14: TpsForm, ITpsViewSetup,
ITpsViewAttivazione
V.B.:
La classe pubblica TpsViewIRC5App14 eredita TpsForm '(prima era TpsControl) implementa

ITpsViewSetup, ITpsViewActivation
Nota
La finestra di progettazione ora mostra la barra del titolo sopra il controllo contenitore.
2 Fai clic con il pulsante destro del mouse in un punto qualsiasi al centro del controllo contenitore e seleziona Proprietà.
3 Inserisci "Questa è la mia applicazione Hello World" nella proprietà Text . Vedi il suggerimento di
Vuoto o Modulo? a pagina 81 se la proprietà Testo non è disponibile.
4 Sempre utilizzando la finestra TpsFormProperties , espandere il nodo della proprietà MainMenu .
5 Fare clic sulla proprietà MenuItems e sul pulsante Sfoglia che viene visualizzato una volta
selezionata la proprietà.


Continua
Passo Azione
6 Nell'editor della raccolta MenuItem, ora avviato, fare clic sul pulsante Aggiungi .
Quindi inserisci "Avvia vista" nella proprietà Testo . Fare clic su OK.
6.3.1_4Ciao
Nota
Il menuItem aggiunto ha la propria proprietà MenuItems . Lo usi se il comando "Avvia

visualizzazione" deve presentare un menu invece di funzionare come un pulsante sulla barra dei
comandi. Il modo in cui ciò può essere fatto è ulteriormente dettagliato nella Barra dei comandi a pagina 85.
7 Aggiungi un gestore eventi con codice che avvierà la visualizzazione Jogging standard quando
viene premuto il pulsante Avvia visualizzazione.
L'aggiunta di gestori eventi viene eseguita in modo diverso in Visual Studio a seconda del
linguaggio di programmazione in uso.
Per C#:
Nel costruttore, dopo la chiamata a InitializeComponent, aggiungi una sottoscrizione all'evento click
del comando “Launch View”. Scrivere:
menuItem1.Fare clic su +=
poi TAB due volte. Come noterai, Visual Studio intellisense genera automaticamente un gestore
eventi e devi solo scrivere il codice per avviare la visualizzazione Jogging:
this._launchService.LaunchView(FpStandardView.Jogging,null,false,out this._cookieJog)
Per VB:
Aggiungere un gestore eventi utilizzando le caselle a discesa precedenti del Visualizzatore codice di
Visual Studio. Trova e seleziona MenuItem1 nella casella a discesa a sinistra e l' evento Click nella
casella a discesa a destra. Il gestore eventi viene ora generato automaticamente e l'unica cosa che
devi fare è scrivere il codice per avviare la vista Jogging (vedi Codice VB in Avvio delle viste
standard a pagina 114).
Nota
Non è possibile allegare un gestore eventi nella finestra delle proprietà, come si fa ad esempio per un
Button.
8 Dichiarare gli oggetti _launchService e _cookieJog: private

ABB.Robotics.Tps.Taf.ITpsViewLaunchServices _launchService;private object
_cookieJog;


Continua
Passo Azione
9 Recupera l'oggetto _launchService nel metodo Install della tua classe:
6.3.1_5Ciao
Per un esempio di codice VB, vedere Installazione di ITpsViewSetup a pagina 113.
10 Nella finestra di progettazione, aprire la finestra Proprietà del pulsante.
11 Inserisci "Press Me" nella proprietà Text .
12 Selezionare la proprietà BackgroundImage e accedere alla cartella Resources dell'installazione

FlexPendant SDK e importare "IRB140.gif".
(Percorso predefinito: C:\Programmi\ABB Industrial IT\Robotics IT\SDK\FlexPendant SDK
5.08\Resources)
13 Costruisci, distribuisci e avvia l'applicazione, ovvero ripeti i passaggi da cinque a otto in Pratica - Ciao
mondo a pagina 70.
14 Fare clic sul comando Avvia vista .
La visualizzazione Jogging dovrebbe aprirsi e concentrarsi.
Mancia
Per ulteriori informazioni sulle possibilità di utilizzare visualizzazioni già esistenti per l'applicazione, vedere
Utilizzo del servizio di avvio a pagina 113 e Utilizzo della finestra di dialogo standard per modificare i dati a
pagina 116.
Design visivo ed esperienza utente

Esiste un'altra definizione del termine Visual design, che non rientra nell'ambito di questo manuale. Ha a che
fare con il modo in cui il design dell'interfaccia utente del software influisce sull'esperienza dell'utente. Questo è
comunque un argomento importante per uno sviluppatore di applicazioni FlexPendant. Sapere cosa
rende un'interfaccia utente intuitiva e facile da usare è essenziale, poiché questo è esattamente ciò che ci si
aspetta da un'interfaccia operatore personalizzata.
Mancia
Una guida allo stile FlexPendant viene fornita con l'installazione di FlexPendant SDK. Ti aiuterà a presentare
le funzionalità dell'applicazione in modo intuitivo, insegnando le migliori pratiche di progettazione visiva e
esperienza utente dal punto di vista FlexPendant.
Si tratta di una bozza preliminare, ma comunque molto utile.
Potresti anche voler studiare lo standard Microsoft per il visual design all'indirizzo: http://
msdn.microsoft.com/library/default.asp?url=/library/en-us/dnwue/html/ch14a.asp

5.3.2 Controlli GUI e gestione della memoria
Panoramica
Tutti i controlli SDK FlexPendant appartengono allo spazio
dei nomi ABB.Robotics.Tps.Windows.Forms. Questo spazio dei nomi comprende quindi oltre 40
classi e sottoclassi utilizzate per sviluppare l'interfaccia utente di un'applicazione FlexPendant.
ABB.Robotics.Tps.Windows.Forms.TpsControl è il tipo base di tutti i controlli SDK

FlexPendant. TpsControl a sua volta estende
System.Windows.Forms.UserControl
TpsControl può essere utilizzato come controllo contenitore di una vista FlexPendant. Ha anche
l'implementazione predefinita di Dispose, che viene chiamata per liberare la memoria allocata per
un controllo che non dovrebbe più essere utilizzato.
Potresti chiederti perché ciò sia necessario, poiché il framework .NET dispone di un garbage
collector, che dovrebbe sollevare lo sviluppatore dal dovere di liberare la memoria allocata.
La risposta è che il garbage collector non sempre recupera la memoria che non viene più utilizzata.
Pertanto, se programmi un'applicazione destinata ad essere eseguita 24 ore su 24 su un
dispositivo con memoria limitata, sei comunque responsabile di liberare memoria che non viene
più utilizzata. Trascurare di farlo comporterà perdite di memoria permanenti.
Come evitare perdite di memoria

Osserva questa figura che mostra una serie di controlli (sia ABB che Microsoft) e apprendi le
nozioni di base sulla gestione della memoria per i controlli della GUI. Non è così
complicato, la cosa più importante è non dimenticare che la pulizia è una tua responsabilità!
6.3.2_1Contr


Continua
Impara e applica queste regole generali per la gestione della memoria dei controlli della GUI. • I controlli
con una rappresentazione grafica, ad esempio ABB Numpad, TabControl, GroupBox, TpsLabel,
ListView e Microsoft PicureBox e DataGrid nella figura, vengono aggiunti automaticamente
alla raccolta di controlli in InitializeComponent. Potrebbe assomigliare a questo:
this.Controls.Add(this.numPad1);
•
Se la figura precedente rappresenta la prima visualizzazione dell'applicazione, i controlli con
rappresentazione grafica verranno eliminati dalla classe base della classe di visualizzazione
quando l'applicazione viene chiusa e il metodo Dispose viene chiamato da TAF. Ciò accade
quando viene eseguita la seguente istruzione nel metodo Dispose: base.Dispose(disponendo);
Se, tuttavia, rappresenta una vista secondaria della tua applicazione
•
(che è effettivamente il caso in questo caso, come puoi vedere dal pulsante di chiusura sulla
barra dei comandi), devi chiamare il suo metodo Dispose dalla prima vista quando viene chiusa.
La sua classe base rimuoverà quindi tutti i controlli che fanno parte della sua raccolta di
controlli, come nel caso precedente.
• I controlli GUI che non hanno una rappresentazione grafica, ma si trovano nel riquadro Componenti
sotto il modulo, ad esempio GTPUSaveFileDialog, RapidDataBindingSource, AlphaPad e
così via NON vengono aggiunti alla raccolta di controlli per impostazione predefinita. Questi
sono quelli che devi prestare particolare attenzione a rimuovere, poiché nessun netturbino
li raccoglierà mai.
Se dimentichi di chiamare esplicitamente Dispose su tali controlli, avrai causato una perdita di
memoria permanente. Studiare attentamente l'esempio di codice nella sezione successiva.
Nota
I controlli Microsoft e ABB si comportano allo stesso modo. La Microsoft ImageList, ad esempio,
comunemente utilizzata nelle applicazioni FlexPendant, non ha una rappresentazione grafica e
deve quindi essere esplicitamente rimossa dal programmatore dell'applicazione.
Codifica del metodo Dispose

Nell'esempio di codice seguente viene mostrato come può essere codificato il metodo Dispose della
vista mostrata nella figura precedente. Tutti i controlli situati nel riquadro dei componenti in Designer
devono essere rimossi esplicitamente dal programmatore. I controlli con una rappresentazione grafica
verranno rimossi quando viene eseguito Dispose della classe base.
override protetto void Dispose (eliminazione bool)

{
se (!ÈDisposto)
{
Tentativo
se (smaltire)
{
//Rimuove la finestra di dialogo SalvaFile



Continua
if(this.gtpuSaveFileDialog1!= null)
{
this.gtpuSaveFileDialog1.Dispose();
this.gtpuSaveFileDialog1 = null;
}
//Rimuove RapidDataBindingSource
if(this.rapidDataBindingSource1!= null)
{
this.rapidDataBindingSource1.Dispose();
this.rapidDataBindingSource1 = null
}
//Rimuove Alphapad
if(this.alphaPad1!= null)
{
this.alphaPad1.Dispose();
this.alphaPad1 = nullo
}
//Rimuove FolderBrowserDialog
if(this.gtpuFolderBrowserDialog1!= null)
{
this.gtpuFolderBrowserDialog1.Dispose();
this.gtpuFolderBrowserDialog1 = null
}
//Rimuove ImageList
if(this.imageList1!= null)
{
this.imageList1.Dispose(); this.imageList1
= nullo
}
}
}
Finalmente
{
//Rimuove tutti i controlli aggiunti alla raccolta di controlli
base.Dispose(smaltimento);
}
}
}
Infine, poiché si tratta di una vista secondaria, dovremmo richiamare il suo metodo Dispose
dalla prima vista quando viene chiusa.
//Questo codice viene eseguito dalla prima vista quando viene eseguita la vista secondaria
è chiuso
void form2_Closed(mittente oggetto, EventArgs e) {
se(form2!= null)
{
form2.Dispose();
forma2 = nullo;
}
}



Continua
ATTENZIONE
Se si dimentica di chiamare Dispose sui controlli che non fanno parte della raccolta di controlli
della classe, si verificheranno perdite di memoria. Ciò potrebbe causare l'esaurimento completo
della memoria della FlexPendant e l'arresto anomalo. Di solito, ciò non accade quando provi la
funzionalità della tua applicazione, ma quando viene eseguita e utilizzata continuamente
durante la produzione. Per verificare che un controllo GUI sia stato effettivamente eliminato,
è possibile, ad esempio, impostare una sottoscrizione al suo evento Disposed e verificare che
venga attivato quando si chiude la visualizzazione.
ATTENZIONE
Anche tutti gli oggetti che accedono ai servizi del controller del robot, ovvero le risorse non
gestite, devono essere rimossi dal programmatore dell'applicazione. Per ulteriori informazioni,
vedere Gestione della memoria a pagina 167.
Liberare memoria allocata per un controllo GUI Si

consiglia di rimuovere un controllo GUI nel metodo Dispose della classe che lo ha creato. Se il
controllo appartiene alla prima visualizzazione dell'applicazione, verrà eliminato quando TAF
chiama Dispose alla chiusura dell'applicazione. Se appartiene a una vista secondaria, sei
responsabile dell'eliminazione della vista secondaria e dei suoi controlli.
C#:
se (this.controlX!= null)
{
controlX.Dispose();
controlloX = nullo;
}
base.Dispose(smaltimento);
V.B.:
Se si dispone Allora Se non
controlX È Niente Allora controlX.Dispose()
controlX = Niente
Finisci se
Finisci se
MyBase.Dispose(smaltimento)
Nota
Quando viene eseguita l'ultima istruzione nell'esempio di codice precedente, la classe base
chiamerà Dispose su tutti i controlli aggiunti alla raccolta di controlli in InitializeComponent.
Ciò significa che non è necessario chiamare Dispose su tali controlli.


5.3.3 Stile del contenitore
Panoramica
Il controllo contenitore di un'applicazione FlexPendant è 640x390 pixel, ovvero la dimensione esatta dello schermo
FlexPendant dedicato per una visualizzazione personalizzata. Questa sezione descrive in dettaglio i due diversi
stili che possono essere utilizzati per una vista FlexPendant: Vuoto e Modulo.
Si seleziona quale utilizzare nell'area Stile della procedura guidata del progetto SDK FlexPendant. A
sinistra nella procedura guidata, un'anteprima ti aiuta a vedere la differenza tra i due stili.
Qui è selezionato il modulo . L'illustrazione di anteprima mostra un TpsForm. Ha una CommandBar

nella parte inferiore e una TpsCtrlTitleBar nella parte superiore.
6.2.2_1FormT
Nota
Quando si aggiunge una nuova vista a un progetto FlexPendant esistente, si sceglie quale controllo utilizzare
nella finestra di dialogo Aggiungi nuovo elemento . Per ulteriori informazioni su come aggiungere una nuova
vista a un progetto esistente, vedere Stile contenitore a pagina 81.
Vuoto o Forma?
La scelta effettuata nella procedura guidata determina il tipo che la classe di visualizzazione erediterà. Se cambi
idea a riguardo, è facile apportare la modifica direttamente nel codice generato automaticamente.
Vuoto
Questo è un semplice TpsControl. Non ha né una CommandBar, né una TpsCtrlTitleBar.
La definizione del codice della classe sarà simile alla seguente:
V.B.:


Continua
La classe pubblica TpsViewMyApp eredita gli implementazioni TpsControl

Modulo
Questo è un TpsForm, che è un TpsControl specializzato.

La definizione del codice della classe sarà simile alla seguente:
V.B.:
La classe pubblica TpsViewMyApp eredita gli implementazioni TpsForm

Nota
Spesso viene scelta Vuota come prima visualizzazione di un'applicazione SDK FlexPendant. Per qualsiasi
vista secondaria, che deve essere aperta dalla prima, Form è il controllo contenitore consigliato.
Nota
Quando selezioni Modulo potresti chiederti perché la barra dei comandi non è visibile nella finestra di
progettazione.
La risposta è che rimane invisibile finché non gli viene aggiunto un MenuItem.
Ciò avviene nella finestra Proprietà del TpsForm, applicando la proprietà MainMenu.
Mancia
Se selezioni il TitlePanel o la CommandBar di un TpsForm vedrai che la finestra Proprietà è disabilitata.

Se desideri modificare il testo del pannello del titolo o aggiungere voci di menu alla barra dei comandi, ad
esempio, devi selezionare TpsForm facendo clic in un punto qualsiasi al centro e quindi modificare la
sua proprietà Text o MainMenu .
Come costruire la barra dei comandi
La barra dei comandi è già pronta, come per TpsForm, oppure utilizzata come controllo separato disponibile
dalla casella degli strumenti. Se la barra dei comandi è già pronta, il suo disegno viene effettuato modificando
la proprietà MainMenu di TpsForm. Se utilizzato come controllo separato, lo si progetta modificando le sue
stesse proprietà. A parte questo, non c'è differenza nel modo in cui controlli il design.
Una cosa importante da ricordare è che devi aggiungere manualmente il codice di controllo che
avverrà quando fai clic su una voce di menu, poiché non ci sono proprietà evento disponibili nella sua
finestra Proprietà .


Continua
Per ulteriori informazioni su come implementare il controllo e i relativi gestori eventi, vedere Barra dei
comandi a pagina 85.
ATTENZIONE
La barra dei comandi della prima visualizzazione di un'applicazione personalizzata non deve avere
un pulsante Chiudi . Il motivo è che tutte le applicazioni personalizzate devono essere chiuse da
TAF, cosa che avviene quando si fa clic sul pulsante di chiusura [ x ] nell'angolo in alto a destra del
display FlexPendant. (Per la definizione di TAF, vedere Terminologia a pagina 17 o per ulteriori
informazioni su TAF, vedere Comprensione del ciclo di vita dell'applicazione FlexPendant a pagina
38.)
Aggiunta di una vista a un'applicazione personalizzata

Per aggiungere un'altra vista al progetto FlexPendant, non è necessario avviare un nuovo progetto.
La seguente procedura spiega come procedere:
Passo Azione
1 Fare clic con il pulsante destro del mouse sul nodo del progetto in Esplora soluzioni, scegliere Aggiungi e selezionare Nuovo
elemento.
2 Selezionare uno dei controlli contenitore FlexPendant disponibili nella finestra di dialogo. Normalmente
sarà una Forma.
Nota! Se selezioni Svuota, il codice che scrivi per aprirlo dalla prima visualizzazione è leggermente
diverso rispetto a quando utilizzi Modulo come visualizzazione secondaria.
In questo modo tutte le tue visualizzazioni costituiscono un'unica DLL, il che è conveniente. Nella
maggior parte dei casi non ha senso dividere l'applicazione in più DLL.
Avvio della visualizzazione

Il codice per avviare la vista secondaria è semplice. Potrebbe assomigliare a questo:
//dichiara la vista secondaria come membro privato
vista privata2 _vista2; //crea la
vista e aggiungi l'iscrizione al suo evento chiuso,

quindi avviare la visualizzazione
private void button1_Click(mittente oggetto, EventArgs e)

{
this._view2 = nuova Vista2();
this._view2.Closed += new EventHandler(view2_Closed); this._view2.ShowMe(questo);
//elimina la vista quando è stata chiusa
void view2_Closed(mittente oggetto, EventArgs e)

{
this._view2.Closed -= nuovo EventHandler(view2_Closed); this._view2.Dispose();
this._view2 = nullo;


Continua
Nota
Assicurati che esista un modo naturale per tornare alla visualizzazione precedente.
Il modo più intuitivo per farlo è fare clic su un pulsante Chiudi o su un pulsante OK o Annulla sulla
barra dei comandi. Se la vista secondaria è un TpsForm, questo gestore eventi la chiude:
void menuItem1_Click(mittente oggetto, EventArgs e){ this.CloseMe();}
Nota
Se stai utilizzando Vuoto come controllo contenitore secondario, il codice che scrivi per avviarlo
è:
this._view2.Mostra(); È
necessario aggiungerlo alla raccolta di controlli della prima visualizzazione prima di poterlo
visualizzare, come un normale controllo .NET.

5.3.4 Barra dei comandi
Panoramica
Per l'utente finale la barra dei comandi è un controllo centrale della FlexPendant e un importante mezzo di
interazione con il sistema. Come descritto in Come creare la barra dei comandi a pagina 82, può essere già
pronta o aggiunta al controllo contenitore da Visual Studio Toolbox.
Come aggiungere voci di menu
Se usi il contenitore Form, una barra dei comandi è incorporata, ma non è visibile finché non aggiungi una
raccolta MenuItem alla proprietà MainMenu di TpsForm. Come eseguire questa operazione è illustrato nei
passaggi 5 - 6 della sezione Pratica - passaggio 2 a pagina 74.
Se si utilizza Vuoto come contenitore è necessario aggiungere la barra dei comandi dalla casella degli
strumenti. Anche in questo caso i comandi vengono aggiunti come un insieme di voci di menu.
6.3.4_1CmdBa
La barra dei comandi in questa figura ha una raccolta di tre voci di menu: Avvia vista, Chiudi vista e Chiudi.
Inoltre, la voce di menu Avvia vista ha una propria raccolta di voci di menu: Dati rapidi, Jogging e Ripristino
backup.
Nella figura, come mostrato dalla barra delle attività, è stata aperta la vista Ripristino Backup.
È stato fatto facendo clic sulla voce di menu Ripristino backup. L'utente è quindi tornato all'applicazione Hello
World utilizzando la barra delle attività. Se si preme Chiudi visualizzazione, la visualizzazione Ripristino backup
verrà chiusa. La sezione successiva mostra come possono essere implementati i gestori eventi per questa barra
dei comandi.


Continua
Come aggiungere la gestione degli eventi delle voci di menu
Le sottoscrizioni agli eventi delle voci di menu e la gestione degli eventi non possono essere aggiunte
utilizzando il supporto di progettazione, ma devono essere implementate manualmente nel file sorgente.
L'esempio di codice seguente mostra come può essere implementata la barra dei comandi nella
figura precedente.
6.3.4_2CmdBa
Nota
Per avviare una visualizzazione standard è necessario l'oggetto ITpsViewLaunchServices, che può
essere salvato dalla classe TpsView nel suo metodo Install. Per ulteriori informazioni, vedere
Utilizzo del servizio di lancio a pagina 113.

5.3.5 Caratteri FlexPendant
5.3.5 Caratteri FlexPendant
Panoramica
Sulla FlexPendant, viene utilizzato TpsFont al posto dei caratteri Windows standard. Utilizzando
TpsFont si risparmia memoria limitata del dispositivo, poiché verranno utilizzati riferimenti statici
invece di nuove istanze di font.
TpsFont
Tahoma è il carattere predefinito della FlexPendant. È anche il font solitamente utilizzato
internamente da TpsFont. Sono preassegnate diverse dimensioni di carattere che possono essere
riutilizzate. Si consiglia di utilizzare TpsFont invece di creare nuove istanze di caratteri per i
controlli dell'interfaccia utente ABB e .NET.
Nota
Per utilizzare il cinese o un'altra lingua con caratteri non occidentali, è necessario utilizzare il
carattere FlexPendant, TpsFont, per tutti i controlli dell'interfaccia utente. Controlla internamente
quale lingua è attualmente attiva sulla FlexPendant e utilizza il carattere corretto per quella
lingua.
Nota
Se si utilizzano caratteri diversi da quelli disponibili sulla FlexPendant, ovvero Tahoma e Courier
New, l'applicazione utilizzerà Tahoma invece di quello previsto.

5.3.6 L'uso delle icone
Panoramica
È facile visualizzare icone, immagini e foto sul touch screen della FlexPendant.
Si consiglia di utilizzare questa possibilità poiché molte persone trovano più facile leggere le immagini
che il testo. Anche le immagini intuitive possono essere ampiamente comprese, il che rappresenta un vero
vantaggio in un contesto multinazionale.
Nota
Il sistema operativo del dispositivo FlexPendant di prima generazione (SX TPU 1) non supporta
immagini con più di 256 colori.
ATTENZIONE
Fare attenzione alle risorse di memoria limitate del dispositivo FlexPendant. Non utilizzare immagini
più grandi del necessario. Vedere anche Introduzione a pagina 165
Controlli FlexPendant con immagini

Diversi controlli FlexPendant supportano immagini, che vengono importate come file bmp, jpg, gif o ico
quando viene impostata una proprietà Image, Icon o BackgroundImage . Questi sono alcuni controlli da
utilizzare con le immagini:
• Elemento del menu
• Pulsante
• TpsCtrlTitlePanel
• SchedaPagina
• ElementoVisualizzazioneelenco
• TpsForm
• FPRapidData, FpToolCalibration, FpWorkObjectCalibration
• Finestra di dialogo GTPUSaveFile
PictureBox e ImageList
Sono inoltre disponibili alcuni controlli Windows che possono essere utilizzati per visualizzare le immagini.
Windows.Forms.PictureBox è uno di questi controlli. Può visualizzare la grafica da un file bitmap (.bmp),
icona (.ico), JPEG o GIF. La proprietà Image viene impostata sull'immagine preferita in fase di
progettazione o in fase di esecuzione.
Windows.Forms.ImageList può gestire una raccolta di oggetti Immagine . ImageList viene in genere
utilizzato da un altro controllo, ad esempio ListView o TabControl. Aggiungi bitmap o icone a
ImageList e l'altro controllo può scegliere un'immagine dall'indice ImageList. Come utilizzare le immagini per
un TabControl è descritto in dettaglio in Come aggiungere immagini di schede a pagina 90.


Continua
La classe TpsIcon
La classe TpsIcon offre riferimenti statici a una serie di icone utilizzate nelle
applicazioni FlexPendant standard. Potresti voler utilizzare alcune di queste icone se
soddisfano le esigenze dell'applicazione. TpsIcon appartiene allo spazio
dei nomi ABB.Robotics.Tps.Drawing.
Mancia
Nel Manuale di riferimento FlexPendant SDK, fare clic sulla scheda Cerca e cercare
Membri TpsIcon per ottenere una breve descrizione delle icone ABB disponibili come
proprietà statiche.

5.3.7 ControlloTab
5.3.7 ControlloTab
Panoramica
ABB.Robotics.Tps.TabControl viene utilizzato e implementato in modo molto simile a un normale

System.Windows.Forms.TabControl. La possibilità di utilizzare le icone delle schede, tuttavia, è una caratteristica
aggiuntiva di ABB TabControl.
Illustrazione
La schermata seguente mostra un TabControl e la relativa finestra Proprietà . Per aggiungere o rimuovere le
schede, fai clic sulla piccola freccia nell'angolo in alto a destra del controllo o fai clic su Aggiungi nuova
TabPage nella parte inferiore della finestra Proprietà .
6.2.4_1TabCo
Nota
ABB TabControl non ha la proprietà TabPages . A seconda del punto in cui si fa clic nel TabControl, si
seleziona l'intero TabControl o una delle TabPages. Per visualizzare la finestra Proprietà per la TabPage
T_ROB1 nella figura, è necessario fare clic sulla scheda T_ROB1 e quindi sulla pagina T_ROB1 successiva
alla scheda.
Come aggiungere immagini di schede
La procedura seguente spiega come utilizzare la proprietà ImageList per aggiungere icone alle schede di
TabControl:
Passo Azione
1 Trascina un System.Windows.Forms.ImageList nell'area Designer . Come noterai,
non ha una rappresentazione visiva, ma è posizionato nel riquadro dei componenti dopo
il controllo del contenitore.
2 Visualizza la finestra Proprietà di ImageList.
3 Fare clic sulla proprietà Immagini e poi sul pulsante Sfoglia, che apparirà.


5.3.7 ControlloTab
Continua
Passo Azione
4 Fai clic su Aggiungi e importa un'immagine. Ripeti finché non hai aggiunto le icone necessarie al
tuo controllo schede.
6.2.4_2TabCo
5 Ora visualizza la finestra Proprietà del TabControl e seleziona ImageList come proprietà ImageList .
6 Selezionare una delle schede e impostare la proprietà ImageIndex, che definisce quale delle immagini
nell'ImageList deve essere utilizzata per la scheda. Ripetere questa procedura per tutte le schede.
Come aggiungere un gestore eventi utilizzando la finestra Proprietà

È semplice collegare un gestore eventi a un controllo utilizzando la finestra Proprietà.
Questa procedura mostra come far accadere qualcosa quando si fa clic su una scheda per
selezionare un'altra scheda:
Passo Azione
1 Nella finestra di progettazione selezionare TabControl e visualizzare la finestra Proprietà .


5.3.7 ControlloTab
Continua
Passo Azione
2 Visualizzare gli eventi disponibili per il controllo facendo clic sul pulsante Eventi .
6.3.4_3CmdBa
3 Selezionare l' evento SelectedIndexChanged e fare doppio clic. Un nome di metodo ora viene
generato automaticamente per l' evento SelectedIndexChanged . La visualizzazione del codice viene
messa a fuoco, il cursore posizionato all'interno del gestore eventi generato.
4 Aggiungi il codice per far accadere qualcosa. Per ora basterà questo codice:
this.Text = "TabControl notifica il cambiamento delle schede"; Ciò modificherà il testo
del titolo di TpsForm quando si fa clic su una scheda.
5 Testare la funzionalità creando, distribuendo e avviando l'applicazione. Per ulteriori informazioni,

vedere il passaggio 5-8 in Hands on - Hello world a pagina 70.
Nota
L'iscrizione all'evento è stata effettuata di nascosto e non devi preoccuparti di questo. Se utilizzi
C# noterai che del codice che aggiunge la sottoscrizione è stato inserito nel metodo InitializeComponent:
this.tabControl1.SelectedIndexChanged += nuovo
System.EventHandler(this.tabControl1_SelectedIndexChanged);
Eliminazione di TabControl
Non è necessario chiamare esplicitamente Dispose sull'oggetto TabControl. Il motivo è che
InitializeComponent aggiunge le schede alla raccolta di controlli di TabControl e il TabControl stesso
alla raccolta di controlli di
la classe contenitore. this.Controls.Add(this.tabControl1);
Il TabControl viene quindi rimosso quando il metodo Dispose della classe contenitore chiama Dispose
sulla sua classe base in questo modo: base.Dispose(disponendo);

5.3.8 Pulsante, casella di testo e casella combinata
5.3.8 Pulsante, casella di testo e casella combinata
Panoramica
I controlli del pulsante FlexPendant, della casella di testo e della casella combinata non sono molto diversi
dai controlli equivalenti di Windows.
Utilizzando il pulsante
*
Una dimensione comune di un pulsante FlexPendant è 120 45 pixel; può essere molto più piccolo
della dimensione predefinita. A differenza di un pulsante di Windows, può visualizzare un'immagine. Come
sottolineato nell'Illustrazione a pagina 90 si utilizza la proprietà BackgroundImage e si cerca l'immagine da
visualizzare.
Utilizzando la casella di testo
Il controllo TextBox è multilinea per impostazione predefinita e utilizza le tipiche barre di scorrimento
FlexPendant come mostrato nella figura seguente.
6.2.7_1TestoB
Utilizzando ComboBox
Il ComboBox è molto simile al System.Windows.Forms.ComboBox, ma è visivamente migliorato per adattarsi
al touch screen FlexPendant. Può essere popolato staticamente utilizzando la proprietà Items come illustrato
nella figura. Se desideri popolarlo dinamicamente, devi scrivere il codice per esso.
6.2.7_2Combinato
SelectedIndexChanged è quello più comunemente utilizzato tra gli eventi. Si verifica quando selezioni un
altro elemento dall'elenco.
5.3.9 AlphaPad
5.3.9 Alpha Pad
Panoramica
Il controllo AlphaPad è una tastiera virtuale che consente di inserire stringhe. Copre l'intero display
della FlexPendant. La figura mostra il suo aspetto in fase di esecuzione.
6.2.10_1Alfa
L'AlphaPad non ha una rappresentazione grafica in fase di progettazione. Quando viene trascinato
dalla Casella degli strumenti al Designer viene posizionato nel riquadro dei componenti, come
mostrato nella figura nella sezione successiva. Viene generato codice simile ai controlli disposti
visivamente sul modulo in fase di progettazione.
Avvio dell'AlphaPad
È necessario scrivere del codice per avviare la tastiera virtuale. Il seguente codice spiega come
farlo:
C#:
this.alphaPad1.ShowMe(questo);
V.B.:
Me.AlphaPad1.ShowMe(Me)
Nota
Il codice per avviare AlphaPad dovrebbe essere eseguito da un gestore di eventi appropriato.


5.3.9 AlphaPad
Continua
Aggiunta di gestori di eventi

La finestra Proprietà può essere utilizzata per programmare i gestori di eventi AlphaPad. Fai doppio clic
sull'evento a cui vuoi rispondere. Questo ti porta all'editor del codice, il cursore posizionato all'interno del
gestore eventi generato automaticamente, dove puoi scrivere il codice per salvare l'input dell'utente in una
variabile membro, ad esempio:
if (alphaPad1.SelectedText!= string.Empty)
{
_userInput = alphaPad1.SelectedText;
}
6.2.10_2Alfa
Convalida del risultato all'evento Closing L'evento

Closing viene generato quando viene premuto il pulsante OK o Annulla dell'AlphaPad. È possibile utilizzare
questo evento per convalidare la stringa immessa dall'utente. Puoi impostare la proprietà Cancel dell'argomento
dell'evento su true se desideri che AlphaPad rimanga aperto finché non viene immesso un valore di input
valido:
V.B.:
Private Sub NamePad_Closing(mittente As Object, e As
System.ComponentModel.CancelEventArgs) Gestisce NamePad.Closing
Se NamePad.SelectedText.CompareTo("Nessun nome") = 0 &&
NamePad.DialogResult = System.Windows.Forms.DialogResult.OK
Poi
e.Annulla = Vero
Finisci se
Fine sott
C#:
private void namePad_Closing(mittente oggetto,
System.ComponentModel.CancelEventArgs e)
{
if ((this.namePad.SelectedText.CompareTo("No Name") == 0) &&
(this.namePad.DialogResult ==
System.Windows.Forms.DialogResult.OK))
{
e.Annulla = vero;
}
}


5.3.9 Alpha Pad
Continua
Utilizzando il risultato all'evento chiuso

L'evento Closed deve essere intercettato da un gestore eventi, poiché l'oggetto non può essere
eliminato finché non viene chiuso. Il risultato può essere recuperato in questo gestore
eventi o nel gestore eventi Closing. Verificare innanzitutto che sia stato premuto OK e non
Annulla, quindi recuperare l'input dell'utente. Infine l'AlphaPad dovrebbe essere eliminato.VB:
Private Sub NamePad_Closed(sender As Object, e As EventArgs) Handles
NamePad.Chiuso
Se NamePad.DialogResult = Windows.Forms.DialogResult.OK Allora
Io.risposta = NamePad.SelectedText
Termina IfNamePad.Dispose()
Fine sott
C#:
private void namePad_Closed(mittente oggetto, EventArgs e) {
if (this.namePad.DialogResult ==
System.Windows.Forms.DialogResult.OK)
{
this.answer = this.namePad.SelectedText;
}
}
Rimozione del controllo AlphaPad

L'AlphaPad NON viene aggiunto alla collezione dei controlli e pertanto NON verrà smaltito dalla
classe base del suo contenitore.
Sei responsabile della chiamata esplicita del relativo metodo Dispose quando non viene più
utilizzato. Nell'esempio precedente, ciò avviene all'evento Closed. Ciò implica che una nuova
istanza AlphaPad verrà creata la prossima volta che verrà attivato il suo evento di lancio.
Un altro modo per gestire questo problema è lasciare attiva l'istanza creata dal Designer finché
la sua vista contenitore non viene chiusa. Questa alternativa significa distruggerlo nel metodo
Dispose della classe contenitore:
ATTENZIONE
Se si dimentica di chiamare Dispose su un controllo AlphaPad si avrà una perdita di

memoria. Per ulteriori informazioni vedere Controlli della GUI e gestione della memoria a
pagina 77.

5.3.10 Visualizzazione elenco
Panoramica
ABB.Robotics.Tps.Windows.Forms.ListView è molto simile a un ListView .Net standard. La differenza principale

è che il suo aspetto è in qualche modo adattato all'uso di un touch screen, come si può vedere nella figura.
È possibile utilizzare il controllo ListView in diversi modi. Di solito lo si utilizza per visualizzare un elenco di
elementi con il testo dell'elemento e, facoltativamente, un'icona per identificare il tipo di elemento. Utilizzando la
proprietà CheckBoxes è anche possibile visualizzare una casella di controllo accanto a ciascun elemento nel
controllo, consentendo agli utenti di selezionare gli elementi su cui desiderano eseguire un'azione.
Illustrazione
La figura mostra il Designer. Vengono visualizzati due diversi elenchi ABB ListView, un .Net ImageList
standard nel riquadro dei componenti sotto gli elenchi e la finestra Proprietà per l'elenco Calibrazione,
HotEdit.
6.3.10_1Elenco
Utilizzo delle proprietà per controllare l'aspetto Il

primo elenco ha CheckBoxes impostato su true. Per visualizzare le colonne, Visualizza deve essere impostato
su Dettagli. Le colonne vengono create selezionando Colonne e aggiungendo un numero qualsiasi di colonne
nell'editor della raccolta ColumnHeader. Scrollable è stato impostato su true per consentire di scorrere l'elenco
per visualizzare tutti gli elementi. Per visualizzare il numero corrente di elementi dell'elenco
ShowNumberOfItems è stato impostato su true. Utilizzando Ordinamento gli elementi dell'elenco possono
essere ordinati alfabeticamente, in questo caso in ordine decrescente . L'elenco viene popolato staticamente
utilizzando la proprietà Items .
La proprietà View dell'altro elenco è impostata su LargeIcon anziché su Details. Per visualizzare le icone viene
utilizzato un .Net ImageList standard. Per prima cosa avvia la finestra Proprietà per ImageList e aggiungi le
immagini che desideri utilizzare. Nel LargeImageList


Continua
della ListView si seleziona l'elenco delle immagini e per ogni Item si seleziona l' ImageIndex da utilizzare,
come mostrato nell'editor della raccolta ListViewItem.
Utilizzando la finestra Proprietà è inoltre possibile aggiungere la gestione degli eventi. L'evento più
comunemente utilizzato è SelectedIndexChanged, che viene attivato quando viene selezionato un nuovo
elemento dell'elenco.
La finestra Proprietà può essere utilizzata per popolare staticamente l'elenco. Di solito, tuttavia, gli elenchi
vengono popolati dinamicamente. In Ottenere segnali utilizzando SignalFilter a pagina 150 è presente un
esempio di codice che mostra come i segnali I/O vengono visualizzati dinamicamente in un ListView ABB.
Proprietà specifiche ABB

Queste proprietà sono specifiche per ABB ListView:
Proprietà Utilizzo
Selezione multipla Specifica se è possibile selezionare più elementi nel controllo.

L'impostazione predefinita è falsa.
Scorrevole Specifica se viene aggiunta una barra di scorrimento al controllo quando non c'è
spazio sufficiente per visualizzare tutti gli elementi. L'impostazione predefinita è vera.
Nota! Le tipiche barre di scorrimento FlexPendant vengono utilizzate dal primo elenco
nella figura precedente.
SelezioneAbilitataOver- Specifica se un tocco all'interno dell'area di scorrimento deve selezionare un elemento

Pulsanti di scorrimento o scorrere l'elenco. L'impostazione predefinita è falsa.
Mostra numero di elementi Specifica se viene visualizzato il numero corrente di elementi nell'elenco.
L'impostazione predefinita è vera. È necessario aggiungere barre di scorrimento al
controllo per consentire di visualizzare tutti gli elementi. Se l'elenco non è scorrevole,
il valore predefinito è false.
Mostra selezione Specifica se la selezione viene visualizzata o meno. L'impostazione predefinita è falsa.

5.3.11 CompactAlphaPad e NumPad
Utilizzando CompactAlphaPad
Il controllo CompactAlphaPad viene utilizzato per abilitare l'input dell'utente. L'input può essere
sotto forma di lettere maiuscole o numeri a seconda della proprietà
ActiveCharPanel, che può essere impostata su Caratteri o Numerico. Ha una dimensione fissa,
abbastanza grande da consentire l'uso di un dito per premere i tasti. Sono disponibili
proprietà per definire se il pannello numerico deve supportare operandi numerici, caratteri
speciali, spazio e virgola. Tutte queste proprietà sono impostate su true nella figura:
6.3.11_1Comp
Affinché la tua applicazione possa utilizzare l'input dell'utente, devi connetterti a una casella di
testo che visualizza il testo o le cifre immesse. Questa connessione deve essere
codificata manualmente, ad esempio nel costruttore, dopo la chiamata a InitializeComponent,
ad esempio:
this.compactAlphaPad1.Target = this.textBox1;


Continua
Utilizzando il tastierino numerico
Il NumPad è molto simile al CompactAlphaPad. Devi creare un Target per utilizzare l'input, ad
esempio:
this.numPad1.Target = this.textBox2;
6.3.11_2Num

5.3.12 GTPUMessageBox
Panoramica
GTPUMessageBox è il controllo della casella di messaggio che deve essere utilizzato dalle applicazioni
FlexPendant. Non utilizzare il MessageBox standard.NET.
Problemi di progettazione
Gli argomenti GTPUMessageBox.Show includono un argomento proprietario, ovvero il controllo che visualizza
MessageBox, e un callback, ovvero un MessageBoxEventHandler chiamato quando
MessageBox viene chiuso.
Tranne questo, viene utilizzato allo stesso modo del normale MessageBox di Windows. Viene utilizzato insieme
ai normali MessageBoxButtons e
MessageBoxIcon.
Esempio di codice semplice

La schermata e il codice seguenti mostrano come visualizzare un messaggio semplice su FlexPendant utilizzando
GTPUMessageBox.
6.2.6_1WinBu
string message = "Non hai inserito il nome del server. Cancellalo

operazione?";
string caption = "Nessun nome server specificato";
GTPUMessageBox.Show(questo, null, messaggio, didascalia,
System.Windows.Forms.MessageBoxIcon.Question,
System.Windows.Forms.MessageBoxButtons.YesNo);
Nota
A volte può essere un po’ complicato comprendere correttamente il primo argomento. Il proprietario potrebbe
essere this, this.Parent o anche this.Parent.Parent.


Continua
Utilizzando una richiamata
La logica del programma determina se è necessaria una richiamata. Nell'esempio precedente

l'argomento callback era null. La finestra di messaggio si chiuderà dopo che l'utente ha risposto
alla domanda, indipendentemente se la risposta è Sì o No.
Se pensiamo al messaggio, sembra tuttavia probabile che qualcosa accada se si fa clic su

No. Modifichiamo l'implementazione e utilizziamo un callback per questo scopo:
GTPUMessageBox.Show(questo, nuovo
MessageBoxEventHandler(OnServerMessageClosed), messaggio, didascalia,
System.Windows.Forms.MessageBoxIcon.Question,
System.Windows.Forms.MessageBoxButtons.YesNo);
//implementa la richiamata
private void OnServerMessageClosed(mittente dell'oggetto,
ABB.Robotics.Tps.Windows.Forms.MessageBoxEventArgs e)
{
if(e.DialogResult == System.Windows.Forms.DialogResult.No)
{
//Utilizza il server predefinito...
}
}
Se davvero non vogliamo agire in base a come risponde l'utente, ha più senso usare OK
invece di Sì e No come pulsanti della finestra di messaggio, ad esempio:
GTPUMessageBox.Show(this, null, "Non sei autorizzato a eseguire
questa operazione, rivolgiti al tuo amministratore di sistema se hai bisogno dell'accesso",
"Sistema di autorizzazione utente", MessageBoxIcon.Hand, MessageBoxButtons.OK);
Nota
L'ultimo esempio utilizza un titolo della finestra di messaggio migliore rispetto a quelli
precedenti. Il titolo preferibilmente dovrebbe dirti da quale parte del sistema proviene il
messaggio.

5.3.13 Finestra di dialogo FileGTPU
Panoramica
L'SDK FlexPendant fornisce una serie di finestre di dialogo di file utilizzate dall'utente finale per interagire con il file system
del controller del robot. Questi controlli ereditano tutti la classe astratta GTPUFileDialog e appartengono allo spazio dei nomi
ABB.Robotics.Tps.Windows.Forms.
Tipi di finestre di dialogo dei file
Esistono tre diversi tipi di controlli della finestra di dialogo dei file:
Utilizzo... quando vuoi...
GTPUOpenFileDialog Consente di specificare un file da recuperare dal file system

del controller.
GTPUSaveFileDialog Consente di specificare un file da salvare nel file system del

controller.
GTPUFolderBrowserDialog Consente di specificare una cartella sul file system del controller.
Nota
La finestra di dialogo Apri/Salva/Sfoglia file rappresenta un modo conveniente per specificare la cartella e il nome file
per un'operazione sui file. Dovresti sapere, tuttavia, che le finestre di dialogo stesse non eseguono alcuna operazione sui
file, forniscono solo il percorso del file system del controller che deve essere utilizzato dall'applicazione.
ATTENZIONE
Una volta aggiunti a Visual Studio Designer dalla casella degli strumenti, questi controlli verranno inseriti nel riquadro dei
componenti. Devono essere rimossi esplicitamente tramite una chiamata al loro metodo Dispose, ad esempio nel metodo
Dispose della classe che li ha creati.


Continua
Illustrazione
Quello che segue è uno screenshot del GTPUSaveFileDialog. Le altre finestre di dialogo dei file hanno quasi lo
stesso aspetto e il modo in cui funzionano è molto simile. Utilizzando le icone della barra dei comandi si creano
nuove cartelle e si sfoglia il file system del controller. Insieme all'elenco e alla casella di testo, specifichi un
percorso remoto. La proprietà FileName deve essere letta per recuperare questo percorso. Restituisce il percorso
completo del file system del controller, anche se nella casella di testo Nome file è visibile solo il nome del file
6.3.13_1Salva
Nota! Il pulsante dopo la casella di testo Nome file apre la tastiera virtuale, consentendo di modificare il nome
del file da salvare. La proprietà Filter del controllo è impostata su TEXT(*.txt)|*.txt. La prima parte dell'impostazione
viene visualizzata nella casella di testo del filtro.


Continua
Questa è la finestra Proprietà di questa finestra di dialogo:
6.3.13_2Salva
Dettagli di implementazione
La finestra Proprietà fornisce una chiara descrizione della proprietà selezionata, come si può vedere nella figura
precedente. Qui verranno descritte in dettaglio solo alcune proprietà importanti:
Proprietà Dettagli
Filtro Osservare attentamente il formato della stringa quando si imposta

questa proprietà, ad esempio: Programmi (*.pgf)|*.pgf La prima
parte viene visualizzata nella casella combinata e la seconda parte
viene utilizzata dall'SDK per recuperare i file corretti da visualizzato
nell'elenco. È inoltre possibile specificare diversi filtri tra cui l'utente può
scegliere.
File di programma (*.pgf)|*.pgf|Tutti i file (*.*)|*.*;
Nome del file Non è possibile accedervi in fase di progettazione utilizzando la finestra Proprietà ,
ma deve essere codificato manualmente quando viene avviata la finestra di dialogo
del file se si tratta di una finestra di dialogo di salvataggio del file.
Quando la finestra di dialogo è chiusa, dovresti leggere questa proprietà.

Contiene il percorso remoto e il nome del file da aprire oppure il
percorso remoto e il nome del file da salvare.
Nota! Ricordare che remoto si riferisce al file system del controller e

locale al file system FlexPendant.
DirectoryIniziale Non è possibile accedervi in fase di progettazione utilizzando la finestra

Proprietà . Specifica la directory iniziale da visualizzare nella finestra di
dialogo del file.
Nota
Affinché il programma possa utilizzare il percorso del controller selezionato dall'utente finale, è necessario
leggere la proprietà FileName nell'evento Closing/Closed della finestra di dialogo del file.



Continua
Esempio
Questo pezzo di codice imposta InitialDirectory e FileName, quindi imposta una
sottoscrizione all'evento Closed e infine visualizza GTPUSaveFileDialog
saveFileDialog.InitialDirectory = diriniziale; saveFileDialog.FileName =
nomeprogramma; saveFileDialog.Closed += nuovo
EventHandler(SaveProgram_FileDialog_EventHandler);
saveFileDialog.ShowMe(_parent);
Il codice del metodo SaveProgram_FileDialog_EventHandler recupera il percorso specificato
del file system remoto, incluso il nome del file, leggendo la proprietà FileName:
string remotePath = saveFileDialog.Filename;
Nota
Il file non è ancora stato salvato sul controller del robot. Per fare ciò dovresti chiamare
FileSystem.PutFile utilizzando il percorso recuperato come argomento remoteFile.
Allo stesso modo, per caricare un file remoto specificato nel file system FlexPendant è
necessario utilizzare il percorso recuperato nella chiamata a FileSystem.GetFile.

5.3.14 Dati di dati RAPID e segnali IO
Cos'è l'associazione dati?

L'associazione dati è il processo di associazione di una proprietà di un controllo GUI a un'origine dati, in modo
che la proprietà rifletta automaticamente il valore dell'origine dati. In .NET CF 2.0 questa funzionalità è stata
semplificata con la classe BindingSource. Questa classe incapsula la complessità relativa all'impostazione e
alla gestione dell'associazione dati. Ti consente di connettere RapidDataBindingSource o SignalBindingSource
a un controllo GUI senza dover scrivere una singola riga di codice. (Tranne la chiamata Dispose quando le origini
di associazione non sono più necessarie.)
Classi SDK FlexPendant da utilizzare come origini di collegamento

Nell'SDK FlexPendant sono presenti due classi che ereditano .NET BindingSource: RapidDataBindingSource e
SignalBindingSource. Queste classi consentono rispettivamente l'associazione ai dati RAPID e ai segnali IO.
Appartengono allo spazio dei nomi ABB.Robotics.DataBinding e l'assembly a cui devi fare
riferimento è ABB.Robotics.DataBinding.dll.
RapidDataBindingSource
Utilizzando RapidDataBindingSource avviene un aggiornamento automatico del controllo GUI associato
quando il valore dell'origine dati RAPID specificata nel controller viene modificato o quando il controllo viene
ridisegnato.
SignalBindingSource
Utilizzando SignalBindingSource, avviene un aggiornamento automatico del controllo GUI associato quando il valore del
segnale IO specificato nel controller è cambiato o quando il controllo viene ridisegnato.
Nota
È possibile utilizzare solo dati RAPID persistenti (PERS) come origine dati.
Nota
Se si desidera consentire agli utenti di modificare i dati RAPID, avviare l'applicazione FlexPendant Program
Data standard dall'applicazione è probabilmente la migliore alternativa.
Per ulteriori informazioni, vedere Utilizzo della finestra di dialogo standard per modificare i dati a pagina116.
Esempio di interfaccia grafica
È possibile utilizzare molti controlli diversi con le origini di associazione, ad esempio TpsLabel, TextBox, ListView
e così via. Lo screenshot seguente mostra due controlli System.Windows.Forms.DataGrid,
ciascuno dei quali si associa a diversi oggetti definiti in RapidDataBindingSource e SignalBindingSource . Le
etichette in ogni GroupBox sono legate alle stesse origini. Come vedi, la griglia visualizza tutti gli oggetti
definiti nel controllo BindingSource, mentre ogni etichetta visualizza la riga della griglia attualmente
selezionata.
Quando un segnale o un valore di dati cambia, questa GUI viene automaticamente aggiornata con il nuovo valore.
Non è necessario scrivere alcun codice per far sì che ciò accada, come durante la configurazione


Continua
gli abbonamenti e l'aggiornamento dell'interfaccia utente vengono eseguiti

dall'implementazione sottostante.
6.3.14_1FPVi
ATTENZIONE
Per evitare eventuali perdite di memoria è necessario effettuare una chiamata esplicita
al metodo Dispose dei controlli BindingSource. Tuttavia, gli oggetti wrapper SignalObject
e RapidDataObject creati per te vengono smaltiti dietro le quinte, quindi non devi preoccuparti di
questo.


Continua
Come utilizzare la finestra di progettazione di

Visual Studio per Questa sezione spiega come creare la vista FlexPendant mostrata nella
sezione precedente. Innanzitutto viene creato un controllo RapidDataBindingSource con
associazioni ai dati RAPID specificati. Quindi viene utilizzata la proprietà DataBindings di un
TpsLabel per associare l'etichetta all'origine di associazione. Infine un DataGrid .NET standard
è associato alla stessa origine di associazione.
Passo Azione
1 Inizia trascinando un RapidDataBindingSource dalla casella degli strumenti al Designer.
Verrà inserito nel riquadro Componenti sotto il modulo. Aprire la finestra Proprietà e
selezionare la proprietà RapidDataList per aggiungere i dati RAPID a cui si è interessati.
Per ogni nuovo membro RapidDataObject è necessario specificare il nome del modulo,
il nome dell'attività e il nome dei dati RAPID persistenti da associare.
6.3.14_2Rilega


Continua
Passo Azione
2 Il passo successivo è aprire la finestra Proprietà per l'etichetta che deve visualizzare
il valore dei dati RAPID. Espandi il nodo DataBindings e seleziona Avanzate.
6.3.14_3Prop


Continua
Passo Azione
3 Nella finestra di dialogo Associazione avanzata visualizzata, scegli il RapidDataBindingSource

già creato nella casella combinata Associazione , specificando allo stesso tempo a quale delle
proprietà RapidDataObject desideri associarti, in questo caso Valore.
(Le altre proprietà disponibili sono il nome della variabile, il nome dell'attività e il nome del modulo,
come si può vedere nella figura al passaggio 1.)
Seleziona anche la modalità di aggiornamento dell'origine dati preferita, in genere OnProper-
tyChanged. Il contrassegno giallo nell'elenco a sinistra mostra che l'associazione è stata eseguita
alla proprietà Text dell'etichetta. Quando un controllo è stato associato a un'origine dati vedrai lo
stesso contrassegno giallo nella sua finestra Proprietà , nella proprietà associata. Per ulteriori
informazioni, vedere l'illustrazione al passaggio 2.
6.3.14_4Adva
Nota
Se un'etichetta è stata associata a un'origine dati con diversi oggetti membro, il primo nell'elenco è
quello visualizzato per impostazione predefinita dall'etichetta. Se l'indice selezionato della lista
cambia (se ad esempio si seleziona una riga nella griglia) l'etichetta viene aggiornata
automaticamente per mostrare il valore dell'indice selezionato. Per ulteriori informazioni, vedere
l'illustrazione in Dati RAPID e segnali IO a pagina 107.


Continua
Passo Azione
4 Ora avvia la finestra Proprietà del controllo DataGrid. Imposta ColumnHeaderVis-ible su true e
seleziona l'origine dati nella proprietà DataSource .
6.3.14_5Griglia
Nota
Il controllo DataGrid visualizza solo una riga in fase di progettazione (per ulteriori informazioni,
vedere l'illustrazione del passaggio 1). In fase di esecuzione, tuttavia, viene visualizzata l'intera
raccolta di membri Rapid-DataObject (vedere la figura in Dati di dati RAPID e segnali IO a
pagina 107).
Sospendi associazione/Riprendi associazione

SuspendBinding() e ResumeBinding() hanno funzionalità estese rispetto ai metodi della
classe BindingSource ereditata. È stata aggiunta la rimozione/aggiunta di abbonamenti, poiché
l'abbonamento a segnali e dati RAPID può richiedere un consumo di risorse. Questi metodi possono
essere utilizzati nei metodi Disattiva/Attiva, che vengono eseguiti ogni volta che si passa da
un'applicazione all'altra utilizzando la barra delle attività FlexPendant. Per ulteriori informazioni,
vedere Utilizzo di Application Framework - ITpsViewActivation a pagina 172.
Se sospendi l'associazione non riceverai più alcun aggiornamento se l'origine dati viene
modificata. Tuttavia, l'associazione esiste ancora, quindi se DataSourceUpdateMode è impostato
su OnValidation il valore verrà aggiornato quando si ridisegna il controllo, poiché il valore dal
controller verrà letto prima di essere ridisegnato.
Metodo Descrizione
SuspendBinding Sospende l'evento di associazione e modifica del valore.
RiprendiBinding Riprende l'evento di associazione e modifica del valore.

5.4.1 Utilizzo del servizio di lancio
5.4 Avvio di altre visualizzazioni
Panoramica
FlexPendant SDK fornisce un servizio di lancio che consente a un'applicazione FlexPendant SDK di avviare
un'applicazione ABB standard, come l'editor di programmi o la visualizzazione jogging.
È anche possibile avviare un'altra applicazione personalizzata specificando il nome dell'assembly proxy e la
classe di visualizzazione dell'applicazione.
Per ulteriori informazioni su come aggiungere e avviare un'altra visualizzazione della propria applicazione,
vedere Aggiunta di una visualizzazione a un'applicazione personalizzata a pagina 83.
Nota
Per avviare una vista al fine di modificare un'istanza di dati rapidi specificata, è disponibile un altro
meccanismo. Per ulteriori informazioni, vedere Utilizzo della finestra di dialogo standard per modificare i dati
a pagina 116.
Installazione di ITpsViewSetup
Solo le classi che ereditano l'interfaccia ITpsViewSetup possono avviare altre applicazioni. Il metodo Install, che
viene chiamato quando viene avviata l'applicazione personalizzata, ha un argomento mittente. L'applicazione
deve salvare questo oggetto per utilizzare l'interfaccia ITpsViewLaunchServices. Viene utilizzato dal servizio di
lancio per chiamare LaunchView e CloseView.
V.B.:
//dichiarazione
iTpsSite privato come ITpsViewLaunchServices
.....
//Metodo di installazione della classe TpsView
Funzione Installa (mittente ByVal As System.Object, dati ByVal As
System.Object) Come booleano implementa ITpsViewSetup.Install
Se il mittente TypeOf è ITpsViewLaunchServices Allora
// Salva l'oggetto mittente per un uso successivo
Me.iTpsSite = DirectCast(mittente, ITpsViewLaunchServices)
Restituisce Vero
Finisci se
Restituisce Falso
Fine funzione
C#:
//dichiarazione
privato ITpsViewLaunchServices iTpsSite;
......
//Metodo di installazione della classe TpsView bool
ITpsViewSetup.Install(mittente oggetto,dati oggetto)


Continua
{
if (il mittente è ITpsViewLaunchServices) {
// Salva l'oggetto mittente per un uso successivo
this.iTpsSite = mittente come ITpsViewLaunchServices;
restituisce vero;
}
restituire falso;
}
Avvio delle visualizzazioni standard

Utilizzando l'enumeratore FpStandardView, è possibile avviare le seguenti visualizzazioni standard utilizzando
i servizi di lancio:
• Editor del programma •
Dati del programma •
Jogging •
Disconnessione • Backup/Ripristino
Mancia
L'avvio della visualizzazione dati del programma è il modo migliore per consentire agli utenti finali di creare
nuovi dati RAPID.
Nota
Per avviare l'editor del programma è possibile utilizzare come argomento un oggetto di inizializzazione di tipo
RapidEditorInitData. Specifica l'attività, il modulo e la riga che l'editor del programma deve visualizzare
all'apertura. Per le altre viste standard non è possibile utilizzare InitData.
Esempio LaunchView / CloseView
Nell'esempio seguente, l'editor del programma viene avviato in una routine specifica.
Viene creato il primo initData. Quindi il riferimento all'oggetto mittente, recuperato dal metodo Install nell'esempio
precedente, viene utilizzato per chiamare LaunchView.
L'argomento cookie out viene successivamente utilizzato per specificare la vista da chiudere con il metodo
CloseView.
V.B.:
Dim initData As RapidEditorInitData = Nuovo RapidEditorInitData

(ATask, AModule, ARoutine.TextRange.Begin.Row)
Se no (Me.iTpsSite.LaunchView(FpStandardView.RapidEditor, initData, True, Me.cookieRapidEd) = True) Allora
GTPUMessageBox.Show(Me, Nothing, "Impossibile avviare
l'applicazione RapidEditor")
Ritorno
Finisci se
......
Me.iTpsSite.CloseView(Me.cookieRapidEd)



Continua
C#:
RapidEditorInitData initData = new RapidEditorInitData(attività,
modulo,routine.TextRange.Begin.Row;
if(this.iTpsSite.LaunchView(FpStandardView.RapidEditor,initData,true,out
this.cookieRapidEd)!= vero) {
GTPUMessageBox.Show(this, null,"Impossibile avviare l'applicazione RapidEditor");
ritorno;
}
.....
this.iTpsSite.CloseView(this.cookieRapidEd);
Cosa succede se la vista specificata è già aperta quando viene effettuata la chiamata? Il terzo
argomento specifica il comportamento dell'applicazione in questo caso. Se vero, viene avviata un'altra
istanza della vista. Se false, la vista già aperta viene messa a fuoco. Si noti, tuttavia, che la
creazione di una nuova istanza non è possibile per tutte le viste standard. Alla visualizzazione
Jogging, ad esempio, non sono consentite più istanze.
Avvio di applicazioni personalizzate

Il servizio di avvio può essere utilizzato anche per avviare un'altra applicazione SDK
FlexPendant. Come argomenti è necessario utilizzare il nome dell'assembly proxy insieme al nome
completo della classe.
V.B.:
In caso contrario (Me.iTpsSite.LaunchView("TpsViewCustomApp.gtpu.dll",

"ABB.Robotics.SDK.Views.TpsViewCustomApp", Nothing, True, Me.cookieUser) = True) Quindi
GTPUMessageBox.Show(Io, Niente, "Impossibile avviare User

applicazione")
Ritorno
Finisci se
C#:
if (this.iTpsSite.LaunchView("TpsViewCustomApp.gtpu.dll",
"ABB.Robotics.SDK.Views.TpsViewCustomApp", null, true, out this.cookieUser)!= true) {
GTPUMessageBox.Show(this, null,"Impossibile avviare User

applicazione");
ritorno;
}
Nota
È lo spazio dei nomi dell'assembly proxy, ABB.Robotics.SDK.Views, che deve essere utilizzato
per specificare la classe TpsView.
Nota
Utilizzando l'argomento cookieUser, l'applicazione può chiudere l'applicazione personalizzata

avviata nello stesso modo dell'esempio precedente Utilizzo del servizio di avvio a pagina 113 .

5.4.2 Utilizzo della finestra di dialogo standard per modificare i dati
Panoramica
Le finestre di dialogo FpRapidData, FpToolCalibration e FpWorkObjectCalibration accettano un riferimento

RapidData come argomento. Quando la finestra di dialogo è aperta consente di operare direttamente sull'oggetto
RapidData di riferimento, ad esempio modificando una variabile di dati RAPID o calibrando un oggetto di lavoro.
Queste finestre di dialogo sono quelle utilizzate dalle applicazioni ABB standard. Sono già pronti e non possono
essere modificati, ad eccezione del titolo.
Creazione della finestra di dialogo

Come per tutte le finestre di dialogo secondarie, il riferimento alla finestra di dialogo deve essere dichiarato
come variabile di classe. Questo per assicurarsi che il riferimento sia disponibile per Dispose.
Il riferimento RapidData può essere dichiarato localmente se viene eliminato immediatamente dopo l'uso,
oppure come variabile di classe. Una volta creata la finestra di dialogo è possibile impostare il titolo utilizzando
la proprietà Text. È necessario aggiungere un gestore eventi Closed per eliminare la finestra di dialogo. Tutte e
tre le finestre di dialogo vengono create allo stesso modo:
V.B.:
ARapidData privato come RapidData

Amico WithEvents FpRD Come FpRapidData
.....
Me.ARapidData = Me.AController.Rapid.GetRapidData(ATaskName,
AModuleName, AVariableName)
Me.FpRD = Nuovo FpRapidData(Me.ARapidData)
Me.FpRD.Text = Me.ARapidData.Nome
AddHandler Me.FpRD.Closed, AddressOf Me.FpRD_Closed Me.FpRD.ShowMe(Me)
C#:
privato FpRapidData fpRD; RapidData

privato aRapidData;
......
this.aRapidData = this.aController.Rapid.GetRapidData(taskName, moduleName, variableName);
this.fpRD = nuovo FpRapidData(this.aRapidData); this.fpRD.Text =

this.aRapidData.Name; this.fpRD.Closed += new
EventHandler( fpRD_Closed); this.fpRD.ShowMe(questo);
Nota
Verificare che RapidData sia del RapidDataType corretto per la finestra di dialogo prima di utilizzarlo, ovvero
tooldata per la finestra di dialogo FpToolCalibration e wobjdata per la finestra di dialogo FpWorkObjectCalibration.
Per ulteriori informazioni, vedere Utilizzo della finestra di dialogo standard per modificare i dati a pagina 116.


Continua
Nota
La finestra di dialogo FpRapidData viene creata con un RapidData come argomento. Se

l'array RapidDataisan, viene utilizzato un argomento indice per specificare quale elemento
deve essere visualizzato (il primo elemento è 1).
Controllo del tipo

Quando si chiama il costruttore FpToolCalibration o FpWorkObjectCalibration, il valore
RapidData deve essere controllato prima dell'uso:
V.B.:
Se TypeOf Me.ARapidData.Value è ToolData allora

Me.FpTC = Nuova calibrazione FpTool(Me.ARapidData)
.....
Finisci se
C#:
se (this.aRapidData.Value è ToolData) {
this.fpTC = nuovo FpToolCalibration(this.aRapidData);

....
}


5.5.1 ABB.Robotica.Controller
5.5 Utilizzo dell'API del controller
API del controller

Per accedere alle funzioni del controller del robot si utilizzano le librerie di classi dell'SDK
FlexPendant denominate Controller Application Programming Interface o CAPI.
L'assembly a cui devi fare riferimento per utilizzare la funzionalità del controller è
ABB.Robotics.Controllers.dll.
Domini CAPI
L'oggetto CAPI principale è ABB.Robotics.Controllers.Controller, che deve essere creato prima
di qualsiasi accesso al controller del robot.
Le librerie di classi sono organizzate in diversi domini (spazi dei nomi), come mostrato nello
screenshot seguente, dalla scheda contenuti del Manuale di riferimento FlexPendant SDK. Il
nome di un dominio ti dice qualcosa sul tipo di servizi che puoi aspettarti da esso.
6.4.1_1FP-Na


Continua
CAPI e domini del controller

Questa è un'illustrazione semplificata di come alcuni domini ABB.Robotics.Controllers
comunicano con i rispettivi domini nel controller del robot:
6.4.1_2Contr
Nota
Nel caso normale, viene creato e utilizzato un singolo oggetto Controller in tutta
l'applicazione, la cui durata corrisponde a quella dell'applicazione.
Quali funzionalità del controller vengono fornite?

Numerose funzionalità del controller robot sono offerte dalle classi e dai metodi dell'SDK
FlexPendant.
Questa tabella presenta brevi descrizioni del tipo di servizi forniti dai diversi domini CAPI:
Dominio CAPI Servizi
Controllori Informazioni sul controller, come indirizzo IP, utente corrente, indirizzo Mac,
modalità operativa, stato del controller e così via. Notifica in caso di modifica
della modalità operativa, dello stato o della padronanza. Backup e ripristino.
Controlla se hai la borsa di studio UAS richiesta e così via.
DominioConfigurazione Leggere o scrivere il valore di un parametro di configurazione nel database di

configurazione del controller.
Dominio registro eventi Notifica quando un nuovo messaggio di registro eventi è stato scritto nel controller.
Titolo, messaggio, categoria, numero di sequenza e timestamp del messaggio.
DominioFileSystem Creare, rinominare o rimuovere file e directory nel file system del controller.
Recuperare un file dal controller e memorizzarlo sul Flex-Pendant e viceversa.
IOSystemDomain Leggere e modificare i segnali I/O. Notifica quando il valore di un segnale

è cambiato.
MotionDomain Ottenere/impostare il sistema di coordinate e la modalità di movimento per il

jogging dell'unità meccanica attiva. Informazioni se l'unità meccanica è calibrata
o meno. Fornire nome, attività, numero di assi, strumento attivo e oggetto di
lavoro e così via. dell'unità meccanica. Avvisa quando i dati dell'unità meccanica
sono cambiati. Inviare una richiesta di avvio o arresto jogging al controller del
robot.


Continua
Dominio CAPI Servizi
RapidDomain Notifica quando lo stato di esecuzione è cambiato. Avvia e arresta

l'esecuzione RAPID. Carica programmi rapidi. Crea, leggi e scrivi
dati RAPID. Notifica quando i dati RAPID o il programma RAPID sono
cambiati. Notifica quando il puntatore del programma è cambiato.
Cerca simboli RAPID e così via.
Dominio informazioni di sistema Informazioni sul sistema attivo del controller robot, ad esempio
versione RobotWare, nome del sistema, versione e percorsi del
sistema, opzioni di sistema esistenti e opzioni aggiuntive installate.
Liberare la memoria
Utilizzando CAPI creerai oggetti che fanno riferimento a risorse non gestite. (Per ulteriori
informazioni, vedere Definizioni a pagina 17.) È necessario deallocare esplicitamente la memoria
di tali oggetti chiamando il relativo metodo Dispose quando non sono più necessari (al più tardi alla
chiusura dell'applicazione). Altrimenti l'applicazione perderà memoria, che è una risorsa scarsa
sulla piattaforma FlexPendant.
Nota
È possibile prevenire perdite di memoria e altri rischi studiando il capitolo

ABB.Robotics.Controllers a pagina 118.
Documentazione di riferimento dell'SDK FlexPendant

Sebbene questo manuale copra gran parte delle funzionalità dell'SDK FlexPendant, non è affatto
completo. Il Manuale di riferimento FlexPendant SDK, che si apre dal pulsante Start di Windows ,
è il riferimento completo alle funzionalità offerte dalle librerie di classi.
Fornisce inoltre preziosi esempi di codice e osservazioni sui metodi che richiedono diverse
sovvenzioni UAS e così via, che non sono inclusi in questo manuale.


5.5.2 Accesso al controllore
Panoramica
L'utilizzo delle funzionalità del controller richiede un'attenzione particolare. L'eliminazione degli oggetti CAPI
quando si chiude una vista o l'intera applicazione è fondamentale per risparmiare memoria.
Un'altra trappola da evitare è l'aggiornamento dell'interfaccia utente su un thread di lavoro.
Istanza del controllore
Prima di accedere alla funzionalità del controller è necessario istanziare l'oggetto Controller. Il posto migliore
per farlo è normalmente nel metodo Install, che viene chiamato da TAF dopo l'esecuzione del costruttore della
classe della vista.
La dichiarazione del Controller dovrebbe essere fatta a livello di ambito della classe:
V.B.:
AController privato come controller
C#:
titolare del trattamento privato aTitolare;
La raccomandazione è di istanziare l'oggetto Controller nel metodo Install:
V.B.:
AController = Nuovo controller
C#:
aController = nuovo Controller();
Utilizzando l'oggetto Controller è possibile accedere ai segnali IO, alle variabili dati RAPID, ai messaggi del
registro eventi e così via. La maggior parte di questi oggetti verrà creata in modo esplicito e dovrà essere
eliminata in modo esplicito.
Nota
Evitare di inserire codice che potrebbe generare un'eccezione prima del metodo InitializeComponent.
Quindi almeno hai un'interfaccia utente, in cui puoi visualizzare un MessageBox con informazioni su
cosa è andato storto.
Nota
Se è necessario che più classi accedano al controller, si consiglia di fare riferimento tutte allo stesso oggetto
Controller.
Iscrizione agli eventi del controller

L'oggetto Controller fornisce diversi eventi pubblici, che consentono di ascoltare i cambiamenti della modalità
operativa, i cambiamenti dello stato del controller, i cambiamenti di mastership e così via
SU.
V.B.:
AddHandler AController.OperatingModeChanged, AddressOf UpdateOP

AddHandler AController.StateChanged, AddressOf UpdateState
AddHandler AController.MastershipChanged, AddressOf UpdateMast



Continua
AddHandler AController.BackupFinish, AddressOf UpdateBack
C#:
AController.OperatingModeChanged += nuovo
OperatingModeChangedEventHandler(UpdateOP);
AController.MastershipChanged += nuovo
MastershipChangedEventHandler(UpdateMast);
Controller.BackupFinish += nuovo
BackupFinishEventHandler(UpdateBack);
Controller.StateChanged += new
StateChangedEventHandler(UpdateState);
Nota
Gli eventi del controller utilizzano i propri thread. Studia eventi e thread di Controller a pagina 51
per scoprire come evitare conflitti di thread.
ATTENZIONE
Non fare affidamento sulla ricezione di un evento iniziale quando si imposta/attiva un evento del
controller. Non vi è alcuna garanzia che venga attivato un evento, quindi è meglio leggere lo stato
iniziale dal controller.
Creazione di un backup
Utilizzando l'oggetto Controller è possibile chiamare il metodo Backup. L'argomento è una stringa
che descrive il percorso della directory sul controller in cui deve essere archiviato il backup. Poiché
il processo di backup viene eseguito in modo asincrono, è possibile aggiungere un gestore eventi
per ricevere un evento BackupCompleted al completamento del backup.
V.B.:
Dim BackupDir As String = "(BACKUP)$"+BackupDirName

AddHandler Me.AController.BackupCompleted, AddressOf
AController_BackupCompleted)
Me.AController.Backup(BackupDir)
C#:
stringa backupDir = "(BACKUP)$"+backupDirName;
this.aController.BackupCompleted += nuovo
BackupEventHandler(controller_BackupCompleted);
this.aController.Backup(backupDir);
Nota
È disponibile anche un metodo di ripristino. Il Manuale di riferimento FlexPendant
SDK è la guida completa alla programmazione dell'SDK FlexPendant ed è più dettagliata di questo
manuale. Per i metodi Backup e Ripristino, ad esempio, ci sono descrizioni di parametri, commenti,
esempi di codice e così via.
Smaltire
L'eliminazione dell'oggetto Controller deve essere eseguita nel metodo Uninstall o Dispose della
classe di visualizzazione dell'applicazione.


Continua
Verificare innanzitutto che lo smaltimento non sia già stato effettuato. Non dimenticare di rimuovere
eventuali sottoscrizioni agli eventi del controller prima della chiamata Dispose():
V.B.:
Se non AController non è niente, allora

RemoveHandler AController.OperatingModeChanged, AddressOf OpMChange
AController.Dispose()
AController = Niente
Finisci se
C#:
se (aController!= null)
{
aController.OperatingModeChanged -= nuovo
OperatingModeChangedEventHandler(OpMChange);
aController.Dispose();
aController = null;
}
ATTENZIONE
I programmatori VB devono essere consapevoli che è un po' complicato utilizzare

WithEvents insieme al pattern Dispose sulla piattaforma .NET. Quando si utilizza
WithEvents, .NET Framework rimuove automaticamente tutte le sottoscrizioni quando l'oggetto
è impostato su Nothing. Se osservi il codice dell'esempio precedente, che NON utilizza
WithEvents, capirai perché tale comportamento causa problemi. Quando il riferimento al
controller è impostato su Nothing e .NET Framework tenta di rimuovere la relativa
sottoscrizione, l'oggetto controller interno è già stato rimosso dalla chiamata Dispose
nell'istruzione precedente e viene generata un'eccezione NullReferenceException. Questo non
è specifico dell'SDK FlexPendant, ma è un problema di Microsoft. Per evitarlo si consiglia di
utilizzare AddHandler e RemoveHandler come nell'esempio.

5.5.3.1 Lavorare con dati RAPID
5.5.3 Dominio rapido
Panoramica
Lo spazio dei nomi RapidDomain consente l'accesso ai dati RAPID nel sistema robotico.
Esistono numerose classi SDK FlexPendant che rappresentano i diversi tipi di dati RAPID. Esiste anche una
classe UserDefined utilizzata per fare riferimento alle strutture RECORD in RAPID.
L'evento ValueChanged abilita la notifica da parte del controller quando i dati RAPID persistenti sono cambiati.
Mancia
Un modo comodo e intuitivo per consentire all'utente finale dell'applicazione di leggere e scrivere su dati
RAPID specifici è utilizzare la visualizzazione standard dei dati del programma FlexPendant. Per ulteriori
informazioni, vedere Utilizzo della finestra di dialogo standard per modificare i dati a pagina 116.
Mancia
L'utilizzo dell'associazione dati per i dati RAPID rappresenta un modo rapido per implementare l'accesso
ai dati RAPID. Per ulteriori informazioni, vedere Dati RAPID e segnali IO a pagina 107.
Fornire il percorso ai dati RAPID

Per leggere o scrivere su dati RAPID è necessario prima creare un oggetto RapidData. Come argomento viene
passato il percorso alla dichiarazione dei dati nel controller. Se non conosci il percorso devi cercare i dati RAPID
utilizzando la funzionalità SearchRapidSymbol. Per ulteriori informazioni, vedere Metodo
SearchRapidSymbol a pagina 139.
Accesso diretto
L'accesso diretto richiede meno memoria ed è più veloce ed è pertanto consigliato se non è necessario utilizzare
successivamente gli oggetti attività e modulo.
L'esempio seguente mostra come creare un oggetto RapidData che fa riferimento all'istanza dati RAPID “reg1”
nel modulo USER.
V.B.:
Dim Rd As RapidData = Me.AController.Rapid.GetRapidData( "T_ROB1", "USER", "reg1")
C#:
RapidData rd = aController.Rapid.GetRapidData("T_ROB1", "UTENTE",

"reg1");
Accesso gerarchico
Se sono necessari oggetti attività e moduli, l'accesso gerarchico può essere più efficiente.
GetRapidData esiste nelle classi Rapid, Task e Module.


Continua
V.B.:
Rd = AController.Rapid.GetTask("T_ROB1").GetModule("USER").
OttieniRapidData("reg1")
C#:
rd = aController.Rapid.GetTask("T_ROB1").GetModule("USER").
GetRapidData("reg1");
Accesso ai dati dichiarati in un modulo condiviso Se

l'applicazione deve essere utilizzata con un sistema multi-move (un sistema con un controller e
diversi task/robot di movimento), può accadere che l'istanza RAPID a cui è necessario accedere sia
dichiarata in un - Modulo RAPID condiviso. Tale modulo può essere utilizzato da tutti i task,
T_ROB1, T_ROB2 e così via.
L'esempio seguente mostra come creare un oggetto RapidData che fa riferimento all'istanza
"reg100", dichiarata in un modulo condiviso.
V.B.:
Dim Rd As RapidData = Me.AController.Rapid.GetRapidData("reg100")

C#:
RapidData rd = aController.Rapid.GetRapidData("reg100");
Un'altra possibilità è utilizzare l'oggetto Task per accedere all'istanza RAPID, in questo modo:
Attività tRob1 = aController.Rapid.GetTask("T_ROB1"); RapidData rData =

tRob1.GetRapidData("reg100");
Nota
Se GetRapidData viene chiamato da Rapid, i dati RAPID verranno trovati anche se il modulo
-Shared è configurato per essere nascosto.
Nota
Se i dati RAPID non esistono, il valore restituito è Nothing/null e viene generata

un'ArgumentNullException. È necessario eseguire un controllo nullo prima di provare a utilizzare
l'oggetto.
Creazione di un oggetto che rappresenta il valore dei dati RAPID

L'oggetto RapidData memorizza il percorso dei dati RAPID. Ma questo non basta se vuoi accedere
al suo valore (almeno non se vuoi modificarlo). Per fare ciò è necessario creare un altro oggetto,
che rappresenta il valore dei dati RAPID.
Nello spazio dei nomi RapidDomain sono presenti tipi che rappresentano i diversi tipi di dati RAPID.
Per creare l'oggetto necessario per rappresentare il valore dei dati RAPID, utilizzare la proprietà
RapidData Value e trasmetterla al tipo corrispondente, ad esempio Num, Bool o Tooldata.
Il codice seguente spiega come eseguire questa operazione se si desidera accedere al valore di un
dato RAPID del tipo di dati RAPID bool:


Continua
V.B.:
'dichiara una variabile di tipo dati RapidDomain.Bool
Dim rapidBool Come RapidDomain.Bool
Dim rd As RapidData = Me.AController.Rapid.GetRapidData( "T_ROB1", "MainModule", "flag" )
'verifica che il tipo di dati sia corretto prima del cast

Se TypeOf rd.Value è RapidDomain.Bool Allora
rapidBool = DirectCast(rd.Value, RapidDomain.Bool)
'controlla se il valore dei dati RAPID è vero
Se (rapidBool.Value) Allora
'
Fare qualcosa...
Finisci se
Finisci se
C#:
//dichiara una variabile di tipo dati RapidDomain.Bool RapidDomain.Bool rapidBool;
RapidDomain.RapidData rd =
aController.Rapid.GetRapidData("T_ROB1", "MainModule", "flag"); //verifica che il tipo di dati sia corretto prima
del cast se (rd.Value è
ABB.Robotics.Controllers.RapidDomain.Bool)
{
rapidBool = (ABB.Robotics.Controllers.RapidDomain.Bool)rd.Value; //assegna il valore dei dati RAPID a una
variabile locale
bool boolValue = rapidBool.Value;
}
Se vuoi solo leggere questa variabile puoi usare questa tecnica invece di creare un oggetto RapidDomain.Bool:
V.B.:
Dim b As Boolean = Convert.ToBoolean(rd.Value.ToString)
C#:
bool b = Convert.ToBoolean(rd.Value.ToString());
Il tipo ToolData (che rappresenta il tipo di dati RAPID tooldata) può essere creato in questo modo:
V.B.:
Dim ATool come ToolData
Se Rd.Value è ToolData allora
ATool = DirectCast(Rd.Value, ToolData)

Finisci se
C#:
ToolData aTool;
if (rd.Value è ToolData)
{
aTool = (ToolData) rd.Value;
}



Continua
Metodo IRapidData.ToString
Tutte le strutture RapidDomain che rappresentano i tipi di dati RAPID implementano
l'interfaccia IRapidData. Ha un metodo ToString, che restituisce il valore dei dati RAPID sotto
forma di stringa. Questo è un semplice esempio:
string boolValue = rapidBool.ToString();
La stringa viene formattata secondo lo stesso principio descritto nella sezione successiva Metodo
IRapidData.FillFromString a pagina 127.
Ecco un esempio di un tipo di dati più complesso. La proprietà ToolDataTframe è di tipo Pose. Il
suo valore Trans viene visualizzato in un'etichetta nel formato [x, y, z].
V.B.:
Me.Label1.Text = ATool.Tframe.Trans.ToString()
C#:
this.label1.Text = aTool.Tframe.Trans.ToString();
Metodo IRapidData.FillFromString
L'interfaccia IRapidData dispone inoltre di un metodo FillFromString, che riempie l'oggetto con
una rappresentazione di stringa RAPID valida. Il metodo può sempre essere utilizzato quando è
necessario modificare i dati RAPID. Utilizzando il metodo con la variabile
RapidDomain.Bool utilizzata in precedenza nel capitolo apparirà così:
rapidBool.FillFromString("Vero")
Usarlo per una variabile RapidDomain.Num è simile:

rapidNum.FillFromString("10")
Formato stringa
Il formato è costruito in modo ricorsivo. Un esempio è il modo più semplice per illustrarlo.
Esempio:
La struttura RapidDomain.Pose corrisponde al tipo di dati RAPID pose, che descrive come un
sistema di coordinate viene spostato e ruotato attorno a un altro sistema di coordinate.
struttura pubblica Posa: IRapidData

{Pos pubblico trans; marciume pubblico dell’Oriente;
}
Questo è un esempio in RAPID:

Fotogramma posa VAR1;
...
fotogramma1.trans := [50, 0, 40];
frame1.rot := [1, 0, 0, 0];
Alla trasformazione delle coordinate frame1 viene assegnato un valore che corrisponde a uno
spostamento nella posizione in cui X=50 mm, Y=0 mm e Z=40 mm. Non c'è rotazione.
Come vedi, la struttura RapidDomain.Pose è composta da altre due strutture, trans e rot. La
struttura trans è composta da tre galleggianti e la struttura marciume
è composto da quattro doppie. Il formato FillFromString per un oggetto Pose è "[[1.0,



Continua
0.0, 0.0, 0.0][10.0, 20.0, 30.0]]”. Questo pezzo di codice mostra come scrivere un nuovo valore in una variabile
di posa RAPID:
V.B.:
Se TypeOf rd.Value è Pose Allora

Dim rapidPose As Pose = DirectCast(rd.Value, Pose)
rapidPose.FillFromString("[[1.0, 0.0, 0.0, 0.0][10, 20, 30]]")
rd.Value = rapidPose
Finisci se
C#:
if (rd.Value è Posa)
{
Posa rapidPose = (Posa) rd.Value;
rapidPose.FillFromString("[[1.0, 0.5, 0.0, 0.0][10, 15, 10]]"); rd.Value = rapidPose;
Nota
Utilizzando lo stesso principio è possibile rappresentare tipi di dati RAPID arbitrariamente lunghi.
Nota
Il formato della stringa deve essere attentamente osservato. Se l'argomento stringa ha il formato
sbagliato, viene lanciata un'eccezione RapidDataFormatException.
Scrittura su dati RAPID La

scrittura su dati RAPID è possibile solo utilizzando il valore Cast RapidData di tipo, al quale viene assegnato
il nuovo valore. Per trasferire il nuovo valore ai dati RAPID nel controller è necessario infine assegnare
l'oggetto .NET alla proprietà Value dell'oggetto RapidData. L'esempio seguente utilizza l'oggetto rapidBool
creato in Creazione di un oggetto che rappresenta il valore dei dati RAPID a pagina 125.
V.B.:
'Assegna un nuovo valore alla variabile .Net

rapidBool.Value = Falso
'Scrivi il nuovo valore nei dati nel controller
rd.Value = rapidBool
C#:
//Assegna un nuovo valore alla variabile .Net

rapidBool.Value = falso; //Scrive un
nuovo valore nei dati nel controller
rd.Value = rapidBool;
Questo era un esempio semplice, poiché il valore da modificare era un semplice bool. Spesso, tuttavia,
RAPID utilizza strutture complesse. Utilizzando il metodo FillFromString è possibile assegnare un nuovo valore
a qualsiasi RapidData e scriverlo nel controller.
La stringa deve essere formattata secondo il principio descritto nella sezione precedente. L'esempio seguente
mostra come scrivere un nuovo valore nella struttura pos (x, y, z) di un tooldata RAPID:
V.B.:



Continua
Dim APos As Pos = Nuova Pos
APos.FillFromString("[2,3,3]")
Me.ATool.Tframe.Trans = APos
Me.Rd.Value = Me.ATool
C#:
Pos aPos = nuova Pos();
aPos.FillFromString("[2,3,3]");
this.aTool.Tframe.Trans = aPos;
this.rd.Value = this.aTool;
Nota
Il nuovo valore non viene scritto nel controller finché non viene eseguita l'ultima istruzione.
Comunicare all'utente che i dati RAPID sono cambiati

Per essere avvisato che i dati RAPID sono cambiati è necessario aggiungere una sottoscrizione all'evento
ValueChanged dell'istanza RapidData. Tieni presente, tuttavia, che ciò funziona solo per i dati RAPID
persistenti.
Aggiungi abbonamento
Il codice seguente spiega come aggiungere una sottoscrizione all'evento ValueChanged:
V.B.:
Addhandler Rd.ValueChanged, AddressOf Rd_ValueChanged

C#:
this.rd.ValueChanged += rd_ValueChanged;
Gestire l'evento
Implementare il gestore eventi. Ricordare che gli eventi del controller utilizzano i propri thread ed evitare
problemi di threading di Winforms utilizzando Control.Invoke, che forza l'esecuzione dal thread in background
al thread della GUI.
V.B.:
Private Sub Rd_ValueChanged(ByVal mittente As Object, ByVal e As

DataValueChangedEventArgs)
Me.Invoke (Nuovo EventHandler (AddressOf UpdateGUI), mittente, e)
Fine sott
C#
private void rd_ValueChanged(mittente dell'oggetto,

DataValueChangedEventArgs e)
{
this.Invoke(nuovo EventHandler (UpdateGUI), mittente, e);
}
Per ulteriori informazioni sui potenziali conflitti di threading nelle applicazioni SDK FlexPendant,
vedere Eventi e thread del controller a pagina 51.
Leggere il nuovo valore dal controller
Aggiorna l'interfaccia utente con il nuovo valore. Poiché il valore non fa parte dell'argomento dell'evento, devi
utilizzare la proprietà RapidDataValue per recuperare il nuovo valore:



Continua
V.B.:
Private Sub UpdateGUI(mittente ByVal As Object, ByVal e As System.EventArgs)
Dim Tool1 As ToolData = DirectCast(Me.Rd.Value, ToolData)

Me.Label1.Text = Tool1.Tframe.Trans.ToString()
Fine sott
C#
private void UpdateGUI(mittente oggetto, System.EventArgs e)
{
ToolData tool1= (ToolData)this.rd.Value;
this.label1.Text = tool1.Tframe.Trans.ToString();
}
Nota
Gli abbonamenti funzionano solo per i dati RAPID dichiarati come PERS.
Smaltimento RapidData
Smaltire sempre gli oggetti RapidData quando non sono più necessari. Se desideri riutilizzare
un oggetto RapidData, dovresti assicurarti di eliminare prima l'oggetto corrente.
V.B.:
Se Not Rd non è niente, allora

Rd.Dispose()
Rd = Niente
Finisci se
C#:
se (rd!= nullo)
{
rd.Dispose();
rd = nullo;
}

5.5.3.2 Gestione degli array RAPID
Panoramica
In RAPID puoi avere fino a tre array dimensionali. Questi sono accessibili utilizzando un oggetto RapidData
come qualsiasi altro dato RAPID.
Esistono principalmente due modi per accedere a ogni singolo elemento di un array: tramite indicizzatori o
tramite un enumeratore.
Mancia
Un modo comodo e intuitivo per leggere e scrivere elementi dell'array è utilizzare la visualizzazione standard
dei dati di programma della FlexPendant. Fornisci l'elemento che desideri venga visualizzato come argomento
e l'utente può visualizzare o manipolare l'elemento nel modo in cui viene solitamente eseguito sulla
FlexPendant. Per ulteriori informazioni, vedere Utilizzo della finestra di dialogo standard per modificare i dati
a pagina 116.
Oggetto ArrayData
Se RapidData fa riferimento a un array RAPID, la proprietà Value restituisce un oggetto di tipo ArrayData. Prima
di effettuare un cast, controlla il tipo utilizzando l'operatore is o utilizzando la proprietà IsArray sull'oggetto
RapidData.
V.B.:
Dim RD As RapidData = AController.Rapid.GetRapidData("T_ROB1",

"Utente", "array_stringa")
Se RD.IsArray allora
Dim AD come ArrayData = DirectCast( RD.Value,ArrayData)
.....
Finisci se
C#:
RapidData rd = aController.Rapid.GetRapidData("T_ROB1", "Utente",

"array_stringa");
se (rd.IsArray) {
Annuncio ArrayData = (ArrayData)rd.Value;

.....
}
Dimensioni della matrice

La dimensione dell'array viene restituita dalla proprietà Rank. Se è necessario verificare la lunghezza dei singoli
array è possibile utilizzare il metodo GetLength sull'oggetto ArrayData passando come argomento l'indice
della dimensione.
V.B.:
Dim ARank As Integer = AD.Rank Dim Len As

Integer = AD.GetLength(ARank)
C#:
int aRango = ad.Rango;

int len = ad.GetLength(aRank);



Continua
Accesso agli elementi dell'array utilizzando gli indicizzatori
Utilizzando gli indicizzatori è possibile accedere a ciascun elemento dell'array, anche in array
tridimensionali. Una combinazione del metodo GetLength e dei cicli For consente di accedere a qualsiasi elemento:
V.B.:
Dim aSum As Double = 0R

Dim aNum Come Num
Se ad.Rank = 1 Allora
For I As Integer = 1 To ad.Length

aNum = DirectCast(annuncio(i), Num)
aSomma += CDbl(aNum)
Prossimo
AltrimentiSe ad.Rank = 2 Allora
For i As Integer = 1 To ad.GetLength(1) - 1 For j As Integer = 1 To ad.Length
aNum = DirectCast(annuncio[i, j], Num)

Prossimo
Prossimo
Altro
For i As Integer = 1 To ad.GetLength(1) - 1

For j As Integer = 1 To ad.GetLength(2) - 1 For k As Integer = 1 To
ad.GetLength(3)
aNum = DirectCast(annuncio(i, j, k), Num)
Prossimo
Prossimo
Prossimo
Finisci se
C#:
doppio aSomma = 0d;

Num aNum;
if (ad.Rango == 1) {
for (int i = 1; i <= ad.Lunghezza; i++)
{
aNum = (Num)ad[i];
aSomma += (doppio)aNum;
}
}
altrimenti se (ad.Rank == 2)
{
for(int i = 1; i< ad.GetLength(1); i++)
{
for (int j = 1; j <= ad.Lunghezza; j++)
{
aNum = (Num)ad[i,j];
}
}



Continua
altro {
for(int i = 1; i< ad.GetLength(1); i++)
for(int j = 1; j< ad.GetLength(2); j++)
for (int k = 1; k <= ad.GetLength(3); k++)
aNum = (Num)ad[i, j, k]; aSomma +=
(doppio)aNum;
Accesso agli elementi dell'array tramite l'enumeratore

È anche possibile utilizzare l'operazione dell'enumeratore (foreach) come viene utilizzata dalle raccolte in .NET.
Si noti che può essere utilizzato sia per array monodimensionali che multidimensionali per accedere a ogni
singolo elemento. L'esempio precedente è molto più semplice in questo modo:
V.B.:
Dim aSum As Double = 0R
Dim aNum Come Num
Per ogni aNum come Num in AD
Prossimo
C#:
doppio aSomma = 0d;
Num aNum;
foreach(Num aNum nell'annuncio)


5.5.3.3 Metodi ReadItem e WriteItem
5.5.3.3 Metodi ReadItem e WriteItem
Panoramica
Un modo alternativo per accedere ai dati RAPID archiviati in un array sono i metodi ReadItem e
WriteItem.
Metodo ReadItem
Utilizzando il metodo ReadItem è possibile accedere direttamente a un elemento dati RAPID in un
array, ad esempio un array con RobTargets o Nums. L'indice dell'elemento è specificato
esplicitamente nella chiamata ReadItem. Il primo elemento è nella posizione 1, ovvero l'array è in
base 1 come in RAPID.
L'esempio seguente recupera il secondo valore Num nel primo array della variabile di dati RAPID
a cui fa riferimento rd.
V.B.:
Dim aNum Come Num
aNum = DirectCast(rd.ReadItem(1, 2), Num)
C#:
Num aNum = (Num)rd.ReadItem(1, 2);
Metodo WriteItem
È possibile utilizzare il metodo WriteItem per scrivere su un singolo elemento di dati RAPID in un
array. L'esempio seguente mostra come scrivere il risultato di una singola operazione del
robot in un array che rappresenta un programma robot totale con diverse operazioni:
V.B.:
Dim aNum As Num = Nuovo Num(OPERAZIONE_OK)
rd.WriteItem(aNum, 1, 2)
C#:
Num aNum = nuovo Num(OPERAZIONE_OK);
rd.WriteItem(aNum, 1, 2);
Nota
Se l'indice non è nell'intervallo specificato, verrà generata un'eccezione IndexOutOfRangeException.


5.5.3.4 Dati definiti dall'utente
Panoramica
Lavori spesso con strutture RECORD nel codice RAPID. Per gestire questi tipi di dati univoci, è stata
implementata una classe UserDefined. Questa classe ha proprietà e metodi per gestire i singoli componenti di
un RECORD.
In alcuni casi l'implementazione della propria struttura .NET può migliorare la progettazione dell'applicazione
e la manutenzione del codice.
Creazione dell'oggetto UserDefined Il

costruttore UserDefined accetta un oggetto RapidDataType come argomento. Per recuperare un oggetto
RapidDataType, viene passato come argomento il percorso della dichiarazione del tipo di dati RAPID.
L'esempio seguente crea un oggetto UserDefined che fa riferimento ai dati di processo RAPID RECORD:
V.B.:
Dim rdt As RapidDataType rdt =

Me.controller.Rapid.GetRapidDataType("T_ROB1", "MyModule", "processdata")
Dim processdata As UserDefined = New UserDefined(rdt)

C#
RapidDataType rdt;
rdt = this.controller.Rapid.GetRapidDataType("T_ROB1", "MyModule", "processdata");
Dati di processo UserDefined = new UserDefined(rdt);
Nota
Se il modulo in cui è definito RECORD è configurato come -Shared, fornisci solo il nome del tipo di dati
come argomento, in questo modo:
rdt = this.controller.Rapid.GetRapidDataType("processdata");
Lettura dei dati definiti dall'utente

È possibile utilizzare un oggetto UserDefined per leggere qualsiasi tipo di variabile RECORD dal controller.
I singoli componenti del RECORD sono accessibili tramite la proprietà Components e un indice. Ciascun
componente può essere letto come una stringa.
V.B.:
Dim processdata As UserDefined = DirectCast(rd.Value, UserDefined)

Dim No1 As String = processdata.Components(0).ToString()
Dim No2 AS String = processdata.Components(1),ToString()
C#:
datiprocesso UserDefined = (UserDefined) rd.Value;

stringa no1 = processdata.Components[0].ToString();
stringa no2 = processdata.Components[1].ToString();


Continua
Ogni singola stringa può quindi essere utilizzata in un metodo FillFromString per convertire il componente in
un tipo di dati specifico, ad esempio RobTarget o ToolData.
Per ulteriori informazioni, vedere Metodo IRapidData.FillFromString a pagina 127.
Scrittura nei dati UserDefined Se si

desidera modificare i dati UserDefined e scriverli nel RECORD nel controller, è necessario prima
leggere l'oggetto UserDefined e applicare i nuovi valori utilizzando il metodo FillFromString. Quindi esegui
un'operazione di scrittura utilizzando la proprietà RapidData.Value.
atC#:
processdata.Components[0].FillFromString("[0,0,0]"); processdata.Components[1].FillFromString("10");
rd.Valore = ud;
Per ulteriori informazioni ed esempi di codice, vedere metodo IRapidData.FillFromString e utilizzo di Rapid
Data.
Implementare la propria struttura che rappresenta un RECORD

L'esempio seguente mostra come creare il proprio tipo di dati .NET che rappresenta un RECORD nel
controller invece di utilizzare il tipo UsefDefined.
Creazione del tipo ProcessData

V.B.:
Dim rdt As RapidDataType = Me.ARapid.GetRapidDataType("T_ROB1", "MyModule", "processdata")
Dim p As ProcessData = Nuovo ProcessData(rdt)
p.FillFromString(rd.Value.ToString())
C#
RapidDataType rdt = this.aRapid.GetRapidDataType("T_ROB1",

"MyModule", "dati di processo");
ProcessData p = nuovo ProcessData(rdt);
p.FillFromString(rd.Value.ToString());
Implementazione della struttura ProcessData

L'esempio seguente mostra come può essere implementato il nuovo tipo di dati ProcessData. Questa
operazione viene eseguita utilizzando una struttura .NET e consentendo a ProcessData di racchiudere
l'oggetto UserDefined.
L'implementazione della struttura deve includere un metodo FillFromString e ToString, ovvero ereditare
l'interfaccia IRapidData. È inoltre possibile implementare qualsiasi proprietà e metodo.
V.B.:
ProcessData della struttura pubblica
Implementa IRapidData
Dati privati come definiti dall'utente
Sottotitolo pubblico nuovo (ByVal rdt come RapidDataType)

dati = Nuovo definito dall'utente(rdt)
Fine sott
Proprietà privata IntData() come definito dall'utente



Continua
Ottenere
Restituire i dati
Fine Ottieni
Set (valore ByVal come definito dall'utente)

dati = valore
Fine impostazione
Fine proprietà
.....
Fine struttura
C#:
struttura pubblica ProcessData: IRapidData
{
dati privati definiti dall'utente; ProcessData
pubblico(RapidDataType rdt)
{
dati = nuovo UserDefined(rdt);
}
privato UserDefined IntData
{
ottieni { restituisci i dati; }
imposta { dati = valore; }
}
public int StepOne
{
Ottenere
{
int res = Convert.ToInt32(IntData.Components[0].ToString());
restituire res;
}
impostato
{
IntData.Components[0] = nuovo Num(valore);
}
}
}
Implementazione dei metodi IRapidData

La parte di codice seguente mostra come è possibile implementare i due metodi IRapidData
ToString e FillFromString.
V.B.:
Implementa Public Sub FillFromString(ByVal newValue As String).

ABB.Robotics.Controllers.RapidDomain.IRapidData.FillFromString
IntData.FillFromString(newValue)
Fine sott
La funzione pubblica esegue l'override ToString() come implementazione di stringa

ABB.Robotics.Controllers.RapidDomain.IRapidData.ToString
Restituisce IntData.ToString()
Fine funzione
C#:
public void FillFromString(string newValue)



Continua
{
IntData.FillFromString(newValue);
}
stringa di override pubblica ToString()
{
return IntData.ToString();
}
NOTA! Il metodo ToString deve utilizzare la parola chiave Overrides in Visual Basic e la parola chiave
override in C#.
Implementazione della proprietà

Ogni elemento nella struttura RECORD deve avere una proprietà corrispondente nel tipo di dati .NET
esteso. I metodi get e set devono implementare la conversione da/a tipo di dati del controller in
tipo di dati .NET.
V.B.:
Proprietà pubblica Step() come numero intero
Ottenere
Dim res As Integer =

Convert.ToInt32(IntData.Components(0).ToString())
Ritorno ris
Fine Ottieni
Set (valore ByVal come numero intero)

Dim tmp As Num = Nuovo Num
tmp.FillFromNum(Valore)
IntData.Components(0) = tmp
Fine impostazione
Fine proprietà
C#:
public int Passo

{
Ottenere
{
int res = Convert.ToInt32(IntData.Components[0].ToString());
restituire res;
}
impostato
{
Numtmp = nuovo Num();
tmp.FillFromNum(valore);
IntData.Components[0] = tmp;
}
}


5.5.3.5 Ricerca RAPIDA di simboli
Panoramica
La maggior parte degli elementi RAPID (variabili, moduli, attività, record e così via) sono membri di una
tabella di simboli, nella quale i relativi nomi vengono memorizzati come parte di una struttura ad
albero del programma.
È possibile eseguire una ricerca in questa tabella e ottenere una raccolta di oggetti RapidSymbol, ognuno
dei quali include il nome, la posizione e il tipo dell'oggetto RAPID.
Metodo SearchRapidSymbol La
ricerca deve essere configurata con attenzione, a causa della grande quantità di simboli RAPID presenti in
un sistema. Per definire una query è necessario considerare da dove nell'albero del programma deve
essere eseguita la ricerca, quali simboli sono di interesse e quali informazioni sono necessarie per i
simboli di interesse. Per abilitare la ricerca da diversi livelli, il metodo SearchRapidSymbol è membro di
diverse classi SDK, ad esempio Task, Module e Routine . L'esempio seguente mostra una ricerca eseguita
con Task come punto di partenza:
V.B.:
Dim RSCol As RapidSymbol()

RSCol = ATask.SearchRapidSymbol(SProp, "num", string.Empty)
C#:
RapidSymbol[] rsCol;
rsCol = aTask.SearchRapidSymbol(sProp, "num", string.Empty);
Il metodo SearchRapidSymbol ha tre argomenti. Il primo argomento, del tipo di dati

RapidSymbolSearchProperties, è dettagliato nella sezione successiva. Il secondo e il terzo argomento sono
dettagliati nelle sezioni seguenti.
Cerca immobili
Il tipo RapidSymbolSearchProperties è complesso e richiede una certa conoscenza dei concetti
RAPID.
Viene utilizzato per specificare il metodo di ricerca, il tipo di simbolo RAPID da cercare, se la ricerca deve
essere ricorsiva, se i simboli sono locali e/o globali e se il risultato della ricerca deve includere o meno solo i
simboli attualmente utilizzati da un programma. Se una proprietà non è valida per un particolare simbolo,
verrà scartata e non escluderà il simbolo dal risultato della ricerca.
La tabella descrive le diverse proprietà di RapidSymbolSearchProperties.
Proprietà Descrizione
Metodo di ricerca Specifica la direzione della ricerca, che può essere Blocca (giù) o Ambito (su).
Esempio: se il punto iniziale della ricerca è una routine, una ricerca a blocchi
restituirà i simboli dichiarati all'interno della routine, mentre una ricerca
nell'ambito restituirà i simboli accessibili dalla routine.


Continua
Tipo di simbolo Specifica quali tipi RAPID si desidera cercare. L'enumerazione

SymbolTypes include Constant, Variable, Persistent, Function, Procedure,
Trap, Module, Task, Routine, RapidData. e così via. (La routine include Funzione,
Procedura e Trappola. RapidData include Costante, Variabile e Persistente.)
Ricorsivo Sia per la ricerca a blocchi che per quella per ambito è possibile scegliere se la
ricerca deve fermarsi al livello di ambito o blocco successivo o continuare
ricorsivamente fino a raggiungere la radice (o foglia) dell'albero della tabella dei simboli.
GlobalRapidSymbol Specifica se i simboli globali devono essere inclusi.
LocalRapidSymbol Specifica se i simboli locali devono essere inclusi.
IsInUse Specifica se devono essere ricercati solo i simboli utilizzati dal programma RAPID
caricato.
Istanza predefinita
RapidSymbolSearchProperties ha un metodo statico, che restituisce un'istanza predefinita.
V.B.:
Dim SPprop As RapidSymbolSearchProperties =
RapidSymbolSearchProperties.CreateDefault()
C#:
RapidSymbolSearchProperties sProp =
RapidSymbolSearchProperties.CreateDefault();
L'istanza predefinita ha i seguenti valori:.
Metodo di ricerca SymbolSearchMethod.Block
Tipo di simbolo SymbolTypes.NoSymbol
Ricorsivo VERO
GlobalRapidSymbol VERO
LocalRapidSymbol VERO
IsInUse VERO
Utilizzando questa istanza puoi specificare le proprietà di ricerca della ricerca che desideri
eseguire.
Esempio:
V.B.:
SPprop.SearchMethod = SymbolSearchMethod.Scope
SPprop.SymbolType = SymbolTypes.Constant o SymbolTypes.Persistent
SPprop.Recursive = Falso
C#:
sProp.SearchMethod = SymbolSearchMethod.Scope;
sProp.SymbolType = SymbolTypes.Constant | SymbolTypes.Persistent
sProp.Recursive = falso;


Continua
Nota
L'istanza predefinita ha la proprietà SymbolType impostata su NoSymbol, il che significa che è

necessario specificarla per eseguire una ricerca significativa.
Nota
La proprietà SymbolType consente di combinare diversi tipi nella ricerca.

Per ulteriori informazioni, vedere l'esempio precedente.
Argomento del tipo di dati

Il secondo argomento del metodo SearchRapidSymbol è il tipo di dati RAPID scritto come stringa. Il
tipo di dati deve essere scritto con lettere minuscole, ad esempio "num", "string" o "robtarget". Può
anche essere specificato come string.Empty.
Nota
Per cercare un tipo di dati UserDefined è necessario passare il percorso completo al modulo che
contiene la definizione RECORD. Per esempio:
risultato =
tRob1.SearchRapidSymbol(sProp,"RAPID/T_ROB1/MyModule/MyDataType", string.Empty);
Tuttavia, se MyModule è configurato come -Shared, il sistema vede i suoi tipi di dati come installati
e l'attività o il modulo non devono essere inclusi nel percorso
risultato = tRob1.SearchRapidSymbol(sProp,"MyDataType", string.Empty);
Argomento del nome del simbolo

Il terzo argomento è il nome del simbolo RAPID. Può essere specificato come string.Empty se
non si conosce il nome del simbolo da recuperare o se lo scopo è cercare TUTTE le istanze “num”
nel sistema.
Al posto del nome del simbolo RAPID è possibile utilizzare un'espressione regolare. Il meccanismo
di ricerca abbinerà quindi il modello dell'espressione regolare ai simboli nella tabella dei simboli. La
stringa dell'espressione regolare non fa distinzione tra maiuscole e minuscole.
Un'espressione regolare è un meccanismo potente. Può essere costituito da caratteri ordinari e

metacaratteri. Un metacarattere è un operatore utilizzato per rappresentare uno o più caratteri
ordinari e lo scopo è estendere la ricerca.
All'interno di un'espressione regolare, tutti i caratteri alfanumerici corrispondono a se stessi, ovvero il

modello "abc" corrisponderà solo a un simbolo denominato "abc". Per abbinare tutti i nomi di simboli
contenenti la sequenza di caratteri “abc”, è necessario aggiungere alcuni metacaratteri. L'espressione
regolare per questo è “.*abc.*”.
Il set di metacaratteri disponibile è mostrato nella tabella seguente:
Espressione Senso
. Qualsiasi singolo carattere
^
Qualsiasi simbolo che inizia con


Continua
Espressione Senso
[S] Qualsiasi singolo carattere nell'insieme non vuoto s, dove s è una

sequenza di caratteri. Gli intervalli possono essere specificati come cc.
[^s] Qualsiasi singolo carattere non presente nel set s.
R* Zero o più occorrenze dell'espressione regolare r.

r+ Una o più occorrenze dell'espressione regolare r.
R? Zero o una occorrenza dell'espressione regolare r.
(R) L'espressione regolare r. Utilizzato per separare un'espressione regolare

da un'altra.
r | R' Le espressioni regolari r o r'.

.* Qualsiasi sequenza di caratteri (zero, uno o più caratteri).
Esempio 1
"^c.*"
Restituisce tutti i simboli che iniziano con c o C.
Esempio 2
"^reg[1-3]"
Restituisce reg1, Reg1, REG1, reg2, Reg2, REG2, reg3, Reg3 e REG3.
Esempio 3
"^c.*|^reg[1,2]"
Restituisce tutti i simboli che iniziano con c o C nonché reg1, Reg1, REG1, reg2, Reg2 e REG2.
Esempio SearchRapidSymbol
L'esempio seguente ricerca i dati num VAR, PERS o CONST in un'attività e nei relativi moduli.
La ricerca è limitata ai simboli dichiarati globalmente. Per impostazione predefinita il metodo
di ricerca è Blocca, quindi non è necessario impostarlo.
V.B.:
Dim sProp As RapidSymbolSearchProperties =

sProp.SymbolTypes = SymbolTypes.RapidData
sProp.LocalRapidSymbol = Falso
Dim rsCol As RapidSymbol()
rsCol = aTask.SearchRapidSymbol(sProp, "num", string.Empty)
C#:
sProp.SymbolType = SymbolTypes.RapidData;
sProp.LocalRapidSymbol = falso;
RapidSymbol[] rsCol;
rsCol = aTask.SearchRapidSymbol(sProp, "num", string.Empty);


Continua
Cerca dati RAPID definiti dall'utente - esempio

Nell'esempio seguente un tipo di dati RECORD definito dall'utente ("mydata") viene dichiarato in un modulo
("myModule"). Supponendo che l'utente finale possa dichiarare e utilizzare dati di questo tipo in qualsiasi
modulo di programma, il metodo di ricerca deve essere Blocca (predefinito).
Una ricerca per tutte le istanze "mydata" potrebbe assomigliare a questa:
V.B.:
Dim sProp As RapidSymbolSearchProperties =
sProp.SymbolType = SymbolTypes.RapidData
Dim rsCol As RapidSymbol()
rsCol = aTask.SearchRapidSymbol(sProp,
"RAPID/T_ROB1/mioModulo/mieidati", stringa.Empty)
C#:
sProp.SymbolType = SymbolTypes.RapidData; RapidSymbol[]
rsCol;
rsCol = aTask.SearchRapidSymbol(sProp, "RAPID/
T_ROB1/myModule/mydata", string.Empty);
Nota
Se myModule è configurato come -Shared e tutte le istanze myData sono dichiarate in myModule, il
metodo di ricerca deve essere impostato su Scope e il metodo
La chiamata SearchRapidSymbol dovrebbe assomigliare a questa:
rsCol = aTask.SearchRapidSymbol(sProp, "mydata", string.Empty);


5.5.3.6 Esecuzione RAPIDA
Avvia e arresta i programmi RAPID

È possibile avviare e arrestare l'esecuzione RAPID utilizzando i metodi Rapid.Start e Stop.
Un StartResult dal metodo Start restituisce il risultato della chiamata. Inizio
si possono usare argomenti. RegainMode definisce il modo in cui l'unità meccanica deve gestire lo stato del
percorso all'avvio. ExecutionMode specifica se il programma deve essere eseguito continuamente, tornare
indietro o passare all'istruzione Move successiva e così via.
Il metodo Stop può includere un argomento StopMode, che specifica quando il programma deve arrestarsi (dopo
il ciclo corrente, dopo il completamento dell'istruzione o immediatamente).
V.B.:
aController.Rapid.Start(RegainMode.Regain, ExecutionMode.Continuous)
.....
aController.Rapid.Stop(StopMode.Instruction)
C#:
aController.Rapid.Start(RegainMode.Regain,
ExecutionMode.Continuous);
.....
aController.Rapid.Stop(StopMode.Instruction);
Nota
È anche possibile avviare una routine di servizio o una routine ordinaria senza parametri, come se fosse
una routine di servizio. Per ulteriori informazioni ed esempi di codice, consultare Task.CallRoutine e
Task.CancelRoutine nel Manuale di riferimento FlexPendant SDK.
Evento di modifica dell'esecuzione RAPID

È possibile iscriversi agli eventi che si verificano quando un programma RAPID inizia l'esecuzione e quando si
arresta. Questo viene fatto sulla proprietà Rapid dell'oggetto Controller, in questo modo:
V.B.:
AddHandler aController.Rapid.ExecutionStatusChanged, AddressOf

AggiornaUI
C#
aController.Rapid.ExecutionStatusChanged += nuovo
ExecutionStatusChangedEventHandler(UpdateUI);
Per ulteriori informazioni ed esempi di codice su come scrivere i gestori eventi necessari per aggiornare la GUI a
causa di un evento del controller, vedere Come comunicare all'utente che i dati RAPID sono cambiati a pagina
129.
Metodo ResetProgramPointer
Il metodo ResetProgramPointer reimposta i puntatori del programma di tutte le attività e li imposta sul punto di
ingresso principale della rispettiva attività.
V.B.:
aController.Rapid.ResetProgramPointer()


Continua
C#:
aController.Rapid.ResetProgramPointer();
Nota
È anche possibile impostare il puntatore del programma su una routine, riga o posizione specificata.
Per ulteriori informazioni ed esempi di codice, consultare Task.SetProgramPointer nel Manuale di
riferimento FlexPendant SDK.

5.5.3.7 Modifica di moduli e programmi
Panoramica
Utilizzando l'oggetto Task è possibile caricare e salvare programmi e singoli moduli. È inoltre possibile
scaricare programmi, ottenere la posizione del puntatore di movimento (MP) e del puntatore di programma
(PP) nonché modificare la posizione del robot.
Caricamento di moduli e programmi

Per caricare un modulo o un file di programma è necessario il percorso del file nel file system del controller.
Quando il file viene caricato in memoria, l'argomento dell'enumerazione RapidLoadMode, Aggiungi
o Sostituisci, specifica se deve sostituire o meno i vecchi moduli o programmi.
Se l'estensione del file non è un'estensione valida di modulo (mod o sys) o di programma (pgf), viene lanciata
un'ArgumentException.
V.B.:
Tentativo
ATask.LoadProgramFromFile(APrgFileName, RapidLoadMode.Replace)
ATask.LoadModuleFromFile(AModFileName, RapidLoadMode.Add)
Cattura ex come ArgumentException
Ritorno
Fine del tentativo
C#:
Tentativo
{
aTask.LoadProgramFromFile(aPrgFileName, RapidLoadMode.Replace);
aTask.LoadModuleFromFile(aModFileName, RapidLoadMode.Add);
}
catch (ArgumentException ex)
{
ritorno;
}
Salvare e scaricare il programma RAPID

È possibile salvare un programma utilizzando il metodo SaveProgramToFile e scaricarlo utilizzando il metodo
DeleteProgram. Questi metodi salvano e scaricano tutti i moduli nell'attività.
V.B.:
Dim TaskCol As Task() = AController.Rapid.GetTasks()

Diminuisci un oggetto come oggetto
Per ogni AnObject in TaskCol
ATask = DirectCast(AnObject, Task)
ATask.NomeProgramma = ATask.Nome
ATask.SaveProgramToFile(SaveDir)
ATask.DeleteProgram()
Prossimo
C#:
Task[] taskCol = aController.Rapid.GetTasks();



Continua
foreach (Attività aTask in taskCol)

{
aTask.PrograamName = aTask.Name;
aTask.SaveProgramToFile(saveDir);
aTask.DeleteProgram();
}
Salva modulo
È possibile salvare un modulo utilizzando il metodo Module.SaveToFile. Come argomento si utilizza
un percorso al file system del controller.
V.B.:
AModule.SaveToFile(AFilePath)
C#
aModule.SaveToFile(aFilePath);
ProgramPointer e MotionPointer
La proprietà Task.ProgramPointer restituisce la posizione corrente del puntatore del programma
(modulo, routine e numero di riga), ovvero dove il programma è attualmente in esecuzione. La stessa
funzionalità è disponibile per il puntatore di movimento utilizzando la proprietà MotionPointer.
V.B.:
Dim APP come ProgramPointer = ATask.ProgramPointer

Se non APP = ProgramPointer.Empty Allora
Dim AStartRow come numero intero = APP.Start.Row
.....
C#:
ProgramPointer pp = aTask.ProgramPointer;
se (pp!= ProgramPointer.Empty)
{
int aRigaInizio = pp.RigaInizio;
.....
}
Metodo ModificaPosizione
Utilizzando il metodo ModifyPosition dell'oggetto Task è possibile modificare la posizione di
un'istanza RobTarget nel programma attualmente caricato. Come argomento fornisci un nome del
modulo e un oggetto TextRange. Il primo RobTarget all'interno dell'intervallo di testo specificato
dall'oggetto TextRange verrà modificato utilizzando il TCP corrente dell'unità meccanica attiva.
V.B.:
Me.ATask.ModifyPosition(AModule, ATextRange)
C#:
this.ATask.ModifyPosition(aModule, aTextRange)



Continua
Mancia
Per ulteriori informazioni sui metodi e sulle proprietà delle attività, consultare il Manuale
di riferimento FlexPendant SDK.


5.5.4 Dominio del sistema IO
Panoramica
Un sistema robotico utilizza segnali di input e output per controllare i processi. I segnali possono essere di
tipo digitale, analogico o di gruppo. Tali segnali di I/O sono accessibili tramite l'SDK.
I cambiamenti di segnale nel sistema robotico sono spesso significativi e ci sono molti scenari in cui gli
utenti finali del sistema necessitano di notifica dei cambiamenti di segnale.
Accesso ai segnali
L'accesso ai segnali avviene tramite l'oggetto Controller e la sua proprietà IOSystem, che rappresenta
lo spazio del segnale IO nel controller del robot.
Per accedere a un segnale è necessario il nome di sistema del segnale. L'oggetto restituito dal metodo
IOSystem.GetSignal è di tipo Signal.
V.B.:
Dim Signal1 come segnale = AController.IOSystem.GetSignal("signal
nome")
C#:
Segnale segnale1 = aController.IOSystem.GetSignal("nome segnale");
L'oggetto Signal restituito deve essere convertito in segnale digitale, analogico o di gruppo.
L'esempio seguente mostra come viene creato un segnale di tipo DigitalSignal:
V.B.:
Dim DISig As DigitalSignal = DirectCast(Segnale1, Segnaledigitale)
C#:
Segnale digitale diSig = segnale (Segnale digitale)1;
L'esempio seguente mostra come viene creato un AnalogSignal:

V.B.:
Dim AISig come segnale analogico = DirectCast (segnale1, segnale analogico)
C#:
Segnale analogico aiSig = segnale (Segnale analogico)1;
L'esempio seguente mostra come viene creato un GroupSignal:

V.B.:
Dim GISig As GroupSignal = DirectCast(Segnale1, GroupSignal)
C#:
Segnale di gruppo giSig = (Segnale di gruppo) segnale1;
Nota
Ricordarsi di chiamare il metodo Dispose del segnale quando non deve più essere utilizzato.



Continua
Ottenere segnali utilizzando SignalFilter

Invece di ottenere un segnale alla volta puoi utilizzare un filtro e ottenere una raccolta di segnali.
Alcuni flag SignalFilter si escludono a vicenda, ad esempio SignalFilter.Analog e
SignalFilter.Digital. Altri sono inclusivi, ad esempio SignalFilter.Digital e SignalFilter.Input. È possibile
combinare i flag di filtro utilizzando il pulsante "|" carattere in C# e l'operatore Or in VB:
V.B.:
Dim aSigFilter As IOFilterTypes = IOFilterTypes.Digital Or IOFilterTypes.Input Segnali Dim As

SignalCollection =
controller.IOSystem.GetSignals(aSigFilter)
C#:
IOFilterTypes aSigFilter = IOFilterTypes.Digital | IOFilterTypes.Input;
Segnali SignalCollection =
controller.IOSystem.GetSignals(aSigFilter);
Questa parte di codice esegue un'iterazione della raccolta di segnali e aggiunge tutti i segnali a un controllo
ListView. L'elenco ha tre colonne che mostrano il nome, il tipo e il valore del segnale:
V.B.:
Per ciascun segnale come segnali di ingresso segnale

Articolo = Nuovo ListViewItem(signal.Name)
Item.SubItems.Add(signal.Type.ToString())
Item.SubItems.Add(signal.Value.ToString())
Me.ListView1.Items.Add(Articolo)
Prossimo
C#:
foreach(Segnale segnale nei segnali)

{
elemento = nuovo ListViewItem(signal.Name);
item.SubItems.Add(signal.Type.ToString());
item.SubItems.Add(signal.Value.ToString()); this.listView1.Items.Add(articolo);
Se gli oggetti di segnalazione non servono più devono essere smaltiti:

V.B.:
Per ciascun segnale come segnali di ingresso segnale

segnale.Dispose()
Prossimo
C#:
foreach(Segnale segnale nei segnali)

{
segnale.Dispose();
}



Continua
Lettura dei valori del segnale IO

Questi esempi mostrano come leggere un segnale digitale e uno analogico.
Segnale digitale
Questo pezzo di codice legge il segnale digitale DO1 e seleziona una casella di controllo se il valore del segnale
è 1 (ON):
V.B.:
Dim sig As Signal = aController.IOSystem.GetSignal("DO1")

Dim digitalSig As DigitalSignal = DirectCast(sig, DigitalSignal)
Dim val As Integer = digitalSig.Get
Se val = 1 Allora
Me.CheckBox1.Checked = Vero
Finisci se
C#:
Sigillo del segnale = aController.IOSystem.GetSignal("DO1");

Segnale digitale digitalSig = (Segnale digitale) sig;
int val = digitalSig.Get();
se (val == 1)
{
this.checkBox1.Checked = vero;
}
Segnale analogico
Questo pezzo di codice legge il valore del segnale analogico AO1 e lo visualizza in una casella di testo:
V.B.:
Dim sig As Signal = aController.IOSystem.GetSignal("AO1")

Dim analogSig As AnalogSignal = DirectCast(sig, AnalogSignal)
Dim analogSigVal As Single = analogSig.Value
Me.textBox1.Text = analogSigVal.ToString()
C#:
Sigillo del segnale = aController.IOSystem.GetSignal("AO1");

Segnale analogico analogSig = (Segnale analogico) sig;
float analogSigVal = analogSig.Value;
this.textBox1.Text = analogSigVal.ToString();
Scrittura dei valori del segnale IO

Nell'esempio seguente vengono scritti nel controller i nuovi valori per i segnali IO recuperati nell'esempio
precedente.
Nota
In modalità manuale è possibile modificare il valore di un segnale solo se il livello di accesso del segnale è
TUTTI. In caso contrario, il controller deve essere in modalità automatica.
Segnale digitale
Questo pezzo di codice modifica il valore di un segnale digitale nel controller quando si seleziona/deseleziona
una casella di controllo:



Continua
V.B.:
Private Sub checkBox1_Click(ByVal sender As Object, ByVal e As System.EventArgs) Gestisce

checkBox1.Click
Se Me.checkBox1.Checked Allora
digitalSig.[Set]()
Altro
digitalSig.Reset()
Finisci se
Fine sott
C#:
private void checkBox1_Click(mittente oggetto, EventArgs e) {
se (this.checkBox1.Checked)
{
digitalSig.Set();
}
altro
{
digitalSig.Reset();
}
}
NOTA! È inoltre possibile impostare il valore utilizzando la proprietà Value.
Segnale analogico
Questo pezzo di codice scrive il valore immesso in una casella di testo sul segnale analogico AO1.
Il valore viene convertito da stringa a float prima di essere scritto nel controller:
V.B.:
Dim analogSigVal As Single = Convert.ToSingle(Me.textBox1.Text) analogSig.Value = analogSigVal
C#:
float analogSigVal = Convert.ToSingle(this.textBox1.Text); analogSig.Value = analogSigVal;
Ascolto delle modifiche del segnale

Una volta che un oggetto Segnale è disponibile, è possibile aggiungere un abbonamento al suo evento Modificato,
che viene attivato al cambiamento del segnale come la modifica del valore, la modifica dello stato simulato
o la modifica della qualità del segnale.
V.B.:
Amico con eventi aiSig come segnale analogico
...
AddHandler aiSig.Changed, AddressOf aiSig_Changed

...
Private Sub aiSig_Changed(mittente As Oggetto, e As

SignalChangeEventArgs) Gestisce aiSig.Changed
Fine sott
C#
this.aiSig.Changed +=new SignalChangeHandler(aiSig_Changed);



Continua
NOTA! La struttura del gestore eventi viene generata automaticamente utilizzando il tasto Tab due volte dopo
"+=" nell'istruzione precedente: private void
aiSig_Changed(object sender, SignalChangeEventArgs e)
{ }
Avviare e interrompere gli abbonamenti

Si consiglia di attivare e disattivare gli abbonamenti all'evento Modificato qualora questi non siano necessari
per tutta la durata dell'applicazione:
V.B.:
AddHandler aiSig.Changed, AddressOf aiSig_Changed RemoveHandler

aiSig.Changed, AddressOf aiSig_Changed
C#:
this.aiSig.Changed += nuovo SignalChangeHandler(aiSig_Changed); this.aiSig.Changed -= nuovo

SignalChangeHandler(aiSig_Changed);
Come evitare conflitti di thread Gli

eventi del controller utilizzano i propri thread, che sono diversi dal thread della GUI dell'applicazione. Ciò può
causare problemi se si desidera visualizzare le modifiche del segnale nella GUI dell'applicazione.
Se non è necessario un aggiornamento dell'interfaccia utente, non è necessario intraprendere alcuna

azione speciale, ma è possibile eseguire il gestore eventi sul thread eventi. Se, tuttavia, devi mostrare all'utente
che il segnale è cambiato dovresti utilizzare il metodo Invoke. Forza l'esecuzione al thread di controllo
della finestra e quindi fornisce una soluzione a potenziali conflitti di threading.
V.B.:
Me.Invoke (nuovo ABB.Robotics.Controllers.IOSystemDomain.

SignalChangedEventHandler(AddressOf UpdateUI), Nuovo Oggetto()
{mittente, e})
C#:
this.Invoke(nuovo ABB.Robotics.Controllers.IOSystemDomain.
SignalChangedEventHandler(this.UpdateUI), nuovo Oggetto[] {mittente, e});
Per ulteriori informazioni, vedere Eventi e thread del controller a pagina 51.
Scoprire il nuovo valore

L'oggetto SignalChangedEventArgs ha una proprietà NewSignalState, che contiene informazioni sul valore del
segnale, sulla qualità del segnale e se il segnale è simulato o meno:
V.B.:
Private Sub UpdateUI(ByVal Sender As Object, ByVal e As

SignalChangedEventArgs)
Dim State As SignalState = e.NewSignalState Dim val As Single
Val = Valore.Stato
Me.TextBox1.Text = Val.ToString()
....
Fine sott



Continua
C#:
private void UpdateUI(mittente dell'oggetto, SignalChangedEventArgs e)
{
Stato SignalState = e.NewSignalState;
....
valore float = stato.Valore
this.textBox1.Text = val.ToString()
}
Nota
Non contare sulla ricezione di un evento iniziale quando imposti l'abbonamento. Per ottenere
le prime informazioni sul valore di un segnale, dovresti leggerlo utilizzando la proprietà Value.
Nota
Assicurati che l'abbonamento venga rimosso prima di eliminare il segnale.


5.5.5 Dominio registro eventi
Panoramica
I messaggi del registro eventi possono contenere informazioni sullo stato del controller,
sull'esecuzione RAPID, sui processi in esecuzione del controller e così via.
Utilizzando l'SDK è possibile leggere i messaggi in coda o utilizzare un gestore eventi che riceverà
una copia di ogni nuovo messaggio di registro. Un messaggio del registro eventi contiene il tipo
di coda, il tipo di evento, l'ora dell'evento, il titolo dell'evento e il messaggio.
Accedi al registro eventi del controller

È possibile accedere al dominio del registro eventi tramite la proprietà EventLog del controller.
V.B.:
Registro privato come EventLog = aController.EventLog

C#:
registro EventLog privato = aController.EventLog;
Accesso alle categorie del registro

eventi Tutti i messaggi del registro eventi sono organizzati in categorie. Per cercare un singolo
messaggio devi sapere a quale categoria appartiene. Il tipo di enumerazione, CategoryType,
definisce tutte le categorie disponibili. È possibile ottenere una categoria utilizzando il metodo
GetCategory o utilizzando la proprietà Categories, che è una matrice di tutte le categorie disponibili.
V.B.:
Dim Cat come categoria EventLog

Gatto = Log.GetCategory(CategoryType.Program)
O
Gatto = Log.Categorie(4)
C#:
EventLogCategoria gatto;
cat = log.GetCategory(CategoryType.Program);
O
cat = log.GetCategory[4];
Nota
EventLogCategory deve essere eliminato quando non viene più utilizzato.
Accedere ai messaggi del registro

eventi Per accedere ad un messaggio si utilizza la proprietà Messaggi dell'oggetto Categoria. Viene
restituita una raccolta di messaggi. La raccolta implementa le interfacce ICollection e IEnumerable
, il che significa che puoi utilizzare le operazioni comuni per le
raccolte. L'accesso viene effettuato utilizzando un indice o eseguendo un'iterazione utilizzando foreach.
V.B.:
Dim msg As EventLogMessage = Cat.Messages(1)



Continua
O
Dim msg come EventLogMessage
Per ogni messaggio in Cat.Messaggi
Me.textBox1.Text = msg.Titolo
.....
Articolo successivo
C#:
EventLogMessage msg = cat.Messaggi[1];
O
foreach(EventLogMessage msg in cat.Messaggi)
{
this.textBox1.Text = msg.Titolo;
.....
}
Evento MessageWritten
È possibile aggiungere un gestore eventi che viene avvisato quando un nuovo messaggio viene
scritto nel registro eventi del controller. Questo viene fatto iscrivendosi all'evento EventLog
MessageWritten.
L'argomento dell'evento è di tipo MessageWrittenEventArgs e dispone di una proprietà Message

che contiene l'ultimo messaggio del registro eventi.
V.B.:
Private Sub Log_MessageWritten(mittente come oggetto, e come
MessageWrittenEventArgs) Gestisce Log.MessageWritten Dim Msg come
EventLogMessage = e.Message
Fine sott
C#:
private void log_MessageWritten(mittente dell'oggetto,
ArgEventoMessaggioWritten e)
{
EventLogMessage msg = e.Message;
}
Nota
Se è necessario aggiornare l'interfaccia utente dell'applicazione in seguito all'evento, è necessario

delegare questo lavoro al thread della GUI utilizzando il metodo Invoke. Per ulteriori informazioni
ed esempi di codice, vedere Eventi e thread del controller a pagina 51.


5.5.6 Dominio del movimento
Panoramica
Lo spazio dei nomi MotionDomain consente di accedere alle unità meccaniche del sistema robotico.
Utilizzando un oggetto MotionSystem è possibile inviare comandi di jogging a un'unità meccanica e ottenere o
impostare la modalità jogging incrementale. Utilizzando un oggetto MechanicalUnit è possibile ottenere molte
informazioni sulle unità meccaniche del sistema robotico.
È inoltre possibile iscriversi alle modifiche dell'unità meccanica, ad esempio modifica dell'utensile, dell'oggetto di
lavoro, del sistema coordinato, della modalità di movimento o della dimensione del passo incrementale.
Oggetto MotionSystem È
possibile accedere al sistema di movimento utilizzando la proprietà Controller MotionSystem.
V.B.:
aMotionSystem privato come MotionSystem

aMotionSystem = aController.MotionSystem
C#
MotionSystem privato aMotionSystem;

aMotionSystem = aController.MotionSystem;
Accesso alle unità meccaniche Le

unità meccaniche possono essere di diversi tipi, ad esempio un robot con TCP, un manipolatore ad assi multipli
o un'unità ad asse singolo. Le unità meccaniche sono disponibili tramite l'oggetto MotionSystem. Se interessa
solo l'unità meccanica attiva, è possibile utilizzare il metodo GetActiveMechanicalUnit.
V.B.:
Dim aMechCol As MechanicalUnitCollection =
aController.MotionSystem.GetMechanicalUnits()
Dim aMechUnit As MechanicalUnit =
aController.MotionSystem.GetActiveMechanicalUnit();
C#:
MechanicalUnitCollection aMechCol =
aController.MotionSystem.GetMechanicalUnits();
UnitàMeccanica aMechUnit =
aController.MotionSystem.GetActiveMechanicalUnit();
Jogging
È possibile muovere l'unità meccanica attiva utilizzando il metodo SetJoggingCmd e le chiamate JoggingStart e
JoggingStop. A seconda del MotionMode e dell'IncrementalMode selezionati vengono configurati giunti e
velocità diversi.
V.B.:
aController.MotionSystem.JoggingStop()
aMechUnit.MotionMode = MotionModeType.Linear
aController.MotionSystem.IncrementalMode = IncrementalModeType.Small
aController.MotionSystem.SetJoggingCmd(-50, 50, 0)
aController.MotionSystem.JoggingStart()


Continua
C#:
aController.MotionSystem.JoggingStop();
aMechUnit.MotionMode = MotionModeType.Linear;
aController.MotionSystem.IncrementalMode =
IncrementalModeType.Small;
aController.MotionSystem.SetJoggingCmd(-50, 50, 0);
aController.MotionSystem.JoggingStart();
Proprietà e metodi dell'unità meccanica Sono

disponibili numerose proprietà per l'unità meccanica, ad esempio Nome, Modello, Numero di assi, Numero
di serie, Sistema di coordinate, MotionMode, IsCalibrated, Strumento e Oggetto di lavoro e così
via. È anche possibile ottenere la posizione corrente di un'unità meccanica come RobTarget o JointTarget.
V.B.:
Diminuisci la luminosità di un controller come nuovo controller()
Dim aRobTarget As RobTarget =

c.MotionSystem.ActiveMechanicalUnit.GetPosition(CoordinateSystemType.World)
Dim aJointTarget As JointTarget =
c.MotionSystem.ActiveMechanicalUnit.GetPosition()
C#:
Controller aController = nuovo Controller();

RobTarget aRobTarget =
aController.MotionSystem.ActiveMechanicalUnit.GetPosition(CoordinateSystemType.World);
JointTarget aJointTarget =
aController.MotionSystem.ActiveMechanicalUnit.GetPosition();
Evento DataChanged
Iscrivendoti all'evento DataChanged dell'oggetto MechanicalUnit, riceverai una notifica quando si verifica un
cambio di utensile, oggetto di lavoro, sistema coordinato, modalità di movimento o dimensione del passo
incrementale.
V.B.:
AddHandler aMechUnit.DataChanged, AddressOf aMech_DataChanged

......
Private Sub aMech_DataChanged(mittente As Oggetto, e As

MechanicalUnitDataEventArgs)
Seleziona e.Motivo
Case MechanicalUnitDataChangeReason.Tool
ChangeOfTool(DirectCast(mittente, MechanicalUnit))
Case MechanicalUnitDataChangeReason.WorkObject
......
Fine Seleziona
Fine sott
C#:
aMechUnit.DataChanged += nuovo
MechanicalUnitDataEventHandler(aMech_DataChanged);
.....


Continua
private void aMech_DataChanged(mittente dell'oggetto,

MechanicalUnitDataEventArgs e) {
interruttore (e. Motivo) {
case MechanicalUnitDataChangeReason.Tool:
ChangeOfTool((MechanicalUnit)mittente)
caso MechanicalUnitDataChangeReason.WorkObject:
......
}
}
Mancia
Maggiori informazioni su classi, metodi e proprietà disponibili in MotionDomain nel Manuale di



5.5.7 Dominio del file system
Panoramica
Utilizzando FlexPendant SDK FileSystemDomain è possibile creare, salvare, caricare, rinominare ed eliminare
file sul controller. Puoi anche creare ed eliminare directory.
Accesso a file e directory

È possibile accedere al dominio del file system tramite la proprietà dell'oggetto Controller FileSystem.
V.B.:
aFileSystem privato come FileSystem = aController.FileSystem

C#:
FileSystem aFileSystem = aController.FileSystem;
Controller e file system FlexPendant

È possibile trovare e impostare la directory remota sul controller e la directory locale sul dispositivo FlexPendant
utilizzando le proprietà RemoteDirectory e LocalDirectory.
V.B.:
Dim remoteDir As String = aController.FileSystem.RemoteDirectory Dim localDir As String =

aController.FileSystem.LocalDirectory
C#:
stringa remoteDir = aController.FileSystem.RemoteDirectory; stringa localDir =

aController.FileSystem.LocalDirectory;
Caricamento dei file del controller

È possibile caricare un file dal controller alla FlexPendant utilizzando il metodo GetFile. Se l'operazione
fallisce viene generata un'eccezione. Gli argomenti sono percorsi completi inclusi i nomi dei file.
V.B.:
aController.FileSystem.FileSystem.GetFile(remoteFilePath,
percorsoFilelocale)
C#:
aController.FileSystem.GetFile(remoteFilePath, localFilePath);
Salvataggio di file
È possibile salvare un file nel file system del controller utilizzando il metodo PutFile. Se l'operazione fallisce viene
generata un'eccezione. Gli argomenti sono percorsi completi inclusi i nomi dei file.
V.B.:
aController.FileSystem.PutFile(localFilePath, remoteFilePath)
C#:
aController.FileSystem.PutFile(localFilePath, remoteFilePath);



Continua
Ottenere più file e directory

La classe FileSystem ha un metodo chiamato GetFilesAndDirectories. Può essere utilizzato per
recuperare una serie di oggetti ControllerFileSystemInfo con informazioni su singoli file e
directory. IL
L'oggetto ControllerFileSystemInfo può quindi essere sottoposto a cast su un oggetto
ControllerFileInfo o su un oggetto ControllerDirectoryInfo.
Nell'esempio seguente viene utilizzato il modello di ricerca per limitare la ricerca.

V.B.:
Dim anArray As ControllerFileSystemInfo()

Dim info As ControllerFileSystemInfo
anArray = aController.FileSystem.GetFilesAndDirectories("search
modello")
Dim I As Integer For I = 0
In array.Length -1
informazioni = anArray(I)
......
Prossimo
C#:
ControllerFileSystemInfo[] anArray;
Informazioni ControllerFileSystemInfo;
anArray = aController.FileSystem.GetFilesAndDirectories("search
modello");
for (int i=0;i<anArray.Length;i++) {
informazioni = anArray[i];
......
}
Utilizzo dei modelli di

ricerca Come visto nell'esempio precedente, è possibile utilizzare i modelli di ricerca per individuare file e
directory utilizzando il metodo GetFilesAndDirectories. Il processo di corrispondenza utilizza la
corrispondenza del modello jolly di Visual Studio. Quello che segue è un breve riassunto:
Carattere nel modello Corrispondenze in stringa
? Qualsiasi singolo carattere

*
Zero o più caratteri
# Qualsiasi singola cifra (0–9)
[lista dei caratteri] Qualsiasi singolo carattere nell'elenco dei caratteri
[!listacarlino] Qualsiasi singolo personaggio non presente nell'elenco dei personaggi
Mancia
Per ulteriori informazioni su classi, metodi e proprietà, consultare

FileSystemDomain nel Manuale di riferimento FlexPendant SDK.

5.5.8 Dominio Informazioni di sistema
Panoramica
Il SystemInfoDomain fornisce informazioni sul sistema robotico attivo. Ciò avviene principalmente attraverso i
metodi e le proprietà statiche della classe SystemInfo:
5.5.8_1Sistema
Classe SystemInfo
Si accede alla funzionalità di SystemInfoDomain chiamando i metodi statici della classe SystemInfo. Il
codice seguente spiega come recuperare il percorso nel file system del controller alla directory di rilascio
(ROBOTWARE) del sistema attivo.
Esempio:
stringa rWDir =
ABB.Robotics.Controllers.SystemInfoDomain.SystemInfo.ReleasePath
Allo stesso modo, è possibile recuperare il percorso della directory di sistema attiva:
stringa sysDir =
ABB.Robotics.Controllers.SystemInfoDomain.SystemInfo.SystemPath


Continua
Opzioni di sistema
Utilizzando la proprietà SystemInfo.SystemOptions è possibile recuperare le opzioni di sistema del
sistema robot attualmente attivo. Il risultato è un array di oggetti SystemOption. Se elenchi la proprietà
Nome di questi oggetti otterrai lo stesso risultato mostrato nel SystemBuilder di RobotStudio, ad esempio:
5.5.8_2Sistema
È possibile recuperare le opzioni secondarie di un'opzione di sistema utilizzando

la proprietà SystemOption.SubOptions.
Opzioni aggiuntive
Utilizzando la proprietà SystemInfo.AdditionalOptions è possibile scoprire quali opzioni aggiuntive sono
installate nel sistema robotico. Il risultato è un array di oggetti AdditionalOption. La proprietà
AdditionalOption.Path restituisce il percorso della directory di installazione dell'opzione aggiuntiva.
Sono disponibili le seguenti proprietà AdditionalOption:
• Stringa di chiavi
• Nome
• Sentiero
• Tipo
• Informazioni sulla versione
Nota
Per ulteriori informazioni su SystemInfoDomain con esempi di codice, consultare il Manuale di



6 robuste applicazioni FlexPendant
6.1 Introduzione

6.1 Introduzione
Panoramica
Sviluppare un'applicazione per un dispositivo con risorse limitate, come memoria e potenza di
elaborazione, può essere piuttosto impegnativo. Inoltre, avere un'applicazione in esecuzione 24 ore
su 24 rivelerà punti deboli nella progettazione e nell'implementazione che potrebbero causare
rallentamenti delle prestazioni o blocchi della FlexPendant.
Nel peggiore dei casi, l'applicazione prosciugherà tutta la memoria della FlexPendant durante
la produzione e causerà un arresto anomalo della memoria esaurita. Può addirittura rallentare
le prestazioni del controller del robot a causa dell'uso eccessivo delle risorse del controller.
Questo capitolo descrive come progettare e implementare applicazioni affidabili e con ottime prestazioni
per FlexPendant. Presenta alcune buone pratiche da utilizzare, così come alcune insidie che
dovrebbero essere evitate.
Panoramica tecnica del dispositivo FlexPendant
Il dispositivo FlexPendant è costituito sia da hardware che da software ed è di per sé un computer

completo, con la propria memoria, file system, sistema operativo e processore.
È parte integrante dell'IRC5, collegato al controller tramite un cavo e un connettore integrati. Utilizzando
l'opzione del pulsante hot plug, tuttavia, è possibile disconnettere la FlexPendant in modalità
automatica e continuare a funzionare senza di essa.
Esistono modi per riavviare la FlexPendant senza dover riavviare il controller (per ulteriori informazioni,
vedere Riavviare la FlexPendant a pagina 35). Al riavvio della FlexPendant gli assiemi e le risorse delle
applicazioni SDK FlexPendant vengono scaricati nel file system FlexPendant dal controller del
robot.
Le applicazioni FlexPendant vengono eseguite su Windows CE, un sistema operativo incorporato

scalabile, e su .NET Compact Framework, che è la versione leggera di Microsoft di .NET Framework,
destinata ai dispositivi di piccole dimensioni.
Questa è la dimensione del touch screen della FlexPendant:
Schermata FlexPendant Misurare
*
Visualizzazione totale 640 480 pixel
*
Visualizzazione dell'applicazione SDK FlexPendant 640 390 pixel
La FlexPendant utilizza questi tipi di memoria:
Tipo di memoria Funzione
Flash: 16 MB Memorizza il software standard FlexPendant, il sistema operativo Windows CE in

formato compresso e il registro.
RAM: 64 MB All'avvio l'immagine compressa viene copiata nella RAM. Tutta l'esecuzione del codice
utilizza la RAM.
E2PROM _ Memorizza i valori di calibrazione del touch screen, i valori di calibrazione del joystick e
così via. Utilizzato solo internamente.


6.1 Introduzione
Continua
Quanto può essere grande un'applicazione personalizzata?

Potresti chiederti quale sia la dimensione massima della tua applicazione personalizzata. Non esiste
una risposta esatta a questa domanda, poiché le variabili da tenere in considerazione sono molte.
Per una stima approssimativa è possibile utilizzare la tabella seguente. Come puoi vedere, il sistema
operativo utilizza circa 8 MB e il software di base ABB circa 25 MB. Ciò significa che metà della
memoria RAM disponibile è già utilizzata una volta avviata la FlexPendant. Le applicazioni standard
del menu ABB e le applicazioni FlexPendant SDK condivideranno tutte la memoria rimasta. Come
regola generale, per le applicazioni personalizzate dovrebbero essere disponibili circa 20 MB.
Risorse di memoria FlexPendant

RAM 128MB
Sistema operativo 8 MB
Software di base ABB 25 MB
Applicazioni personalizzate ~20 MB
Ecco alcuni consigli per aiutarti ad assicurarti che la tua applicazione non superi i limiti di memoria:
1 Non consentire più di UNA istanza impostando il parametro TpsViewType dell'attributo TpsView
su Statico. Per ulteriori informazioni, vedere Tipo di applicazione a pagina 42.
2 Evitare l'uso eccessivo di immagini. Non utilizzare immagini più grandi del necessario.
Controlla la dimensione delle immagini che utilizzerà la tua applicazione.
3 Utilizzare fpcmd “-memShow” per verificare la quantità di memoria in uso quando l'applicazione
è attiva. Apri un paio di editor di programmi e avvia l'esecuzione RAPID. Per ulteriori
informazioni, vedere Individuazione delle perdite di memoria a pagina 169.
4 Evitare dati e metodi statici.
5 Rilasciare memoria per gli oggetti che non vengono utilizzati chiamando Dispose
metodo.


6.2 Gestione della memoria
Raccolta e smaltimento dei rifiuti

Una funzionalità importante dell'ambiente runtime .NET è il Garbage Collector, che recupera la
memoria senza riferimenti dall'heap gestito. In generale ciò significa che il programmatore non
dovrebbe liberare memoria allocata utilizzando new. Uno svantaggio, quando la memoria è
limitata, è che l'esecuzione del Garbage Collector non è deterministica. Non c'è modo di sapere
esattamente quando verrà eseguita la garbage collection.
L'interfaccia IDisposable, invece, rappresenta un modo per ottenere la deallocazione deterministica

delle risorse. Dovresti quindi chiamare Dispose() su tutti gli oggetti usa e getta quando non sono più
necessari, poiché ciò libererà risorse preziose il prima possibile.
Inoltre, gli oggetti utilizzati per accedere alle risorse del controller del robot devono essere rilasciati
dall'applicazione personalizzata tramite una chiamata esplicita al relativo metodo Dispose.
Anche gli oggetti SignalBindingSource e RapidDataBindingSouce, così come tutti gli altri oggetti
situati nel riquadro dei componenti di Visual Studio Designer, devono essere eliminati esplicitamente,
altrimenti l'applicazione avrà una perdita di memoria permanente.
Nota
Il creatore di un oggetto che implementa l'interfaccia IDisposable è responsabile della sua durata e
della chiamata a Dispose.
Mancia
Potresti chiederti perché il Garbage Collector .NET non può garantire che tutti gli oggetti a cui non
viene più fatto riferimento vengano definitivamente distrutti? Il team di sviluppo FlexPendant ha fatto
del suo meglio per rimuovere tutti gli oggetti rimanenti di un'applicazione SDK alla chiusura
dell'applicazione, ad esempio i finalizzatori implementati per le classi TpsControl,
RapidDataBindingSouce e SignalBindingSource. A causa dell'implementazione di Microsoft,
tuttavia, il runtime .NET rifiuta comunque di distruggere questi oggetti a meno che non venga
chiamato il loro metodo Dispose. Questo comportamento è in discussione. Se sei curioso di saperne
di più, questi articoli della community potrebbero interessarti.
Dispose, Finalization e Resource Management (Joe Duffy): http://
www.bluebytesoftware.com/blog/PermaLink.aspx?guid=88e62cdf-5919-4ac7-bc33-20c06ae539ae
Garbage Collection: gestione automatica della memoria in Microsoft .NET Framework (rivista
MSDN): ms-help://ms.msdnqtr.v80.en/
ms.msdn.v80/dnmag00/html/GCI.htm
Finalizzazione - WebLog di cbrumme: http://

blogs.msdn.com/cbrumme/archive/2004/02/20/77460.aspx

Continua
Utilizzo di Application Framework: ITpsViewSetup

Il framework applicativo TAF, che ospita i controlli che compongono un'applicazione
FlexPendant, offre alcuni meccanismi che dovrebbero essere utilizzati dalle applicazioni client. Per
ulteriori informazioni su TAF, vedere Comprensione del ciclo di vita dell'applicazione FlexPendant a
pagina 38.
La classe di visualizzazione dell'applicazione deve implementare ITpsViewSetup e

ITpsViewActivation. Per informazioni generali su queste interfacce, vedere ITpsViewSetup
e ITpsViewActivation a pagina 44 e per informazioni su come utilizzare ITpsViewActivation
per migliorare le prestazioni, vedere Utilizzo di Application Framework - ITpsViewActivation a pagina
172.
L'interfaccia ITpsViewSetup dispone di due metodi: Installa e Disinstalla.

Install viene chiamato durante la creazione della vista, subito dopo l'esecuzione del costruttore.
La disinstallazione viene richiamata quando la visualizzazione client viene chiusa. Dopo la disinstallazione è
stato chiamato, TAF chiamerà anche il metodo Dispose della classe view. Questi metodi
offrono quindi l'ultima opportunità per pulire e rilasciare la memoria e le risorse di sistema
conservate dall'applicazione personalizzata.
Nota
È necessario chiudere l'applicazione utilizzando il pulsante di chiusura, [x], nell'angolo in alto a

destra del display, nello stesso modo in cui vengono chiusi i dati del programma o altre applicazioni
standard. Non implementare mai un pulsante di chiusura alla prima visualizzazione. Quando
l'applicazione viene chiusa nel modo corretto, prima Deactivate, poi Uninstall e infine Dispose
verranno chiamati da TAF.

Continua
Come programmare il metodo Dispose - esempio

Quando si avvia un nuovo progetto FlexPendant in Visual Studio, viene generata
automaticamente una struttura per il metodo Dispose. Dovresti usarlo per aggiungere codice per la
pulizia, come mostrato nello screenshot seguente:
7.2_1Smaltire
Nota
La gestione degli errori dovrebbe essere aggiunta al metodo Dispose (lasciato fuori nella figura).
Nota
Assicurati di aver annullato la sottoscrizione a tutti gli eventi dal controller del robot prima di
chiamare il metodo Dispose di un oggetto CAPI. Se è stato fatto con il metodo Deactivate,
che è quello solitamente consigliato, non dovresti farlo di nuovo con il metodo Dispose.
Assicurati inoltre di non tentare di accedere a un oggetto dopo che è stato eliminato.
Scopri le perdite di memoria

Quando la tua applicazione interagisce con il controller del robot, vengono creati oggetti non gestiti
dietro le quinte. Se si dimentica di chiamare Dispose su tali oggetti si verificheranno perdite di
memoria.
Ti consigliamo di testare il consumo di memoria della tua applicazione. Utilizzare una finestra della
console del controller sul PC e il comando fpcmd_enable_console_output
3 per abilitare le stampe. Quindi utilizzare il comando "-memShow" con un argomento punto che
produce, ad esempio, una stampa ogni 500 secondi, in questo modo:
-> punto 500, fpcmd, "-memShow"

Continua
Per ulteriori informazioni sulla finestra della console, vedere Codici di errore di eccezione a pagina 181
Risultato:
attività generata: id = 0xba7f3b8, nome = t2value = 195556280 = 0xba7f3b8-> [fp]: Memoria

disponibile: 20881408 (tot 40394752), disco: 737148 (tot 1728512) carico: 54(261955)[fp]:
La componente di carico indica la quantità di memoria RAM utilizzata sulla FlexPendant (espressa in
percentuale della quantità totale) e il numero tra parentesi indica il tempo impiegato in ms dopo l'avvio.
Ad esempio, nel risultato precedente, 54 è la percentuale di memoria utilizzata nella FlexPendant e
261955 ms è il tempo impiegato dopo l'avvio.
Testare tutte le funzioni dell'applicazione con diverse altre viste FlexPendant visibili nella barra delle
attività ed eventualmente con una o più attività RAPID in esecuzione. Osserva come la tua
implementazione influisce sulla memoria. Chiudi l'applicazione e assicurati che sia disponibile la
stessa quantità di memoria di prima di aprirla.
La seguente procedura mostra ancora un altro modo per verificare che l'applicazione venga pulita
correttamente:
Passo Azione
1 Disconnettersi dalla FlexPendant facendo clic su Disconnetti nel menu ABB.
2 Nella finestra della console del controller scrivi fpcmd_enable_console_output.
3 Scrivi fpcmd "-a".
4 Per ogni classe cpp controlla il numero di istanze. Deve essere 0, ad eccezione
di AdaptController (1) e AdaptEventImpl (1).
5 Se il passaggio precedente mostra che sono rimasti oggetti non gestiti, è necessario
cercare nel codice le chiamate Dispose mancanti.
Nota
È necessario utilizzare il dispositivo FlexPendant reale durante la verifica del consumo di memoria e
la ricerca di perdite di memoria nel codice.


6.3 Prestazioni
6.3 Prestazioni
A proposito di prestazioni
Un'applicazione FlexPendant non può soddisfare le impegnative richieste in tempo reale. Tuttavia, non
dovrebbero esserci differenze nelle prestazioni tra un'applicazione FlexPendant SDK e le applicazioni standard
del dispositivo. Se la tua richiesta è lenta, i consigli contenuti in questa sezione ti saranno utili.
Mancia
Non lasciarti sopraffare dal numero di restrizioni presentate in questa sezione.

La maggior parte delle volte non noterai alcuna differenza se decidi di trascurarne alcuni. Tuttavia, è bene
sapere cosa si può fare ogni volta che le prestazioni diventano un problema.
Meno codice significa codice più veloce
Un consiglio generale (forse una raccomandazione troppo ovvia) è che meno codice normalmente significa codice
più veloce. Ricordare che i metodi eseguiti frequentemente, come OnPaint, gestori di eventi e così via. deve
essere efficiente. Tutto ciò che può essere calcolato una volta e memorizzato per un uso futuro dovrebbe essere
calcolato una sola volta.
Meno accessi al controller significano codice più veloce
La cosa migliore che puoi fare per migliorare le prestazioni è probabilmente assicurarti di non accedere alle
funzionalità del controller più spesso del necessario. Per raggiungere questo obiettivo è necessario comprendere
CAPI, le librerie di classi SDK utilizzate per accedere alle funzionalità del controller del robot.
È molto facile utilizzare una proprietà di una classe e non rendersi conto che è stato effettivamente effettuato
un accesso al controller. Una raccomandazione generale è provare a utilizzare le sottoscrizioni alle informazioni
del controller (eventi) ove applicabile e lasciare che l'applicazione memorizzi i valori aggiornati invece di eseguire
numerose operazioni di lettura verso la stessa risorsa del controller.
Mancia
Puoi ottenere facilmente una stima del numero di accessi al controller eseguiti dalla tua applicazione
in diversi scenari utente utilizzando una console del controller del robot. Il comando della console
robdisp_watch 2 monitora e stampa gli accessi al controller effettuati dalla FlexPendant alla console. Fare clic
su un pulsante dell'applicazione, ad esempio, e studiare come la FlexPendant e il controller comunicano
in risposta a questa azione. Inserisci il comando robdisp_watch 0 per disattivare questo servizio. (Il
servizio monitor rallenta il tempo di risposta della tua applicazione, a causa della stampa sulla console. Quindi
non preoccuparti se la tua applicazione sembra insolitamente lenta!)

6.3 Prestazioni
Continua
Nota
Tieni presente che un numero eccessivo di accessi al controller rallenterà le prestazioni della tua
applicazione. Nel peggiore dei casi, potrebbe addirittura influire sulle prestazioni del controller del robot.
Nota
Anche l’uso eccessivo degli abbonamenti potrebbe rappresentare un problema. Se la tua applicazione
deve gestire un carico continuo di dati Rapid ed eventi di segnali I/O e i tuoi gestori di eventi devono
manipolare i dati prima di presentarli, l'interazione della GUI potrebbe diventare lenta. Come regola
generale, non stimare più di 20 eventi/sec. e mantenere sottili i gestori di eventi.
Meno oggetti significano codice più veloce

Meno oggetti significano prestazioni migliori. Se sai che un oggetto verrà utilizzato di nuovo, crealo una
volta e mantieni un riferimento. Inoltre, cerca di non creare oggetti che potrebbero non essere utilizzati.
Riutilizzare oggetti esistenti invece di crearne di nuovi è particolarmente importante quando si esegue
ripetutamente lo stesso codice, ad esempio in cicli stretti.
L'esempio seguente mostra come dovrebbe essere fatto:

oggetto _o = nuovo oggetto(); for (int i =
0; i < 100000; i++)
{ ... }
Mancia
Non creare più oggetti Controller, ma riutilizzarlo inviandolo come parametro durante la creazione
di una nuova vista o condividerlo tra le classi come proprietà pubblica.
Trasferimento di file
Il trasferimento di file tra il dispositivo e il controller del robot richiede tempo e occupa anche la memoria di
archiviazione del dispositivo. Scrivere codice efficiente e tollerante agli errori se è necessario farlo.
Utilizzo di Application Framework: ITpsViewActivation

L'interfaccia ITpsViewActivation viene utilizzata da TAF per nascondere e visualizzare l'applicazione. Ha
due metodi: Attiva e Disattiva. Il primo viene chiamato da TAF al momento della creazione della vista del
client, subito dopo l'esecuzione del metodo ITpsViewSetup.Install. Quest'ultimo viene chiamato all'arresto
della visualizzazione client, subito prima dell'esecuzione del metodo ITpsViewSetup.Uninstall.
L'interfaccia viene utilizzata anche quando si seleziona un'altra applicazione sulla barra delle applicazioni.
TAF chiama quindi ITpsViewActivation.Deactivate (ma non ITpsViewSetup.Uninstall).
Allo stesso modo, quando l'applicazione riprende lo stato attivo tramite

6.3 Prestazioni
Continua
sull'icona della barra delle applicazioni, TAF chiama ITpsViewActivation.Activate

(ma non ITpsViewSetup.Install).
Si consiglia di abilitare e disabilitare eventuali sottoscrizioni agli eventi del controller nei metodi
ITpsViewActivation, poiché le risorse preziose non dovrebbero essere conservate quando
l'applicazione non viene utilizzata. Tieni presente che i valori correnti devono essere letti prima di
abilitare l'abbonamento.
Per lo stesso motivo con queste modalità è possibile attivare e disattivare eventuali timer.
In questo modo i timer non verranno eseguiti quando sono attive altre applicazioni, risparmiando così la
potenza del processore.
Una manipolazione eccessiva delle stringhe è

costosa. La classe string è di tipo immutabile, ovvero una volta creata una stringa il suo valore
non può essere modificato. Ciò significa che i metodi stringa che sembrano modificare la stringa in
realtà creano nuove stringhe.
Guarda questo esempio di concatenazione di stringhe:

string name = "192.168.126.1"; stringa str
= "/" + nome + "/" + "RAPID";
Quattro stringhe verranno aggiunte a una stringa risultante. Non meno di quattro stringhe aggiuntive
verranno create e allocate quando viene eseguito il lato destro dell'assegnazione. Un'idea migliore
è utilizzare la classe StringBuilder o string.Format (che utilizza StringBuilder internamente):
string str = string.Format("/{0}/RAPID", nome);
Di norma, se si intende eseguire una sola operazione su una stringa particolare, è possibile
utilizzare il metodo stringa appropriato. È quando inizi a eseguire numerose operazioni sulle
stringhe che devi utilizzare StringBuilder o string.Format.
Evita Control.Refresh
Control.Refresh() deve essere utilizzato solo quando è assolutamente necessario un aggiornamento
immediato della GUI. Refresh effettua una chiamata diretta al metodo OnPaint del Control ed è
quindi molto più costoso di Control.Invalidate().

6.3 Prestazioni
Continua
Diverse chiamate a Invalidate non significheranno diverse chiamate a OnPaint. Quando il
Il thread della GUI elabora il messaggio Invalidate, tutti i messaggi in coda dello stesso controllo vengono
gestiti contemporaneamente, risparmiando così potenza di processo.
Nota
Nella versione 2.0 di .NET CF sono presenti nuovi metodi da utilizzare per i controlli GUI che ereditano
System.Windows.Forms.Control:
• SospendiLayout()
• RiprendiLayout()
• InizioAggiornamento()
• FineAggiornamento()
Questi metodi vengono utilizzati per controllare gli aggiornamenti della GUI durante la modifica di un elemento della GUI.
Il controllo non verrà disegnato quando viene chiamato SuspendLayout, ad esempio, ma viene bloccato
finché non viene chiamato ResumeLayout.
Evitare boxing e unboxing Un motivo

comune per la lentezza del codice è il boxing e unboxing involontario. Per evitare ciò, è necessario essere
consapevoli della differenza tra tipi di riferimento e di valore.
I tipi di riferimento (viene utilizzata la classe parola chiave) vengono sempre allocati nell'heap, mentre i
tipi di valore vengono allocati nello stack; a meno che non sia incorporato in un tipo di riferimento.
Il boxing è l'operazione in cui un tipo di valore viene convertito in un tipo di riferimento. Viene eseguito
automaticamente quando è richiesto un riferimento a un tipo di valore. Successivamente verrà creato un
nuovo oggetto, allocato nell'heap con una copia dei dati originali.
Ecco alcuni esempi di boxing/unboxing non così ovvi: • L'utilizzo dell'istruzione
foreach su un array che contiene tipi di valore causerà

i valori da boxare e unboxare.
• L'accesso ai valori di una Hashtable con una chiave di tipo valore causerà la creazione di un riquadro
nel valore della chiave quando si accede alla tabella.
• Utilizzo di un ArrayList con tipi di valore; questo dovrebbe essere evitato: utilizzare invece array tipizzati.
Gli array tipizzati sono migliori anche grazie alla sicurezza del tipo, poiché il controllo del tipo può
essere eseguito in fase di compilazione.
• I seguenti metodi dovrebbero essere sovrascritti per evitare inutili operazioni

boxing/unboxing: Uguale( ), GetHashCode( ).
Per ciascuno
L'uso di un ciclo for è spesso più veloce dell'uso dell'istruzione foreach, soprattutto se viene effettuato un
numero elevato di iterazioni. Il motivo è che al compilatore JIT (vedere Informazioni su termini e acronimi a
pagina 17) non è consentito ottimizzare l'esecuzione del codice quando viene utilizzato foreach.
Tuttavia, foreach rende il codice più leggibile ed è quindi un'opzione migliore quando le prestazioni non sono
cruciali.

6.3 Prestazioni
Continua
La riflessione richiede prestazioni elevate

La riflessione è un meccanismo utilizzato per leggere i metadati di un assembly. L'operatore
typeof, ad esempio, utilizza la riflessione per determinare il tipo di un oggetto. Un altro
esempio è object.ToString(), che utilizza anch'esso la riflessione.
Poiché la riflessione richiede molto prestazioni, si consiglia di sovrascrivere o evitare il
metodo ToString() per i tipi di riferimento.
Analisi efficiente di Xlm

XmlTextReader e XmlDocument possono essere entrambi utilizzati per analizzare i
dati XML. XmlTextReader è l'opzione preferita nella maggior parte dei casi; è più leggero
(meno ingombro di memoria) e molto più veloce da istanziare. La limitazione
di XmlTextReader è che è possibile solo la lettura in avanti.
Anche la struttura xml può avere un impatto sulle prestazioni. Se i dati xml sono organizzati
in modo non flat, le operazioni di ricerca saranno più veloci, poiché gran parte delle
informazioni potranno essere saltate. Ciò si ottiene utilizzando categorie e sottocategorie.


6.4 Affidabilità
6.4 Affidabilità
Panoramica
Questa sezione presenta informazioni su come rendere robusta l'applicazione. Il meccanismo più
importante legato alla robustezza e all’affidabilità è la gestione degli errori. Evitare conflitti di thread
e perdite di memoria è tuttavia anche un mezzo importante per migliorare l'affidabilità.
Gestione degli errori nelle applicazioni .NET

Come già sottolineato in questo manuale, Microsoft consiglia di utilizzare le eccezioni per scoprire
e segnalare anomalie nelle applicazioni .NET. Se non si è sicuri su quando utilizzare le eccezioni
o su come eseguire l'implementazione, leggere Gestione delle eccezioni a pagina 56 per
comprendere l'idea generale prima di passare alle informazioni specifiche su FlexPendant di
questa sezione.
Classi di eccezioni SDK

Lo spazio dei nomi ABB.Robotics fornisce alcune classi di eccezioni, utilizzate dalle applicazioni
FlexPendant SDK e SDK. Inoltre, l'SDK utilizza anche le eccezioni di sistema e può, ad esempio,
generare un oggetto System.ArgumentException.
Ogni volta che viene generata un'eccezione, l'applicazione deve rilevarla e intraprendere l'azione
adeguata. Puoi rilevare un'eccezione utilizzando le istruzioni try-catch(-finally).
Per ulteriori informazioni su come implementare queste istruzioni, vedere Gestione delle eccezioni
a pagina 56.
Come puoi vedere nell'immagine seguente, GeneralException deriva da

BaseException, che a sua volta deriva da System.ApplicationException della libreria di classi .NET
Framework.
ApplicationException viene generata dai programmi utente, come FlexPendant
SDK, non da Common Language Runtime (CLR, per ulteriori informazioni, vedere

6.4 Affidabilità
Continua
Definizioni a pagina 17). Rappresenta quindi un modo per distinguere tra

eccezioni definite dalle applicazioni ed eccezioni definite dal sistema.
Come vedi, ci sono tipi derivati in GeneralException. La tabella seguente elenca e
descrive brevemente questi tipi:
7.4_1Generale
7.4_2FP_SDK_

6.4 Affidabilità
Continua
Mancia
Per ulteriori informazioni sulle classi di eccezioni SDK FlexPendant, consultare il Manuale di
Affinità di filo
Dovresti essere consapevole che l'esecuzione del codice che modifica l'interfaccia utente deve essere
eseguita sul thread che ha creato il controllo della GUI, il cosiddetto thread della GUI.
Un'applicazione inizialmente inizia con un singolo thread. Normalmente tutti i controlli dell'interfaccia
utente vengono creati da questo thread. Gli oggetti dell'interfaccia utente di Windows CE sono
caratterizzati dall'affinità di thread, il che significa che sono strettamente associati al thread che li ha
creati.
L'interazione con la coda di messaggi di un controllo interfaccia da un thread diverso dal thread di
creazione può causare il danneggiamento dei dati o altri errori. Questa restrizione si applica al pool
di thread nonché ai thread creati esplicitamente.
Quando si esegue su un thread secondario, un cosiddetto thread di lavoro, è quindi necessario

eseguire un aggiornamento dell'interfaccia utente con molta attenzione, imponendo il passaggio al
thread della GUI. Questo è in effetti uno scenario molto comune, poiché gli eventi del controller
utilizzano i propri thread e spesso dovrebbero essere comunicati all'utente finale tramite un aggiornamento della GUI.
Nota
L'affinità del thread è particolarmente rilevante per quanto riguarda gli eventi del controller del robot,
poiché questi vengono eseguiti per impostazione predefinita su un thread in background. Per ulteriori
informazioni ed esempi di codice, vedere Eventi e thread del controller a pagina 51 ed Eventi e
thread del controller a pagina 51. Anche la sezione seguente tratta lo stesso problema.
Invocare
Per eseguire un metodo sul thread della GUI è possibile utilizzare Control.Invoke.
Dovrebbe tuttavia essere eseguito con attenzione, poiché effettua una chiamata sincrona al gestore di
eventi specificato, che blocca l'esecuzione finché il thread della GUI non ha terminato l'esecuzione del
metodo. Tutte le chiamate simultanee a Invoke verranno accodate ed eseguite nel relativo ordine di
coda dal thread della GUI. Ciò potrebbe facilmente rendere la GUI meno reattiva.
Ora esiste una versione asincrona di Invoke, che dovrebbe essere utilizzata quando possibile.
TpsControl.BeginInvoke è un metodo non bloccante, che consente al thread di lavoro di continuare
l'esecuzione invece di attendere che il thread della GUI abbia elaborato il metodo
Ricordare che Invoke e BeginInvoke devono essere utilizzati solo sul codice che modifica l'interfaccia
utente. Dovresti mantenere l'esecuzione nel thread in background il più a lungo possibile.
Nota
Se il codice tenta di accedere a un controllo GUI da un thread in background, Common Language

Runtime .NET genererà un'eccezione System.NotSupportedException.

6.4 Affidabilità
Continua
Perdite di memoria
Poiché le applicazioni FlexPendant dovrebbero essere eseguite senza interruzioni, non possono essere
consentite perdite di memoria. È tua responsabilità ripulire adeguatamente e chiamare Dispose.
Prendersi il tempo necessario per studiare Come evitare perdite di memoria a pagina 77, Gestione della
memoria a pagina 167 e Panoramica tecnica del dispositivo FlexPendant a pagina 165.
Utilizzo del multithreading

Il threading consente al programma di eseguire elaborazioni simultanee in modo da poter eseguire più di
un'operazione alla volta. Ad esempio, puoi utilizzare il threading per monitorare l'input dell'utente ed
eseguire attività in background contemporaneamente. Lo spazio dei nomi System.Threading
fornisce classi e interfacce che consentono di eseguire facilmente attività come la creazione e l'avvio di
nuovi thread, la sincronizzazione di più thread, la sospensione e l'interruzione dei thread.
Le classi Thread e ThreadPool possono essere utilizzate per eseguire metodi su un lavoratore
filo. Utilizza ThreadPool per l'utilizzo temporaneo di un thread in background quando si prevede che
un'attività termini abbastanza presto. Utilizza Thread solo per il lavoro in background che persisterà, ad
esempio un thread che recupera continuamente dati dal controller.
In .NET CF sono disponibili due timer che possono essere utilizzati per eseguire metodi periodicamente
a intervalli specificati. Esiste tuttavia un'importante differenza tra questi. System.Threading.Timer esegue
il metodo su un thread in background, mentre System.Windows.Forms.Timer esegue il metodo sul thread
dell'interfaccia utente.
Nota
Utilizzare System.Threading.Timer se si desidera eseguire il polling dei dati dal controller per ridurre il
carico sul thread della GUI.
Dichiarazione di blocco
L'istruzione lock viene utilizzata nelle applicazioni multi-thread per garantire che l'accesso a una parte
del codice venga effettuato esclusivamente da un thread. Se un secondo thread tenta di bloccare il codice
che è già stato bloccato da un altro thread, deve attendere finché il blocco non viene rilasciato.
Ricordati di limitare il segmento di codice che vuoi controllare, ovvero blocca solo ciò che è
assolutamente necessario per rendere sicuro il thread di codice:
Oggetto thisLock = nuovo Oggetto();
serratura (questa serratura)
{
// Sezione del codice critico
}
Bisogna evitare le situazioni di stallo. Possono verificarsi se viene utilizzata più di una serratura. Se è
necessario trattenere più di un oggetto di blocco, questi devono sempre essere bloccati e rilasciati nello
stesso ordine, ovunque vengano utilizzati.


6.4 Affidabilità
Continua
Nota
Se si verifica un deadlock, il sistema FlexPendant si bloccherà. Se ciò accade, dovresti

collegare il dispositivo al debugger di Visual Studio e studiare lo stack di chiamate dei thread
nella finestra Threads.
ATTENZIONE
L'utilizzo dell'istruzione lock in combinazione con una chiamata a Invoke è una potenziale
causa di situazioni di stallo, poiché Invoke è una chiamata bloccante. Insomma, fate attenzione
se usate le serrature!
Delegati multicast
Se viene eseguito un delegato multicast, l'esecuzione dei delegati viene terminata se viene
lanciata un'eccezione da uno dei delegati. Ciò significa che i restanti delegati nell'elenco
non verranno eseguiti se viene generata un'eccezione. Questa situazione può causare un
comportamento irregolare, che potrebbe essere difficile da tracciare ed eseguire il debug.
Pertanto, se disponi di numerosi delegati che devono essere eseguiti come risultato dello stesso
evento, potresti voler implementare il metodo GetInvocationList. Recupera un elenco con una
copia dei delegati. Questo elenco può essere ripetuto e ciascun delegato può essere
chiamato direttamente:
7.4_3.GetInv

7 FlexPendant - Debug e risoluzione dei problemi
7.1 Debug

7.1 Debug
introduzione
L'utilizzo del debugger di Visual Studio per un'applicazione SDK FlexPendant non presenta alcuna
differenza rispetto allo sviluppo .NET standard. Il debug può essere eseguito utilizzando l'IRC5
virtuale in RobotStudio o un controller reale.
Codici di errore di eccezione

Ad alcune eccezioni che potrebbero apparire durante lo sviluppo sono associati codici di errore. I
codici di errore possono aiutarti a correggere il problema.
Codice Descrizione
0x80040401 Non è stato possibile soddisfare il livello di sondaggio richiesto, viene utilizzato il livello di sondaggio basso.
0x80040402 Non è stato possibile soddisfare il livello di sondaggio richiesto, viene utilizzato il livello di
sondaggio medio.
0xC0040401 Nessuna connessione con il controller.
0xC0040402 Errore di connessione al controller.
0xC0040403 Nessuna risposta dal controllore.
0xC0040404 Coda messaggi piena. (Dovrebbe verificarsi solo se vengono effettuate

chiamate asincrone.)
0xC0040405 In attesa di una risorsa.
0xC0040406 Il messaggio inviato è troppo grande per essere gestito.
0xC0040408 Una stringa non contiene caratteri esclusivamente di una codifica supportata,
ad esempio ISO-8859-1 (ISO-Latin1).
0xC0040409 La risorsa non può essere rilasciata poiché è in uso.
0xC0040410 Il client è già connesso come utente controller.
0xC0040411 Il controller non era presente in NetScan.
0xC0040412 Il NetScanID non è più in uso. Controller rimosso dall'elenco.
0xC0040413 L'ID client non è associato a un utente controller. Restituito solo dai metodi che
devono verificarlo prima di inviare la richiesta al controller. Altrimenti vedere
0xC004840F.
0xC0040414 La versione di RobotWare è successiva al Robot Communication Runtime

installato. È necessario installare un Robot Communication Runtime più
recente. Restituito da RobHelperFactory.
0xC0040415 La maggior parte della versione RobotWare è nota, ma la revisione è successiva

e non completamente compatibile. È necessario installare un Robot
Communication Runtime più recente. Codice restituito da RobHelperFactory.
0xC0040416 La versione RobotWare non è più supportata. Codice restituito da

RobHelperFactory.
0xC0040417 Il tipo di supporto non è supportato da RobotWare. L'helper potrebbe essere

obsoleto o per versioni successive di RobotWare oppure potrebbe non
essere supportato da un controller BootLevel. Codice restituito da
RobHelperFactory.


7.1 Debug
Continua
Codice Descrizione
0xC0040418 L'ID di sistema e l'ID di rete non corrispondono, non identificano il file
stesso controllore.
0xC0040601 La chiamata è stata effettuata da un client diverso da quello che ha effettuato la chiamata
Chiamata Connect().
0xC0040602 File non trovato nel file system locale. Può essere quel file, directory
o il dispositivo non esiste.
0xC0040603 File non trovato nel file system remoto. Può darsi che il file, la directory o il
dispositivo non esista.
0xC0040604 Errore durante l'accesso/creazione del file sul file system locale.
0xC0040605 Errore durante l'accesso/creazione del file sul file system remoto.
0xC0040606 Il percorso o il nome file è troppo lungo o comunque non valido per il file system
Vx-Works.
0xC0040607 Il trasferimento del file è stato interrotto. Durante il trasferimento a remoto

sistema, la causa potrebbe essere che il dispositivo remoto è pieno.
0xC0040608 Il dispositivo locale è pieno.
0xC0040609 Il client ha già una connessione e non può effettuare una nuova connessione
finché quella attuale non viene disconnessa.
0xC0040701 Uno o più file nella directory di rilascio sono danneggiati e non possono essere salvati
essere utilizzato quando si avvia un VC.
0xC0040702 Uno o più file nella directory di sistema sono danneggiati e non possono essere salvati
essere utilizzato quando si avvia un VC.
0xC0040703 È già stato avviato un VC per questo sistema; un solo V.C

per sistema è consentito.
0xC0040704 Impossibile avviare a caldo VC poiché è necessario prima avviarlo a freddo.
0xC0040705 L'operazione richiesta non è riuscita poiché la proprietà della VC non è mantenuta
o non è stato possibile ottenerlo.
0xC0048401 Fuori dalla memoria.
0xC0048402 Non ancora implementato.
0xC0048403 Il servizio non è supportato in questa versione del controller.
0xC0048404 Operazione non consentita sul sistema attivo.
0xC0048405 I dati richiesti non esistono.
0xC0048406 La directory non contiene tutti i dati necessari per il completamento

l'operazione.
0xC0048407 Operazione rifiutata dalla limitazione dell'accesso di sicurezza del controller

meccanismo.
0xC0048408 La risorsa non è trattenuta dal chiamante.
0xC0048409 Un argomento specificato dal client non è valido per questo tipo di
operazione.
0xC004840A Mancata corrispondenza nell'ID del controller tra il backup e il sistema corrente.
0xC004840B Mancata corrispondenza nell'ID chiave, ovvero opzioni, lingue e così via.
tra il backup e il sistema corrente.
0xC004840C Mancata corrispondenza nel tipo di robot tra il backup e il sistema corrente.
0xC004840D Al client non è consentito accedere come utente locale.
0xC004840F Il client non è connesso come utente controller.


7.1 Debug
Continua
Codice Descrizione
0xC0048410 La risorsa richiesta è già trattenuta dal chiamante
0xC0048411 È stato raggiunto il numero massimo di risorse richieste.
0xC0048412 Nessuna richiesta attiva per l'utente specificato.
0xC0048413 Timeout dell'operazione/richiesta sul controller.
0xC0048414 Nessun utente locale è connesso.
0xC0048415 L'operazione non è stata consentita per l'utente specificato.
0xC0048416 L'URL utilizzato per inizializzare l'helper non si risolve in a

oggetto valido.
0xC0048417 La quantità di dati è troppo grande per soddisfare la richiesta.
0xC0048418 Il controller è occupato. Riprovare più tardi.
0xC0048419 La richiesta è stata respinta.
0xC004841A La risorsa richiesta è detenuta da qualcun altro.
0xC004841B La funzionalità richiesta è disabilitata.
0xC004841C L'operazione non è consentita nella modalità operativa corrente. Per

Ad esempio, a un utente remoto potrebbe non essere consentito eseguire l'operazione
funzionamento in modalità manuale.
0xC004841D L'utente non ha la padronanza richiesta per l'operazione.
0xC004841E Operazione non consentita mentre il backup è in corso.
0xC004841F Operazione non consentita quando le attività sono in stato sincronizzato.
0xC0048420 Operazione non consentita quando l'attività non è attiva nella selezione dell'attività
pannello.
0xC0048421 Mancata corrispondenza nell'ID del controller tra il backup e il sistema corrente.
0xC0048422 Mancata corrispondenza nell'ID del controller tra backup e corrente.
0xC0048423 ID cliente non valido.
0xC0049000 Il simbolo RAPID non è stato trovato.
0xC0049001 La posizione della sorgente specificata non è valida per l'operazione.
0xC0049002 Il file indicato non è stato riconosciuto, ad esempio, come file di programma
la semantica XML potrebbe non essere corretta.
0xC0049003 Nome del modulo ambiguo.
0xC0049004 Il nome del programma RAPID non è impostato.
0xC0049005 Il modulo è protetto dalla lettura.
0xC0049006 Il modulo è protetto da scrittura.
0xC0049007 L'operazione non è valida nello stato di esecuzione corrente.
0xC0049008 L'operazione non è valida nello stato dell'attività corrente.
0xC0049009 Il robot non è sul percorso e non è in grado di riavviarsi. Riprendere a o

percorso chiaro.
0xC004900A L'operazione non è valida al livello di esecuzione corrente.
0xC004900B L'operazione non può essere eseguita senza distruggere la corrente

contesto di esecuzione.
0xC004900C La memoria heap RAPID è piena.
0xC004900D Operazione non consentita a causa di errori di sintassi.


7.1 Debug
Continua
Codice Descrizione
0xC004900E Operazione non consentita a causa di errori semantici.
0xC004900F Data la routine non è un punto di ingresso legale. I motivi possibili sono:
la routine è una funzione oppure la routine ha parametri.
0xC0049010 È illegale spostare il PCP in un determinato luogo.
0xC0049011 È stato superato il numero massimo di target da derubare.
0xC0049012 L'oggetto non è mod possibile. I motivi possibili sono: l'oggetto è a

variabile, oggetto è un parametro, oggetto è un array.
0xC0049013 Operazione non consentita con spostamento attivo.
0xC0049014 Il robot non è sul percorso e non è in grado di riavviarsi. Riprendere a

sentiero. Non è consentito cancellare.
0xC0049015 Rimane il percorso precedentemente pianificato. Scegli se consumare

il percorso, il che significa che il movimento iniziale potrebbe essere in un
direzione inaspettata, o per liberare il percorso e spostarsi direttamente verso
prossimo obiettivo.
0xC004A000 Errore generale di gestione dei file.
0xC004A001 Il dispositivo è pieno.
0xC004A002 Disco sbagliato. Cambia disco e riprova.
0xC004A003 Il dispositivo non è pronto.
0xC004A004 Percorso non valido.
0xC004A005 Dispositivo non valido.
0xC004A006 Impossibile creare la directory.
0xC004A007 La directory non esiste.
0xC004A008 La directory esiste già.
0xC004A009 La directory contiene dati.
0xC004A00B Impossibile creare il file.
0xC004A00C File non trovato o impossibile aprirlo per la lettura.
0xC004A200 Disabilitazione dell'unità non consentita al livello di fiducia 0.

7.2 Uscita di debug
7.2 Uscita di debug
Panoramica
È possibile ottenere l'output di debug dalla FlexPendant utilizzando la rete. Ciò è utile per diversi motivi. Rivelerà
eventuali eccezioni generate durante l'esecuzione, ad esempio fornendo messaggi di errore e stack di chiamate.
Inoltre, può aiutarti a controllare il consumo di memoria e le perdite di memoria nella tua applicazione.
Il messaggio FlexPendant viene compresso in un messaggio di rete e inviato sulla rete come messaggio broadcast
sulla porta 9998. Tale messaggio può essere raccolto in diversi modi:
• Collegare un hub alla rete FlexPendant locale e collegarvi un PC. Utilizzo
nc.exe per raccogliere i messaggi (nc - lup 9998). • I messaggi
inviati vengono inoltre memorizzati in un ring buffer di dimensione 100kB. Leggere

il buffer per archiviarlo e memorizzarlo sul controller, è possibile utilizzare FlexPendant Command Server.
Utilizzare fpcmd “-d”.
•
È anche possibile avviare un'attività sul controller che ascolta la porta 9998 e visualizza tutti i messaggi
nel buffer della console. Utilizzare il comando fp_enable_console_output.
Mancia
Per un elenco delle eccezioni che il Controller IRC5 può lanciare, vedere Debug a pagina 181.
Abilita l'output di debug Per
abilitare l'output di debug scrivere fpcmd_enable_console_output nella finestra della console del controller. Per
ulteriori informazioni sulla finestra della console, vedere Codici di errore di eccezione a pagina 181.
Questi sono i comandi della console utilizzati per abilitare e disabilitare le stampe:
Comando della consolle Risultato
fpcmd_enable_console_output 1 Inizia a produrre stampe da RobotWare alla console del controller

del robot.
fpcmd_enable_console_output 2
fpcmd_enable_console_output 3 Inizia a produrre stampe dall'applicazione SDK.
Combina i due precedenti: stampe RobotWare + SDK.
fpcmd_disable_console_output Interrompe la stampa sulla console del controller del robot.
Il seguente comando può essere utilizzato per recuperare lo stato dettagliato del controller del robot, il
che potrebbe essere utile, sebbene potrebbe non essere specificamente correlato alla tua applicazione.
Comando della consolle Risultato
fpcmd “-d” Produce un file di registro con informazioni dettagliate sullo

stato del sistema nel file del controller del robot sys-
tem(hd0a/temp). Utilizzare un client ftp o File Manager in RobotStudio
per trasferire il file sul PC.


7.2 Uscita di debug
Continua
Server dei comandi FlexPendant

Utilizzando la riga di comando sul controller è possibile inviare comandi al file
FlexPendant. La FlexPendant dispone di un server di comando che interpreta i comandi
ed esegue l'operazione richiesta. La sintassi per i comandi della riga di comando
è fpcmd “<comando>”. L'unico comando che devi ricordare è fpcmd "-h",
che è il comando Aiuto. Produce una stampa della FlexPendant disponibile
comandi nella console del controller:
-> fpcmd valore "-h" = 8 = 0x8-> [fp]: FlexPendantCmd: Guida
La tabella seguente elenca il comando con le azioni specifiche:
Comando Azione
fpccmd "-h" Aiuto
fpccmd "-a" Routine di spettacolo dell'adattatore
fpcmd "-m" Misurare il tempo negli adattatori
fpcmd "-i" Visualizza le informazioni sulla FlexPendant
fpcmd "-f" Porta i servizi GTPU in primo piano
fpccmd "-x" Nascondi la barra di avanzamento dell'avvio
fpcmd "-s" Avvia l'applicazione
fpcmd "-d" Copia il file di debug sul controller
fpcmd "-as" Schermata di stampa
fpcmd "-rd" Debug del runtime di comunicazione del robot
fpcmd "-riavvia" Riavvia il dispositivo
fpcmd "-memshow" Memoria disponibile
fpcmd "-modulo" Informazioni sul modulo di un processo
fpcmd "-filePut" Caricare un file sulla FlexPendant
fpcmd "-filettato" Scaricare un file sulla FlexPendant
fpcmd "-diarista" Elenca una directory
Nota
Tutti i comandi supportano -? (ad esempio fpcmd “-memShow -?”), che dà

ulteriori informazioni sul comando specifico.
Mancia
È possibile monitorare il consumo di memoria nella console del controller del robot
finestra:
1 Scrivi fpcmd_enable_console_output 3.
2 Scrivere fpcmd "-memShow".
Per ulteriori informazioni, vedere Gestione della memoria a pagina 167.


7.2 Uscita di debug
Continua
Traccia e debug
Lo spazio dei nomi ABB.Robotics.Diagnostics fornisce servizi di traccia e debug. Le
sue classi Trace e Debug sono progettate specificatamente per l'ambiente FlexPendant.
Le proprietà e i metodi nella classe Trace vengono utilizzati per strumento di build di
rilascio, che consente di monitorare l'integrità dell'applicazione in esecuzione in un
ambiente reale. La traccia può aiutarti a isolare i problemi e risolverli senza disturbare
il sistema in esecuzione.
Se utilizzi metodi nella classe Debug per stampare informazioni di debug e verificare la
logica con le asserzioni, puoi rendere il codice più robusto senza influire sulle prestazioni e
sulla dimensione del codice del prodotto spedito. In Visual Studio, la creazione di una build
di debug abilita Debug.
Traccia e Debug forniscono informazioni sulla stampa durante l'esecuzione. I
messaggi vengono visualizzati sullo schermo della FlexPendant o nella console del
controller del robot. La funzionalità è simile a quella fornita dalle classi .NetTrace e Debug.
Il metodo Assert verifica una condizione e visualizza un messaggio di asserzione sulla
FlexPendant, incluse informazioni dettagliate e un'analisi dello stack, se la condizione è
falsa. Il messaggio viene visualizzato anche nella finestra della console del controller
se si immette prima il comando fpcmd_enable_console_output.
Nota
Aggiungi lo spazio dei nomi ABB.Robotics.Diagnostics alla sezione using nella parte
superiore del file del codice sorgente.

7.3 Debug della FlexPendant virtuale
Panoramica
Quando si esegue il debug dell'applicazione è spesso conveniente utilizzare l'ambiente
virtuale, ma è quasi altrettanto semplice collegare il debugger di Visual Studio al dispositivo
FlexPendant reale. Per informazioni su come eseguire questa operazione, vedere Debug del
dispositivo FlexPendant a pagina 192.
Questa sezione descrive come avviare il debugger di Visual Studio, collegarvi una Virtual
FlexPendant in esecuzione, impostare punti di interruzione e scorrere il codice sorgente di
un'applicazione FlexPendant.
Procedura di debug
Esistono diversi modi per collegare un debugger di Visual Studio a un'applicazione Virtual FlexPendant
in esecuzione. In questa sezione un metodo è descritto in dettaglio.
Non è possibile avviare l'applicazione FlexPendant dall'interno dell'ambiente Visual Studio. È
necessario iniziare distribuendo l'applicazione sulla Virtual FlexPendant in RobotStudio. Come
eseguire questa operazione è descritto in Hands on - Hello world a pagina 70.
Quindi avviare Virtual FlexPendant e collegarvi il debugger di Visual Studio.
Nota
Per utilizzare i punti di interruzione, la configurazione di compilazione del progetto deve essere
Debug. Lo imposti nella scheda Costruisci delle Proprietà del progetto. La directory di output,
dove si trova l'assembly (*.dll), l'assembly proxy (*gtpu.dll) e il database del programma
(*.pdb) è la directory bin/Debug, una sottodirectory del progetto Visual Studio.

Continua
Allega al processo
Quando hai un'applicazione in esecuzione sulla Virtual FlexPendant, segui questi passaggi:
Passo Azione
1 In Visual Studio nel menu Debug selezionare Connetti al processo. Viene visualizzata questa finestra
di dialogo:
9.1.3_1Attac
2 Selezionare il processo Virtual FlexPendant.exe e fare clic sul pulsante Allega .
3 Imposta un punto di interruzione nel codice sorgente.
4 Sulla Virtual FlexPendant, fare clic su un pulsante dell'applicazione o su qualcos'altro che farà sì che
l'esecuzione del programma raggiunga il punto di interruzione.


Continua
Passo Azione
5 Nel menu Debug puntare su Windows e selezionare le informazioni di debug da visualizzare
durante il debug. Vedi il seguente esempio:
9.1.3_2PassaggioB
6 Nel menu Debug selezionare il comando Passaggio appropriato durante l'esecuzione del
codice.
7 Nel menu Debug fare clic su Scollega tutto o Interrompi debug quando si desidera
interrompere il debug.

Continua
Gestore dei processi di Windows

È inoltre possibile allegare un'applicazione in esecuzione tramite Task Manager di Windows.
Fare un passo
1 Avvia Task Manager di Windows e seleziona la scheda Processi .
9.1.3_3AttivitàM
2 Selezionare il processo Virtual FlexPendant.exe e fare clic con il pulsante destro del mouse per
ottenere il menu contestuale. In quel menu seleziona Debug. Riceverai un messaggio di avviso, ma
seleziona Sì.
3 Verrà visualizzata una finestra di dialogo Debug Just-In-Time. Seleziona il tuo progetto applicativo come
debugger da utilizzare.
Avvio del debugger in modo programmatico

Ancora un altro modo per collegare un debugger è avviarlo in modo programmatico, scrivendo codice
nell'applicazione.
Passo Azione
Inserisci la seguente riga nel punto in cui desideri che venga avviato il debugger:
System.Diagnostics.Debugger.Launch()
Avviare l'applicazione nella Virtual FlexPendant ed eseguire l'azione che consiste nell'avviare il debugger.
Verrà visualizzata la finestra di dialogo Debug Just-In-Time .
Seleziona il tuo progetto Visual Studio come debugger. Fare clic su OK e avviare la sessione di debug.

7.4 Debug del dispositivo FlexPendant
Panoramica
Questa sezione fornisce informazioni su come eseguire il debug di un'applicazione in esecuzione sul
dispositivo FlexPendant reale.
In generale, l'utilizzo del debugger di Visual Studio per eseguire il debug del dispositivo funziona molto
bene ed è fortemente consigliato, ma a seconda del sistema operativo, della versione di Visual Studio
e della versione FlexPendant che si utilizza, i requisiti per la configurazione e il collegamento del debugger
di Visual Studio differiranno leggermente.
Ulteriori informazioni e aggiornamenti riguardanti questo argomento verranno pubblicati a partire da

questa versione sul forum degli utenti dell'SDK FlexPendant (e non nel manuale dell'applicazione).
Per ulteriori informazioni, consultare Forum utenti SDK FlexPendant a pagina 194.
Prerequisiti
È necessario soddisfare i seguenti requisiti: • Service
Pack 1 o 2 per .NET Compact Framework 2.0 (.NET CF 2.0 SP2) è richiesto per impostare e utilizzare
il debugger di Visual Studio sul dispositivo FlexPendant. Può essere scaricato da http://
www.microsoft.com/downloads.
• Per eseguire il debug con Visual Studio 2008 (così come Visual Studio 2005 senza SP1) è necessario
seguire una procedura che verrà presentata nel forum degli utenti di FlexPendant SDK. La
procedura sarà diversa per ciascuna versione di RobotWare.
•
Se il tuo PC utilizza Windows Vista, per connettersi al dispositivo è necessario installare “Centro
gestione dispositivi Windows Mobile”.
Configurazione della rete

Questa illustrazione mostra come collegare la FlexPendant, il controller del robot e il PC per eseguire il
debug dell'applicazione utilizzando il debugger di Visual Studio.
9.1.4_3Debug
La FlexPendant ha un indirizzo IP statico 192.168.126.10. L'indirizzo IP del tuo PC deve

essere uno sulla sottorete 126, ovvero 192.168.126.x (non 1 o 255).
Tieni presente che questa configurazione è completamente indipendente dalle porte LAN e di servizio.
Stai collegando il cavo TPU dall'RC allo switch, un cavo dall'interruttore all'RC e un cavo dal PC allo
switch.

Continua
Una connessione tramite la porta LAN è facoltativa, ma utile, poiché potrebbe essere necessario
utilizzare RSO o FTP contemporaneamente. Per utilizzare entrambe le connessioni, il PC richiede
due schede NIC.
Procedura di debug
Seguire questi passaggi per configurare e collegare il debugger di Visual Studio 2005 SP1 al dispositivo
FlexPendant:
Passo Azione
1 Nel menu Strumenti in Visual Studio 2005 fare clic su Opzioni.
2 Nella finestra di dialogo Opzioni espandere il nodo Strumenti dispositivo e selezionare Dispositivi.
Selezionare il dispositivo Windows CE 5.0 come mostrato nello screenshot seguente.
9.1.4_6FPDeb
Nota! Se la versione della FlexPendant è SxTpu1, l'opzione Dispositivo Windows CE 5.0 non è
disponibile. Dovresti invece selezionare Dispositivo Pocket PC 2003.
3 Una volta selezionato il dispositivo corretto, fare clic su Proprietà e quindi su Configura.
4 Applicare le impostazioni mostrate nell'immagine.
9.1.4_7FPDeb


Continua
Passo Azione
5 Nel menu Debug/Strumenti in Visual Studio fare clic su Collega al processo. Nella finestra di
dialogo selezionare Smart Device for Transport e fare clic sul pulsante Sfoglia per specificare la
piattaforma e il dispositivo. Quindi fare clic su Connetti.
9.1.4_8FPDeb
6 Nell'elenco Processi disponibili selezionare taf.exe. Fare clic su Allega.
7 Imposta un punto di interruzione nel codice sorgente.
8 Sulla FlexPendant, fare clic su un pulsante dell'applicazione o su qualcos'altro che farà sì che
l'esecuzione del programma raggiunga il punto di interruzione.
Nota
Se il tuo PC NON utilizza XP con Visual Studio 2005 SP1, devi trovare informazioni
su come collegare il debugger di Visual Studio per il tuo ambiente specifico nel
forum degli utenti di FlexPendant SDK.
Forum utenti dell'SDK FlexPendant

Il forum degli utenti della community RobotStudio di ABB ha una sezione dedicata a
FlexPendant SDK. Qui sia i principianti che gli esperti discutono online di codici e soluzioni.
Qui è anche dove trovi le versioni dell'SDK FlexPendant per il download gratuito e tutte le
informazioni che il team di sviluppo o supporto desidera condividere con te.
Per ulteriori informazioni, vedere Comunità RobotStudio a pagina 16.

7.5 Risoluzione dei problemi delle applicazioni FlexPendant
Panoramica
Se riscontri problemi durante l'esecuzione dell'applicazione, è necessario fare alcune cose prima di contattare
l'organizzazione di assistenza. I seguenti passaggi rappresentano una linea guida approssimativa:
Azione
1 È possibile avviare la domanda? In caso contrario, vedere L'applicazione FlexPendant non si avvia a
pagina 195.
2 Hai controllato le note sulla versione dell'SDK FlexPendant? Molte domande troveranno risposta nelle
Release Notes della specifica release. Questi sono disponibili sul DVD Ro-botWare e sul sito di
download del software.
3 Hai provato a individuare il problema eseguendo il debug della FlexPendant? In caso contrario,
vedere Debug del dispositivo FlexPendant a pagina 192 per informazioni su come farlo.
4 Hai provato a ottenere le stampe di debug? Per ulteriori informazioni, vedere Output di debug a
pagina 185.
5 Il problema è che la FlexPendant pende? Assicurati di utilizzare Invoke quando modifichi l'interfaccia
utente a causa di un evento del controller del robot. Per ulteriori informazioni, vedere Thread di eventi
della GUI e del controller in conflitto a pagina 51 e Metodo Invoke a pagina 52.
Quando si verifica un blocco, collegare il debugger di Visual Studio a FlexPendant. Nel menu Debug
puntare su Windows e selezionare Thread. Esaminare i thread per scoprire eventuali deadlock.
Mancia
Se non hai ancora trovato una soluzione al tuo problema, dai un'occhiata al Forum degli utenti della
community di RobotStudio, che include un forum dedicato alla discussione e alla chat su argomenti
di sviluppo FlexPendant SDK, RAPID e IRC5.
Per ulteriori informazioni, vedere Documentazione e guida a pagina 15
L'applicazione FlexPendant non si avvia

Se non riesci ad avviare l'applicazione, la tabella seguente suggerisce possibili scenari.
Problema Possibile soluzione
L'assembly proxy (*.gtpu.dll) non è stato Correggere eventuali errori di parametro nell'attributo TpsView.
creato. Per ulteriori informazioni, vedere Attributi FlexPendant TpsView
a pagina 40.

Continua
Problema Possibile soluzione
Lo strumento di conformità ABB lamenta Succede che l'installazione di Visual Studio non imposta
di non riuscire a trovare il compilatore correttamente il percorso del compilatore C#. Il compilatore C# è
C#. necessario per eseguire ABB Compliance Tool.
Confermare che il compilatore C# sia disponibile avviando una

finestra di comando ed eseguire "CSC.EXE". Se il risultato è simile
a questo il percorso è impostato correttamente:
C:\>csc.exe
Compilatore Microsoft (R) Visual C# .NET versione
7.10.3052.4
per Microsoft (R) .NET Framework versione
1.1.4322Copyright (C) Microsoft Corporation 2001-2002.
Tutti i diritti riservati.
errore fatale CS2008: nessun input specificato
In caso contrario, trova CSC.EXE e copia il suo percorso nella
finestra di dialogo Proprietà del tuo progetto Visual Studio.
Aggiungere anche il percorso alle variabili d'ambiente PATH del
sistema. Per Windows 2000 Pro e Windows XP trovare la relativa
finestra di dialogo in: Pannello di controllo -> Sistema -> Avanzate
->Variabili d'ambiente -> Variabili di sistema-> Aggiungi nuovo.
Aggiungere il percorso alla directory in cui viene conservato il
compilatore C#. Si noti che un punto e virgola separa gli elementi
del percorso. Successivamente verificare nella finestra di comando che viene eseguito CS
L'applicazione non viene visualizzata nel menu Assicurarsi che il sistema robotico disponga del FlexPendant
Inter-ABB. opzione viso.
Eccezione di riferimento nullo o "Impossibile assicurarsi che tutti gli argomenti nell'attributo TpsView siano
oggetto di ricerca" quando si tocca l'ap appropriato. Per ulteriori informazioni, vedere Icona di plicazione
FlexPendant nel menu ABB. Attributo TpsView a pagina 40.
Il costruttore bitmap fallisce quando si modificano le immagini se utilizzano più di 256 colori. la vera FlexPendant
tenta di caricare Il sistema operativo della FlexPend di prima generazione: le vostre immagini, nel dispositivo
ambientale virtuale (SxTPU1) supporta solo 256 colori. mento questo non accade.
Il processo Virtual FlexPendant rimane Se si dimentica di eliminare un oggetto che ha un riferimento

attivo. COM, come l'oggetto Controller o un Segnale, il processo
Virtual FlexPendant potrebbe rimanere attivo. Passare
attraverso l'applicazione e assicurarsi di eliminare tutti gli oggetti
che dispongono di un metodo Dispose.
Informazioni di supporto importanti

Se non riesci a risolvere il problema da solo, assicurati che prima di contattare un'organizzazione di
supporto siano disponibili queste informazioni:
• Descrizione scritta del problema. • Codice
sorgente dell'applicazione. • Registri
degli errori di sistema. • Un
backup del sistema. • Descrizione
della soluzione alternativa, se esistente.
Mancia
Ancora meglio dell'applicazione completa è un piccolo programma di riproduzione, che espone il tuo
problema.

8 Localizzazione di un'applicazione FlexPendant
8.1 Aggiunta del supporto per diverse lingue

introduzione
Questo capitolo fornisce le informazioni necessarie per localizzare un'applicazione personalizzata.
FlexPendant dispone di supporto integrato per la localizzazione e i meccanismi utilizzati dalle
applicazioni FlexPendant standard possono essere utilizzati anche dalle applicazioni FlexPendant
SDK.
Ciò consente di presentare le applicazioni personalizzate nella lingua attiva della FlexPendant,
ovvero la lingua selezionata nella visualizzazione standard Pannello di controllo - Lingua.
Affinché ciò funzioni, i testi visualizzati nell'applicazione personalizzata devono essere tradotti e
l'applicazione localizzata come descritto in questo capitolo.
Iniziare
Sviluppare l'applicazione utilizzando l'inglese come lingua predefinita. La raccomandazione è di
progettare, implementare e testare l'applicazione prima di aggiungere il supporto per altre lingue.
Per localizzare un'applicazione FlexPendant, completare attentamente ciascuna procedura di
questo capitolo.
Nota
È necessario un metodo per gestire la localizzazione quando vengono aggiunte nuove funzionalità
dell'applicazione.
1 Creare un progetto per le risorse di testo

Questa procedura crea un progetto separato per i testi dell'interfaccia utente.
Passo Azione
1 Creare un nuovo progetto nella soluzione. Scegli un dispositivo intelligente - Windows CE 5.0 -
Progetto vuoto e assegna al progetto il nome <YourAppName>Testi.
Nota
Entrambi i progetti dovrebbero appartenere alla stessa soluzione. L'applicazione verrà ora compilata
in tre assembly: <YourAppName>.dll , <YourAppName>.gtpu.dll e <YourAppName>Texts.dll.
2 Nel progetto Testi aggiungere un riferimento a System (.Net ).

3 Imposta il tipo di output su Libreria di classi (questo viene fatto nelle Proprietà del progetto).
4 Lo spazio dei nomi utilizzato per il progetto Testi deve essere lo stesso utilizzato per il progetto
principale. Poiché lo spazio dei nomi non è visibile nel file di risorse, è necessario modificarlo nelle
Proprietà del progetto in questo modo:
10.1_5Stringa

Continua
Passo Azione
5 Aggiungere un file di risorse al progetto facendo clic con il pulsante destro del mouse sul progetto in Esplora
soluzioni e selezionando Aggiungi nuovo elemento. Impostare il nome del file su “strings.resx”. Questo file
conterrà i testi della lingua predefinita (normalmente inglese).
6 Apri il file di risorse e aggiungi nome e valore per i testi della lingua predefinita.
Utilizza le lettere maiuscole nella colonna del nome.
6.5.1_1Multi
7 Nel progetto Testi crea una cartella con la forma abbreviata della cultura come nome, ad esempio de per il
tedesco e sv per lo svedese.
10.1_6FPLang
Nota
Il russo (ru) è stato aggiunto in RobotWare/FlexPendant SDK 5.11.
ATTENZIONE
È necessario utilizzare i moduli brevi standard elencati nello screenshot precedente.
Nota
Per utilizzare il cinese o un'altra lingua con caratteri non occidentali, è necessario utilizzare il carattere
FlexPendant, TpsFont, per tutti i controlli dell'interfaccia utente. Controlla internamente quale lingua è
attualmente attiva sulla FlexPendant e utilizza il carattere corretto per quella lingua.
8 Copia il file "strings.resx" nelle cartelle create nel passaggio precedente.


Continua
Passo Azione
9 Il nome del file utilizzato per le risorse esterne dovrebbe essere strings.<culture>.resx, ad esempio
"strings.sv.resx" come nello screenshot seguente. Fare clic con il pulsante destro del mouse sul file
e rinominarlo.
10.1_4Stringa
10 Apri il file di risorse e traduci i testi nella colonna del valore. Il nome è l'identità del testo e dovrebbe
rimanere lo stesso.
Nota
Ovviamente i testi potrebbero allungarsi o accorciarsi una volta tradotti. Potrebbe quindi essere
necessario aumentare le dimensioni di alcuni controlli della GUI dopo aver testato l'applicazione.
2 Preparare il progetto principale per la localizzazione

Segui questi passaggi per aggiungere la localizzazione al tuo progetto principale:
Passo Azione
1 Aggiungere un riferimento ad ABB.Robotics.Taf.Base nel progetto principale.

2 Nell'attributo TpsView della classe view inserisci il nome della dll Texts in questo modo:
[assembly: TpsView("ABB_MENU_TITLE_TXT","tpu-Operat-
or32.gif","tpu-Operator16.gif", "TpsViewIRC5App.dll",
"TpsViewIRC5App.TpsViewIRC5App", StartPanelLoca-tion.Left,
TpsViewType.Static,"TpsViewLocalizedApp-Texts.dll", TpsViewStartupTypes.Manual)]

Continua
Passo Azione
3 Dichiarare un oggetto TpsResourceManager all'inizio della classe come variabile membro privata e
inizializzarlo nel costruttore.
Aggiungi una chiamata a un metodo InitializeTexts.
//dichiarazione
privato ABB.Robotics.Tps.Resources.TpsResourceManager _tpsRM;
//metodo del costruttore
_tpsRM = nuovo ABB.Robotics.Tps.Resources.TpsResourceMan-

ager("TpsViewLocalizedApp.strings", ABB.Robot-
ics.Taf.Base.TafAssembly.Load("TpsViewLocalizedApp-Texts.dll"));
InizializzaComponente();
Inizializza testi();
Nota
Il primo argomento del costruttore dovrebbe essere il nome della tua applicazione con .strings come
suffisso aggiunto. Il secondo argomento è il nome dell'assembly contenente le risorse.
4 Implementare InizializzaTesti( ). Utilizza l'oggetto TpsResourceManager e chiama GetString() utilizzando

l'identità (nome) del testo che vuoi come argomento. A seconda della lingua attiva della FlexPendant,
questa chiamata recupererà la risorsa linguistica corrispondente.
Esempio:
Inizializza testi()
{
this.Label1.Text = _tpsRM.GetString("TXT_INSTR_LABEL");
}
Lasciare il contenuto del metodo InitializeComponent così com'è, ad esempio Label1.Text = "Signals"
e così via.
5 L'oggetto TpsResourceManager non è ancora stato creato quando si vuole che l'icona e il titolo
dell'applicazione appaiano nel menu di ABB, per cui è necessario utilizzare un'altra tecnica per
visualizzarli correttamente. Aggiungi un nome di risorsa per il titolo dell'applicazione e un valore nel file
di risorse di ciascuna lingua.
Nell'attributo TpsView il primo argomento è il titolo dell'applicazione. Sostituirlo con il nome della risorsa.
Potrebbe assomigliare a questo: [assembly:
TpsView("ABB_MENU_TITLE_TXT", ...,...
TpsViewIRC5AppTexts.dll")]
Verrà ora utilizzato il valore della risorsa corrispondente. Nel caso in cui non venga trovata alcuna risorsa,
il nome verrà utilizzato così com'è.


Continua
3 Costruire l'assieme satellite

Seguire questi passaggi per creare un assembly satellite del file resx localizzato:
Passo Azione
1 Il file di risorse localizzato non deve essere creato con il normale processo di compilazione, ovvero
la proprietà Build Action deve essere impostata su "Nessuno". Fare clic con il tasto
destro sul file strings.<culture>.resx e selezionare proprietà:
6.5.1_4resxP
2 È ora necessario utilizzare lo strumento resgen.exe di Visual Studio 2005 per compilare il file resx in
una risorsa binaria. Successivamente lo strumento di collegamento assembly di Visual Studio 2005
al.exe dovrebbe creare un assembly satellite della risorsa binaria.
Leggere attentamente i seguenti passaggi per assicurarsi che il gruppo satellite sia costruito
correttamente.
Nota
La localizzazione con Visual Studio 2008 non è stata ancora testata.

Continua
Passo Azione
3 Crea un evento post-costruzione nel progetto Testi per automatizzare il processo di
costruzione.
Esempio: TpsViewLocalizedApp con risorse in svedese: mkdir ..\..\lingual
mkdir ..\..\lingua\sv
mkdir ..\..\lingua\sv\tps
cd..\..\sv\
del *.resources
del *.dll
se esiste strings.sv.resx (
resgen strings.sv.resx TpsViewLocalizedApp.strings.sv .re-
fonti
al /t:lib /embed:TpsViewLocalizedApp.strings.sv.resources
/culture:en /out:TpsViewLocalizedAppTexts.resources.dll
copia TpsViewLocalizedAppTexts.resources.dll ..\lan-
guage\sv\tps\TpsViewLocalizedAppTexts.resources.dll)
10.1_9BuPost
Il comando resgen è scritto così:

resgen strings.<culture>.resx
<Namespace>.strings.<culture>.resources dove <culture>
deve essere sostituito con la forma breve della lingua corretta e <Namespace> deve essere
sostituito con lo spazio dei nomi dell'applicazione.
Il comando al prende la dll risultante situata nella stessa directory del file resx e ne crea un
assembly satellite: al /t:lib /
embed:<Namespace>.strings.<culture>.resources /culture:en /out:
<NomeAssemblea>.resources.dll
Nota
Il nome dell'assembly satellite sarà lo stesso per tutte le lingue localizzate.

Il terzo argomento del comando al, culture:en, dovrebbe essere “en” . Il motivo è che il sistema
operativo FlexPendant ha l'inglese come lingua sottostante.

Continua
Passo Azione
4 È necessario garantire che il passaggio di post-compilazione venga eseguito con le versioni corrette di
resgen.exe e al.exe. Il modo più semplice per eseguire questa operazione consiste nell'utilizzare un
prompt dei comandi di Visual Studio 2005 per creare il progetto (o la soluzione) o avviare Visual
Studio da tale prompt.
Fare innanzitutto clic sul menu Start di Windows per avviare il prompt dei comandi (in Programmi >
Microsoft Visual Studio 2005 > Strumenti di Visual Studio). Quindi utilizzare il comando devenv per
avviare Visual Studio 2005.
Ora apri la tua soluzione e costruiscila. Ora è garantita l'esecuzione del comando post-compilazione
con le impostazioni corrette.
6.5.1_5VSCmd
Nota
Per impostazione predefinita, Visual Studio eseguirà i comandi post-compilazione utilizzando le

impostazioni utente del PC (percorsi e così via). Se in precedenza era stato installato Visual Studio
2003, è molto probabile che il comando post-build utilizzi le versioni errate di resgen.exe e al.exe.
La procedura descritta in precedenza garantisce che vengano utilizzate le versioni di Visual Studio
2005.
(Questi si trovano in: C:\Programmi\Microsoft Visual Studio 8\SDK\v2.0\bin/
resgen.exe C:\WINNT\Microsoft.NET\Framework\v2.0.50727/al.exe)
4 Testare un'applicazione
localizzata Per testare un'applicazione localizzata, le risorse devono essere organizzate
correttamente nel file system del controller. Questo dovrebbe essere fatto nello stesso modo
in cui il test viene eseguito su una FlexPendant virtuale o reale. Seguire questi passaggi
per testare l'applicazione su una FlexPendant reale:
Passo Azione
1 Trasferisci, utilizzando un client FTP o il File Manager di RobotStudio, gli assiemi dell'applicazione nella
directory HOME del sistema attivo. (TpsViewLocalizedApp-Texts.dll, TpsViewLocalizedApp.gtpu.dll,
TpsViewLocalizedApp.dll nella schermata seguente).

Continua
Passo Azione
2 Copia la cartella della lingua creata dall'evento post-compilazione nella directory HOME.
10.1_3Lingua
Nota
È anche possibile che sia gli assembly che la cartella della lingua si trovino nella cartella SYSTEM al
livello superiore. Il vantaggio di utilizzare HOME è che i file vengono inclusi in un backup.
3 Verificare che la cartella della lingua contenga cartelle per ogni lingua e che ciascuna cartella tps
disponga di una DLL .resources. Se così non fosse, devi tornare all'evento post-build del tuo
progetto Texts e verificare cosa è andato storto.
10.1_3bLingua
Nota
Il nome dell'assembly satellite è lo stesso per tutte le lingue, TpsViewLocalized-AppTexts.resources.dll

nell'esempio precedente.
4 Passare a un'altra lingua (Pannello di controllo - Lingue) e riavviare la FlexPendant.
5 Verifica che il nome della tua applicazione nel menu ABB sia corretto.

Continua
Passo Azione
6 Aprire l'applicazione e verificare che i testi della GUI siano visualizzati correttamente. Verificare in particolare che
le caselle di testo, le etichette, le colonne della visualizzazione elenco e così via. sono sufficientemente ampi per
visualizzare i testi tradotti.


9 Distribuzione di un'applicazione SDK FlexPendant

9.1 Panoramica

9.1 Panoramica
introduzione
Affinché il cliente finale possa utilizzare la tua applicazione, questa deve essere distribuita al
controller del robot del cliente. Questa operazione viene eseguita quando viene creato il sistema robotico
del cliente, utilizzando System Builder in RobotStudio. L'applicazione personalizzata può quindi essere
aggiunta come opzione aggiuntiva utilizzando una chiave di licenza oppure aggiunta alla directory Home
del file system del controller utilizzando una delle finestre di dialogo della procedura guidata System Builder.
Per un'applicazione con supporto multilingue ci sono alcune cose in più da affrontare.
Nota
È possibile utilizzare un client FTP per caricare l'applicazione da un PC a un controller del robot a scopo
di test. Questa operazione può essere eseguita anche se è necessario aggiungere l'applicazione
personalizzata a un sistema esistente, già in esecuzione in produzione. Per ulteriori informazioni, vedere
Distribuzione tramite FTP a pagina 215.
Realizzare un prodotto
Di seguito sono riportati i passaggi per realizzare un prodotto di un'applicazione FlexPendant
personalizzata: 1 Approvazione della specifica dei requisiti del prodotto FlexPendant SDK.
2 Progettazione e sviluppo di un prototipo di GUI FlexPendant SDK.
3 Approvazione del prototipo della GUI dell'SDK FlexPendant.
4 Progettazione e sviluppo di un prototipo funzionale dell'SDK FlexPendant.
5 Approvazione del prototipo funzionale FlexPendant SDK.
6 Progettazione e sviluppo di un prodotto SDK FlexPendant.
7 Approvazione del prodotto FlexPendant SDK.
8 Progettazione e sviluppo di un prodotto SDK FlexPendant distribuibile.
Distribuzione di un prodotto SDK FlexPendant Prima di

distribuire un'applicazione personalizzata è necessario considerare questi problemi: • Il prodotto
dovrebbe essere concesso in licenza, ovvero essere venduto come opzione?

•
È necessario localizzare il prodotto, ovvero creare supporto per le lingue native?
A seconda della risposta alle domande precedenti ci sono quattro alternative (dettagliate separatamente
nelle sezioni seguenti di questo manuale):
1 Licenza e localizzazione
2 Licenza ma nessuna localizzazione
3 Nessuna licenza ma localizzazione
4 Nessuna licenza e nessuna localizzazione

9.1 Panoramica
Continua
Nota
Se il prodotto deve essere concesso in licenza, dovrebbe essere distribuito come opzione
aggiuntiva. In caso contrario, è necessario utilizzare RobotStudio per distribuire l'applicazione nella
directory Home del sistema.

9.2 Distribuzione di un'applicazione senza licenza
Panoramica
Se non crei un'opzione aggiuntiva per la tua applicazione, l'utente finale non avrà bisogno di una licenza per
utilizzarla.
Quando viene creato il sistema del cliente, utilizzando System Builder di RobotStudio, l'applicazione deve essere
aggiunta alla directory Home del sistema.
Questa sezione fornisce informazioni su come eseguire questa operazione. Per prima cosa viene spiegata
l'alternativa più semplice, che non offre supporto per lingue aggiuntive.
Nessuna licenza e nessuna localizzazione
Utilizzare la procedura seguente per distribuire un'applicazione senza licenza né supporto multilingue.
Passo Azione
1 Utilizzare System Builder in RobotStudio.
2 Aggiungi gli assembly dell'applicazione (.dll) e altre risorse ('.jpg, *.gif,*.bmp) alla directory
Home:
10.1_2SysBui
3 Scaricare il sistema sul controller del robot.
Nota
Avere l'applicazione distribuita nella directory Home significa che verrà inclusa in un backup del sistema.

Continua
Nessuna licenza ma localizzazione
Utilizzare la procedura seguente per distribuire un'applicazione senza licenza ma con supporto
multilingue.
Passo Azione
1 Implementare il supporto multilingue. Per ulteriori informazioni, vedere Localizzazione di
un'applicazione FlexPend-ant a pagina 197.
2 Utilizzare System Builder in RobotStudio.

3 Aggiungi gli assembly dell'applicazione (.dlls) e altre risorse ('.jpg, *.gif,*.bmp) alla directory Home:
10.1_2SysBui
Nota! Nella figura manca TpsViewIRC5AppTexts.dll.

4 Generare il sistema robotico.
5 Nel sistema RobotWare generato, aggiungere una directory della lingua con tutte le lingue
supportate nella directory Home. Quindi, per ogni lingua supportata, aggiungi una cultura specifica
e una directory tps.
10.1_3Lingua
Nota
Per le diverse lingue è necessario utilizzare nomi standard (de, zh e così via). Per l'elenco completo,
vedere Aggiunta del supporto per diverse lingue a pagina 197.

Continua
Passo Azione
6 Trasferisci ogni binario della risorsa nella sottodirectory tps della rispettiva directory della
cultura, ad esempio:
TpsViewIRC5App.strings.de.resources.dll nella directory Language/de/tps e così via.
7 Scaricare il sistema sul controller del robot.
Per ulteriori informazioni su come aggiungere il supporto per le lingue native all'applicazione
personalizzata, vedere Localizzazione di un'applicazione FlexPendant a pagina 197.

9.3 Distribuzione di un'applicazione con licenza
Panoramica
Quando il sistema del cliente viene creato dal System Builder di RobotStudio, è possibile aggiungere al
sistema un'applicazione FlexPendant come opzione aggiuntiva.
Questa sezione descrive come creare l'opzione aggiuntiva, necessaria per la distribuzione di un'applicazione
personalizzata concessa in licenza. Descrive inoltre la modalità di installazione dell'opzione da parte del cliente.
ATTENZIONE
Un'opzione aggiuntiva deve essere distribuita in base alla versione e revisione di RobotWare. Presta attenzione
se stai utilizzando funzionalità che sono state incluse in una revisione!
Nota
Un'opzione aggiuntiva deve essere implementata con la struttura di RobotStudio.
Procedura per creare un'opzione aggiuntiva Utilizzare la
seguente procedura per creare un'opzione aggiuntiva di un'applicazione SDK FlexPendant.
Passo Azione
1 Implementare il supporto multilingue se ritenuto necessario. Per ulteriori informazioni, vedere
Localizzazione di un'applicazione FlexPendant a pagina 197.
2 Ordina una licenza e un CD Key Maker presso l'ufficio ABB locale, che a sua volta
contatterà il supporto prodotto ABB SEROP in Svezia.
3 Crea la seguente struttura:
10.1_12_Opti
La cartella della lingua è necessaria se deve esserci il supporto per altre lingue.
Nota
Utilizzare sempre lettere maiuscole per il nome dell'opzione.

Continua
Passo Azione
4 Crea il file versione.xml. Potrebbe assomigliare a questo:
10.1_13Vers
5 Crea il file install.cmd. Potrebbe assomigliare a questo:
10.1_14Insta
6 Crea il file relkey.txt. Potrebbe assomigliare a questo:
10.1_15MyOpt
7 Con la licenza, inserita nel CD Key Maker, generare un file chiave che includa il numero di serie del
controller del robot, ad esempio MYOPTION508.kxt (questo è il file che inserirai in System
Builder quando verrà creato il sistema robotico).
8 Confeziona il prodotto su CD nel modo consigliato dalla tua organizzazione.
Nota
Se l'opzione è solo un'applicazione SDK FlexPendant, è sufficiente la procedura descritta.

Ma se l'opzione deve includere anche RAPID e la configurazione, è necessario leggere
come realizzare un'opzione aggiuntiva in un altro manuale, che è per uso interno ABB.
Vedere Informazioni correlate alla fine di questa sezione.
Installazione dell'opzione presso il cliente

La procedura seguente mostra come il cliente installa un'applicazione con licenza:
1 Installare l'opzione aggiuntiva da un CD.
2 Creare il sistema robotico utilizzando System Builder.
3 Nella finestra di dialogo Aggiungi parametri/Aggiungi opzioni aggiuntive individuare il
file chiave, ad esempio MYOPTION508.kxt fornito con l'installazione dell'opzione
aggiuntiva.


Continua
10.1_16AddOp
Manuale dell'applicazione - Opzioni aggiuntive, 3HAC023668-001 Il manuale
è destinato esclusivamente all'uso da parte di ABB. Contatta il servizio post-vendita a Västerås, Svezia.

9.4 Distribuzione tramite FTP
9.4 Distribuzione tramite FTP
Panoramica
La regola generale è che la distribuzione utilizzando un client FTP dovrebbe essere eseguita solo
durante la fase di sviluppo.
Se la distribuzione presso un cliente viene eseguita in questo modo, ciascun controller deve essere
aggiornato individualmente con file di assembly e risorse grafiche e linguistiche. L'organizzazione
dei file nel file system del controller robot è responsabilità dello sviluppatore dell'applicazione o
dell'integratore di sistema.
Procedura
Seguire questi passaggi per distribuire l'applicazione utilizzando, ad esempio, il File Manager di
RobotStudio o un client FTP come Ftp Voyager:
Passo Azione
1 Sul controller accedere al sistema che si desidera aggiornare con l'applicazione
FlexPendant.
2 Trasferire l'assembly, l'assembly proxy e le risorse grafiche utilizzate dall'applicazione
nella directory di sistema Home.
3 Per il supporto multilingue, nella directory Lingua creare sottodirectory per ciascuna
lingua utilizzando il nome breve della lingua.
4 Crea una sottodirectory “tps” in ciascuna di queste directory.
5 Copia ciascuna risorsa linguistica nella cartella tps della cultura corrispondente.
6 Riavviare la FlexPendant. L'applicazione personalizzata dovrebbe ora essere accessibile
dal menu ABB.
Per ulteriori informazioni su come riavviare la FlexPendant ma non il controller, vedere
Riavviare la FlexPendant a pagina 35.


Indice
Indice
UN
AlphaPad, 94 G
Evento conclusivo, 95 Sovvenzioni, 55
Lancio, 94 Definizione, 54
Finestra di proprietà, 95 Sovvenzioni per la domanda, 55
Rimozione, 96 Ottieni sovvenzioni attuali, 55

Applicazione, 13 GTPUFolderBrowserDialog, 103
Architettura, 31 Finestra di dialogo GTPUOpenFile, 103
assembly, 41 Finestra di dialogo GTPUSaveFile, 103
nome della classe, 42
Distribuzione, 34 H
Ciao mondo, 70 anni
Sviluppo, 25
Dll, 33
IO
icone, 41
ListaImmagini, 88, 97
lingue, 25
Installazione, 19
Ciclo di vita, 38
Requisiti, 19
luogo, 42 nome,
Invocare, 52
41
ITpsViewAttivazione, 172
Orientamento agli oggetti, 48
ITpsViewSetup, 113
Portamento, 28
Vero, 28
l
Correre, 33
LaunchView, 114
Icona della barra delle applicazioni, 41
Visualizzazione elenco, 97
TpsView, 40
Illustrazione, 97
Tipo, 42
Selezione multipla, 98
UA, 54
Scorrevole, 98
Versioni, 21
Pulsanti SelectionEnabledOverScroll, 98
Virtuale, 27
MostraNumeroOggetti, 98
MostraSelectio, 98
C
Domini CAPI, 118
M
ChiudiVisualizza, 114
Perdite di memoria, 77
CompactAlphaPad,
compatibilità 99, 46 N
Configurazione, 62 Tastierino numerico, 100
finestra della console, 24
Comandi, 186 P
PictureBox, 88
D Progetto, 64
Associazione dati, 107 Vuoto, 81
Rilegatura avanzata, 111 Modulo, 82
Classi, 107 Nuovo progetto, 64
Definizione, 107 Procedura, 64
RapidDataBindingSource, 107 Mago, 74
RiprendiBinding, 112 Finestra Proprietà, 105
SignalBindingSource, 107 NomeFile, 105
SuspendBinding, 112 finestra Filtra, 105
di dialogo, 116 DirectoryIniziale, 105
FpRapidData, 117
FpToolCalibrazione, 116 R
Calibrazione FpWorkObject, 116 Grado, 131
Smaltire, 122, 169 RAPID, 144
array, 131
F dimensioni degli array, 131
FlexPendant
BeginInvoke, 52
Applicazioni, 21 Registro eventi, 155
Comunicazione, 37 Invocare, 52
Memoria, 165 Caricamento moduli, 146
perdite di memoria, 169 Finestra di messaggio, 55
panoramica, 165 ModificaPosizione, 147
Piattaforma, 31 MotionPointer, 147
Ricominciare, 35 Puntatore di programma, 147
Schermo, 165 RestProgramPointer, 144
Salva e scarica, 146

Indice
Modulo di salvataggio, 147 T

Inizio, 144 TpsFont, 87
Ferma, 144 TpsForm, 82
TpsControl, 52 Prova a prendere finalmente, 56
Leggi l'articolo, 134 Tipografia, 57
U
Sicurezza S , 11 Forum degli utenti, 194
Segnali, 149
accesso, 149
Cambiamenti nell'ascolto, 152 Tastiera virtuale V , 94
SignalChangedEventArgs, 153
SignalFilter, 150
W
valori, 151 Scrivi oggetto, 134

Contattaci
ABB AB
Automazione e movimento discreti
Robotica
S-721 68 VÄSTERÅS, Svezia
Telefono +46 (0)21 344 400
vH
,100-859630CA en,R
B
3
e
ABB AS, Robotica
Automazione e movimento discreti
Casella 265
N-4349 BRYNE, Norvegia
Telefono: +47 51489000
ABB Ingegneria (Shanghai) Ltd.

5 Lane 369, ChuangYe Road
KangQiao Town, PuDong District
SHANGHAI 201319, Cina
Telefono: +86 21 6105 6666
ABB Inc.
Discrete Automation and Motion
Robotics
1250 Brown Road
Auburn Hills, MI 48326
USA
Telefono: +1 248 391 9000
www.abb.com/robotics

Abb Manuale Applicativo Sdk Con Flex Pendant

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Abb Manuale Applicativo Sdk Con Flex Pendant

Caricato da

Copyright:

Formati disponibili

Machine Translated by Google

©Copyright 2010-2013 ABB. Tutti i diritti riservati.

©Copyright 2010-2013 ABB. Tutti i diritti riservati.

2 Ambiente di installazione e sviluppo 19

4 Sviluppo di applicazioni del controller 47

5 Utilizzo dell'SDK FlexPendant 61

5.3.12 GTPUMessageBox ............................................ .................................... 101 5.3.13 Finestra di

6 robuste applicazioni FlexPendant 165

7 FlexPendant - Debug e risoluzione dei problemi 181

7.1 Debug.................................................... .................................................... .... 181 7.2 Uscite di

8 Localizzazione di un'applicazione FlexPendant 197

8.1 Aggiunta del supporto per più lingue............................................ ....................197

9 Distribuzione di un'applicazione SDK FlexPendant 207

Panoramica di questo manuale

Chi dovrebbe leggere questo manuale?

• avere familiarità con IRC5, FlexPendant e RobotStudio. • essere utilizzato

dei linguaggi di programmazione .NET C# o Visual

• essere utilizzato per la programmazione orientata agli oggetti.

Organizzazione dei capitoli

Contenuto del capitolo

1 Introduzione. Terminologia. Sicurezza.

2 Installazione e configurazione. Sviluppo dell'ambiente . Tecnologia dei robot virtuali.

4 Sviluppo di applicazioni SDK FlexPendant. Analisi e progettazione. Importanti questioni di

Continua nella pagina successiva

©Copyright 2010-2013 ABB. Tutti i diritti riservati.

Contenuto del capitolo

6 Come sviluppare applicazioni FlexPendant robuste e performanti. Memoria

8 Come aggiungere il supporto per diverse lingue a un'applicazione FlexPendant personalizzata.

9 Come creare un'opzione aggiuntiva e come realizzare un prodotto da una FlexPendant

Manuale operativo - IRC5 con FlexPendant 3HAC16590-1

Manuale operativo - RobotStudio 3HAC032104-001

Manuale operativo - Per iniziare, IRC5 e RobotStudio 3HAC027097-001

Manuale tecnico di riferimento - Istruzioni RAPID, Funzioni e 3HAC16581-1

Manuale dell'applicazione: SDK per PC 3HAC036957-001

Da FlexPendant SDK 5.13 in poi questo manuale sostituisce:

©Copyright 2010-2013 ABB. Tutti i diritti riservati.

Documentazione del prodotto, M2004

Manuali dei prodotti

Manipolatori, controller, DressPack/SpotPack e la maggior parte degli altri componenti hardware

sicurezza. • Installazione e messa in servizio (descrizioni dell'installazione meccanica o dei

• Manutenzione (descrizione di tutte le procedure di manutenzione preventiva richieste

• Riparazione (descrizioni di tutte le procedure di riparazione consigliate, compresi i pezzi di ricambio

Informazioni di riferimento (norme di sicurezza, conversioni di unità, giunzioni a vite, elenchi

• Schemi elettrici (o riferimenti agli schemi elettrici).

Manuali tecnici di riferimento

• Manuale tecnico di riferimento - Lubrificazione nei riduttori: Descrizione delle tipologie

tecnico di riferimento - Parametri di sistema: Descrizione del sistema

Manuali delle applicazioni

Continua nella pagina successiva

Un manuale applicativo generalmente contiene informazioni su:

Sicurezza del personale

Questa pagina è stata lasciata vuota intenzionalmente

1.1 Informazioni sulla creazione di applicazioni controller

Interfacce utente flessibili

Per le applicazioni basate su PC, vedere Manuale dell'applicazione - PC SDK.

Client locale o remoto

Facilità d'uso in fabbrica

Continua nella pagina successiva

.NET e Visual Studio

sappia programmare per piattaforme .NET utilizzando Visual Studio.

1.2 Documentazione e aiuto

• Guida allo stile FlexPendant

Il PDF del manuale dell'applicazione è reperibile nella directory di installazione, in

Si consiglia di mantenere aperti i file della guida durante la programmazione, poiché ne