WEBVTT

00:01.570 --> 00:08.550
Sappi che tenere a mente il tuo programma è memorizzato in aree diverse a seconda della tua configurazione sul tuo

00:08.550 --> 00:09.540
computer desktop.

00:09.600 --> 00:16.230
Il programma può essere memorizzato sul disco rigido o sulla RAM o in entrambi, a seconda di

00:16.230 --> 00:24.750
come è stato configurato il computer, la scheda madre ha un bus indirizzo e il bus dati il bus indirizzo per i circuiti

00:25.140 --> 00:28.720
di utilità si trova all'interno del chip del microprocessore.

00:28.770 --> 00:36.810
Ora il contatore del programma è un registro di una posizione di memoria come qualsiasi altro registro nel microprocessore.

00:36.810 --> 00:43.170
Ora mentre conta automaticamente con tutte le sfere dell'orologio è un registro che puoi leggere e puoi scrivere

00:43.170 --> 00:50.820
per selezionare vedere il tuo programma alla riga 40 in hack e in realtà hai scritto il tuo programma per guardare uno

00:50.820 --> 00:53.990
degli ingressi per vedere se premi il bottone.

00:54.270 --> 01:00.570
Rileva che hai premuto quel pulsante e quindi vuoi saltare in avanti nel tuo programma per dire

01:00.630 --> 01:01.420
linea esadecimale.

01:01.440 --> 01:07.550
A A tutto ciò che devi fare è impostare il contatore del programma sul braccio ETU.

01:07.980 --> 01:13.740
Il programma contrasta un registro che ha un indirizzo come qualsiasi altro registro e puoi semplicemente

01:13.740 --> 01:20.280
scrivere il tuo programma in modo che indirizzi il contatore del programma e carichi quel registro con qualsiasi

01:20.280 --> 01:21.180
numero desideri.

01:21.180 --> 01:23.530
Proprio come qualsiasi altro registro.

01:23.550 --> 01:27.340
Quindi ora puoi saltare il tuo programma in questo modo.

01:27.780 --> 01:33.220
Ad esempio, di solito, se raggiungi la fine del tuo programma, lo rimandi all'inizio.

01:33.300 --> 01:36.980
Altrimenti eseguirà il programma una volta e quindi interromperà tutte le funzioni.

01:37.110 --> 01:43.530
Ora forse è proprio quello che vuoi e quello che vuoi è che è il tuo programma

01:43.530 --> 01:50.130
che puoi fare quello che vuoi ma molto probabilmente vorrai eseguire il tuo programma più e più

01:50.130 --> 01:52.480
volte in un ciclo continuo.

01:52.560 --> 01:59.940
Quindi alla fine del tuo programma invii un esagono 0 0 al tuo contatore del programma e voilà

01:59.940 --> 02:03.050
hai appena impostato il tuo programma all'inizio.

02:03.060 --> 02:09.690
Quindi, con questa idea che il tuo programma sta andando a correre più e più volte pensare al tuo programma

02:09.690 --> 02:17.890
come una parte di routine di quella routine è controllare se hai spinto il grande pulsante rosso che vuoi che il tuo robot inizi

02:17.890 --> 02:20.230
a correre in cerchio urlando .

02:20.280 --> 02:25.400
Ha spinto il pulsante rosso per la tua vita o qualcosa del genere.

02:25.570 --> 02:30.850
Hai una serie di istruzioni che vuoi che il robot funzioni quando premi il grande pulsante rosso.

02:32.110 --> 02:39.430
Quando viene premuto quel grosso pulsante rosso, vogliamo lasciare la nostra normale routine in cui il robot sta lavando

02:39.430 --> 02:40.470
i piatti.

02:40.900 --> 02:44.500
Quindi la routine normale dei robot è di sedersi lì e fare i piatti.

02:44.510 --> 02:53.800
Comunque ora vogliamo lasciare temporaneamente la nostra routine ed eseguire una subroutine che la subroutine possa essere eseguita in tre cerchi che urlano,

02:53.980 --> 02:59.980
ah, mette il grosso pulsante rosso in esecuzione per le vostre vite e poi torna

02:59.980 --> 03:04.660
a fare qualsiasi cosa prima di eseguire quella subroutine .

03:04.790 --> 03:13.730
Quindi chiamiamo questa subroutine la nostra subroutine potrebbe essere di 30 righe di codice e in realtà possiamo memorizzare quel codice in

03:13.730 --> 03:16.270
qualsiasi indirizzo di memoria che vogliamo.

03:16.580 --> 03:22.910
Quindi diciamo che abbiamo riempito le 30 righe di codice a partire dall'indirizzo esadecimale 5 che stiamo eseguendo la tua routine originale

03:23.000 --> 03:27.980
e il nostro contatore del programma era a 0 F quando abbiamo colpito il grande pulsante rosso.

03:28.130 --> 03:29.450
Ecco cosa succede.

03:30.550 --> 03:36.400
L'istruzione del codice macchina è chiamata quando chiamiamo subroutine a frase.

03:36.610 --> 03:42.280
Quali sono i circuiti di utilità che chiamerò Dan, l'uomo estrae il numero dal contatore

03:42.490 --> 03:45.550
del programma e lo inserisce nello stack.

03:45.550 --> 03:47.380
Una pila è come una mensola.

03:47.500 --> 03:51.520
Lo stack è una pila di posizioni di memoria dei registri.

03:51.570 --> 03:56.980
Quindi l'uomo inserisce l'indirizzo per la subroutine nel contatore del programma.

03:56.980 --> 04:01.550
Così ora il microprocessore inizia a eseguire il programma memorizzato all'indirizzo di hacking.

04:01.600 --> 04:08.880
D 5 alla fine della routine si impartisce un comando per tornare.

04:09.460 --> 04:13.470
Fondamentalmente stai dicendo a papà l'uomo che vuoi restituire da dove siamo venuti.

04:13.570 --> 04:19.640
Sadan l'uomo afferra il numero dalla pila e lo mette nel contatore del programma.

04:19.660 --> 04:25.960
Ora sei tornato a eseguire la routine principale originale esattamente dove ti eri interrotto.

04:25.960 --> 04:27.310
Ora ecco la cosa.

04:27.370 --> 04:31.260
Quindi l'uomo ha una pila di scaffali che puoi chiamare una subroutine.

04:31.420 --> 04:36.580
E poi mentre sei nel mezzo di quella sottoprogramma in esecuzione puoi chiamare un'altra subroutine che

04:37.600 --> 04:38.590
puoi chiamare.

04:38.590 --> 04:40.560
Quindi chiami una subroutine.

04:40.840 --> 04:46.210
Dan l'uomo prende il numero dal contatore del programma e ne fa il resto sul ripiano più in alto della pila.

04:46.210 --> 04:51.970
Inserisce l'indirizzo per la prima subroutine di superficie nel contatore del programma e inizia a eseguire il

04:51.970 --> 04:53.000
programma D5.

04:53.020 --> 04:59.050
Ora mentre il mio robot gira in tondo e urla che spingo il pulsante rosso

04:59.050 --> 05:06.010
grande, prendo il grande pulsante arancione che non so farò sparare al robot perché sai che respirare fuoco

05:06.010 --> 05:13.420
è un portafoglio di opzioni che va in giro urlando su come si preme il grosso pulsante rosso, la mia

05:13.420 --> 05:20.490
subroutine antincendio si trovava in corrispondenza dell'indirizzo di memoria EF 0, il nostro contatore del programma continua a contare.

05:20.540 --> 05:22.450
Quindi era diventato esadecimale.

05:22.450 --> 05:23.580
D a.

05:23.750 --> 05:25.910
Quando ho colpito il grande pulsante arancione.

05:25.910 --> 05:32.930
Quindi Dan l'uomo afferra il numero in cima allo stack lo infila sullo scaffale sottostante, afferra il DA dal contatore del

05:32.930 --> 05:35.720
programma lo mette in cima allo stack.

05:36.580 --> 05:44.140
Poi gira f 0 l'indirizzo per la nostra subroutine arancione del pulsante nei contatori del programma ai microprocessori ora

05:44.230 --> 05:48.880
inizia a eseguire il programma situato in hack di f 0.

05:49.240 --> 05:55.230
Quando arriva alla fine di quella subroutine il programma che hai scritto emette il comando di ritorno.

05:55.610 --> 05:56.970
Dan l'uomo prende il numero.

05:57.130 --> 06:01.160
Questo è in cima allo stack e lo mette nel contatore del programma.

06:01.420 --> 06:05.960
Prende il numero dal secondo scaffale della pila e lo mette in cima alla pila.

06:06.280 --> 06:10.180
Il programma riprende da dove era stato interrotto nella prima subroutine.

06:10.660 --> 06:15.170
Arriva alla fine di quella subroutine, dice a Dan l'uomo di tornare.

06:15.230 --> 06:20.680
Dan l'uomo ora prende il numero dalla cima del ripiano allo stile più in alto dello stack e lo

06:20.710 --> 06:22.420
inserisce nel contatore del programma.

06:22.420 --> 06:27.120
Ora siamo tornati al punto in cui ci eravamo interrotti nella nostra cattiva routine.

06:27.850 --> 06:35.290
Quindi lo stack dell'uomo potrebbe essere solo 10 alti in alto, puoi chiamare una subroutine quindi una sottoroutine sub all'interno di quella

06:35.290 --> 06:40.960
quindi una sub sub suburb team all'interno di quella poi una sotto sub sub sub di

06:40.960 --> 06:46.000
routine e poi l'uomo continuerà a catturare qualunque numero era nel contatore del programma.

06:46.270 --> 06:53.940
Lo metterà in cima alla pila e muoverà gli altri numeri nella pila uno ora che ha solo 10 scaffali

06:53.940 --> 06:55.350
nel suo stack.

06:55.500 --> 07:02.680
Se chiami 10 subroutine senza problemi, ma il suo stack è pieno, non ha più spazio di archiviazione.

07:02.790 --> 07:06.040
Ha esaurito i registri di archiviazione nello stack.

07:06.120 --> 07:11.270
Quindi prova a chiamare una subroutine 11 e poi l'uomo perde e scatta.

07:11.280 --> 07:13.100
Si gira e inizia a urlare contro di te.

07:13.230 --> 07:15.630
Non posso più farlo, posso farlo.

07:15.630 --> 07:20.700
Non vedi lo stack che scorre troppo.

07:20.730 --> 07:27.210
Questo è chiamato un errore di overflow dello stack e potresti aver riscontrato un errore simile nei tuoi

07:27.210 --> 07:31.170
viaggi su Internet o nei programmi che Cresta sul tuo computer.

07:31.170 --> 07:38.060
Esiste persino un sito Web chiamato Stack Overflow che utilizza questo errore comune come nome della propria home page.

07:39.520 --> 07:45.520
Quindi lo stack è un gruppo importante di registri che vengono utilizzati per memorizzare numeri temporanei come

07:45.520 --> 07:50.630
i contatori del programma durante le subroutine, ma lo stack di solito è limitato.

07:50.650 --> 07:52.380
Dipende dal microprocessore.

07:52.540 --> 07:57.280
Ho visto il più comunemente avere una pila di 10 livelli di profondità.

07:57.730 --> 07:59.710
Ora un microprocessore.

07:59.710 --> 08:01.090
Tutto ciò che fa è trattare con i numeri.

08:01.090 --> 08:02.730
Questo è davvero tutto ciò che fa.

08:02.800 --> 08:07.040
Quindi eseguirà la matematica nella manipolazione dei numeri.

08:07.060 --> 08:10.830
La caduta di Clinton, per esempio, è stata quella che chiamiamo complementare.

08:10.840 --> 08:15.610
Ha cambiato tutti gli zeri e gli zeri in uno.

08:15.610 --> 08:20.710
Ora immagina questo per un secondo se darai un'occhiata al registro di Clinton che è

08:20.710 --> 08:24.730
a 8 bit un byte guardando solo un bit per farlo.

08:24.730 --> 08:31.390
Il circuito di Clinton deve avere un gate non ma deve essere combinato con un gate AND perché deve essere

08:31.390 --> 08:37.450
guidato dal ciclo di clock che Clinton deve controllare quando il circuito effettua la conversione in modo da

08:37.660 --> 08:41.140
poter memorizzare il nuovo numero in un secondo registro .

08:41.200 --> 08:47.440
Quindi il secondo registro richiede anche tutte queste porte come abbiamo fatto prima e

08:47.440 --> 08:54.160
quindi le linee di controllo per scaricare quel registro sul bus dati per trasferirlo ovunque sia necessario.

08:54.160 --> 09:00.970
Quindi questa è una funzione semplice e abbiamo bisogno di moltiplicare tutti questi circuiti per otto perché ci

09:00.960 --> 09:08.530
sono 8 bit in ogni morso che Clinton deve convertire in altri circuiti di utilità che potrebbero avere il circuito

09:08.530 --> 09:10.840
duro per aggiungere due numeri insieme.

09:10.840 --> 09:17.460
Quindi ha bisogno di avere due registri uno per ogni numero da aggiungere che sono collegati da tutta la massa di

09:17.460 --> 09:20.670
gate di controllo del clock che aggiungono i due bit.

09:20.710 --> 09:26.800
E poi se c'è un riporto, è come se aggiungessi un sette e un otto arrivasse a 5 e

09:26.800 --> 09:27.480
portassi l'uno.

09:27.490 --> 09:35.140
Bene se aggiungi binario 1 e binario 1 ottieni 0 e porti quello al prossimo bit più significativo.

09:35.320 --> 09:38.770
Tutti i circuiti devono avere tutte le porte per fare tutto questo.

09:38.830 --> 09:41.460
C'è un sacco di circuiti coinvolti qui.

09:42.790 --> 09:48.310
Quindi puoi iniziare a immaginare il circuito coinvolto nella moltiplicazione o nella divisione a 8 cifre.

09:48.410 --> 09:53.540
Diventa davvero grande e complicato in una grande fretta.

09:53.990 --> 09:59.750
Se volessimo, potremmo costruire quell'enorme varietà di circuiti di utilità collegati a ogni singolo

09:59.750 --> 10:01.010
registro nel microprocessore.

10:01.430 --> 10:03.440
Ma perché dovremmo farlo.

10:03.440 --> 10:09.680
La quantità di spazio che occuperebbe tutto quel circuito estraneo sarebbe enorme.

10:09.680 --> 10:17.090
Piuttosto, ciò che i progettisti fanno è creare un registro specializzato che ha tutti questi complessi circuiti digitali collegati ad esso per

10:17.090 --> 10:23.240
eseguire tutte le funzioni matematiche se abbiamo bisogno di fare matematica sul numero che è memorizzato in

10:23.240 --> 10:25.100
un registro da qualche parte.

10:25.280 --> 10:32.990
Carichiamo quel numero dal registro nel registro di elaborazione matematica, facciamo qualsiasi funzione matematica vogliamo

10:32.990 --> 10:39.380
fare e quindi possiamo inviare il risultato ovunque nel registro da dove

10:39.380 --> 10:40.130
proviene.

10:40.130 --> 10:43.960
O qualche altra destinazione nel microprocessore.

10:44.060 --> 10:52.240
In questo modo abbiamo solo bisogno di uno di tutti quei circuiti di utilità che sono così grandi e complicati.

10:52.550 --> 10:56.490
Il registro matematico di specialità è chiamato un gruppo di nomi diversi.

10:56.540 --> 11:01.780
L'unità logica aritmetica o Alieu in breve è un nome.

11:01.910 --> 11:08.110
E questo ha molto senso per il nome, ma ho visto che ha chiamato tutti i tipi di cose diverse che ho

11:08.110 --> 11:13.750
avuto il mio primo assaggio della programmazione del codice macchina sul venerabile Commodore VIC 20, che è stato uno dei

11:13.750 --> 11:15.360
primi computer domestici mai costruiti.

11:15.370 --> 11:20.840
Era anni prima del suo tempo ed era il predecessore del Commodore 64.

11:21.040 --> 11:29.260
Mentre il primo comando di codice macchina che abbiamo appreso era LDK caricare l'accumulatore, l'accumulatore era il nome

11:29.260 --> 11:36.910
che hanno dato al registro matematico speciale e il primo comando che abbiamo appreso era caricato

11:37.750 --> 11:45.200
con il numero su cui poi eseguivamo alcune funzioni matematiche perché era la matematica Registrare.

11:45.340 --> 11:52.940
Quindi, quando il microprocessore stava per essere utilizzato nella prossima lezione, lo chiamano registro di lavoro.

11:53.050 --> 12:01.420
Quindi, qualunque sia il suo nome, questo registro di specialità è il registro a cui è collegato tutto questo circuito

12:01.420 --> 12:09.120
complicato in modo da poter manipolare il numero che è stato dato, ora che alcuni microprocessori hanno più

12:09.120 --> 12:11.370
di un registro di massa.

12:11.640 --> 12:19.110
Ma il numero di questi registri di specialità è sempre un piccolo numero per il semplice

12:19.200 --> 12:28.570
fatto che ognuno richiede enormi banchi di circuiti di utilità che sono così complicati e occupano così tanto spazio e lavoro

12:28.770 --> 12:32.220
per costruire un grande Sei ancora esausto.

12:32.490 --> 12:35.330
Perché ora scaveremo nei microcontrollori.
