Led chaser” con 74HC164

[boiler]

Per me la discussione è stata molto interessante.

Mi fa piacere

il tempo di propagazione delle retroazioni diventa pari al tempo di ciclo

E questa appunto è un'altra espressione della grande differenza di cui parlavo: il tempo di ciclo in un programma equivalente (chiamiamolo così o chiamiamolo simulazione, insomma quello) non ha niente a che fare con la realtà! Non nel senso che differiscono numericamente, ma sono due concetti completamente dissociati.

Boiler

[gekofive]

@Boiler

Non intendo farti fare brutta figura, non mi interessa. Non mi interessa neppure convincerti che hai torto, sono problemi tuoi.

Veniamo alla tua richiesta. Il circuito che hai descritto è quello dello schema che hai postato al post 19 che riporto qui per chiarezza.

Sorgente FidoCadJ | Ingrandisci | Cos'è Fidocad

Il procedimento, che può essere totalmente automatizzato è il seguente.
1) Individuazione delle uscite. Nel nostro caso ne abbiamo una, X.

Codice: Seleziona tutto

X

2) Individuazione delle dipendenze di quell'uscita. Nel nostro caso M, N con funzione OR.

Codice: Seleziona tutto

X = OR(M, N)

3) Ripetizione del passo 2 per ognuno dei nuovi nodi. Nel nostro caso
3.1) per M otteniamo A, B con funzione NAND,

Codice: Seleziona tutto

X = OR(M, N)
M = NAND(A, B)

3.2) per N otteniamo B, !N con funzione XOR

Codice: Seleziona tutto

X = OR(M, N)
M = NAND(A, B)
N = XOR(B, !N)

4) Ripetizione del passo 2 per ognuno dei nuovi nodi. Nel nostro caso
4.1) Per A nessuna operazione, perché A è un ingresso.
4.2) Per B nessuna operazione, perché B è un ingresso.
4.3) Per !N otteniamo N con funzione NOT. N è un nodo già valutato in precedenza (al punto 3.2), questo indica una retroazione e la necessità di aprire il circuito. N diventerà un'uscita (tale e quale a X), mentre la funzione per !N diventerà il NOT di un nuovo ingresso, che chiamiamo N'. Viene aggiunta in testa alla lista l'uguaglianza dei due nodi

Codice: Seleziona tutto

N' = NOP(N)
X = OR(M, N)
M = NAND(A, B)
N = XOR(B, !N)
!N = NOT(N')


Il lavoro del compilatore è ora terminato. Il programma sequenziale è quello che esegue le operazioni della lista in ordine inverso

Codice: Seleziona tutto

!N = NOT(N')
N = XOR(B, !N)
M = NAND(A, B)
X = OR(M, N)
N' = NOP(N)

Per ottenere un risultato sensato è necessario stabilire lo stato iniziale del nodo N' altrimenti impossibile da stabilire con qualsiasi descrizione del circuito si voglia utilizzare.

Il processo di generazione della lista e del programma qui sopra è del tutto indipendente dall'estensione e dalla complessità della rete che si vuole compilare. Io stesso ho scritto un compilatore per circuiti Functional Block che funziona con questo principio e non ha limitazione di complessità o di retroazioni anche multiple, nidificate, o interallacciate. Questo è il motivo per il quale posso spendere una parola sull'argomento.

Se la dimostrazione qui sopra non ti convince, io non posso fare molto di più.

[djnz]

il tempo di ciclo in un programma equivalente (chiamiamolo così o chiamiamolo simulazione, insomma quello) non ha niente a che fare con la realtà! Non nel senso che differiscono numericamente, ma sono due concetti completamente dissociati

Ma per un chaser LED che male che vada lavorerà con tempi minimi di 30 ms fa qualche differenza? O per il ciclo di scansione di qualche millisecondo di un PLC. Secondo me c'è da considerare anche il tempo di processo, che non è il tempo di ciclo, ma può essere centinaia di volte superiore.

[boiler]

Scrivere circuiti digitali in C porta forzatamente ad introdurre una componente sequenziale che nel circuito non c'è!

Questa affermazione è sbagliata: i circuiti logici, senza limitazioni di dimensioni e complessità, possono essere scritti con linguaggio procedurale.

Il programma sequenziale è quello che esegue le operazioni della lista in ordine inverso

Il lavoro del compilatore è ora terminato. Il programma sequenziale è quello che esegue le operazioni della lista in ordine inverso

Codice: Seleziona tutto

!N = NOT(N')
N = XOR(B, !N)
M = NAND(A, B)
X = OR(M, N)
N' = NOP(N)

Per ottenere un risultato sensato è necessario stabilire lo stato iniziale del nodo N' altrimenti impossibile da stabilire con qualsiasi descrizione del circuito si voglia utilizzare.

Tutto qui? Questo è quello che pensavi mi sfuggisse? Questo mi è chiaro piú o meno della terza settimana del primo semestre di tecnica digitale.

Proviamo ad eseguire il tuo codice (prendiamo come stato iniziale N' = 0):

Codice: Seleziona tutto

!N = NOT(N') = NOT (0) = 1
N = XOR(B, !N) = XOR(0, 1) = 1
M = NAND(A, B) = NAND(0, 0) = 1
X = OR(M, N) = OR(1, 1) = 1
N' = NOP(N) = NOP(1) = 1

Eccoci alla fine del programma. Il risultato è che X = 1 per N'=0, A=0 e B=0.
Che è sbagliato. X oscilla.
Ma questo il programma non lo indica. Non può indicarlo, non ne ha i mezzi.

C non ha il concetto di sensitivity list (un'altra parola strana dietro alla quale mi piace nascondermi).
Lo si può introdurre, strumentando il codice (aggiungendo per esempio un while attorno al codice qui sopra con un osservatore che decide quando e se si è raggiunto uno stato stabile). Ed è questo il passaggio per il quale io non conosco un tool che lo faccia in automatico.

Siamo su livelli di astrazione completamente diversi. Io dico che le banane sono gialle e tu mi rispondi che sbaglio, le banane sono frutti.
Se ti fa piacere pensare che ho torto, fai pure.
Io penserò che tu non hai colto l'essenza del discorso, lo considererò anch'io come un problema non mio.
E così non solo il codice in C, ma anche questa discussione è arrivata ad uno steady-state conclusivo.

Ma per un chaser LED che male che vada lavorerà con tempi minimi di 30 ms fa qualche differenza?

Assolutamente no, ma il discorso era passato ad un tema piú generale, indipendente dal chaser.

Boiler

[gekofive]

Eccoci alla fine del programma. Il risultato è che X = 1 per N'=0, A=0 e B=0.
Che è sbagliato. X oscilla.

Voler aver ragione a tutti i costi porta a scrivere queste cose, che fanno un po' sorridere...

Ti rispondo seguendo il tuo sentiero.

Il programma non finisce alla fine delle istruzioni elencate (non c'era questo dettaglio nel programma di Tecniche Digitali?), ma le istruzioni sono inserite all'interno di un loop di ripetizione infinita.

Il risultato che si ottiene per l'uscita X, con A=0, B=0 e N' iniziale =0, vale

0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0...

Guarda te, oscilla.

[boiler]

Il programma non finisce alla fine delle istruzioni elencate (non c'era questo dettaglio nel programma di Tecniche Digitali?), ma le istruzioni sono inserite all'interno di un loop di ripetizione infinita.

(aggiungendo per esempio un while attorno al codice qui sopra con un osservatore che decide quando e se si è raggiunto uno stato stabile)

Vedi, se non leggi è inutile che fai il prezioso...
Veramente, non stai capendo il concetto. Lasciamo perdere.

[gekofive]

Ma perché lasciar perdere, non è con i voti negativi che rendi più credibile ciò che stai affermando, continuiamo invece, che diventa sempre più interessante.

Io non ho fatto ancora l'università, ma ho studiato Sistemi Elettrici Automatici e credo proprio di aver acquisito le competenze per poter discutere con te sull'argomento.

Nel post 34 tu prendi un'uscita istantanea X=0 e ti stupisci che non oscilla. Ma sei serio o no? Qualsiasi multivibratore al quale campioni l'uscita in un istante singolo ha uscita 0 o 1. Un'oscillazione è un evento che si protrae nel tempo, non puoi determinarla analizzando un singolo istante.

O no?

E' fare polemica farti notare che la tua affermazione sulla mancata oscillazione al singolo istante sembra un modo per ingarbugliare le cose invece di discuterne seriamente? A me pare proprio di no!

E nota che è proprio perché ti ritengo competente che la tua affermazione al post 34 è evidentemente un tentativo di sviamento: non puoi non aver chiaro un concetto tanto elementare.

[boiler]

continuiamo invece, che diventa sempre più interessante.

Per me si può continuare a condizione di lasciar perdere i toni polemici, frecciatine e qualificare come "nomi strani" concetti importanti che forse ancora non si conoscono. Altrimenti il discorso non è produttivo per nessuno.

Io non ho fatto ancora l'università, ma ho studiato Sistemi Elettrici Automatici e credo proprio di aver acquisito le competenze per poter discutere con te sull'argomento.

Non mi piace sbandierare titoli e qualifiche sul forum, ma ho un Master in Elettrotecnica con specializzazione in VLSI ed esperienza professionale nel campo. Non è che sia proprio a digiuno dell'argomento.

Nel post 34 tu prendi un'uscita istantanea X=0 e ti stupisci che non oscilla. Ma sei serio o no?

Sì e no.
L'affermazione è evidentemente retorica. Il problema è quel loop infinito che citi: non c'è.

Va aggiunto. E chi lo aggiunge?

Lo sviluppatore software? No, abbiamo detto che deve succedere in automatico, anche per permettere di analizzare circuiti molto complessi.
Il tuo script? Forse (nota 1).
Il compiler C? No, sicuramente no.

Se lo aggiunge il tuo script, ecco il tool di cui parlavo. Ma il punto importante è che il tuo tool prende codice C in ingresso e genera codice C in uscita.

Ovviamente questi due codici non sono tra loro equivalenti, altrimenti il tutto sarebbe inutile.

Questo processo aggiunge elementi che non ci sono nella logica iniziale per permettere al programma di realizzare la stessa funzione.

È questo che sposta tutto il livello del codice ad un'altra dimensione. Il codice non implementa la logica iniziale ma implementa una logica che permette di simulare la logica iniziale.

sulla mancata oscillazione al singolo istante

Il problema non è il singolo istante. Se in quel codice (senza loop) leggo il valore di X ripetutamente ottengo sempre lo stesso risultato. Quello che manca lì è l'iteratività dell'operazione, che viene aggiunta con il loop.

Quello che voglio dire è che benché un codice in C e un circuito reale (o in VHDL) possano realizzare la stessa funzione logica, non sono concettualmente equivalenti!

Boiler

Nota 1: mi sono accorto rileggendo la mia risposta che forse c'è un livello di complessità che per me è evidente, ma che non è stato esplicitato. Quando parliamo di un circuito complicato ci possono essere diversi livelli di retroazione, uno dentro all'altro e uno in parallelo all'altro. E a quel punto non basta farli viaggiare dentro un loop infinito, altrimenti arrivato a quello piú interno non ne uscirò mai e la logica esterna non si aggiornerà. Qui le aggiunte da fare al codice C diventano piú complesse e forse la differenza tra i due piani di cui parlo diventa piú evidente.

[gekofive]

Per me si può continuare a condizione di lasciar perdere i toni polemici, frecciatine e qualificare come "nomi strani" concetti importanti che forse ancora non si conoscono. Altrimenti il discorso non è produttivo per nessuno.

Questa medaglia ha due facce. Anche tu devi lasciar perdere le divagazioni finalizzate a sviare l'attenzione dal focus del discorso.

Non mi piace sbandierare titoli e qualifiche sul forum, ma ho un Master in Elettrotecnica con specializzazione in VLSI

Io non metto in dubbio i titoli accademici che puoi aver ottenuto. Ho contestato una tua affermazione errata che ti ostini a voler ribadire anche se ti vengono date prove dell'opposto.

Nel post 34 tu prendi un'uscita istantanea X=0 e ti stupisci che non oscilla. Ma sei serio o no?

Sì e no.
L'affermazione è evidentemente retorica. Il problema è quel loop infinito che citi: non c'è.

Sono queste le affermazioni che mi fanno pensare. Qual è adesso il problema, il loop? Allora anche il sistema operativo, il mouse, il monitor. Cosa c'entra questo con la tua affermazione "Non, no, non si può fare"? Il loop è parte della procedura di realizzazione del circuito con il programma sequenziale, è parte del procedimento indicato al post 32, non citato perché ritenuto ovvio. Aggiungilo all'elenco se vuoi, è un passo aggiuntivo che non cambia nulla al concetto espresso in quel post.

Questo processo aggiunge elementi che non ci sono nella logica iniziale per permettere al programma di realizzare la stessa funzione.

Ma cosa c'entra.. non c'è nulla che viene aggiunto o tolto, è una cosa completamente diversa. Ovvio che è diverso, una una descrizione schematica, l'altro un programma per un automa. Non hanno nulla in comune, ma la cosa fondamentale è proprio che si può fare, in modo automatico è nega la tua affermazione "No, no, non si può fare".

È questo che sposta tutto il livello del codice ad un'altra dimensione. Il codice non implementa la logica iniziale ma implementa una logica che permette di simulare la logica iniziale.

No, non è vero. Implementa esattamente la logica compilata. Se implementasse una logica diversa, i risultati sarebbero diversi.

Quello che voglio dire è che benché un codice in C e un circuito reale (o in VHDL) possano realizzare la stessa funzione logica, non sono concettualmente equivalenti!

Certo che sono concettualmente diversi, non hanno nulla in comune dal punto di vista concettuale. Il programma realizza con una sequenza di istruzioni l'esatta logica hardware che vuole essere compilata. Ciò che neghi con il "No, no, non si può fare".

Nota 1: mi sono accorto rileggendo la mia risposta che forse c'è un livello di complessità che per me è evidente, ma che non è stato esplicitato. Quando parliamo di un circuito complicato ci possono essere diversi livelli di retroazione, uno dentro all'altro e uno in parallelo all'altro.

Evidentemente non hai letto con attenzione i miei post. Quando al post 32 affermo che il metodo "non ha limitazione di complessità o di retroazioni anche multiple, nidificate, o interallacciate", mi riferisco proprio a quanto tu metti in discussione qui. Ripeto, funziona perfettamente anche in quei casi.

Aggiungo anch'io una nota che non vuole essere polemica. Ma, all'università non insegnano come si aprono i grafi nidificati e interlacciati? A me sembra strano.

E a quel punto non basta farli viaggiare dentro un loop infinito, altrimenti arrivato a quello piú interno non ne uscirò mai e la logica esterna non si aggiornerà.

Questa affermazione mi fa capire che non hai colto come funziona quel compilatore. Riguardati senza preconcetti il post 32, è interessante capire come funziona.

[boiler]

È questo che sposta tutto il livello del codice ad un'altra dimensione. Il codice non implementa la logica iniziale ma implementa una logica che permette di simulare la logica iniziale.

No, non è vero. Implementa esattamente la logica compilata. Se implementasse una logica diversa, i risultati sarebbero diversi.

No. Se non capisci questo, il resto è davvero tutto divagazione.
Ho finito, stavolta per davvero.