O Guia +Hardcore de Introdução à COMPUTAÇÃO

o olá pessoal fábio ártica se você tá cético sobre esse episódio porque não tem nenhum interesse por videogames não se preocupe a intenção de hoje é apresentar muitos dos conceitos

fundamentais para você entender melhor o que a programação esse vai ser mais um daqueles episódios que você vai ficar se perguntando mas onde diabos japonês quer chegar mas como paciência as peças se

encaixam e já aviso que esse também vai ser um vídeo bem complexo pausa voltem assistir de novo não conteúdo que dá para entender 100% assistindo só uma vez

com tudo isso fora do caminho vamos lá quem me acompanha nos resta da vida sabe que um dos meus hobbies favoritos é jogar vídeo-game além dos jogos triple whey eu também gosto bastante de voltar

aos jogos da minha infância de alex kidd a sony que a super mario eu não faço coleção de cartucho porque ele não tem nesse espaço físico para tudo são milhares e milhares de jogos infelizmente hoje é muito simples basta

baixar uma das dezenas de emuladores e carregar a rom dos games por exemplo posso carregar esse ré o que tem o número da sic top bun super

mario a ideia desse vídeo veio quando eu tava assistindo dois dos meus canais do youtube favoritos o primeiro é o retro game mechanics prende o cara é muito bom

por exemplo para quem gosta do pokémon original the game boy ele explica bit-a-bit o mistério do elusivo nice no recomendo que assistam mas o vídeo que eu tava assistindo me lembrou de outro

dispositivo que existiu durante os anos 90 muitos de nós gostamos de games só que mais como passatempo e não somos tão obsessivo sem completar 100 porcento dos jogos vou fazer speed rãs para bater o

recorde quem acaba no menor tempo e só porque um jogo antigo não quer dizer que é fácil muitos tinham dificuldade maior e mais brutal que jogos de hoje tem que jogar coisas como mega man original ou

battle toads no nintendinho para ver o que eu quero dizer para que antigamente nem todo jogo tinha uma bateria para salvar o progresso então você dava game over você realmente tinha que começar do

zero então surgiram dispositivos que o tite quem joga online conhece essa palavra e os diversos softwares ante ti para evitar que jogador está passeio com

rex antes que vira e mexe cria um polêmica como no recente caso do jogo valor ante cujos olhos foi acusado de causar até estragos de hardware enfim nos anos 90 a tecnologia era mais

simples existiam diversas marcas diferentes com o action replay game shark ou mais famoso game genie funcionava assim você pulava o cartucho na parte de cima e daí pegava o conjunto

no console o game genie ficava entre o cartucho e o console ele engana o console por exemplo se pergunta para o cartucho com quantas vidas super mario tem que começar daí tá gravado em algum

lugar do cartucho o número três mas aí se você colocar um código mágico no game genie como a a rose ele devolve 9 para o console no lugar de três e o jogo começa

com nove vidas eu vou mudar alguém medir em outras coisas sobre emuladores na parte 2 desse vídeo de uma forma complementar aos vídeos do canal retrô game mechanics a chegar nisso o episódio de hoje vai

ser uma longa introdução à computação usando o meu segundo canal favorito tudo bem inter o canal do bem é hardcore ele explica todas as fundações eletrônicas da computação em particular exatamente

arquitetura por trás de computadores como nintendinho eu vou tentar resumir o canal dele e condensar no único vídeo para tentar fazer vocês finalmente enxergarem a meio triste hoje vai

precisar ter bastante paciência [Música]

o nintendinho roda o famoso processador mostro 650 128 bits derivado do desenho do motorola 68000 e fabricado pela morte

tecnólogos a partir de 1975 esse processador foi usado não só no nintendinho mas em dezenas de outros consoles e computadores pessoais dos anos 80 incluindo coisas como lendário é

por dois que o avô do mcqueen tocha ou concorrente à tarde os britânicos commodore bbc micro ele foi um dos componentes que ajudou a iniciar a revolução dos computadores pessoais nos

anos 80 e exatamente por isso é um bom ponto de partida para entender a computação de hoje em dia apesar de internamente processar em 8-bits em possui uma interface de comunicação de

16 bits 16-bits em hexadecimal que são dois bytes se representa com quatro dígitos já o valor de 8 bits ou um bike se apresenta com dois dígitos como o

código mágico atozy que falei tem 6 caractéres então já começa a ficar fácil de entender o que está acontecendo aqui muito provável o endereço de 16 bits e um valor de 8

bits exatamente o que o 6502 entende e de fato esse código se transforma o endereço 906 a e no valor 09 que da nova em vendas ao super mario é importante que vocês entendam como enxergar

binários e hexadecimais de qualquer forma tudo em computação é binário esse vídeo que você está assistindo é uma string de bits o jogo super mario é um punhado de bicos um arquivo de texto ou

código em javascript é um arquivo de bits muita gente acha que arquivos texto e binário são diferentes mas não ambos são binários a diferença com você representa esse binário depois de abrir

para mostrar o usuário deixa eu mostrar na maioria dos sistemas operacionais existem editores de textos sejam miserável luti pede no windows ou moderno vs code seu abrir um arquivo que

contém texto qualquer um vai abrir sem nenhum problema mas se no mesmo editora tentar abrir o arquivo da rom super mario vai aparecer esse monte de nicho na tela isso porque um editor de texto

só sabe interpretar um su é de binários e por convenção representa letras números e símbolos eu abrir um editor de gravar a palavra hello word e

gravar podemos abrir o arquivo puro com visualizador de binário como o comando xx de trás uber e pronto isso é o que está gravado no arquivo veja esse primeiro bloco de 8 bits que a letra h

vejam esses dois blocos repetidos são os dois l e assim por diante claro que ele bit-a-bit assim é bem conveniente então podemos pedir para ferramenta converter esses vídeos em uma representação

hexadecimal usando o mesmo comando xx de sem o parâmetro traço traço e temos o seguinte agora assim aquele bloco de bits é o número 48 em hexadecimal que

não é a mesma coisa que 48 em decimal eu já vou explicar essa é a letra h depois temos 666 e que obviamente é o código hexadecimal para letra l e assim por

diante mas quem disse que 48 é h ou que 6cl é uma convenção internacional conhecida como unicold é um conjunto de tabelas as regras que matei um cada caractere em

todas as línguas não código de um ou mais bike emojis também cada um tem seu código tudo é um número a tabela mais antiga e mais simples que ainda acabamos

usando é a haste para quem não sabe o que chamamos de um em retrô games são os bits que vêm gravados no cartucho e que está irmos para dentro de um arquivo é isso que um emulador de nintendinho

lendo um lugar do cartucho de verdade com o mesmo comando xd mas passando com o piper para o humor para podemos ver as primeiras linhas temos o seguinte deixa eu explicar melhor o que essa

representação do comando xx de aliás existem diversas ferramentas que consegue abrir binário um dos mais usados é um rex damp mas eu prefiro mostrar o xx de para dar outra

alternativa a diferença dos dois é que o x vamp só mostra o vinagre na forma de hexadecimal já o xd faz a mesma coisa mas consegue também gravar de volta para

o binário por isso se somar o xx de com o vim você pode editar qualquer vinagre de é bom coluna da direita são os endereço seguido de uma linha de 16 bytes

organizados em grupos de quatro letras cada um com dois baixo no total de 8 blocos de quatro letras cada uma letra é um byte em hexadecimal você começa o

endereço 0 e vai contando até 15 que a letra f daí na segunda linha endereço começa em 16 que o hexa decimal 10 conta mais 16 elementos agora chega no

elemento 32 que em hexa é 20 e assim por diante na terceira coluna ele mostra a ponta quando o byte não tem representação um texto quando tem ele mostra o que seria o código na tabela

assistir vocês vão notar que nos primeiros três bairros temos aparecendo o texto nessa nessa terceira coluna nessa é como nintendinho é chamado nos estados unidos o nintendo entertainment

system obviamente não é coincidência todo o cartucho distribuído nos estados unidos começa com esse código isso é só uma etiqueta arbitrária para facilitar a identificar o que é esse binário muitos

outros formatos eu vou fazer a mesma coisa se eu abrir uma imagem formato png com os xd olha só aparece um código 89 e depois os códigos

as que formam a palavra png se abrirmos uma imagem de e pegue todos começam com f f d 8ff eseba em alguns bairros para a direita aparece gif que a sigla para dia

e pega e faye o interchange format se eles estão binário compilado com a extensão ponto class de java olha o que aparece identificador de todo o vinagre odiava hexadecimal que forma as palavras

café baby se não ficou claro o que estamos vendo na tela com xx de não é um binário de verdade assim como o editor de textos como notepad mostra uma

representação em forma de texto legível dos números binários reais o x de mostra os binários de uma forma que seja fácil da gente conseguir acompanhar essas colunas da esquerda e da direita

obviamente não existem e não existe quebra de linha um binário são os bilhetes escritos um atrás do outro numa única linha continuar e pense no arquivo binário como um rolo

de fita entendi agora porque você vê computadores antigos gravando dados no rolo de fita ou nunca 7 é assim mesmo que funciona até hoje se você já programa em alguma coisa pense no

binário usam como um array existem vários sites e vídeos que ensinam em detalhes como converte e faz contas em binário e hexadecimal então eu vou resumir hiper resumido basicamente

sistemas decimais representamos em números que vão de 0 a 9 em hexadecimal representam os números indo de 0 a f onde a é 10 bbb 11 até fica 15 todas as

regras a gente médicas de soma subtração funcionam igual quando você faz f mais um colocar zero sob um daí eu hexadecimal 110 equivale a 16 e sem você precisa se acostumar manipular números

em hexadecimal até mesmo como trabalha com front aí no css sabe que as coisas são uma piadas em números hexadecimais e você faz conta com elas para fazer degradê de cores por exemplo você subtrai para tornar

o curso ou faz somas para tornar os mais claras voltando para o cabeçalho do java o primeiro ser não é a letra do alfabeto c e sem o número 12 em hexadecimal já

brincaram com calculadora de cabeça para baixo por exemplo você digita 0734 e vira calculadora e temos hello o digitamos três 76006 e de cabeça para

baixo temos google todo mundo já brincou com isso e café baby do java é parecido só que como em hexadecimal temos de verdade as seis primeiras letras do alfabeto da para representar palavras

mas é só uma brincadeira mesmo agora voltando ao binário como tu tá em bits tem algumas vantagens computador fazer alguns tipos de conta em particular multiplicar por 2 / 2 pega o número 4

tem 4 bits seria 0100 se mover um para a esquerda vira 1000 o que é oi é para dividir o oposto só vão ver tudo para

direita então quatro que 0110 0,0010 que é dois eu estou simplificando o claro porque se dividiu o número ímpar e o resto assim aliás isso que eu falei de mover para esquerda ou para a direita

é o que se chama de operador bitewings em qualquer linguagem moderna que é o shift-left é menor menor e shift right que é maior maior se abrir qualquer

navegador e inspecionar o elemento você abre o tal console de java script aqui podemos exercitar o que eu acabei de falar por exemplo se eu quiser representar um número em binário começa

o digitando 0b daí por exemplo 0100 o que é quatro e é exatamente isso que ele mostra vou criar um texto agora chamado palavra e dentro colocar hello world que tem 11 letras se eu quiser pegar a

décima primeira letra dessa palavra posso fazer palavra coxa s10 e 10 pouquinho programação tudo começa de zero então zero é h1e e assim por diante

e a décima posição é de podemos chegar na mesma letra se fizermos palavra entre colchetes 0x 0 a lembra que eu falei que a em hexa é 10 forjado escrito saber que

isso na verdade é o número colocamos zé e antes para ficar mais hardcore podemos fazer palavra entre pochete 0b 10 1060 bf-1 já inscrito saber que é o número

binário tanto 0 x a quanto 011101110 são formas diferentes escreveu o mesmo número 10 é tudo o mesmo número só que podemos representar de formas diferentes e internamente sempre atum um número

binário as linguagens de programação só facilitam e nos deixam usar números em decimal o mesmo letras se eu fizer 10 shift-light um é divisão por dois eu

posso fazer palavra colchete 0x a maior maior um onde a é descem hexa shift-light um que a divisão por 2 e ele devolvem espaço que é o que tem na

posição cinco naquele hello world entendido isso vamos pular para outro conceito todo mundo ouvi falar sobre computadores de 32 bits ou 64 bits se você parar para pensar em base decimal

da impressão que estamos só dobrando de 32 para 64 mas o que que significa que oi gente o computador consegue fazer cálculos e processadores de 32 ou 64

bits de comprimento de uma só vez até agora eu fiz exemplos com números de quatro minutos que dá para contar só até 256 lembra que eu falei que cada um bitcoin para a esquerda tô multiplicando

o número todo por dois então 5 bits já é o dobro de 4 bits 6 bits é o dobro de 5 bits 33 é o dobro de 32 bits e 64 é 32

bits ao quadrado a metade de 64-bits não é 3263 bits em 32 bits podemos representar até quase quatro ponto 3

bilhões de números em 64-bits podemos representar um número gigante 1.8 x 10 elevado a 19 ou seja o número usam de 19

casas é a casa dos quintilhões entendo essas relações de dimensão a vantagem de usar essa desse mal é que esse número usamos 64 bits pode ser representado por 16 caracteres mesmo que você ainda

esteja coçando a cabeça nesse ponto veja aqui a tendência com números vão de quintilhões de 4 bits fica bonitinho tudo com f f f f f f em hexadecimal isso

porque propositalmente estamos usando números derivado da base dois e por isso um megabyte não é bill gates esse 1024 bytes quem é que seria 4000 a gente

tende a usar números que são redondos em hexadecimal de qualquer forma 64 bits é um número difícil de visualizar na cabeça não se preocupe eu acho que até o final do vídeo vocês vão começar a se

acostumar com isso mas eu acho que a forma mais fácil de entender como as coisas funcionam hoje é ver como funcionavam ontem porque o que temos hoje são mais ou menos camadas estas em

cima da mesma base de antigamente componentes mais modernos métodos de fabricação melhores mas a fundação ainda exatamente a mesma por isso quero voltar

para os anos 70 mais especificamente para 1975 e olhar mais de perto o cérebro do nosso nintendinho se abrirmos o nintendinho essa

e a mãe com os diferentes chips mas por agora vamos focar nesse daqui o moço 6502 que eu falei antes se eu quisesse mostrar o nível zero de verdade da

fundação precisaria começar com base com eletrônico mas eu também só sei o básico é o que você aprenderia em engenharia elétrica ou engenharia da computação e não em ciências mas eu quero resumir

pelo menos e para isso resolvi pegar emprestado o material de outros os meus canais favoritos do bem e ter que eu falei no começo do vídeo uma das playlists dele mostra como você constrói

um processador de 8 bits do zero e outra playlist dele por acaso é como fazer um hello world com um 6502 que é o mesmo cpu do nintendinho só para mostrar um

hello world ele levou meses produzindo uns nove vezes com mais de meia hora cada são horas de vídeo eu vou resumir tudo em alguns minutos então depois eu

recomendo assistirem com calma os vídeos dele como eu disse daria para descer no nível da física elétrica mas a partir do nível que eu vou mostrar nesse vídeo é um mínimo suficiente para se ter um desenho na cabeça para

conseguir visualizar o tem um programa de fato tá fazendo lowrider eu acho muito mais difícil aprender a programar sem entender o que acontece por baixo quem tá iniciando em eletrônica hoje em

dia tem bastante material da hora para treinar uma dessas ferramentas se chama breadboard que é uma placa feita para montar protótipos de circuitos eletrônicos sem precisar ficar sondando

os componentes você só encaixou chips e fios na placa ngi a força no momento de 5 volts e pronto fazer circuitos integrados é literalmente programação de

baixo nível ele inclusive vende kits com todos os componentes que você vai ver se tiver como investir recomendo como bom aprendizado é como se fosse brincar de lego mas bem mais interessante a lógica

por trás de linguagens de programação modernas segue os mesmos princípios da lógica em nível de hardware se você já ouviu falar isso de t a lógica para programar mas nunca

entendeu onde começar começa entendendo portas lógicas e máquinas de estado para começar veja o diagrama do 6502 todo o chip tem essas perninhas ou pinus nelas

você liga ou desliga corrente em alguns pinos para se comunicar com o chip e os traços numa placa recebem corrente quando o chip que envia dados uma placa de verdade com solda e tudo o que liga

um pingo de um chip a outros são traços condutores não breadboard se usa fios de metal mesmo para facilitar agora vamos ver o diagrama de pinos e a primeira coisa que eu quero chamar atenção são

esses primos que vão de 0 até a 15 e os primos que vão de de 0 até de sete não é coincidência que são 16 pinos ah e oito pelos de eu disse que o 6502 é um

processador de 8 bits então quando você quer ler o resultado de algum processamento que ele fez cerão valores de 8 bits de comprimento e eles vão trafegar por esses pinos de 0 até de sete e quando o processador

o real endereço para buscar na memória ram por exemplo ele pode mandar um número de até 16 bits que trafega por esses pinos de a zero até a 15 e vamos

que eu quero mandar o número em hexa a 9 pelos pelos de dados e seminário seria um 0101001 e cada um desses bits vai um

pino de de 9 a 0 cada componente que coloca nesse breadboard sempre vai ligar um pingo de força e um pino the ground ou terra é como você passa energia para o componente daí ele vai ligar outros

pinos por exemplo para habilitar cpu outro para conectar no coque e um coque é exatamente o que o nome diz um componente com cristal de quartzo que oscila enviando um sinal elétrico uma

frequência precisa e constante todo componente que processo alguma coisa no computador precisa estar ligado no mesmo coloque para tudo funcionar sincronizado um computador é uma grande orquestra de

componentes e o clock é o maestro muitas instruções do cpu demoram mais de um clã o alinhado de acordo com a frequência desse coloque a menor unidade de

processamento no computador é esse curso que eu vou ficar chamando de coque durante o vídeo um coque de sistema convencional é pequeno como esse de um mega hair 1 milhão de pulsos por segundo

que o bem tá mostrando mas ele vai usar o mais feinho que ele mesmo construiu em outro vídeo a vantagem é operar mais devagar e dá a opção de poder pausar o

coque e manualmente solta um pulso de cada vez todo componente do computador incluindo a cpu vai pausar junto e rodar um ciclo de coque de cada vez um

processador 6502 original não suportavam uma pausa dessas mas esse que ele tá usando é uma versão mais moderna que é fabricado até hoje ele tem mais funcionalidades continuando ele precisa

ligar o pino que indica para o cpu rodar que é o rd y ou rede depois o pino que liga com o botão de reset que é um resbe daí liga o pino de coca e ligamos a placa do coque

a eterna placa principal só de fazer isso ligando a placa principal numa tomada de 5 volts a cpu já tá funcionando e fazendo alguma coisa uma forma simples de monitorar pinos de

dados é ligar leds direto em cada um deles por exemplo ligando os pinos a 0 a 4 em cinco leads para gente ver se tem alguma coisa acontecendo e de fato tem

alguma coisa mais bem aleatório para monitorar melhor o bem montou um sistema de monitoramento com arduino em outro vídeo e vai usar aqui um arduino é um

microcontrolador e tem algumas dezenas de pinus que servem tanto como entrada de dados ou saída então ele vai ligar primeiro os primos de 0 até a 15 da cpu

com os pinos 22 a 52 no arduino um arduino é programável e podemos escrever programinha simples e enviar para ele executar e é isso que o bem vai fazer não se preocupe se você nunca vi um

programa de arduino código dessa demonstração é hiper simples é só prestar atenção que dá para entender sem nenhum problema o primeiro vamos declarar uma lista com quais pinos do arduino vamos trabalhar e

vai ser de 22 a 52 de dois a dois daí fazemos um loop lendo o número a número e mandando um comando para dizer que vamos ouvir o que vier nesse pino ou

seja ele são input agora fazemos outro look pela mesma lista para ir lendo que vem cada pino essa função devolve true ou false então quando via tro devolvemos

o número um e quando vê false devolver 10 inscrevemos na tela daí escrevemos uma quebra de linha com printline e repete tudo de novo finalmente não podemos esquecer de declarar a

velocidade vamos trafegar dados que vai ser de 57600 baldes não se preocupe com esse número mágico transmitimos o programa para o arduino vi essa interface e abrimos um monitorador de

sistema para ver o resultado desse programa rodando e vemos um monte de números binários 16 bits no total que o número de pinos que estamos monitorando entendo o que está acontecendo ocp outra

processando alguma o sertão do bico nos pingos de endereço esses pinos estão ligados no arduino que tá lendo esses micos um a um daí fazemos

um loop infinito puxando esses bits constantemente e imprimindo na tela mas não estamos ligados ao corte então ele vai ficar que nem doido lendo imprimindo sem parar sem qualquer ordem para

melhorar podemos sincronizar o arduino ao mesmo coloque também eis um exemplo de porque os componentes precisam estar sincronizados com o coloque o arduino não sabe quando ele precisa ler dos

pinos então fica lendo que nem doido e não faz sentido nenhum negando ao coque ele vai nesse só uma vez a cada puxo então em vez de fazer um loop infinito vamos ligar um código de leitura ao

evento de um pulso do coque assim se para usarmos ocorre o programa também vai pausar porque nenhum evento vai ativar o código de leitura podemos ligar ocorre em qualquer lugar mas o bem

decidiu ligar no pino 2 do arduino e com isso também precisamos configurar o pino 2 como entrada para ler o pulso que vier de lá a forma de ligar um evento e eu creio numa interrupção no clock

quando ocorre pulsa e enviam um sinal do pino dois isso vai interromper o sistema e chamar essa função um coque que estamos definindo se você já programou front ainda ou já myscript já viu o

mesmo conceito que a orientação a evento o conceito existe desde a invenção dos computadores só para saber agora movemos o código do loop de leitura para dentro

do evento ou um coque aproveitamos para declarar também os pinos de 39 a 53 onde vamos ligar os primos de dados d0 a d7 do cpu para poder monitorar o que

acontece lá também agora copiamos o mesmo código que leva os pinos de endereço da cpu para nem os pinos de dados da cpu é o mesmo loop só muda os

números dos pinos também copiamos o mesmo código de inicialização para configurar os pinos 39 a 53 como input para o arduino receber bits e copiamos o

mesmo código no evento de um coque para ler os pelos de dados e imprimir até é que fica mostrando os 24 bits de zeros e uns dos primos um ajuda muito para saber o que tá acontecendo muita gente

experiente não consegue ler um monte de blocos de bits e entender exatamente o que tá rolando então vamos converter de bits para hexadecimal e imprimir do lado para fazer isso inicializando uma

variável como meu zero daí para cada pino que lemos nesse for damos um shift para a esquerda e adicionamos o novo beach no final de novo faz shift para

esquerda adiciona no final faz shift para a esquerda adiciona e assim que se monta um número lendo do binário fazemos a mesma coisa com os pinos de dados

agora usamos uma função que é comum em quase todas as linguagens que serve para formatar números em strings queremos formatar o número em uma string

hexadecimal de 4 bytes para representar o endereço de 16 bits e 2 bikes para o valor de dados de 8 bits os pinos de dados podem tanto receber dados quando

enviar dados e para isso serve o pino do lado para dizer qual o modo ser weed white então ligamos ele no pino 3 do arduino para saber se o cpu está

querendo ler ou escrever como fizemos com os outros primos declaramos no código como três que é onde vão me ligar o pino rw do cpu dizemos a ordem do planeta esse pepino ou seja input

conduzimos do pino se devolver tron escrevemos r para leitura ou se devolver força e screamos w para escrita pronto agora iniciamos o clock no monitor

podemos ver que o cpu tá cuspindo alguma coisa nos pelos de endereço e de dados mas tá difícil de entender o que que tá acontecendo isso porque não tem nada enviando dados ao cpu daí quando ele

tenta ler alguma coisa dos pinos de dados vem lixo e tenta rodar esse lixo e fica soltando lixo por isso parece aleatório agora que temos o cpu ligado e

monitorado vamos enviar o primeiro dado de verdade para ele lembre-se enviar ou receber dados e literalmente aumentar ou diminuir voltagem nos primos

15 multi do pino de zere o cpu vai ler o bilhete um corte a voltagem no primo de um e o cpu vai interpretar com bit 0 nesse pino então se quisermos mandar um

valor constante nos pinos de dados podemos ligar resistores se quisermos obter 0 ligamos resistor no terras fizemos obter um ligamos resistor no 5

volts da placa e com isso configuramos o binário 10 10 10 voltando a monitor executamos em veja que na última coluna vem e a que é o hexadecimal do binário

que acabamos de configurar como não mandamos o cpu gravar o pino de vídeo white tá solid e note como nos pelos de endereço a cada coloque ele vai incrementando o endereço vamos ver com

mais calma passo a passo esse coque simples do bem tem a opção de pausar e manualmente solta um pulso de clock de cada vez clicando no botão segundo o

manual do processador os primeiros sete cox é uma rotina de inicialização cpu então podemos ignorar logo em seguida o o programa carrega o vetor de reset dos

endereços f f f c e f f f de como único dado com que tá conectado é o ea dos resistores ele vai ler o endereço é a duas vezes e montar o endereço e a que é

para onde o cpu vai procurar a primeira instrução do programa para executar daí ele vai colocar e aí a nos pinos de endereço ea única resposta que vai ter continuar sendo ea de novo porque é o

único dado fixo dos pingos de dados o bem escolheu e a de propósito porque é um opcode vale do 6502 esse olhar nos qualquer documentação dessa cpu vamos

descobrir quem é o tópico dinop ou no operation que é literalmente um comando que não faz nada por dois ciclos quando o primeiro nop terminar o contador de programa aponta para o próximo endereço

que é a e b e de novo nos pneus de dados só vai ler e a daí o cpu executa nop e o contador de programa agora vai para a e c e assim por diante e infinitamente até

aqui você acabou de aprender os principais elementos que tem em qualquer cpu primeiro que ele tem pinos para enviar endereço segundo ele tem pinos para enviar e receber dados que

ele tem um computador de programa que aponta para o endereço da próxima instrução terceiro que instruções e dados são tudo minaria que não existe diferença entre um byte de dados e um

byte de instrução mas só deixar um valor fixo com resistores não é muito interessante para ficar melhor precisamos de alguma coisa que consigo enviar uma sequência maior de bikes

formando um programa para isso bem escolheu uma eprom do mesmo fabricante de silicone d6502 que estamos usando para facilitar vale explicar o que que é isso hum acho que todo mundo tem noção

do que é o que chamamos de memória podemos escrever e ler dados da memória e quando o computador desliga o que tá na apaga daí temos um que é sigla de

bridge only memory ou seja uma memória que só dá para ler o que tem dentro e não é possível sobrescrever e nem apagar só para ter um modelo simplificado na

e pense na rom como se fosse uma grade pense em cada linha dessa grade como o endereço de 0 a 10 x e digamos que cada linha dessa grade tem oito cruzamentos

ou no cruzamento tá aberto podemos dizer que o bit 1 quando ele tiver queimado pensa que é queimado mesmo então não tem como recuperar esse vai ser o bit 0 o conteúdo de um marrom é fixo não tem

como regravar você só consegue enviar endereço e ler o que tiver nesses endereços agora eprom é um circuito mais complicado quando ligamos no computador

eles simulam marrom ou seja passe o endereço e ele devolve um dado porém usando um gravador especial ele permite que a gente escreva nela na prática uma

evolução de ser promoção chips de memória flash usados em pen drive ou ssds por exemplo eprom é sigla para eletrônica e recebo programmable rom nos

anos 90 eu usava eprom para gravar um boot de rede de computadores da faculdade presas bo bom e se conectar e na rede para baixar o sistema operacional de verdade dá para usar e pronto para muita coisa seria

como botar de um pendrive hoje mas a vantagem na época que era difícil de pular esse bucho obrigatório diferente de ram mesmo quando desligarmos a força o conteúdo não vai se apagar igual um

pen drive tanto nos vídeos do bem quanto aqui vamos ficar toda hora chamando isso de ruim porque mais curto mas lembre-se que é uma eprom e no caso é um modelo até grandinho de 32 kg mais se olhar o

diagrama vemos que a pinagem é muito simples ele tem pena de aí o zero a ai ou sete para dar um vedados e pinos de 0 a 14 para receber endereços e porque vai

só terá 14 não até a 15 porque ele só tem 32 kg que é metade 64k com 16 bits conseguimos contar de zero até 64k e com

15 bits que é metade com os rios uma os 32k que têm nessa rom por isso não precisa de mais um bit estão começando a se acostumar com essa história de bits

o bitcomp no chip desses repetindo um 16-bits podemos uma piada de 0000 até ffff prestem atenção do cumprimento

dessas palavras cada digito representa 4 bits cada dois dígitos em um byte 16-bits é a mesma coisa que dois vai te conheço quatro dígitos metade de 16-bits

é só um bilhete a menos o que nos dá os endereço de 0000 até 7fff se você p ou tentar mandar o endereço de 8000 para cima o primeiro bit é ignorado e o

restante é igual a primeira metade então ele devolve a mesma coisa que devolveria com o endereço de primeiro bit 0 por exemplo se pedir o endereço 8004 é a

mesma coisa que pedir 0004 note outra vantagem de usarmos hexadecimais como eu sei exatamente qual é o número do meio entre 0/65 1353 eu disse que para

dividir um número por 2 é só fazer shift para a direita daí um por exemplo vira zé e esse é o número do meio em hexa qual é

a metade de fs7 porque é fé 15 então metade dffff é 7fff que até onde vai o endereço nessa rom tô vendo porque a

gente usa hexa.com decimal não é intuitivo de trabalhar e aliás 7fff cd 32767 como cpu consegue entender

qualquer endereço entre 0000 e f f f f não queremos que a rom responda em todos aqui é uma decisão de engenharia mas para manter a lógica simples podemos escolher fazer a responder a primeira

metade os endereços ou a segunda metade e o bem resolveu responder me responder a segunda metade ou seja quando o primeiro bit do endereço por um isso

porque já vimos que o cpu procura logo de cara nos endereços f f f c c f f f b que ficam na segunda metade dos endereços logo é mais conveniente uma

direto para lá para fazer isso funcionar queremos responder somente a endereços que cor o primeiro bit sendo um ou seja quando o pino a 15 for um aliás se vocês não

perceberam a ordem dos beatles é o inverso da numeração dos pinos acostume-se com isso além disso para ruim ficar habilitada ele precisa receber baixa voltagem no pelo the tip

nemo ou cê e é como um botão de liga e desliga da rom e para ele responder precisa estar habilitado também isso é simples colocamos um inversor entre o a

15 e ser assim quando a 15 estiver em alta voltagem ou seja representando o bit 1 porque queremos todos os endereços que começam com o inversor vai reverter

e enviar baixa voltagem 110 para você que vai habilitar o resto dos pinos podemos ligar direto da cpu para 1 para 1 a 14 da cpu para 14 dá um de zero da

cpu ai 10 da rom e assim por diante coisas comecei inversor como mencionei pode ser montado com uma porta lógica chamada nand eu mencionei portas loja

o preço do episódio de supremacia quântica mas o canal do bem tem vídeos detalhados explicando como transistores funcionam e como podemos montar portas

lógicas como um lanche num breadboard também o protótipo de hoje ele usa um chip pré pronto com portas nand embutidas mas entenda que todos os chips que vocês estão vendo são montados com

transistores imagine transistor com peças de lego e chips como sendo um conjunto de transístores conectados com a rom conectada e pronta precisamos carregar algum programa nela para isso

bem vai usar python para criar um arquivo binário odiamos usar o próprio xx de para escrever na mão mas qualquer linguagem de programação consegue fazer a mesma coisa usa que achar mais simples

mas vamos seguir no código dele para entender que não é tão difícil que lembrando que antes a cpu a receber somente o valor fixo dos registradores o

hexadecimal e a que é a instrução op code nop vamos gerar um binário que é exatamente a mesma coisa primeiro declaramos uma variável que vai ser um

array de bytes o conteúdo vai ser e a 32 1768 vezes que é o total de bytes que dá exatamente 32 kilobytes agora vamos abrir um arquivo para escrever em modo

binário com o arquivo aberto escrevemos o array de bytes direto e isso vai gerar o arquivo com um ponto bean se fizermos um rex damp podemos ver que só tem e a

quando tem um asterisco é a ferramenta rex dumb querendo dizer que o mesmo conteúdo se repete até o fim que é o endereço 7fff o último em 32 kg

lembrando que a cpu vai pedir endereço a partir de 8000 mas como a rom não recebe o primeiro bit só os 15 bits restantes do endereço então o endereço 8000 virar

automaticamente zero como eu já expliquei agora podemos pegar o arquivo binário e usar o programa mini pro que envia os bits para o gravador de eprom isso é só um detalhe relevo

a fusão gravador de eprom como da demonstração do bem mas é assim que se grava se você tinha curiosidade finalmente colocamos a efron de volta na placa e ligamos o arduino de novo para

monitorar podemos usar o mesmo script do arduino de antes e ligar o monitor e como esperado está recebendo só e a para ver passo a passo damos um reset e para

usamos o clock agora podemos ir coloque a corte os primeiros sete é inicialização cpu depois disso ele nos endereços f f f c e f f d e lê e a como

antes e com isso ele porque o endereço é a e continuar lendo só e a até aqui replicamos exatamente o que os registradores estáticos faziam vamos fazer algo um pouco mais útil voltamos

para o programa em python e depois de ter o array de bytes com ea acessamos a posição 7 ffc e colocamos os valores 0 e

na posição 7ff de colocamos valor 80 duas coisas levam na explicação de binário que eu os exemplos de scripts onde eu explico que podemos acessar posições numa rei

tanto com números decimais quanto com números direto em binário escrever 7fc é a mesma coisa que escrever 32 1764 e

repetindo porque 7f fc e não ffc que é o que o cpu é procurar porque o cpu vai mandar o endereço ffc para rom mas o primeiro bit é ignorado lembra como o

endereço 8000 vira zero então é só fazer fc - 8000 e vou lá temos sete ffc ou

entendeu f em ex é 15 subtrai 8 temos sete agora uma coisa que eu deixei para explicar só agora o cpu vai pedir o valor do endereço ffc e vai encontrar

zero e daí vai pedir fffd e vai encontrar 80 esses dois valores vou formar o endereço 8000 essa forma de ordenar os bailes ao contrário se chama

little angel os outros processadores como o intel ou amd o mesmo usar miss de celulares também são little angel o processador

ibm powerpc dos macs anteriores a 2006 eram big encher então os bytes em um aparecer na ordem natural que nós humanos lemos mesmo os processadores arm

de hoje são b angel quer dizer que ele suporta ambos mas a maioria é usado como uniram angel parece meio estranho porque que eu ia querer ler números de mais de

1 byte em ordem reversa na realidade parece estranho porque a gente lê da esquerda para a direita mas quando implementamos em hardware é mais simples ler da direita para a esquerda requer

menos ciclos para fazer contas sem entrar em detalhes do hard vamos dar um exemplo onde a ordem natural pode não facilitar nossa vida imagine datas no

formato brasileiro com dia mês e ano mande um computador ordenar podemos usar o comando sorte que tem todo o linux porém coloque as mesmas datas agora em formato japonês quer ano mês hein

olá pintor de nada a mesma forma e veja só só de mudarmos a ordem dos elementos das mesmas datas a ordenação funcionou muito mais fácil aliás isso é um insight

que todo programador precisa ter boa parte do que a programação é retrabalhar os dados para ficar mais fácil de computar o que queremos little angel no nível do processador é algo parecido na

hora de fazer contas para agora só assume que quando você vê dois bytes que apresentam endereço de 16-bits eles vão estar invertidos então o 0080 vai ser na

verdade 8000 uma vez eu justamente precisei fazer um pequeno protocolo de rede binário para trafegar dados entre computadores intel e powerpc acho que eu

tava usando um mac book g4 antigo e eu recebi a lixo no lado do intel até que eu me dei conta pontos para pc é big and daí eu inverti os bytes no meu protocolo antes de mandar e do lado do intel

passou a receber direitinho você não vê isso porque se único protocolo que já usou foi http na camada de baixo no e ele se vira para reverter os bytes para trafegar entre processadores com em

diferente se você já usou algum o google protobus a biblioteca se encarrega de converter se precisar isso tudo explicado vamos fazer um programinha agora lembrando um cpu tem registradores

e pode guardar dados de 8 bits 1 byte nelas pensa em registradores como se fossem variáveis globais uma linguagem de programação qualquer elas vão ser uma ordem de grandeza mais rápida de acessar

do que estiver que sair do cpu e pedir memória para um chip de ram por exemplo registradores que podemos usar no 6502 incluem o ar xix y e outros cada

registrador vai ter um comando de load para jogar um valor nele e um comando de store para tirar o valor do registrador e jogar em outro lugar na memória se tiver hum por exemplo vamos fazer um

longe hein aqui é o happy code ld assim como linguagens modernas existe o conceito de polimorfismo ou seja a mesma função responder argumentos diferentes

é de máquina o mesmo comando é líder na verdade representado por diferentes hexadecimais para cada variação de argumento por exemplo existe a instrução added mas a versão que queremos é a que

aceita só o valor simples e não o endereço de memória como argumento então essas esse mal da instrução l.d.a. que

queremos é um a nove de volta ao python se acessarmos o primeiro valor do array posição zero colocamos o valor a 9 que é o comando ldd e na sequência colocamos o

argumento dessa instrução que pode ser qualquer o valor de 1 byte e aqui colocamos 42 arbitrariamente a instrução completa são esses dois baixos dependendo da instrução pode ter mais

argumentos usando mais baixos na sequência e o cpu sabe quantos bytes cada instrução precisa tudo tem tamanho fixo em bikes na cpu ea se ele sabe qual

o batman instrução e quais bikes são dados como agora temos um valor no registrador a podemos fazer alguma coisa com isso tipo escrevemos pingo

e para isso usamos o store from o grave a partir de ar que é o comando s t a e ele recebe um argumento de 2 bikes que é o endereço para onde queremos enviar o

valor de ar então acessamos a posição dois do array e colocamos o binário oito de que a instrução st a agora nas posições seguintes queremos enviar esse

dado para o endereço 6000 como eu já expliquei queremos universo disso então na posição 3 do array colocando zero e na posição quatro colocamos 60 essa

sequência de 3 bikes vai fazer o seguinte escrever o valor que está no registrador a nos pneus de dados mudar o boot do pino de slide para escrever e

mudar os pneus de endereço para 6000 podemos um script python para gerar o novo binário gravamos na eprom com o mini pro de novo e colocamos a rom na

placa e ligamos a energia eo monitor do arduino fazemos reset com coque pausado e vamos manualmente o clássico mesma coisa de antes ignoramos os sete primeiros que a

inicialização a cpu pede os valores de f f f c c f f f d que puxa da rom o endereço 8000 esse é o reset vector ea

cpu pede o que tem nesse endereço que sabemos que o endereço 10 da rom e tem instrução ldh que é o a9 o contador vai incrementando a partir de 8000 e pede o

que tem 800 um que é o valor 42 a instrução tá completa e a cpu grava no registrador agora o contador pula para 8002 e de lá tem a próxima instrução st

que é oito de o cpu vai incrementar o contador e nem os próximos dois bytes que vai ser primeiro zero e depois 60 que forma o endereço 6000 tudo

funcionando conforme esperado mas ao configurar os primos para gravar não tem ninguém no barramento que responde a essas ordens e nada acontece no próximo ciclo esse dado vai sumir do barramento

precisamos de algo e para segurar esse dado enquanto a cpu fica livre para fazer outras coisas esse seria um componente chamado leite que acho que podemos produzir para tranca

para esse protótipo bem escolher um chip que foi feito pelo mesmo fabricante de silicone d6502 em um adaptador que serve para muitas coisas incluindo trancar alguns valores pense como se fosse uma

mini memória por acaso os pinos desse adaptador são muito parecidos com o da rom que já estamos usando e tem espaço para gravar até dois dados de 8 bits no

que ele chama de portas tem uma porta a de 8 bits em uma porta bebê de 8 bits por isso você tem pílulas de pa0 até a 7 pinos pb0 apb 7 a essa altura você já

deve ter entendido a ideia de pinus ser em cada um ambiente né diferente da rom não precisamos de 16 pinos para o endereço porque esses tipos só consegue armazenar dois valores sabemos que

cremos ativar esse chip quando passarmos endereços que comecem com 60 que em binário é zé 100 000 resumindo que o bem explica o vídeo dele ele vai ligar os endereços a

15 a a 13 com os pinos de chip select que são certinho e cs2 e colocar um inversor e a multa a porta nand no meio deles para configurar o chip corretamente os detalhes não importam

para onde eu quero chegar mas recomendo que assistam episódio de para entender os detalhes o importante é entender que quando a cpu colocar endereço 6000 6001

e assim por diante esse chip vai entender os primeiros três meses ligar e esse é meu dado de 8 bits dos pinos de dados e gravar na porta a ou porta b que

indica a operação é o segundo byte do endereço entenda o cpu chama os primos de endereço mas são mitos podemos ligar esses pinos um qualquer outra coisa para

montar nossa lógica o chip de tranca segundo a documentação ele espera receber quatro bits de configuração em quatro registradores diferentes podemos ligar esses pinos aos pinos as

bom dia quatro que são últimos bits do endereço de 16-bits cima da 0010 que é o número dois ele direciona para porta b e se mandar zero ele manda gravar

efetivamente na porta b portanto a cpu precisa mandar o endereço 6002 para o mesmo tempo habilitar e configurar a direção e depois mandar o endereço 6000

para de fato gravar o que estiver nos planos de dados da porta b parece complicado mas é bem simples vamos ver para ver isso em funcionamento podemos ligar alguns leds nos pinos da porta b

assim quando o valor for trancado ele vai ligar os leds correspondentes de volta ao pai tô mas antes de continuar é uma boa hora para refatorar esse código para ficar mais legível é assim que se

programa primeiro fazemos a coisa mais simples que funciona primeiro agora vemos padrões no código que pode dificultar continuar então pensamos em formas de tornar o código mais fácil de

manusear uma das formas de fazer isso é definir um novo array de bytes em cima do arreio oi gente nesse novo array a gente coloca exatamente os mesmos bairros que estavam

lá embaixo quem está a posicionando manualmente depois de copiar para cima é só apagar o que tava embaixo agora o a hands-on vai ser esse novo a rede código

mais uma rei preenchido com essa só que em vez de ser vezes 32.768 vai ser 32768 - o cumprimento do novo a rede opcodes

assim o array do binário vai ter exatamente o mesmo comprimento de antes e isso é importante porque tem que ser tudo preciso escrever tudo numa linha ou dividir múltiplas linhas para o pai tu

não faz nenhuma diferença só faz diferença para a gente conseguir ver mais fácil e de propósito colocamos 2 bikes uma linha porque o primeiro é o ex da instrução ld a seguiram do seu

argumento e na segunda linha colocamos três baixo onde o primeiro é instrução st a seguido de dois bairros que formam o endereço para onde gravar o conteúdo de ar esse código é exatamente igual o

que tínhamos antes e agora temos a tranca que exige primeiro uma instrução para dizer a direção para saber qual porta usar então precisamos mandar o endereço 6002 mas

também precisamos mandar algum dado pelos primos de dados cima da tudo zero ele habilita a porta b para ser input em cima da tudo um ele habilita a porta b

para ser out e gravar o que receber envia tudo um em 8-bits é o hexa efe então mudamos o nosso a rede código para em vez de carregar aquele 42 vamos

carregar com o número ff em vez de mandar esse valor para o endereço 6000 vamos mandar primeiro para o 6002 e com isso você tamos a direção do chip para

porta b e para ela ser out na sequência podemos fazer o que queremos antes travar um valor digamos o ex a 55 agora

é só mandar instrução st6000 por acaso 55 em excel 01010101 isso vai ligar os leds alternando o primeiro apagado o segundo a seja assim por

e para ficar mais legal podemos agora repetir os comandos e mandar mazena a a em hexa que é 10 10 10 10 em binário e

alternando os bits com o valor anterior daí os leds apagados vão acender e os acessos vão apagar só uma brincadeira para mostrar como podemos controlar alguns leds para finalizar seria legal

colocar essas duas sequências no loop para os leds ficarem piscando sem parar repetindo essa sequência ea forma de se fazer loop segundo a documentação do

6502 é com jump que a instrução jmp ele manipula o contador de programa para apontar para outro endereço qualquer fazendo cpu continuar incrementando de

lá então podíamos fazer jump para 8000 que é o endereço 10 na ruim e começar tudo do zero mas não tem necessidade de reiniciar tudo um jump com o endereço

8005 é suficiente ou seja pulando os primeiros cinco babys agora podemos rodar o script geral novo binário gravar se liga um testar e pronto os leds

piscando como esperado se você chegou até esse ponto e tá entendendo mais ou menos no mínimo já deve tá ficando meio ansioso de ver esse monte de baixo numa rei nesse ponto o bem resolver explicar

uma forma menos feia me gerar esse binário obviamente ninguém escreve código em binário direto assim hoje em dia mas considere por um instante que nos anos 50 para trás era exatamente

assim que eu precisava escrever e a forma de fazer isso era confio sabe os pinos de dados e endereço que ligamos registradores e agora negamos a rom antigamente era um pet penal lembra

aqueles seriados ou filmes antigos dos anos 50 que mostra uma telefonista conectando uma ligação colocando um fio o tirando fios de um painel é algo parecido configura os bicos e manda para

o computador um conjunto de bits de cada vez se você já leu alguma mini biografia do bill gates ou do paul allen vai lembrar que o primeiro computador comercial para qual eles escreveram base

e foi o alter 8800 que vinha com processador intel 8080 de 8 bits isso foi um ano antes de aparecer o processador motorola 68000 que foi a

base por 6502 que eu tô mostrando aqui se você nunca viu o walter veja essa foto tá vendo esses switches no painel a etiqueta em cima dele está escrito d0 a

d7 e abaixo a 0 a 15 agora você já sabe para que que serve esse suítes você tinha que escrever bit-a-bit subindo o descendo esse suítes um a um os bits de

dados e os bichos de endereço e depois puxar o switch the deposit next e tem nesse painel para registrar na memória e fazem isso instrução a instrução que o

equivalente do nosso array de bytes que você tá achando tem dioso que a gente está fazendo imagina escrever um programa inteiro só com esses sonhos bit-a-bit sem errar nenhum beach essa é

a verdadeira definição de escovar beach felizmente oi flores caseiros que vieram depois ganharam teclados e monitores isso facilitou o ordens de grandeza a

programar de qualquer forma havia uma opção um nível acima de escrever binários direto ea escrever em assembly que é assembly com y no final que é

escreveu usando mnemônicos como usar a palavra ldh em vez de escrever o binário a 9 em vez de escrever direto a 9ff

podemos escrever l de hash dólar ff o dólar indica que estamos escrevendo um número em hexa e o resto significa que é um valor imediato e não o endereço

quando compila sem o hash apesar do mnemônicos e l de ar temos um tipo de polimorfismo como eu já expliquei se passarmos um valor com o hash vamos

escolher o a9 mas sem o hash ff é o endereço e o happy code é diferente viraria a cinco continuando em vez de 8

b0060 podemos escrever stat6 10 ou seja também não precisamos nos preocupar com a inversão de niro winger como falei antes de escrever na ordem

natural da leitura humana nas seguintes fazemos ele da55 st a6000l de um st6000

e jump 680 05 exatamente a mesma coisa que fizemos no binário para declarar que o início do programa é o endereço 8000 colocamos o indicador no começo do

arquivo ponto org 8000 que declara a origem lembre-se na rom o endereço inicial vai ser zero mas do ponto de vista do cpu é o endereço 8000 no final

do código colocamos um novo.org ffc que é o primeiro endereço que o cpu sempre vai pedir para buscar qual é o próximo onde tem a primeira instrução do programa já repetimos isso várias vezes

e aí colocamos um word 8000 que indica o endereço inicial para o cpu buscar word é como chamamos um conjunto de 2 nós salvamos esses comandos no arquivo

texto e agora podemos passar isso para um assembler com e r no final que vai traduzir esse texto em binário em inglês assembly que terminei y significa

montagem que tipo a instrução de montagem ou o código-fonte e assembler que termina com r é o montador que vai pegar essa instrução de montagem e

montar o binário propriamente dito para gerar o binário correto precisamos do assembler específico por 6502 na maioria dos linux basta instalar o pacote vazio

para quem tá em windows ou mac vou deixar o link do site nas descrições abaixo e o vídeo do bem explica em detalhes como usa existem vários

assemblers diferentes para família 6502 praia por dois é diferente do atari que é diferente do 6502 genérico o assembleia que precisamos se chama vaso

m6502 old style se abrirmos o binário que ele gera com o ex damp compararmos com o nosso o script de python vemos que é idêntico ao array de bytes que estamos escrevendo

na mão para completar os 32k menos que faltam só dois bytes no final para isso só adicionando um novo word no fim do código com 2 bikes para completar mas

agora que estamos escrevendo em assembly podemos usar funcionalidades do assembler vasilhame que melhora um pouco nossa qualidade de vida de programação em baixo nível a maioria dos acender

implementam macros e outras coisas para evitar que a gente tem que ficar fazendo repetições ou decorando endereços de cabeça por exemplo lembra que temos um

jump para o endereço fixo 8005 e se colocarmos mais instruções antes de disso toda hora e a precisa ficar atualizando esse endereço na mão em vez

disso podemos adicionar um leibo e fazer o jump pular para esse nemo e deixar o assembler calcular qual é o endereço correto a diferença no código é que precisamos sempre identar com espaços ou

tá o lemos começam já na primeira coluna sem identação só de fazer isso já nos livramos de um número hardcoded números

mágicos como esse sempre são ruins e em assembly e isso não é diferente ainda dá para melhorar esse código podemos delimitar a região de reset com um label

e só para brincar vamos mudar o valor 55 para ser 50 look vamos tirar o que tinha antes e colocar uma instrução nova que horror ou rotate right e a cada loop ele

vai dar shift rotacionar para direita significa que vai ter só dois leds acesos acaba coque eles vão se movimentando para a direita podemos compilar com o vaso e para gerar o

binário gravada é pro e fazer o de sempre colocar na placa ligar força resetar e ver se funciona no caso ele tá rotacionando para a esquerda porque a

placa tá de ponta cabeça nos vídeos mas você entendeu com os leds fazendo o que esperávamos sabemos que a trava tá funcionando e gravando o dado na porta certa

nós podemos um passo além essa trava pode funcionar mais ou menos como um buffer para uma tela e o bem conseguiu uma tela de lcd simples novamente vamos

pular configuração toda do hardware mas a parte importante aquele recebe 8 pinos de dados como a rom e um let e assim como let ele tem três pinos de controle

onde podemos ativar configurações em resumo o lcd pode ou receber instruções um e receber dados que seriam as letras que queremos que apareça na tela

instruções são coisas como limpar tela mudar a posição configurar um curso foi assim por diante o manual da tela tem os detalhes de cada configuração mas vou mostrar o valor que eu nos mandaram

acendem direto para receber dados vamos conectar os pinos de dados do lcd com os pinos da porta b dulet e para configurar os três pinos de controle vamos ligar em

três pinos da porta adolescente como refatorar o código de novo crença alguns símbolos ou constantes por código ficar um pouco

bom então queremos porte b = 6 000 porte igual 6001 drb é a direção se vamos escrever na porta b e o endereço é 6002

mais se quiser um se inscrever na porta a temos que sentar de dr a que é 600 3ff significa tudo um em hexa podemos deixar mais claro escrevendo o número em

binário direto bit a bit devemos para o assembler que estão no binário colocando por cento no começo e ponto e vírgula é comentário que não aparece no binário

final agora os pelos de controle do lcd para isso vamos sentar só os primeiros três bits que são os conectamos nos pinos de controle da tela agora é uma sequência específica desse modelo de lcd

então não se preocupem tanto com os detalhes do valor em si para inicializar tela começamos mandando 100 1000 o primeiro bit certa modo 8 bits o segundo

set duas linhas na tela e o terceiro certa fonte de cinco por 8 pixels por fim um e tá mandando para porta b carregando 10 com ele ah e mandamos para porta a com s

t a para limpar os pinos de controle rs rw e rs é o pino que selecionasse estamos mandando instruções soldados para tela rw você estamos lendo

escrevendo e esse tá habilitado para receber comandos agora queremos habilitar com ele de ar do valor e e depois desligarmos ensinei boo é uma sequência bem burocrática mesmo e a

maioria dos raros tem uma sequência de controle desse jeito mas é o que a documentação do mc diz que precisa fazer então vamos seguir e já tá quase acabando cada nova instrução que

queremos mandar precisa copiar toda essa sequência agora mandamos 000010 de novo três minutos mas agora é para ligar o display ligar o cursor e não fazer blynk

quer ficar piscando na tela copiamos todo o bloco de controle de colocamos em baixo a última configuração é mandar 0000010 quer dizer

é que para cada nova letra que mandarmos é para incrementar a posição e não fazer nenhum tipo de escuro e tem que copiar todo o bloco de controle tudo de novo

finalmente podemos enviar a letra que queremos escrever no lcd poderemos dar l de ar do número em binário ou hexa que representa a letra na tabela ascii mas

como estamos usando um assembler ele sabe converter sozinho então podemos escrever o stringer h direto entre aspas que ele se vira daí mandamos para porta

b com st o bloco seguinte é um pouco diferente do que fizemos antes em vez de dizer ah os pinos de controle temos que ligar o pino que seleciona o registrador

para em vez de receber instrução receber dado que a nossa letra h então configuramos com a constante rs que tinhamos declarado antes na sequência

além de só habilitar com a constante tem que mandar junto o bit de rs para isso usamos o operador between the work é uma barra vertical o que que isso faz

e me faz um or bit a bit de novo esse a lógica na prática o resultado é mesclar os bits de rs com o di e como rs-010 e é

1000 resultado vai ser 10 10 aqui valeriam a tangente mas como já tá cumprindo eu só quero deixar um lembrete que essa é uma técnica muito usada especialmente para quem mexe com protocolos de rede isso é como

trabalhamos bitfields procurem sobre isso no google é uma forma eficiente de enviar várias características de alguma coisa embutido no único byte em vez de ter um bike separado para cada valor por

fim zeramos o bloco de loop para quando chegar nele fica no loop infinito e não fazer nada assim ele termina de escrever na tela e não faz mais nada compilamos

gravar eprom e testamos e aparece o h na tela como queremos para escrever o resto das letras do hello world por agora vamos fazer do jeito mais porco e sujo

só para ver o resultado rápido ou seja cop e peixe nervoso de toda a sequência a pagar para cada uma das outras letras isso é obviamente péssimo de se fazer

para testar a primeira vez quando você ainda não sabe se vai dar certo tudo bem mas obviamente a gente vai voltar e melhorar isso depois vamos compilar e não só o código assembly ficou longo mas

o binário refletir isso olha como o binário do rex dando ficou gigantesco com mais de 300 bytes só para escrever um mísero hello world escrever código

longo e sujo além de feio e ruim de manter também gera instruções redundantes e aumenta o tamanho do binário agora podemos transferir para rom ligar na porca e como esperávamos

temos um hello world aparecendo se o objetivo for só escrever loword do jeito mais feio do mundo já acabamos mas podemos só acrescentar uma última coisa para melhorar muito esse código vamos

aumentar nosso arsenal de assembly aprendendo o conceito de sub-rotinas que é uma forma primitiva de funções aliás para quem já é programador de já ouviu falar do conceito de

e isso é o jump para o endereço fixo que mostramos com o happy code jmp mas nem assembleia obrigatório usar só jumpers para refatorar esse código vamos criar

uma sub-rotina é chamada lcd instruction que manda os comandos para escrever os dados na tela depois do l de toda aquela sequência que demos cop peixe várias vezes no começo do código a gente coloca

nela já sabemos que jump pula para o endereço fixo o problema é que uma vez que você pula não tem mais como voltar para trás para ter esse recurso podemos

usar o aplicou dj srt jump subiu tiny que pula para uma sub-rotina e grava o endereço atual do contador de programas daí no final da sub-rotina usamos o

comando rts que tipo brittany não java script e vai pegar o último endereço gravado pelo jsr e colocar de volta no contador de programas e com isso cpu

continua na instrução logo depois do jsr essa é a forma mais rudimentar e uma função é de máquina fazemos a mesma coisa criando uma sub-rotina print shar

chamamos o jsr depois download da letra e no final da sub-rotina colocamos rts para voltar para o bike seguinte da instrução de jump depois de compilar

podemos comparar o tamanho dos binários o anterior surge 333 bike agora ficou bem menor em tamanho só que isso não sai de graça a versão anterior era maior mas

é pouca coisa mais rápido porque agora cpu vai executar um monte de jump return já me retorne que não tinha antes cada uma dessas novas instruções usa coque para executar porém é aquele causa que

um ganho de performance não compensa a sujeira do código via de regra você sempre deve preferir código legível do que uma otimização prematura mesmo em

assembly isso faz parte do dia a dia de um programador tem que escolher quando você escreve um pouco mais sujo para ganhar performance e quando o ganho de performance é tão pequeno que não

compensa não existe uma receita é só com experiência você vai saber mas via de regra você só toma essa decisão depois de conseguir testar o código e

mensurar se eu ganho vale a pena ou não nunca acha que só porque um código rodou a primeira vez já tá pronta e nunca mais vai mudar nesse exemplo besta já em

fatoramos o código várias vezes imagina não código grande de verdade gravamos na rom testamos e nada acontece o programa parece que travou porque ela descobrir

vamos ligar o monitor de arduino de novo resetar e colocar em coque manual para irem a linha uma será direto para o suspeito mais óbvio que é o jsr temos o

ld aqui vai configurar a primeira configuração para tela em seguida temos o pico de 20 que é o jsr deveríamos ver

algo como um 20 e depois cinco de80 representando o endereço 805 de que é onde está a sub-rotina mas em vez disso temos essa sequência estranha cinco de

800 e no meio aí de volta ao normal continuando a instrução com 80 restante para formar 805 de e aí ele pula para subir rotina e

podemos ver que ele segue normalmente seguimos mais algumas instruções e chegamos no ap cold 60 que é o rps ou retorne mas para onde ele vai retornar

deveria ser para 800 f que é o próximo endereço depois do último jsr em 800 e podemos ver no monitor que o cp 80 né

alguma coisa em 012 30124 o lance é que jrs erps dependem de algum hardware que responde nesses endereços para gravar o endereço de retorno mas no momento não

temos nenhum hardware que responde quando chama jsr ele tenta gravar nesses endereços mas não tem ninguém esperando isso então o endereço de retorno vai para o limbo quando chega no rps ele

tenta recuperar o endereço e não tem ninguém para responder então acaba tendo algum lixo nos pinos e o cpu assume que é o endereço a rua para lá no caso veio um lixo 8 de

8 de e o cpu vai para lá mas não tem nada e o programa se perde esses endereço 012 30124 são específicos do

processador 6502 segundo a documentação d01100 a 0ff temos o steck uma pilha e temos mais um registrador que ainda não

mencionei chamado sp todos cpu tem uma série de instruções implementadas em hardware como o l a s t a js js r outros instruções como ele dá grava no

registrador chamado a até agora só vemos dois o registrador a e o pc que é o contador de programa e o último registrador novo importante para hoje é esse sp que é o stack pointer que

guardam o endereço do topo de uma pilha o sp que permite a existência do conceito de sub-rotinas e funções steck um pilha é uma estrutura de dados lembra a tal fundação que eu sempre falo que

você estudar a estrutura de dados vai descobrir a pilha e estruturas mais básicas e que você aprende logo no começo dessa matéria todo iniciante tem que saber o que é uma

pilha e quando usar ela em resumo é uma cadeia de elementos onde você vai colocando um elemento de cada vez no topo e toda vez que pedi para devolver o elemento vai removendo do topo essa

pilha é um tipo particular chamada jennifer last in first out ou seja quem entra por último sai primeiro a vantagem de uma estrutura dessas é que basta aguardar o endereço do topo depois que

adiciona um elemento decremento o endereço do topo para puxar da fila devolve o dado no topo e incrementam o endereço no registrador sp quando falamos topo não necessariamente

começamos do zero e vamos subindo um a um o caso do 6502 ele prefere inicial no meio da pilha em 0124 e vai subindo até zero e quando chegar no zero ele

rotaciona para o fim da pilha em 0ff e continua subindo toda vez que você faz um jsr ele vai acumular oi a ilha se você fizer mais que 255 juntos

sem fazer um rethane ele vai estourar o tamanho da pilha e vai começar a sobrar escrever o primeiro endereço gravado é isso que se chama de transbordar da

pilha ou em inglês stackoverflow mesmo com uma pilha pequena dessas é muito difícil fazer 255 dias sem retorno quando isso acontece normalmente é uma

recursão mal feita recursão é uma sub-rotina que da jsr para o começo dela mesma é muito fácil o iniciante errar com recursão outra coisa interessante de

saber é que registradores são literalmente com variáveis globais e você já trabalhou com seus javscript já deve ter ouvido falar de couro tenebroso uma variável global pode ser antes de

fazer o jsr no nosso código setamos o registrador a com o valor usando a n d a mas quando pulamos para nós subir rotina dentro dela modificamos esse registrador

a se depois que retornássemos o programa e se encontrar o mesmo valor original em ar teríamos problemas como no nosso caso depois que retornamos não faz diferença

porque vamos escrever a próxima letra em cima do ar mesmo então tudo bem mas se quiséssemos evitar algum efeito colateral no código maior poderíamos primeiro empurrar o valor de ar para o

steck também usando a instrução de puxe a que é ph e eu antes de retornar com rts podemos puxar o valor de do topo do

stec usando tu à opeia por garantir então devemos usar isso no começo e fim de toda a sub-rotina né há mais ou menos porque esse raro é antigo só tem 255

slots na pilha lembro se você souber que não vai estourar pode fazer isso como eu falei tudo uma questão de trem do office eu quiser garantir os demais os recursos podem acabar cedo demais também e acabar

gerando um blog tipo stack overflow sem querer só por comodidade podemos mudar o registrador sp de 0124 para começar em 01 o que é o fim da pilha em vez de ser do

meio para isso podemos procurar uma instrução como um loada mas não tenho load para registrador sp da pilha e sim transfer que é pxs que transfere o valor

do registrador s paulo sp e aqui aprendemos que existe um outro registrador chamado x além do ar tudo isso entendido precisamos de algum lugar

que tem espaço para gravar 255 elementos de uma pilha e responde aos endereços de 01 00 a 01 ff nosso chip de trava só tem duas portas então não serve chegou a

hora de adicionarmos um chip de memória ram o bem escolher um chip de ram que é muito parecido com a pinagem do eprom e da trava que já estamos usando então

vamos pular configuração do hardware que a mesma coisa assim como no caso do rum e do lcd precisamos definir os endereços que a hum vai responder sabemos que o

steck precisa pelo menos o endereço 0100 até 01 ff mas vamos uma o é um quarto dos endereços do topo que

vai dizer 1000 até 3fff que é bem longe dos endereços 6000 que o lcd usa e nos endereços 8000 para frente que a rom usa

isso é suficiente para 16 kg bytes de ram por acaso esse chip moderno tem mais espaço que isso então vamos desperdiçar um pouco nesse protótipo para usar tudo daria mais trabalho para criar o

mapeador de endereço mas lembre-se que eu não entendi eu tinha só dois quilos bytes de ram e 2 kilo bytes de memória de vídeo e no próximo episódio vou explicar por que não dá para ter muito

mais que isso mesmo existe um pequeno circuito que precisa ser adaptado e eu vou pular essa explicação mas em resumo a forma de conectar a hanna cpu é ligar

o pino a 14 da cpu com a 14 da hum cruzando com oauth nemo e o a 15 da cpu de novo através de um inversor e um lanche no tpm bow o que precisamos saber

é que isso vai habilitar a hum quando o endereço começar com 0 0 a cobra os endereços que queremos para entender porque a ligação em harvard é dessa maneira veja o vídeo do bem feito

isso agora temos um ligado e configurado respondendo nos endereços que precisamos então teoricamente já temos uma pilha disponível e com isso o programa já

devia funcionar se ligarmos e dermos reset de fato agora o hello world aparece como deveria com o código usando um jsr e tudo resolvido vamos ligar o

arduino para entender como programa tá se comportando fazemos reset e deixamos o coque manual de novo como sempre ignoramos o 7 primeiro coloque de inicialização e pulamos rápido até o

ponto onde o programa faz um um pires jsr que é o opcode de 20 lembrando que configuramos o registrador sp para começar de 01 ff que é o fim do espaço

de endereços da pilha e de fato vamos no monitor que tá escrevendo 80 no final do stec em 01 ff daí o cp

o registrador sp para o próximo endereço c0f e escrever um la801 é o endereço de retorno da sub-rotina agora ele salta

para subir rotina que tá em 80 60 como já fazia antes executa a sequência para escrever a letra no lcd e chega na instrução rts que é ó ficou de 60 a

instrução de retorno vai desempenhar o primeiro baixo do topo da pilha que tá em 01 fdn 11 da incremento o registrador

sp e 80 e isso forma o endereço 801 que é para onde o programa tem que voltar e com isso temos o suficiente de hardware para fazer juntos o que garante que podemos programar praticamente qualquer

coisa só com o que temos aqui os dois registradores de controle de um cpu são contador de programa o pc que tem o endereço da próxima instrução ou byte que ele tem que ler e o apontador de

pilha ou sp que é o endereço do topo da pilha tendo esses dois se você consegue executar uma instrução após a outra e consegue dar juntos para continuar executando de outro endereço e

conseguir retornar para o anterior ou seja você tem o equivalente a um look com uma linguagem de alto nível da existem instruções de brent e com o perry e serve para comparar valores e da

jump dependendo das condições que você configurar e isso é equivalente a um if numa linguagem moderna com essas poucas instruções o que vocês viram já dá para ter um modelo da maioria das

funcionalidades básicas de qualquer linguagem no disfunções e if so brand diz que não cheguei a mostrar mas acho que você já consegue imaginar como seria de qualquer maneira eu queria passar

pelos principais pontos dos vídeos do bem para que vocês pudessem ver como um cpu funciona de verdade e como ele se comunica com outros componentes como

memória ram ou lcd simples como o cpu carrega um programa executa e no fim do dia não importa que linguagem você tá usando ele vai ser convertido em baixo

e funções parecidas com que eu acabei de mostrar vocês viram que só de pular do binário para escrever em assembly já ganhamos algumas conveniências que o assembler vaso e nos dá quanto mais

conveniências uma linguagem adiciona mais abstrações ele faz e mais lento ele tende a ser como eu falei antes existe um trade-off sempre entre um balanço de

ser conveniente em ser rápido entre ser rápido ou seguro e assim por diante em outros vídeos eu vou tentar explicar as diferenças as principais linguagens levando em consideração que vocês

assistiram este vídeo no próximo vídeo eu vou usar o que eu mostrei aqui de uma maneira mais prática eu mostrei a ideia do game dinho no começo desse vídeo mas eu não fiz nada com ele hoje é o que eu

vou começar mostrando na parte dois a parte 2 vai ser bem menos tedioso que essa partiu isso eu garanto porque agora podemos usar tudo que eu mostrei aqui na prática em programas de verdade muitos

programa dois associam linguagem de máquina com algo difícil inatingível que é para eles mas não é verdade linguagem de máquina e o hard trance são

razoavelmente simples peças de lego tudo funciona em cima das mesmas peças e você vai ser um programador melhor se pelo menos tiver uma imagem mental de como

seu código interage com esses componentes uma coisa parece difícil só porque você nunca viu é que nem o truque de mágica mas depois que ele te revela o truque as coisas ficam muito mais claras

e você não entendeu o vídeo todo não se preocupe eu literalmente resumiu equivalente a uma 5 horas de aula do canal do bem e ter aqui então eu vou deixar os links para o canal dele nas

descrições abaixo se quiserem adicionar mais essa conversa não deixa de mandar os comentários se curtir um vídeo mandem o joinha assinem o canal e clique no sininho para não perder o próximo

episódio como sempre compartilhem o vídeo para ajudar o canal a gente se vê na próxima até mais