Registrador LFSR
Informe uma fileira inicial de bits, as posições de toma e um número de passos, e receba a sequência de um LFSR de Fibonacci: a semente 1000 com tomas 4 e 1 por 8 passos emite 00011110 e termina em 1101. Útil para exercícios de CRC. Grátis no seu navegador.
- Grátis
- Funciona no seu navegador
- Sem cadastro
- Seus dados não saem do seu aparelho
Executar grátis
Exemplo resolvido
- Estado
- 1000
- Toques
- 4, 1
- Comprimento
- 4
- Sequência
- 00011110
- Estado final
- 1101
Um registrador de deslocamento com realimentação linear, ou LFSR, é uma máquina digital compacta que guarda uma fileira de bits e, a cada pulso de clock, aplica XOR a um punhado de posições de toma para calcular um novo bit de entrada enquanto desloca o restante. Projetistas usam registradores LFSR para gerar fluxos de bits pseudoaleatórios, restos de redundância cíclica, sequências de scramble e padrões de autoteste embutido sem armazenar uma tabela de consulta. Esta calculadora aceita o estado inicial do registrador como uma cadeia de zeros e uns, uma lista de posições de toma numeradas a partir de 1 e contadas da esquerda, e o número de passos de clock a executar. Implementa um LFSR de Fibonacci: cada passo emite o bit mais à direita, desloca o registrador uma casa para a direita e insere à esquerda o XOR dos bits tomados.
O que é um LFSR de Fibonacci e como cada clock produz um bit
Um registrador de deslocamento com realimentação linear é uma máquina de estados finitos cujo próximo bit de entrada é uma função linear do conteúdo atual, tomada sobre o corpo de dois elementos GF(2). Em hardware essa função linear é simplesmente XOR. As posições são numeradas de 1 à esquerda da cadeia de estado até n à direita.
A cada clock o motor lê os bits nessas tomas, combina-os com XOR para obter um único bit de realimentação, emite o bit mais à direita como a próxima amostra de saída, desloca cada bit uma casa para a direita e escreve o bit de realimentação na célula esquerda que ficou vaga.
Repetir esse passo produz uma sequência de bits determinística cujo período é no máximo 2^n menos um: o estado de zeros é um ponto fixo, e qualquer outro estado de um polinômio de período máximo (primitivo) percorre os 2^n menos um vetores não nulos restantes antes de se repetir. Polinômios clássicos de sala de aula como x^4 mais x mais um, que corresponde às tomas 4 e 1 em um registrador de quatro bits, atingem esse período máximo quando partem de uma semente não nula.
LFSRs de Galois aplicam XOR em várias células ao deslocar e produzem um fluxo aparentado, porém não idêntico, para o mesmo polinômio; esta calculadora não emula a fiação de Galois.
Casos de uso
Exercícios de sala com LFSR e CRC
Avance um registrador de Fibonacci a partir de uma semente e de uma lista de tomas e compare a sequência de bits emitida e o estado final com o dever resolvido à mão ou com o polinômio do livro.
Prefixos PRBS e de autoteste embutido
Gere um prefixo conhecido de um fluxo LFSR de período máximo para conferir se um FPGA, um ASIC ou um scramble de software coincidem com as tomas especificadas após o reset.
Oráculos para bancadas de teste HDL
Alimente testes unitários com um despejo de bits determinístico para que um modelo LFSR em Verilog ou VHDL não adote em silêncio o sentido de deslocamento oposto nem tomas numeradas a partir de 0.
Perguntas frequentes
Como este registrador de deslocamento com realimentação linear avança a cada passo?
Implementa um LFSR de Fibonacci. O XOR dos bits nas posições de toma numeradas a partir de 1 é a realimentação. O bit mais à direita é emitido, o registrador desloca uma casa para a direita e o bit de realimentação é escrito na célula mais à esquerda.
Como as posições de toma são numeradas?
O polinômio x^4+x+1 em quatro bits corresponde às tomas 4 e 1.
O que uma semente de zeros produz?
Todos os bits de saída permanecem 0 e o registrador fica em zeros, porque XOR de zeros é zero. Esse ponto fixo é comportamento real de um LFSR, não um erro. Use uma semente não nula para um fluxo não trivial.
O que acontece se uma toma passar do tamanho do registrador?
A execução é recusada com uma mensagem, sem dar a volta na posição. Cada toma precisa ficar entre 1 e a quantidade de bits da semente, contando a partir da esquerda.
Qual é a sequência mais longa que um LFSR pode gerar?
No máximo 2 elevado a n menos 1 bits antes de repetir, sendo n o tamanho do registrador. Tomas de período máximo, como 4 e 1 num registrador de quatro bits, chegam a esse limite a partir de qualquer semente que não seja só zeros.
Ferramentas relacionadas
Para desenvolvedores — acesso via API
Tudo nesta página está disponível via API. Esta seção é para equipes que querem integrar a ferramenta aos próprios sistemas; quem não precisa disso pode simplesmente usar a ferramenta acima.
Endpoint
Autenticação por token Bearer. Um único POST coloca a tarefa na fila; o resultado chega por webhook ou link assinado.
Chame do seu código
curl -X POST https://api.kit.forhosting.com/math/linear-feedback-shift-register \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"state":"1000","taps":[4,1],"steps":8}'const res = await fetch("https://api.kit.forhosting.com/math/linear-feedback-shift-register", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"state": "1000",
"taps": [
4,
1
],
"steps": 8
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/math/linear-feedback-shift-register",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"state": "1000",
"taps": [
4,
1
],
"steps": 8
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/linear-feedback-shift-register", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"state":"1000","taps":[4,1],"steps":8}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"state":"1000","taps":[4,1],"steps":8}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/linear-feedback-shift-register", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Exemplo de requisição
{
"state": "1000",
"taps": [
4,
1
],
"steps": 8
}Exemplo de resposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "math.linear_feedback_shift_register",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}A API é assíncrona: cada chamada devolve um task_id na hora. Se preferir polling, consulte o status a até 1 requisição por segundo.
Preço
Preço publicado, sem tokens nem créditos escondidos. Tarefa que falha não é cobrada.
Limites
max_length | 64 |
max_steps | 4096 |
Erros
| HTTP | Código | O que significa |
|---|---|---|
401 | unauthorized | Token ausente ou inválido. Confira o header Authorization. |
402 | insufficient_balance | Saldo insuficiente para esta tarefa. Faça uma recarga e tente de novo. |
404 | unknown_type | Esse tipo de tarefa não existe. Confira o campo type no catálogo. |
429 | rate_limited | Muitas requisições em pouco tempo. Espere um instante e tente de novo. |
Notas técnicas
Se alguma toma ficar além do comprimento do registrador, a tarefa falha com invalid_input em vez de inventar um wrap-around.
O que é um LFSR de Fibonacci e como cada clock produz um bit
A forma de Fibonacci, que este endpoint implementa, mantém uma fileira de n bits e uma lista de posições de toma.
Contrato de entrada, numeração das tomas, formato da resposta e erros
Envie por POST um corpo JSON com três campos obrigatórios. state é o registrador inicial como cadeia de caracteres 0 e 1; o caractere mais à esquerda é a posição 1 e o comprimento da cadeia é a largura do registrador, de um a sessenta e quatro bits. Espaços em branco dentro de state são ignorados, então um nibble espaçado como 1 0 0 0 é aceito. taps é um array não vazio de posições inteiras numeradas a partir de 1 cujos bits são combinados com XOR para formar a realimentação de Fibonacci; cada toma deve ficar entre 1 e o comprimento do registrador, inclusive. steps é o número de clocks a executar, um inteiro de 1 a 4096; cada clock emite um bit de saída. São aceitos os alias seed ou register para state, tap_positions para taps, e n ou count para steps. Campos ausentes, não-bits em state, não inteiros, listas de tomas vazias e valores fora dos limites publicados falham com invalid_input nomeando o campo e não são cobrados. Em caso de sucesso o corpo ecoa length, a cadeia canônica state, taps e steps; devolve bits como um array de inteiros 0 e 1 na ordem do clock; devolve sequence como esses mesmos bits concatenados para copiar e colar; e devolve final_state, o conteúdo do registrador após o último deslocamento, para que quem chama possa retomar a máquina. Exemplo: state 1000, taps 4 e 1, steps 8 produz bits 0,0,0,1,1,1,1,0, sequence 00011110 e final_state 1101.
Onde uma API de sequência de bits LFSR vale a pena
Cursos de projeto digital e laboratórios de HDL pedem que os estudantes avancem à mão um LFSR de Fibonacci por alguns passos e confrontem um polinômio de folha de dados com um despejo de bits; um oráculo determinístico que usa a mesma numeração da esquerda para a direita e a mesma convenção de deslocamento à direita elimina discussões sobre qual extremidade é o bit zero. A validação que falha não consome saldo. Tarefas de comunicações e de codificação usam LFSRs curtos como motor linear por trás de checagens de resto CRC, códigos de Gold e scramble aditivo; gerar aqui o fluxo de referência permite que um corretor compare a implementação do estudante com um contrato JSON estável em vez de uma captura de tela. Geradores de autoteste embutido e de PRBS em silício e em tecidos FPGA são LFSRs na essência: scripts de verificação podem chamar este endpoint para produzir um prefixo conhecido de uma sequência de período máximo e depois conferir se o dispositivo sob teste emite o mesmo prefixo após o reset. Como a implementação é parse puro de tier A, cada chamada bem-sucedida custa o preço-base publicado de US$ 0,002 sem tokens de modelo e sem rede de saída.
Perguntas técnicas
O que acontece se uma toma exceder o comprimento do registrador?
A tarefa falha com invalid_input. Uma toma maior que n descreveria um polinômio diferente; o handler recusa o wrap-around para que o contrato continue honesto.
Quanto custa a calculadora de registrador de deslocamento com realimentação linear?
A ferramenta do navegador é gratuita. As requisições à API usam saldo pré-pago de KIT a US$ 0,002 por chamada bem-sucedida; entrada inválida não é cobrada.