Arduino è un microcontrollore unico che ti consente di creare qualsiasi dispositivo, limitato solo dall'immaginazione dell'ingegnere. Oggi parleremo di uno di questi progetti e analizzeremo l'analizzatore d'antenna su Arduino, così come tutte le sfumature che dovrai affrontare durante la saldatura e la programmazione.

In effetti, un analizzatore di spettro su Arduino è un progetto abbastanza semplice, ma ideale per i principianti e per chi vuole aggiungersi questo dispositivo al tuo kit di strumenti. Diamo un'occhiata a cos'è un analizzatore logico su Arduino e quali insidie ​​​​ti aspettano durante la progettazione e la saldatura.

Circuito analizzatore logico basato su Arduino MK

Per prima cosa dobbiamo progettare ciò che salderemo. Un analizzatore logico è uno strumento semplice il cui intero compito è leggere e analizzare un codice binario (segnale digitale) trasmesso attraverso l'applicazione dell'elettricità.

In altre parole, ogni 5 volt forniti al dispositivo è uno, la sua assenza è zero. Questo codice binario viene utilizzato nella codifica dei dati e in molti dispositivi, compresi quelli basati su Arduino. La lettura inizia, di regola, con uno. E per controllare il tuo progetto con la codifica binaria, avrai bisogno di un analizzatore logico.

Il modo più semplice è provare il dispositivo sul bus I2C, che ancora oggi viene utilizzato nella maggior parte dei dispositivi elettronici. Per capire cosa dobbiamo progettare, vediamo le caratteristiche principali del dispositivo:

1. 4 canali per l'analisi logica dei segnali in ingresso.
2. La variabilità delle frequenze del segnale arriva fino a 400 kHz, questa gamma coprirà la maggior parte dei dispositivi moderni, ad eccezione di quelli specializzati;
3. La tensione in ingresso dovrebbe essere fino a +5 Volt, come già descritto, questo è lo standard preso come unità (presenza del segnale).
4. Display LED per la visualizzazione delle informazioni. I programmatori particolarmente sofisticati possono acquistare un paio di LED e costruire il proprio display della diagonale di cui hanno bisogno, ma per tutti gli altri scrivere software per un dispositivo del genere richiederà troppo lavoro e si rivelerà un passaggio non necessario. Pertanto, qui considereremo una versione del dispositivo con display LCD.
5. 4 batterie per l'alimentazione, 1,2 V a tensione massima a 4,8 Volt.
6. RAM. Si consiglia di adottare due varietà: ad alta velocità (3,6 ms per segnale) e a bassa velocità (36 s), questa soluzione consentirà di coprire l'intera gamma di segnali.
7. Un pannello di controllo o una coppia di pulsanti.
8. Qualsiasi guscio per il fissaggio della struttura. Puoi stamparlo su una stampante 3D, puoi prendere una scatola di plastica non necessaria o fare a meno della custodia. Qui non daremo consigli, il dispositivo funziona, con o senza shell, a voi la scelta.

Per l'alimentazione è necessario scegliere le batterie, poiché 4 batterie da 1,5 Volt possono danneggiare Arduino e bruciare la scheda. Per non parlare del pericolo per il display LCD. Pertanto, non lesinare e prendi componenti di qualità. Dopotutto, la qualità del prodotto finale è pari al parametro del suo componente peggiore.

Non dimenticare di aggiungere l'interruttore S1 al circuito finale, che verrà utilizzato per fornire alimentazione e spegnere il dispositivo in modo che le batterie non si scarichino semplicemente.

Saranno inoltre necessarie speciali resistenze pull-up, che elimineranno i dati falsi che potrebbero apparire a causa del campo elettromagnetico delle dita della sonda di segnale. Di conseguenza, il rumore e la distorsione sugli ingressi digitali saranno minimi.

Puoi prendere il LED come desideri, è necessario indicare la presenza di un segnale digitale e può essere completamente sostituito dal software per il display LCD. Questa soluzione è utile solo come indicatore di registrazione segnali digitali in memoria, ma sarà comunque necessario attivare manualmente il dispositivo, per cui tale indicazione, se necessario, potrà essere rimossa.

Periferiche consigliate per creare un analizzatore logico basato sul microcontrollore Arduino

Da tutto quanto sopra hai già stilato un elenco approssimativo di periferiche da acquistare, ma chiariamo questo punto. Nell'analizzatore logico avrai bisogno di:

1. Il microcontrollore Arduino stesso. Non fa differenza quale scegli, influenzerà solo la dimensione finale del dispositivo. Il software per qualsiasi versione sembra lo stesso. È stata utilizzata la tavola nella foto sopra.
2. Display LCD. Se hai un vecchio telefono a pulsanti, puoi rimuoverlo e impostare una produzione “senza sprechi”.
3. Resistori di varie capacità.
4. Sensore di corrente.
5. 4 batterie.
6. Un LED o due.
7. Scheda di memoria, ma questo è opzionale.

Inoltre, avrai naturalmente bisogno di un saldatore, di una saldatrice e di altri accessori. È meglio trovare in anticipo un posto dove raccogliere tutto questo. E se lavori per la prima volta con un saldatore, studia le regole di sicurezza antincendio e le caratteristiche del suo funzionamento in modo da non risaldare ciascuna parte 10 volte.

Programmazione di Arduino MK durante l'implementazione del progetto "analizzatore logico".

Grazie alla popolarità di Arduino, su questo MK sono già disponibili librerie e funzioni già pronte per gli analizzatori logici. Tutto quello che devi fare è scegliere quello giusto e riscrivere il codice del programma per il tuo dispositivo. Dopotutto, schede, sensori e altri input sono diversi per ognuno e affinché il tuo dispositivo funzioni senza problemi, dovrai adattare il codice di qualcun altro alle tue esigenze. Se non vuoi disturbarti e hai esperienza di programmazione in C++, puoi utilizzare qualsiasi ambiente tu voglia.

Il codice per il circuito nella foto sopra potrebbe essere così:

/************************************ Analizzatore logico LCD 128 x 64 6 canali e 3 Mb/s Di Bob Davis utilizza la libreria grafica universale a 8 bit, http://code.google.com/p/u8glib/ Copyright (c) 2012, [e-mail protetta] Tutti i diritti riservati. ************************************************** ****/ #include "U8glib. h" // 8Bit Com: D0..D7: 8,9,10,11,4,5,6,7 en=18, di=17,rw=16 // U8GLIB_ST7920_128X64_4X u8g(8, 9, 10, 11 , 4, 5, 6, 7, 18, 17, 16); // **** NOTA **** Ho spostato i tre pin di controllo!!! U8GLIB_ST7920_128X64_4X u8g(8, 9, 10, 11, 4, 5, 6, 7, 1, 2, 3); int Esempio; int Ingresso=0; int VecchioInput=0; int xpos=0; void u8g_prepare(void) ( u8g.setFont(u8g_font_6x10); u8g.setFontRefHeightExtendedText(); u8g.setDefaultForegroundColor(); u8g.setFontPosTop(); ) void DrawMarkers(void) ( u8g.drawFrame (0,0,128,64); u8g .drawPixel(20,1); u8g.drawPixel(60,1); u8g.drawPixel(20, 62); attende l'attivazione di un ingresso con andamento positivo Input=digitalRead(A0); while (Input != 1)( Input=digitalRead(A0); ) // raccoglie i dati analogici in un array // Nessun loop è circa il 50% più veloce ! Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; Campione=PINC; // visualizza i dati analogici raccolti dall'array for(int xpos=0; xpos<128; xpos++) { u8g.drawLine (xpos, ((Sample&B00000001)*4)+4, xpos, ((Sample&B00000001)*4)+4); u8g.drawLine (xpos, ((Sample&B00000010)*2)+14, xpos, ((Sample&B00000010)*2)+14); u8g.drawLine (xpos, ((Sample&B00000100)*1)+24, xpos, ((Sample&B00000100)*1)+24); u8g.drawLine (xpos, ((Sample&B00001000)/2)+34, xpos, ((Sample&B00001000)/2)+34); u8g.drawLine (xpos, ((Sample&B00010000)/4)+44, xpos, ((Sample&B00010000)/4)+44); u8g.drawLine (xpos, ((Sample&B00100000)/8)+54, xpos, ((Sample&B00100000)/8)+54); } } void setup(void) { pinMode(A0, INPUT); pinMode(A1, INPUT); pinMode(A2, INPUT); pinMode(A3, INPUT); pinMode(A4, INPUT); pinMode(A5, INPUT); // assign default color value if (u8g.getMode() == U8G_MODE_R3G3B2) u8g.setColorIndex(255); // RGB=white else if (u8g.getMode() == U8G_MODE_GRAY2BIT) u8g.setColorIndex(3); // max intensity else if (u8g.getMode() == U8G_MODE_BW) u8g.setColorIndex(1); // pixel on, black } void loop(void) { // picture loop // u8g.firstPage(); do { draw(); } while(u8g.nextPage()); // rebuild the picture after some delay delay(100); }

Non dimenticare di scaricare le librerie per lavorare con Arduino. E tieni anche presente che l'output va allo schermo LCD. Una volta terminata la scrittura del software, è sufficiente caricarlo sulla scheda utilizzando uno speciale adattatore USB.

Può succedere che, a causa del modo in cui le informazioni vengono visualizzate sul display LCD, non si disponga di memoria permanente sufficiente sul dispositivo. In questo caso, ha senso acquistare un'unità flash e collegarla al sistema. Fortunatamente, questo viene fatto in modo abbastanza semplice e tutto ciò di cui hai bisogno è un adattatore speciale per il fattore di forma della tua unità fisica.

Molto spesso nell'artigianato elettronico domestico è necessario guardare questo o quel segnale e la sua rappresentazione digitale è sufficiente: cosa trasmette l'MK tramite I2C, se il PWM è configurato correttamente, ecc. Se hai un buon oscilloscopio al lavoro, acquistarne uno per casa è troppo costoso, soprattutto quando la necessità si presenta solo occasionalmente.
Recentemente sono comparsi analizzatori logici poco costosi (circa 50 dollari), ma un pensiero mi ha sempre impedito di acquistarli: la cosa è estremamente semplice, perché non realizzarli da soli con materiali di scarto?
In questo articolo ti spiegherò come realizzare un semplice analizzatore logico con costi finanziari minimi: tutto ciò di cui hai bisogno è la scheda di debug Stm32F4Discovery.

Analizzatore logico (di seguito denominato LA)– un dispositivo progettato per registrare, visualizzare e analizzare i segnali nei circuiti digitali. Come un oscilloscopio, un LA è collegato con una o più sonde al circuito da analizzare, ma a differenza di un oscilloscopio, registra solo due stati di segnale “0” e “1”. Una funzione importante dell'aereo è la capacità di decifrare automaticamente i segnali registrati, ad esempio, di analizzare lo scambio di dati sul bus I2C o SPI. Inoltre, gli LA si distinguono per un numero maggiore di linee analizzate rispetto agli oscilloscopi: da 8 nei semplici analizzatori a centinaia nei campioni industriali.
Il progetto qui descritto - LogicDiscovery - è un analizzatore logico compatibile con SUMP, realizzato nel formato di un set-top box USB per un PC. Ha caratteristiche piuttosto modeste: 20MHz, 16 canali, 24kB di memoria. Tuttavia, questo è sufficiente per una vasta gamma di compiti: analisi di linee UART, I2C, SPI (entro diversi megahertz), bus paralleli, misurazione delle caratteristiche di temporizzazione del segnale, ecc.

Iniziamo

Quindi, tutto ciò di cui abbiamo bisogno è:

• Scheda di sviluppo Stm32F4Discovery. Da 500 rubli nella vendita al dettaglio di Mosca, o forse è già nei tuoi bidoni? Funzionerà anche qualsiasi altra scheda basata su STM32F4 o STM32F2, ma in questo caso dovrai correggere i sorgenti.
• Diversi fili da collegare al circuito da analizzare.
• Il firmware pronto all'uso è disponibile su Google.Code. Ci sono anche le fonti.
• Inoltre è necessario un client per PC, io consiglio OLS.

Il client è scritto in Java, quindi la soluzione risultante è indipendente dal sistema operativo. In teoria, puoi utilizzare qualsiasi client compatibile con SUMP, ma di seguito descriverò come lavorare con questo particolare programma.
Stm32F4Discovery è alimentato da una porta mini-USB, attraverso la quale viene flashato. Per utilizzare le funzioni del velivolo, la scheda è collegata ad un PC tramite una porta micro-USB. Per alimentare la scheda dalla stessa porta collegare i pin con un ponticello PA9 E 5 V. PA9 è collegato direttamente al Vbus della porta micro-USB e 5V è l'ingresso dello stabilizzatore che genera energia per la scheda. Per verificare il funzionamento, collegare le porte PA2 E PD0. Un segnale di test viene generato su PA2 e PD0 è il primo ingresso dell'aereo.

La scheda viene riconosciuta dal PC come porta COM; per Linux i driver sono standard e dovrebbero essere già nel kernel; per Win i driver si scaricano dal sito della ST. Una volta identificata la scheda, è possibile avviare il client e mettersi al lavoro.
Ma prima, un neo.

Restrizioni

Il progetto utilizza il protocollo aperto SUMP. Questo protocollo è stato originariamente sviluppato per velivoli basati su FPGA e poiché i microcontrollori sono ancora inferiori a loro in termini di registrazione dei segnali di ingresso e analisi del flusso di dati, non tutte le funzioni implementate nel client saranno a nostra disposizione:

• Frequenza massima di registrazione – 20 MHz, nell'originale fino a 200 MHz
• La compressione RLE e il filtraggio del rumore non sono supportati.
• Non è possibile selezionare gruppi di canali arbitrari, solo il primo (8 canali) o il primo + il secondo (16 canali).
• I trigger non funzionano in base al valore, ma in base al vantaggio (tuttavia, secondo me, questo è già un vantaggio).
• Non è disponibile alcun supporto per i trigger avanzati (complessi).

Queste restrizioni dovrebbero essere tenute presenti durante la configurazione del client. Non sa nulla di queste restrizioni e ti permetterà di scegliere qualsiasi impostazione. Il risultato ottenuto in questo caso sarà errato.

Noi usiamo

Lanciamo il client tramite il file run.bat o run.sh, a seconda del sistema operativo utilizzato. Puoi leggere le funzioni del client sulla sua pagina; qui descriverò il processo per ottenere i primi campioni e quelle impostazioni soggette a restrizioni.

Sul menu "Catturare", selezionando un elemento "Inizia la cattura", aprire la finestra delle impostazioni di registrazione. In prima pagina nel campo ""Porta dell'analizzatore" selezioniamo il porto su cui si trova il nostro aereo, non è necessario modificare nient'altro. Pulsante "Mostra metadati dispositivo" Puoi verificare la connessione:

Nella seconda pagina indichiamo i parametri di cattura. Non tocchiamo i primi due punti,
"Frequenza di campionamento" non superiore a 20 MHz (se si specifica di più, la scheda utilizza comunque 20 MHz, ma il cliente penserà che venga utilizzato il valore specificato, in generale non avrà senso).
"Gruppi di canali": 0 – utilizziamo un gruppo di canali, queste sono le linee PD0-PD7, oppure 0 e 1 – utilizziamo due gruppi di canali - linee PD0-PD15.
"Dimensioni della registrazione": per un gruppo di canali - qualsiasi valore, per due gruppi - non più di 12kB (il client avviserà se viene selezionato un valore errato in questo campo).
Non tocchiamo le caselle di controllo in questa pagina, non sono supportate:

Pagina "Trigger"- Il più interessante. Selezioniamo la prima casella per abilitare semplicemente i trigger.
"Rapporto prima/dopo" consente di specificare, in termini percentuali, quanti dati salvare prima che venga attivato il buffer. Dopo aver cliccato "Catturare" Il velivolo inizia immediatamente a registrare i dati, aggiungendoli a un buffer ciclico e, quando viene attivato il trigger, conta la percentuale di tempo specificata nel campo Dopo e invia i dati al PC.
"Tipo"- Solo "Semplice", "Complesso" - non supportato.
"Modalità"- Solo “Parallelo”.
"Maschera"- queste sono le linee su cui il trigger attenderà la caduta del segnale; posizionare il flag nella posizione zero per eseguire il trigger sulla linea PD0
"Valore"- il fronte del segnale in corrispondenza del quale verrà attivato il trigger. La bandiera è spuntata: bordo anteriore. Deselezionato – posteriore:

Per verificare il funzionamento, collegare le porte PD0 e PA2 (il segnale di test UART viene emesso su questa porta) con un ponticello.

Questo è tutto, clicca "Catturare" e osserva il segnale ricevuto (Ctrl+F - scala panoramica):

Se non succede nulla, significa che hai impostato il grilletto in modo che si attivi sulle linee sbagliate o che non c'è alcun segnale: controlla le impostazioni e i collegamenti della scheda. Il trigger può essere lanciato manualmente premendo il pulsante Utente (pulsante blu).

Misure di sicurezza

Ricordare: ti colleghi direttamente alle porte del microcontrollore! Non c'è altra protezione oltre ai diodi integrati nel MK sulla scheda. Pertanto, prima assicurarsi che il segnale in studio abbia una tensione massima di 3,3 V, in casi estremi 5 V, ma poi è consigliabile aggiungere un resistore di protezione tra la sorgente del segnale e l'aereo.

Quando ci si connette al circuito da analizzare, non dimenticare di collegare prima la massa e solo successivamente le linee di segnale. Soprattutto quando il circuito analizzato è alimentato dal proprio alimentatore e non dallo stesso PC a cui è collegato l'aereo.

0

Vassilis Serasidis Un analizzatore logico è uno strumento che consente di vedere e analizzare la sequenza di 0 e 1 logici in un segnale digitale. Ad esempio, puoi studiare il segnale digitale dal ricevitore del demodulatore IR TSOP-1736, i segnali di uscita e di ingresso del chip MAX232, nonché il bus I2C (linea orologio e linea dati) in molti dispositivi elettronici. In questo articolo esamineremo il progetto di un analizzatore logico in miniatura a 4 canali con display LCD di un telefono cellulare Nokia 5110/3110. La base del progetto è il microcontrollore Atmel ATmega8, oltre ad esso vengono utilizzati molti altri componenti discreti; Principali caratteristiche del dispositivo: analizzatore logico a 4 canali; la capacità di studiare segnali con una frequenza fino a 400 kHz; tensione di ingresso fino a +5 V; Display LCD con risoluzione 84×48 pixel; alimentazione con 4 batterie 1,2 V, tensione massima di alimentazione 4,8 V; memoria: da 3,7 ms per segnali ad alta velocità a 36 s per segnali a bassa velocità; pulsanti di controllo; design semplice. Diagramma schematico La Figura 1 mostra un diagramma schematico del dispositivo. Va subito notato che il dispositivo è alimentato da 4 batterie con una tensione di 1,2 V ciascuna.
Clicca per ingrandire Attenzione!!! L'alimentazione da 4 batterie con una tensione di 1,5 V non è accettabile per questo circuito del dispositivo, poiché una tensione di 6 V può danneggiare il microcontrollore e il display LCD.
L'interruttore S1 è progettato per fornire alimentazione. I resistori pull-up R2-R5 sono installati per prevenire la comparsa di dati falsi sugli ingressi digitali del dispositivo a causa dell'influenza dei campi elettromagnetici o quando le dita toccano le sonde del segnale. Il LED1 ha lo scopo di indicare la presenza di un segnale agli ingressi digitali del dispositivo e, quindi, l'inizio della registrazione dei segnali in memoria. Il circuito utilizza un indicatore LCD di un telefono cellulare Nokia 3310/5510, è progettato per funzionare con una tensione di alimentazione di 3,3 V - 5,0 V, tuttavia, la tensione massima per la retroilluminazione del display è 3,3 V, quindi il circuito contiene tre 1N4007 diodi collegati in serie (D1-D3) tramite la linea di alimentazione della retroilluminazione del display. Grazie ai diodi, la tensione scenderà a 2,7 V e sarà sufficiente per alimentare la retroilluminazione. Processo di acquisizione dati e software Va notato che l'autore ha preparato due versioni del firmware del microcontrollore. Inizialmente, per la versione 1.00 dell'analizzatore logico, è stato utilizzato l'ambiente di sviluppo integrato AVR Studio 4.18, ma poi l'autore ha ricompilato il codice sorgente per AVR Studio 5 - versione 1.01. Dopo la ricompilazione per la versione 5 dell'ambiente di sviluppo e ulteriori test del dispositivo, è stato notato un miglioramento nella stabilità dei segnali catturati. I segnali vengono registrati nel buffer di memoria RAM interna, progettata per 290 campioni. Il buffer dati è formato da 870 byte (per la versione 1 del programma del microcontrollore), di cui 2 byte vengono utilizzati per il contatore e 1 byte per le informazioni sul canale di ingresso. Nella versione 1.01, il buffer dei dati è stato ridotto a 256×3=768 Byte per aumentare la velocità di acquisizione dei dati, perché La variabile della dimensione del buffer è a 8 bit, anziché a 16 bit, utilizzata nella prima versione del software. Dopo aver applicato l'alimentazione, il microcontrollore entra in modalità di attesa degli impulsi su uno qualsiasi dei 4 ingressi del dispositivo. Quando viene rilevato un impulso in ingresso, il microcontrollore inizia a contare il tempo fino all'arrivo dell'impulso successivo su uno qualsiasi dei 4 ingressi. La durata del campione è memorizzata nella variabile a 16 bit “counter”. Dopo l'overflow di questa variabile, le informazioni sullo stato dei 4 ingressi e il valore del contatore vengono archiviate in un buffer e il valore del suo indirizzo viene aumentato di tre (2 byte per il contatore e 1 byte per le informazioni sulla linea di ingresso). Questo processo viene ripetuto finché il microcontrollore non riempie l'intero buffer (870/3=290 campioni o impulsi). Il processo di registrazione dei segnali nella memoria del microcontrollore è mostrato in Figura 2. Dopo aver riempito il buffer, tutti i dati accumulati vengono visualizzati sul display LCD sotto forma di oscillogramma. L'utente può controllare la forma d'onda: spostarla a sinistra (pulsante S3) o a destra (pulsante S4) per visualizzare l'intera sequenza di impulsi salvata. Se sono stati registrati segnali a bassa velocità, l'utente può modificare la scala di 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096 o 8192 premendo il pulsante S2. Quando si programma il microcontrollore, è necessario impostare i bit del fusibile in base alla figura. Tipo di circuito stampato e ubicazione dei componenti

1. Introduzione:

Questa analisi logica L'attore è progettato per registrare, emettere e analizzare varie sequenze di impulsi e protocolli sequenziali con un determinato periodo. Preso per l'hardware multiprogrammatore su FT232

2. Breve descrizione

L'analizzatore dispone di 7 canali di ingresso/uscita, che sono collegati ai vari dispositivi in ​​esame a discrezione dell'utente.

I canali 1-5 corrispondono a ingresso/uscita. Questi canali possono essere emessi o immessi a seconda dell'impostazione del canale. Il canale 5 non è indirizzato ad alcun connettore, ma ha un pad di contatto sulla scheda.

Canale 6 – solo ingresso. Questo canale viene utilizzato insieme al canale 1 e serve per simulare ingresso/uscita bidirezionale, ad esempio, come nel bus I2C, ovvero la direzione di trasmissione del canale cambia durante il funzionamento del protocollo. I dati di uscita vanno all'uscita 3 e i dati di ingresso passano attraverso il canale 6. Per maggiori dettagli vedere "Implementazione del protocollo I2C".

Viene emesso solo il canale 7. Questo canale sul programmatore è implementato come una potente uscita da 12 V. Ad esempio, è stato utilizzato come alimentazione di retroilluminazione quando si lavora con il display del Nokia 6100 (vedi esempi di utilizzo)

Sul lato sinistro della finestra di lavoro del programma ci sono le impostazioni per le porte dell'analizzatore: queste sono:

• velocità di trasmissione (BoudRate)
• inversione di canale (seleziona " N.E.G."
• direzione del porto ( DENTRO FUORI)
• dimensione dell'array di output (è consentita una dimensione fino a 65 kbit)

Nella parte centrale della finestra del programma è presente una rappresentazione grafica dello stato dei canali sotto forma di diagramma temporale. E nella parte inferiore del campo ci sono informazioni aggiuntive, che mostrano le sfumature quando si utilizzano le varie modalità dell'analizzatore selezionate.

Sul lato destro del campo del programma ci sono i controlli per i protocolli simulati. Disponibile:

• menu a discesa per la selezione del protocollo
• 7 menu a discesa (per canale): seleziona l'assegnazione del canale e il segnale del protocollo
• inversione dei dati del protocollo (da non confondere con l'inversione delle porte)
• finestra per l'inserimento dei dati (per impostare la sequenza numerica del protocollo)

3. Gestione einserimento dati.

Clic sinistro del mouse imposta il cursore in questa posizione sul pannello della forma d'onda senza modificare lo stato di questo bit.

Fare clic con il tasto destro nel pannello della forma d'onda, posiziona il cursore in questa posizione e modifica lo stato del bit in questa posizione.

Oltre a inserire i dati con il mouse, puoi inserirli dalla tastiera. Dopo aver premuto il tasto "0" o "1", al posto del cursore viene inserito rispettivamente 0 o 1. Inoltre, per comodità, la funzione del pulsante "0" viene duplicata sul pulsante "2", ovvero. quando si preme il tasto “2”, viene inserito 0.

Inserimento dei dati dell'array(solo per la cronaca). La sequenza del protocollo può essere inserita in formato decimale (1 34 987), binario (0b100 0b101010 0b1111111111111) ed esadecimale (0xFA 0x 12C 0x 1a 2cb ). I dati vengono inseriti separati da spazi.È anche possibile mischiare formati dati (123 0b1010 0x12aB).

Vengono inseriti i dati seguiti da un incremento dell'indirizzo. Quando viene raggiunto il limite dell'array, la sua dimensione aumenterà. Dimensione massima dell'array di dati: 65 kbit

Inserimento dei dati per file. Per inserire i dati per file, è necessario creare un file con qualsiasi estensione, ad esempio txt. Formato libero.

Puoi separare i numeri in un file con un punto, una virgola o uno spazio. Le spiegazioni nel file sono separate da punto e virgola “;”.

Contenuto del file di esempio:

123 343, 234 ; ecco le spiegazioni dopo il punto e virgola

0x12F, 0b10101010 ; e così via.

Driver per l'analizzatore.

L'analizzatore utilizza funzioni speciali dell'FT232R, per le quali è necessario installare il driver speciale FTD 2XX. L'installazione di una normale porta COM non è adatta. Si consiglia di prendere il driver dal produttore, ad esempio.

4. Collegamento dell'analizzatore:

L'aspetto dell'analizzatore è mostrato nella Figura 2.

J1– ponticello di alimentazione (Vcc). Ha 4 stati: 1,8 V, 3 V, 5 V e alimentazione esterna

XT1– miniUSB. Connessione al PC.

XT2– connettore di interfaccia per collegare l'analizzatore al soggetto in prova. Ha 10 contatti:

1 canale 1 (ingresso/uscita)
2 porte di uscita di alimentazione (Vcc) (a seconda dello stato del ponticello di alimentazione, l'alimentazione verrà immessa o emessa)
3 Cbus 4 non viene utilizzato. Ma puoi emettere la frequenza 6,12,24 o 48 MHz (per maggiori dettagli, vedi "uso di Cbus")
5 canali 2 (ingresso/uscita)
7 canali 3 (ingresso/uscita)
9 canali 4 (ingresso/uscita)
4,6,8,10 totali

XT3– connettore di interfaccia per collegare l'analizzatore al soggetto in prova. Ha 10 contatti

1 porte di uscita di alimentazione (Vcc) (a seconda dello stato del ponticello di alimentazione, l'alimentazione sarà in ingresso o in uscita).
3 canali 3 (ingresso/uscita)
5 canali 4 (ingresso/uscita)
7 canali 6 (solo ingresso)
Uscita 9 canali 7 Segnale 12V!!!
2,4,6,8,10 totali

J2– ponticello per 2 posizioni. Cambia la funzione del canale 6.

posizione 1-2 cambia il canale 6 da Vcc a 12V
posizione 2-3 cambia il canale 6 da 0 V a 12 V
la posizione 1-2 viene utilizzata nel programmatore per generare il segnale MCLR quando si lampeggiano i controller PIC.

I canali 1-5 sono ingressi per impostazione predefinita e si trovano nel terzo stato (stato Z). Quando un canale è impostato per l'uscita, verrà emesso solo durante la trasmissione.

Ciascun canale dispone di resistori di limitazione della corrente da 300 ohm.

Il canale 6 è sempre l'uscita. Lo stato predefinito è "0".

5. Utilizzando il segnale Cbus (pin 3 del connettore XT2)

Questo segnale non viene visualizzato nell'analizzatore perché lo è non sincrono con segnali di uscita e ha una frequenza superiore agli impulsi di uscita. Non abilitato per impostazione predefinita.

Questo pin può emettere frequenze di 6, 12, 24 e 48 MHz. Questo viene fatto utilizzando una speciale utility MProg, che puoi prendere

6. Una breve descrizione di cosa fare per inviare una frequenza a Cbus:

1. installare l'utilità Mprog.
2. seleziona la ricerca del dispositivo facendo clic sulla lente di ingrandimento o nel menu Dispositivo->Scansione, dopodiché l'utilità trova il dispositivo e ne visualizza il PID, ecc.
3. selezioniamo la funzione Leggi e analizza nella scheda Strumenti, ovvero leggiamo impostazioni attuali e visualizzare l'argomento sul display.
4. aprire il segnalibro FT232R (se non si è aperto da solo), dopodiché si aprono 2 campi. Inverti segnale RS 232 (questo non ci riguarda, poiché il programma dell'analizzatore gestisce questi segnali a modo suo) e il campo Controlli I/O.
   Il campo Controlli I/O ha 4 sottomenu C1-C4.
5. selezionare il menù C4. Questo è quello che è funzioni aggiuntive Segnale Cbus4. Tra tutte le funzioni proposte, a noi interessano CLK6, CLK12, CLK24 e CLK48. Tutto dovrebbe essere chiaro dai nomi delle funzioni J . Le restanti funzioni non hanno alcun effetto (più precisamente, selezionandole, non è possibile prevedere lo stato di questo pin), poiché sono progettate per funzionare in modalità porta COM.
6. Affinché FT232R possa utilizzare la funzione selezionata, è necessario salvare il progetto (senza questo non funzionerà), ecco come è scritta questa utility.
7. Dopo aver salvato il progetto su disco, puoi riprogrammare il nostro FT232R. Il pulsante del fulmine è attivato. Dopo averlo premuto M prog scriverà le nostre impostazioni nel chip.

7. Come descrivere e utilizzare il proprio protocollo

Per creare una descrizione del protocollo, dovrai scriverne una tua INI. Consiglio di copiare uno dei file esistenti e modificarlo. Prendiamo come esempio il file SPI_9BIT. Le spiegazioni in questi file devono essere indicate su righe separate!!!

;L'intestazione delle impostazioni in questa sezione del file specifica le impostazioni specifiche del protocollo:

;numero di righe nel protocollo. Ce ne sono 4 in questo
numero_lin = 4
;sotto le righe sono elencate per numero e sono indicati i loro nomi
lin1 = MOSI
lin2 = MISO
lin3 = SCK
lin4 = SS
;numero di bit trasmessi
bit = 18
;aggiungere. informazioni, queste verranno visualizzate nella finestra delle informazioni aggiuntive.
avviso = il canale 6 è collegato al canale 1 nell'hardware. La velocità di trasmissione viene divisa per 2, poiché la frequenza di clock viene trasmessa in 2 cicli di clock
;intestazione del protocollo. Le sequenze utilizzate nel protocollo saranno descritte di seguito.

SS = N N N N N N N N N N N N N N N N N N N
SCK = N O N O N O N O N O N O N O N O N O
MOSI = 0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8
MISO = N N N N N N N N N N N N N N N N N N N

In questa sezione, come bit trasmessi, viene indicato il numero di bit 0 1 2 14 34, ecc. Come 1 trasmesso, scrivi O (dall'inglese One), come 0 trasmesso, scrivi N (cioè Null).

IMPORTANTE: quando si descrive un protocollo, potrebbe esserci una differenza nel numero di bit specificati in num_lin e quelli descritti nella sezione protocollo.

Dopo aver corretto o scritto il file INI, è necessario aggiungere una voce al file protocollo.lst. in modo che il programma possa trovare e utilizzare il nuovo protocollo.

8. Un esempio di utilizzo dell'analizzatore per analizzare il bus I2C

Innanzitutto colleghiamo l'analizzatore al bus I2C (il dispositivo in prova è un joystick Nunchuck della console Wii), non sono necessari elementi esterni. Lo schema di collegamento è mostrato nella Figura 3. Non vedo il motivo di descrivere il protocollo. Questo è scritto in dettaglio su Internet.

Come si può vedere dal diagramma, per l'implementazione vengono utilizzati 3 canali (canali 1,4,5) e il protocollo I2C è a due fili. La conclusione è che l'analizzatore non ha la capacità di cambiare la direzione del bus durante la trasmissione del segnale, quindi la separazione dei segnali di ingresso e di uscita avviene su un transistor (vedi diagramma). Pertanto, il canale 1 è l'uscita: emette dati in I2C. E il canale 5 è in ingresso: riceve i dati tramite I2C.

Per configurare, selezionare "I2C" nel menu di selezione dell'interfaccia e impostare le seguenti caselle e pulsanti:

Canale 1 NEG (uscita inversa) OUTSDA _OUT dati di uscita

Segnale di clock OUTSCL del canale 4

Canale 5 IN Dati di ingresso SDA _IN

9. Un esempio di utilizzo di un analizzatore per analizzare un busSPI (9morso)

Questo esempio mostra un'imitazione del protocollo seriale per il controllo del display del Nokia6100. Lo schema per collegare il display all'analizzatore è mostrato nella Figura 4. Degli elementi esterni, è necessario solo un resistore limitatore di corrente per retroilluminare il display. Una particolarità è che la trasmissione SPI non è come al solito a 8 bit, ma a 9.

Per utilizzare questo protocollo, nell'analizzatore è stata creata una SPI separata a 9 bit.

Configurazione dei segnali dell'analizzatore e del protocollo.

Per configurare, selezionare "SPI _9BIT" nel menu di selezione dell'interfaccia e impostare le seguenti caselle e pulsanti:

Canale 1 OUT; registreremo questo segnale manualmente. Non è registrato

Canale 2 OUT SS; segnale di selezione del chip

Canale 3 OUT SCK ;orologio del protocollo

Canale 4 OUT MOSI; segnale dati

Poiché non abbiamo dati ricevuti, tutti i segnali sono configurati come uscita e non viene utilizzato alcun segnale del protocollo MISO.

È inoltre necessario impostare il ponticello di alimentazione sulla posizione 3,3 V, poiché il dispositivo verrà alimentato dall'analizzatore.

Un analizzatore logico è un assistente indispensabile per il debug dei circuiti digitali. Diamo un'occhiata alle tecniche di base per lavorare con il Saleae Logic Analyser e i suoi analoghi cinesi.

Per lavoro avremo bisogno di:

• cavi di collegamento (consiglio questo set);
• tagliere.

1 Specifiche dell'analizzatore logico Analizzatore logico di Saleae

Un analizzatore logico è uno strumento per l'analisi temporale dei segnali digitali. Questo è uno strumento indispensabile, davvero indispensabile per il debug dell'elettronica digitale. Gli analizzatori originali di rinomati produttori costano tanti soldi. Puoi acquistare un dispositivo del genere dai nostri amici cinesi per pochi centesimi. Pertanto, se non lo hai ancora, assicurati di acquistarlo. Caratteristiche di questo piccolo dispositivo Piuttosto impressionante.

La tabella elenca i parametri principali dell'analizzatore logico, la mia copia cinese dell'analizzatore dell'azienda Saleae.

2 Installazione del driver per analizzatore logico Saleae

Fortunatamente, per questo analizzatore logico, una copia cinese, è adatto il driver dell'originale. Vai al sito ufficiale, scarica il programma per il tuo sistema operativo e installarlo. I driver verranno installati insieme al programma. A proposito, una panoramica delle capacità del programma sotto forma di istruzioni su lingua inglese allegato alla fine di questo articolo.

Se disponi di una copia di un'altra azienda, ad esempio USBee AX Pro, con un alto grado di probabilità saranno adatti anche i driver del produttore dell'analizzatore originale.

3 Esempi di lavoro con analizzatore logico

Per il primo esperimento, prendiamo un convertitore USB-UART sul chip FTD1232. Colleghiamo l'analizzatore a porta USB. Colleghiamo i pin dei canali da 1 a 6 ai pin del convertitore USB-UART. In generale, siamo più interessati solo a due linee: Rx e Tx, possiamo cavarcela solo con loro. Il convertitore viene identificato nel sistema come porta COM. Avviamo qualsiasi terminale (qui, ad esempio, c'è un buon programma per lavorare con una porta COM) e connettiamoci alla porta.

Collegamento di un convertitore USB-UART sul chip FTD1232 a un analizzatore logico

Avvia il programma Logica delle Sale. Se i driver per l'analizzatore sono installati correttamente, il titolo del programma lo indicherà Collegato- connesso. Diciamo che non sappiamo su quale canale ci sarà un segnale e su quale canale no, quindi non imposteremo un trigger per iniziare a catturare il segnale. Basta fare clic sulle frecce del grande pulsante verde Inizio(Avvia) e mettilo in campo Durata(Durata) diciamo 10 secondi. Questo è il tempo durante il quale l'analizzatore logico raccoglierà i dati provenienti da tutti gli 8 canali dopo aver premuto il pulsante “Avvia”. Iniziamo l'acquisizione e allo stesso tempo inviamo qualche messaggio alla porta COM. Dopo 10 secondi, l'analizzatore finirà di raccogliere i dati e visualizzerà il risultato nel campo di visualizzazione del segnale. In questo caso, il segnale sarà su un solo canale, che è collegato al pin Tx (trasmettitore) del convertitore USB-UART.

Per chiarezza, è possibile configurare decodificatore dati intercettati. Per fare ciò, nella colonna di destra troviamo il campo Analizzatori, fare clic sull'icona più - "Aggiungi", indicare il tipo - Seriale asincrona. Apparirà una finestra che ti chiederà di selezionare le impostazioni. Nel primo campo, inserisci il numero del canale su cui hai i dati. Lasciamo il resto così com'è. Dopo aver premuto il pulsante Salva(Salva), sopra il campo del canale corrispondente appariranno dei segni blu che mostrano i valori dei byte che sono stati intercettati. Facendo clic sull'ingranaggio in questo decodificatore, è possibile impostare la modalità di visualizzazione dei valori: ASCII, HEX, BIN o DEC. Se hai inviato una stringa alla porta COM, seleziona la modalità ASCII e vedrai il testo che hai inviato alla porta.

Proprio lì, nella colonna di destra del programma Saleae Logic, puoi aggiungere segnalibri ai dati intercettati, misurare ritardi e durate, impostare tutti i tipi di marcatori e persino cercare tra i dati i protocolli decodificati.

Colleghiamo allo stesso modo l'analizzatore logico al convertitore USB-RS485. Ci sono solo due linee dati, quindi è possibile impostare un trigger per attivarsi sul fronte di uno qualsiasi dei canali: il segnale nel protocollo RS-485 è differenziale e i fronti dell'impulso appaiono simultaneamente su ciascuno dei canali, ma in antifase.

Fare clic sul pulsante "Start" nel programma dell'analizzatore. Utilizzando il nostro terminale ci collegheremo al convertitore USB-RS485 e trasferiremo alcuni dati. Quando viene attivato il trigger, il programma inizierà a raccogliere i dati e, al termine, li visualizzerà sullo schermo.

Saleae Logic consente di esportare i dati salvati sotto forma di immagini e dati di testo, salvare le impostazioni del programma, annotazioni e decodificatori di canali.

L'ultimo esempio in questo piccola recensione- frame di dati catturato trasmesso tramite il protocollo seriale SPI. Il canale 2 mostra il segnale di selezione dello slave, il canale 0 mostra gli impulsi di clock e il canale 1 mostra i dati effettivi dal master allo slave.

conclusioni

Un analizzatore logico può essere molto utile durante lo sviluppo e la configurazione di tutti i tipi di dispositivi elettronici, durante la scrittura Software, lavorando insieme all'hardware, quando si lavora con microcontrollori, FPGA e microprocessori, per analizzare il funzionamento vari dispositivi e protocolli di scambio dati e per molte altre applicazioni. Inoltre, è portatile e non richiede un'alimentazione separata.

Scarica le istruzioni per l'utilizzo del programma per l'analizzatore logico Saleae

• Scarica le istruzioni per l'utilizzo del programma per l'analizzatore logico Saleae da Depositfiles.com
• Scarica le istruzioni per l'utilizzo del programma per l'analizzatore logico Saleae da File-upload.com
• Scarica le istruzioni per l'utilizzo del programma per l'analizzatore logico Saleae da Up-4ever.com
• Scarica le istruzioni per l'utilizzo del programma per l'analizzatore logico Saleae da Hitfile.com