# Máquinas de estados e controladores Projetar Moore e Mealy, codificar estados, minimizar e coordenar circuitos. Página: https://resumos.rgo.pt/cadeiras/fsc/maquinas-estados/ Uma máquina de estados finita, FSM, guarda apenas a parte do passado necessária para decidir o comportamento seguinte. Para reconhecer se um número binário é múltiplo de 3, não precisamos de guardar todos os bits recebidos: chega guardar o resto da divisão por 3, porque o próximo resto depende só do resto atual e do bit que chega. ## Moore e Mealy Numa Moore, a saída depende só do estado atual. Numa Mealy, pode depender também das entradas atuais. O próximo estado depende sempre do estado e das entradas. Num diagrama Moore, escreve a saída dentro do estado e a condição na seta. Num Mealy, escreve condição/saída na seta. Uma saída Mealy pode mudar entre flancos se a entrada mudar; não a trates como um valor sempre registado. ## Resto de uma sequência binária Se o prefixo lido vale $v$ e chega um bit $b$, o novo valor é $2v+b$. Para o resto $r$ módulo 3, com $$ r^+=(2r+b)\bmod3. $$ Usamos estados R0, R1, R2 e saída $z=1$ em R0. O reset põe a máquina em R0. Aqui o prefixo vazio é interpretado como zero; se a especificação exigir pelo menos um bit, é preciso guardar também essa informação. | Estado | $b=0$ | $b=1$ | $z$ | | --- | --- | --- | --- | | R0 | R0 | R1 | 1 | | R1 | R2 | R0 | 0 | | R2 | R1 | R2 | 0 | Diagrama da Moore ![Moore de divisibilidade por três: R0 tem saída 1; R1 e R2 têm saída 0. Cada seta segue o novo resto de 2r+b.](https://resumos.rgo.pt/cadeiras/fsc/maquinas-estados/figura-1.svg) Ao ler `110`, passamos R0 → R1 → R0 → R0, e o número é 6, múltiplo de 3. Ao ler `101`, passamos R0 → R1 → R2 → R2: 5 deixa resto 2; a saída observada depois de cada flanco corresponde ao prefixo já recebido. ### Laboratório de máquinas No laboratório, cada passo corresponde a um flanco com o bit indicado. A saída de R0 antes de receber bits aparece no passo 0. Altera a saída de R0 para 0 e executa a entrada vazia: o erro já é observável antes do primeiro bit. Repõe o exemplo e segue `110`; o percurso R0,R1,R0,R0 deve produzir 1,0,1,1, incluindo a saída inicial. Em **Resolver exercício**, recebe uma máquina com um erro. Corrige-a ou usa **Construir do zero** para criar a tua solução. **Verificar máquina** compara as saídas para todas as entradas: explora os pares de estados alcançáveis com a referência e mostra uma palavra testemunha se encontrar uma diferença. Os exemplos apresentados ajudam a localizar o erro; são a exploração completa dos pares, e não esses exemplos isolados, que decide a equivalência. Esta comparação é entre máquinas do mesmo modelo e alfabeto, não entre Moore e Mealy. O seletor inclui também os exercícios do resto módulo 5 e da deteção Mealy de `11`. Para o resto módulo 5, escolhe essa máquina e usa **Resolver exercício** seguido de **Construir do zero**. O estado após cada prefixo deve representar o seu resto. Com `1010`, que representa 10, visita R1,R2,R0,R0 depois dos flancos; as saídas são 0,0,1,1, além do 1 inicial. A [prática do capítulo](https://resumos.rgo.pt/cadeiras/fsc/maquinas-estados/#exercicios) pede a tabela e a justificação desse significado. ## Síntese com flip-flops D Codifica R0=`00`, R1=`01`, R2=`10`. São necessários dois flip-flops, porque $\lceil\log_2 3\rceil=2$. Escolhe recuperação de `11` para `00`, com saída 0. A tabela anterior, expandida para bits $q_1,q_0,b$ com próximo estado $n_1n_0$, dá o seguinte, onde cada linha com próximo bit 1 gera um termo do produto: | $q_1q_0$ | $b=0\to n_1n_0$ | $b=1\to n_1n_0$ | | --- | --- | --- | | 00 pronto R0 | 00 | 01 | | 01 pronto R1 | 10 | 00 | | 10 pronto R2 | 01 | 10 | | 11 inválido | 00 | 00 | $$ D_1=\overline q_1q_0\overline b+q_1\overline q_0b, $$ $$ D_0=\overline q_1\overline q_0b+q_1\overline q_0\overline b, $$ $$ z=\overline q_1\overline q_0. $$ Cada termo de D vem de uma linha cuja próxima saída do flip-flop é 1. As equações dão `00` para o estado inválido, como escolhido. O circuito tem lógica combinatória para D e dois flip-flops que atualizam juntos. Em one-hot usamos um bit por estado: $h_0,h_1,h_2$ representam R0,R1,R2, com exatamente um bit a 1. A escrita `h0 h1 h2` dá R0=`100`, R1=`010`, R2=`001`. Para obter o próximo bit de cada estado, reúne as setas que chegam a esse estado: $$ normal_0=h_0\overline b+h_1b, $$ $$ normal_1=h_0b+h_2\overline b, $$ $$ normal_2=h_1\overline b+h_2b. $$ Por exemplo, R0 recebe uma seta de R0 com b=0 e outra de R1 com b=1. São os dois produtos de $normal_0$. Cada equação é uma OR de duas AND de duas entradas. Estas equações só garantem a máquina pretendida nos códigos válidos. O código `000` ficaria em `000`, porque todos os produtos valem 0. O reset estabelece `100`; só a partir de um código válido é que as transições seguem a tabela. Se exigirmos recuperação de qualquer código inválido, precisamos também de verificar o invariante: $$ val=h_0\overline h_1\overline h_2+\overline h_0h_1\overline h_2+\overline h_0\overline h_1h_2. $$ Com $inv=\overline{val}$, escolhemos $$ h_0^+=normal_0+inv, $$ $$ h_1^+=normal_1\,val, $$ $$ h_2^+=normal_2\,val. $$ Se val=1, conservamos as transições normais. Se val=0, os próximos bits são `100`, mesmo num código com vários bits a 1. O custo desta recuperação é adicional ao das três equações base; one-hot não elimina estados inválidos. ## Reconhecer padrões e produzir um impulso Para detetar `101` com sobreposição, os estados distinguem os prefixos já reconhecidos: nenhum, `1`, `10` e deteção `101`. Depois de detetar, o último `1` já pode iniciar outra ocorrência, por isso em `10101` há duas deteções; voltar incondicionalmente ao estado inicial perderia a segunda. Uma Moore completa para esse caso tem esta tabela, onde a saída indicada é a do estado atual e só D deteta o padrão: | Estado | Prefixo útil | Saída | Próximo com 0 | Próximo com 1 | | --- | --- | --- | --- | --- | | A | Nenhum | 0 | A | B | | B | `1` | 0 | C | B | | C | `10` | 0 | A | D | | D | Deteção `101`, termina em `1` | 1 | C | B | Partindo de A, `10101` dá B,C,D,C,D. Observamos 0,0,1,0,1 depois dos flancos; em D, um novo 0 já completa o prefixo `10`, por isso a transição vai para C. É esta informação conservada que permite a sobreposição. Para produzir um impulso de um ciclo quando um botão fica 1, usa estados Espera, Impulso e Libertação. Espera entra em Impulso quando x=1; Impulso passa a Libertação se x ainda for 1, ou Espera se já for 0; Libertação conserva enquanto x=1. A saída só é 1 em Impulso. Sem Libertação, uma entrada longa pode provocar vários impulsos. ### Mealy e sobreposição Para detetar `11`, basta recordar se o bit anterior era 1. Usa A para bit anterior 0, incluindo o reset, e B para bit anterior 1; a saída é 1 só quando o estado anterior é B e a entrada atual é 1: | Estado anterior | Entrada 0, destino/saída | Entrada 1, destino/saída | | --- | --- | --- | | A | A/0 | B/0 | | B | A/0 | B/1 | Em B, um novo 1 deteta um par e conserva B. Por isso, `111` produz 0,1,1: o segundo bit completa o primeiro par e o terceiro completa outro par com o segundo. Se a deteção voltasse a A, a segunda ocorrência perder-se-ia. No [laboratório](https://resumos.rgo.pt/cadeiras/fsc/maquinas-estados/#laborat%C3%B3rio-de-m%C3%A1quinas), escolhe **Mealy: detetar 11** e segue `111011`. Antes dos flancos, os estados são A,B,B,B,A,B; as saídas da amostra são 0,1,1,0,0,1. O estado indicado na linha de cada passo é o destino da transição, mas a saída usa o estado anterior e o bit dessa linha. Não uses o novo estado B para atribuir 1 ao primeiro bit: ainda não havia um 1 anterior. Com um flip-flop q que guarda esse bit anterior, as equações são $q^+=b$ e $z=qb$. A entrada b pode mudar z entre flancos. O simulador mostra amostras de entradas estáveis; não modela atrasos, glitches nem metastabilidade. Uma saída registada depois do flanco exigiria um registo de saída e uma especificação temporal própria. ## Controlar uma soma em memória Um controlador pode coordenar um contador de endereços e um acumulador sem executar instruções. Considera uma memória de 64 words com sinal de 32 bits, leitura combinatória e dados que não mudam durante o cálculo. Queremos somar os **módulos** dos 64 valores. Supomos que cada leitura, cálculo do módulo e soma estabilizam antes do flanco seguinte. Usa um contador i de 6 bits para endereçar a memória. Se o bit de sinal do dado for 0, conserva-o; se for 1, calcula o complemento para dois. Interpreta a saída deste bloco como magnitude **sem sinal**: para `0x80000000`, o módulo é $2^{31}$ e continua a ter o padrão `0x80000000`. Não cabe como inteiro positivo com sinal de 32 bits, mas cabe numa magnitude sem sinal de 32 bits. Antes de somar ao acumulador, alarga a magnitude com zeros. O pior caso são 64 valores iguais a $-2^{31}$: $$ S_{max}=64\times2^{31}=2^{37}. $$ Um acumulador sem sinal de 37 bits só chega a $2^{37}-1$. São necessários **38 bits** para garantir o resultado exato. O somador e o registo do acumulador têm essa largura; os endereços continuam a ter 6 bits. Uma Moore com Espera, Soma e Concluído controla o percurso: | Estado | Ação no flanco seguinte | Próximo estado | | --- | --- | --- | | Espera, start=0 | S←0, i←0 | Espera | | Espera, start=1 | S←0, i←0 | Soma | | Soma, i diferente de 63 | S←S+módulo(Mem\[i\]), i←i+1 | Soma | | Soma, i=63 | Acrescenta o último módulo; contador volta a 0 | Concluído | | Concluído | Conserva o resultado | Concluído | `done=1` só em Concluído; o reset coloca o controlador em Espera. Neste contrato, reset prepara uma nova operação. Não o confundas com um controlador que aceite start novamente em Concluído. Os controlos da Moore dependem só do estado: Espera inicializa os registos em cada flanco; Soma habilita a soma e o contador; Concluído conserva. start e a comparação i=63 só decidem o próximo estado. O flanco de arranque inicializa, mas ainda não soma. Os **64 flancos seguintes** somam as posições 0 a 63. No último, soma-se o dado do endereço antigo 63, o contador volta a 0 e entra-se em Concluído; a habilitação da soma desliga-se nesse novo estado. Se o contador voltasse a 0 com a soma ainda habilitada, os mesmos dados seriam somados de novo. Com memória síncrona de latência de um ciclo, este traço deixa de servir: seria preciso lançar o endereço num ciclo e usar o dado no seguinte, com registos e estados adicionais. A largura da memória, a capacidade, a latência de leitura e a largura do resultado são decisões distintas. ## Minimização e comunicação Para minimizar uma Moore, agrupa primeiro estados com a mesma saída. Divide um grupo quando dois dos seus estados, para a mesma entrada, transitam para grupos diferentes. Repete até estabilizar. Só estados que continuam indistinguíveis podem ser fundidos; ter a mesma saída hoje não chega. Exemplo de partição Considera esta Moore, com estado inicial A: | Estado | Saída | Próximo com 0 | Próximo com 1 | | --- | --- | --- | --- | | A | 0 | B | D | | B | 0 | C | D | | C | 0 | C | C | | D | 1 | E | D | | E | 1 | D | E | Começamos com $\{A,B,C\}$ e $\{D,E\}$. A entrada 1 separa C de A,B, pois C permanece no grupo de saída 0 enquanto A,B vão para saída 1. Ficamos com $\{A,B\},\{C\},\{D,E\}$. A entrada 0 separa agora A de B: A vai para o grupo A,B, mas B para C. A partição final é $\{A\},\{B\},\{C\},\{D,E\}$. D e E continuam juntos porque ambas as suas transições ficam no seu próprio grupo. A máquina reduzida tem quatro estados: A, B, C e H, que representa D/E. A vai para B/H, B para C/H, C para C/C e H para H/H, respetivamente com 0/1. Conserva as saídas 0,0,0,1. Não conseguimos fundir A e B, apesar da mesma saída inicial: a sequência 01 termina em saída 1 a partir de A e 0 a partir de B. Duas máquinas podem coordenar-se por handshake de quatro fases, com dados, `valid` e `ack` no tempo, segundo a tabela seguinte: | Passo | Dados | valid | ack | Regra | | --- | --- | --- | --- | --- | | 1 | emissor fixa D | 0 | 0 | D estabiliza antes de valid | | 2 | D estável | 1 | 0 | emissor pede aceitação | | 3 | D estável | 1 | 1 | recetor aceitou D | | 4 | D estável | 0 | 1 | emissor fecha pedido | | 5 | livre | 0 | 0 | recetor fecha confirmação | Neste protocolo conservamos D até ao fim da confirmação. O emissor baixa `valid` depois de ver `ack=1`; o recetor baixa `ack` depois de ver `valid=0`. Só então se prepara a transferência seguinte. Mudar D logo após pôr `valid=1` pode fazer o recetor aceitar outra palavra. A confirmação também permite esperar pelo recetor: um impulso de um ciclo sem confirmação pode ser perdido se ele não o observar. Entre relógios diferentes, entradas podem violar setup/hold e provocar metastabilidade. O modelo de FSM assume entradas amostradas válidas. A implementação exige sincronização apropriada; sincronizar bits independentes não garante uma palavra de dados coerente. ## Exercícios Guardar o que interessa Constrói a tabela de transições Moore que indica se o prefixo binário é divisível por 5. Usa estados R0 a R4, com saída 1 só em R0, e segue a entrada 1010. Constrói também a máquina no [laboratório da lição](https://resumos.rgo.pt/cadeiras/fsc/maquinas-estados/#laborat%C3%B3rio-de-m%C3%A1quinas): escolhe **Moore: resto módulo 5**, **Resolver exercício** e **Construir do zero**. Define as saídas e as dez transições, depois executa `1010`. **Verificar máquina** compara o comportamento para todas as entradas; a autoavaliação abaixo serve para conferir a tabela e a explicação de cada estado. Pista Usa r seguinte=(2r+b) módulo 5. Mais uma pista Cada linha tem duas transições, uma por bit de entrada. Solução Para b=0/b=1: R0→R0/R1; R1→R2/R3; R2→R4/R0; R3→R1/R2; R4→R3/R4. Partindo de R0, 1010 dá R1,R2,R0,R0. O valor 10 é divisível por 5. O prefixo vazio continua interpretado como zero. Confere a tua resposta: * Constrói dez transições pelo resto (2r+b) módulo 5. * Segue 1010 por R1,R2,R0,R0. Erros frequentes Não guardes apenas o último bit nem confundas o resto anterior com o valor completo. [Voltar à explicação](https://resumos.rgo.pt/cadeiras/fsc/maquinas-estados/#resto-de-uma-sequ%C3%AAncia-bin%C3%A1ria) Binário e one-hot Uma Moore tem seis estados. Quantos flip-flops precisa com codificação binária mínima e com one-hot? Como deve ficar o reset one-hot? Pista Conta códigos na opção binária. Mais uma pista No one-hot apenas o flip-flop do estado inicial deve estar a 1. Solução Binária: $\lceil\log_2 6\rceil=3$ flip-flops, com dois códigos não usados cujo comportamento deve ser definido. One-hot: seis flip-flops. No reset, o bit do estado inicial fica 1 e os outros cinco 0. Todos a zero não representa qualquer dos seis estados. Confere a tua resposta: * Binário três FF; one-hot seis. * Reset one-hot ativa só o estado inicial. Erros frequentes One-hot não usa logaritmo do número de estados nem elimina automaticamente estados inválidos. [Voltar à explicação](https://resumos.rgo.pt/cadeiras/fsc/maquinas-estados/#s%C3%ADntese-com-flip-flops-d) Entrada longa, saída curta Partindo de Espera, segue a entrada amostrada 0,1,1,1,0,1 no controlador Espera/Impulso/Libertação. Dá a saída depois de cada flanco. Pista A saída Moore é 1 só no estado Impulso. Solução Os estados depois dos flancos são Espera,Impulso,Libertação,Libertação,Espera,Impulso. As saídas são 0,1,0,0,0,1. A sequência longa de 1 gera um único impulso; o 0 prepara a próxima deteção. Confere a tua resposta: * Saídas 0,1,0,0,0,1. * Libertação impede repetir o impulso durante uma entrada longa. Erros frequentes Não retomes Espera incondicionalmente no fim de Impulso, porque a entrada longa poderia gerar outra deteção. [Voltar à explicação](https://resumos.rgo.pt/cadeiras/fsc/maquinas-estados/#reconhecer-padr%C3%B5es-e-produzir-um-impulso) Uma saída igual não chega Numa Moore, P e Q têm saída 0, R tem saída 1. Com entrada 0, P vai para R e Q para Q. Podem P e Q ser fundidos? Justifica pela minimização. Pista Começa pela partição das saídas. Solução Não. A partição inicial é $\{P,Q\}$ e $\{R\}$. Com entrada 0, P vai para o grupo de saída 1 e Q para o grupo de saída 0. O grupo $\{P,Q\}$ tem de ser dividido. Um observador distingue-os depois desse input, apesar de a saída inicial ser igual. Confere a tua resposta: * P e Q não são equivalentes. * A entrada 0 leva-os a grupos de saídas diferentes. Erros frequentes Comparar apenas a saída atual não prova equivalência de estados, porque dois estados só se fundem se as saídas futuras também coincidirem. [Voltar à explicação](https://resumos.rgo.pt/cadeiras/fsc/maquinas-estados/#minimiza%C3%A7%C3%A3o-e-comunica%C3%A7%C3%A3o) Dados recebidos antes de mudar Num handshake valid/ack de quatro fases, o emissor pode mudar os dados assim que põe valid=1? Dá a sequência correta. Pista Valid anuncia dados estáveis, por isso o emissor só os pode mudar depois da aceitação. Mais uma pista O recetor confirma a aceitação com ack. Solução O emissor prepara dados e ativa valid. O recetor aceita-os e sobe ack; o emissor observa ack=1 e baixa valid; o recetor observa valid=0 e baixa ack. Neste protocolo, os dados ficam estáveis durante toda a confirmação, até ack voltar a 0. Só então pode prepará-los para a transferência seguinte. Mudar antes de ack pode fazer o recetor aceitar outra palavra. Um impulso curto sem confirmação pode perder-se. Confere a tua resposta: * Sequência valid1, ack1, valid0, ack0. * Mantém os dados até ack voltar a 0, conforme o protocolo da lição. Erros frequentes Não assumas que os dois circuitos observam valid no mesmo instante. [Voltar à explicação](https://resumos.rgo.pt/cadeiras/fsc/maquinas-estados/#minimiza%C3%A7%C3%A3o-e-comunica%C3%A7%C3%A3o) Saída na transição Projeta uma Mealy que, na amostra antes de cada flanco, produz z=1 quando a entrada atual completa dois bits 1 consecutivos, permitindo sobreposição. Usa um estado q que guarda o bit anterior, reset q=0, e define q seguinte e z. Segue 1,1,1,0,1,1. A saída deve ser observada com a entrada estável antes do flanco. No [laboratório](https://resumos.rgo.pt/cadeiras/fsc/maquinas-estados/#laborat%C3%B3rio-de-m%C3%A1quinas), escolhe **Mealy: detetar 11** e constrói a tua resposta através de **Resolver exercício** e **Construir do zero**. A e B podem representar q=0 e q=1, mas os nomes não influenciam a correção. Verifica a máquina e compara a saída de `111011` com a sequência calculada à mão. A verificação automática compara saídas; a autoavaliação abaixo inclui também as equações e a interpretação temporal. Pista Só precisas de recordar se o bit anterior era 1. Mais uma pista A saída usa q antigo e a entrada b atual. Solução Escolhe $q^+=b$ e $z=qb$. Antes dos seis flancos, q é 0,1,1,1,0,1, pelo que z é 0,1,1,0,0,1. Em `111`, o segundo e o terceiro 1 completam pares diferentes. Como é Mealy, z também depende de b entre flancos. Se precisarmos de uma saída registada depois do flanco, a especificação e o circuito têm de o dizer. Confere a tua resposta: * q seguinte=b e z=q AND b. * Saídas antes dos flancos 0,1,1,0,0,1; permite sobreposição. Erros frequentes Não uses o q recém-atualizado para a saída pedida antes do flanco. Isso marcaria também o primeiro 1, que ainda não completa um par. [Voltar à explicação](https://resumos.rgo.pt/cadeiras/fsc/maquinas-estados/#moore-e-mealy) One-hot do resto módulo 3 Uma Moore lê bits b do mais significativo para o menos significativo e guarda o resto $r^+=(2r+b)\bmod3$. Usa a codificação one-hot `h0 h1 h2`: R0=`100`, R1=`010`, R2=`001`, com saída z=h0 nos estados válidos. Escreve as três equações de próximo estado para esses códigos. Modifica-as para que qualquer código inválido, incluindo `000` e `110`, recupere para R0 no flanco seguinte. Define também z nos códigos inválidos. Pista Aplica r+=(2r+b) mod 3 a cada origem one-hot. Mais uma pista h0+=h0¬b+h1b; h1+=h0b+h2¬b; h2+=h1¬b+h2b sob exatamente-um-a-1; 000 regressa a 100 com o termo de recuperação. Solução As transições normais dão $n_0=h_0\overline b+h_1b$, $n_1=h_0b+h_2\overline b$ e $n_2=h_1\overline b+h_2b$. Cada termo corresponde a uma seta que entra no estado respetivo. Define $v=h_0\overline h_1\overline h_2+\overline h_0h_1\overline h_2+\overline h_0\overline h_1h_2$, que só vale 1 nos três códigos válidos. Usa $h_0^+=n_0+\overline v$, $h_1^+=n_1v$ e $h_2^+=n_2v$. Se v=0, o próximo código é `100`, tanto para `000` como para `110`, independentemente de b. Para manter z=0 até à recuperação, usa $z=h_0v$. O reset também estabelece `100`; não substitui a lógica de recuperação se esta for exigida durante a execução. Confere a tua resposta: * Derivaste as três equações das transições * Garantiste recuperação para 100 de todos os códigos inválidos * Definiste z=0 nos códigos inválidos Erros frequentes Pôr tudo a 0 não é R0 válido. [Voltar à explicação](https://resumos.rgo.pt/cadeiras/fsc/maquinas-estados/#s%C3%ADntese-com-flip-flops-d) O último endereço e o maior módulo Uma memória de leitura combinatória contém 64 words de 32 bits em complemento para dois. Os dados não mudam durante a operação e todos os caminhos estabilizam antes do flanco seguinte. Projeta um datapath com um único somador e um controlador Moore para somar os módulos de todos os valores, sem overflow. Indica as larguras do endereço, do bloco de módulo e do acumulador, incluindo o pior caso. Define o flanco de arranque, a atualização no último endereço e quando done fica ativo. Reset prepara outra operação; start não inicia nova operação no estado Concluído. O que teria de mudar se a memória só entregasse o dado um ciclo depois de receber o endereço? Pista O menor negativo de 32 bits não tem simétrico positivo na mesma representação. Separa a magnitude sem sinal da interpretação C2. Solução O contador tem 6 bits. O bloco de módulo conserva o dado positivo ou calcula o complemento para dois se for negativo, produzindo uma magnitude sem sinal de 32 bits. O módulo de $-2^{31}$ é $2^{31}$, código `0x80000000`, que é válido nessa interpretação. Alarga a magnitude com zeros para a entrada do somador. O máximo da soma é $64\times2^{31}=2^{37}$. Precisas de 38 bits **sem sinal**, porque o máximo de 37 bits é $2^{37}-1$. O somador e o acumulador têm 38 bits; um resultado com sinal exigiria mais um bit. Em Espera, os controlos inicializam S=0 e i=0 em cada flanco; start=1 decide a passagem para Soma. Cada flanco em Soma captura S mais o módulo do dado no endereço antigo e incrementa i. Se o i antigo for 63, acrescenta essa última word, o contador volta a 0 e a máquina entra em Concluído. São 64 flancos de soma depois do arranque. done é 1 só em Concluído e o acumulador fica desabilitado nesse estado. Reset volta a Espera. Com memória síncrona de latência de um ciclo, não podes consumir no mesmo ciclo o dado do endereço acabado de lançar. Acrescenta uma fase de pedido e outra de consumo, ou registos que conservem o endereço e a validade do dado. O novo traço tem de respeitar essa latência; não se mantém automaticamente o custo de 64 ciclos. Confere a tua resposta: * Dimensionei contador de 6 bits e acumulador unsigned de 38 bits. * Tratei o módulo de −2^31 como magnitude unsigned e alarguei com zeros. * Somei 64 posições depois do flanco de inicialização e parei depois da posição 63. Erros frequentes O estado seguinte é decidido pelo i antigo. Se esperares por mais um flanco para sair quando i já for 0, voltas a somar a primeira posição. Testar i=63 não deve impedir a soma da própria posição 63. [Voltar à explicação](https://resumos.rgo.pt/cadeiras/fsc/maquinas-estados/#controlar-uma-soma-em-mem%C3%B3ria)