<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>microcontrolador C tutorial - MCU &amp; FPGA</title>
	<atom:link href="https://mcu.tec.br/tags/microcontrolador-c-tutorial/feed/" rel="self" type="application/rss+xml" />
	<link>https://mcu.tec.br</link>
	<description>Microcontroladores &#38; FPGA</description>
	<lastBuildDate>Fri, 04 Apr 2025 15:54:55 +0000</lastBuildDate>
	<language>pt-BR</language>
	<sy:updatePeriod>
	hourly	</sy:updatePeriod>
	<sy:updateFrequency>
	1	</sy:updateFrequency>
	<generator>https://wordpress.org/?v=7.1.3</generator>

<image>
	<url>https://mcu.tec.br/wp-content/uploads/2025/02/Robo-para-o-site-MCU.tec_.br-512x512-1-150x150.png</url>
	<title>microcontrolador C tutorial - MCU &amp; FPGA</title>
	<link>https://mcu.tec.br</link>
	<width>32</width>
	<height>32</height>
</image> 
	<item>
		<title>Como Calcular CRC e Checksum em C para Comunicação entre Microcontroladores</title>
		<link>https://mcu.tec.br/algoritimos/como-calcular-crc-e-checksum-em-c-para-comunicacao-entre-microcontroladores/?utm_source=rss&#038;utm_medium=rss&#038;utm_campaign=como-calcular-crc-e-checksum-em-c-para-comunicacao-entre-microcontroladores</link>
		
		<dc:creator><![CDATA[Carlos Delfino]]></dc:creator>
		<pubDate>Fri, 04 Apr 2025 15:54:35 +0000</pubDate>
				<category><![CDATA[Algoritimos]]></category>
		<category><![CDATA[algoritmo de checksum]]></category>
		<category><![CDATA[cálculo de CRC]]></category>
		<category><![CDATA[Checksum em C]]></category>
		<category><![CDATA[comunicação entre microcontroladores]]></category>
		<category><![CDATA[CRC]]></category>
		<category><![CDATA[CRC em C]]></category>
		<category><![CDATA[CRC-16]]></category>
		<category><![CDATA[CRC-32]]></category>
		<category><![CDATA[Cyclic Redundancy Check]]></category>
		<category><![CDATA[microcontrolador C tutorial]]></category>
		<category><![CDATA[otimização CRC]]></category>
		<category><![CDATA[protocolo UART com CRC]]></category>
		<category><![CDATA[sistemas embarcados]]></category>
		<category><![CDATA[transmissão de dados STM32]]></category>
		<category><![CDATA[verificação de integridade]]></category>
		<guid isPermaLink="false">https://mcu.tec.br/?p=308</guid>

					<description><![CDATA[<p>Aprenda a calcular Checksum e CRC (Cyclic Redundancy Check) em linguagem C com exemplos práticos e fórmulas. Ideal para verificação de integridade em sistemas embarcados e comunicação entre microcontroladores.</p>
<p>The post <a href="https://mcu.tec.br/algoritimos/como-calcular-crc-e-checksum-em-c-para-comunicacao-entre-microcontroladores/">Como Calcular CRC e Checksum em C para Comunicação entre Microcontroladores</a> first appeared on <a href="https://mcu.tec.br">MCU & FPGA</a>.</p>]]></description>
										<content:encoded><![CDATA[<p class="wp-block-paragraph">A confiabilidade na troca de dados é um dos pilares mais críticos em sistemas embarcados, especialmente em ambientes industriais, automotivos e médicos, onde microcontroladores operam sob rigorosas exigências de precisão. Dados transmitidos entre dois dispositivos podem ser corrompidos por diversas razões: interferência eletromagnética, falhas de temporização, perda de sincronismo ou problemas no barramento físico. Quando isso acontece, mecanismos de verificação de integridade são essenciais para garantir que o receptor consiga validar (ou rejeitar) os dados recebidos de maneira eficiente.</p>



<p class="wp-block-paragraph">Entre os métodos mais amplamente utilizados para detecção de erros estão os algoritmos de <strong>checksum</strong> e <strong>CRC (Cyclic Redundancy Check)</strong>. Ambos introduzem <strong>redundância controlada</strong> no fluxo de dados: ao invés de transmitir apenas as informações úteis, adiciona-se um ou mais bytes extras que permitem ao receptor verificar se os dados foram alterados durante a transmissão. A diferença entre eles está na <strong>força estatística com que detectam erros</strong>, na <strong>complexidade computacional</strong> envolvida e no tipo de erro que são capazes de identificar.</p>



<p class="wp-block-paragraph">O <strong>checksum</strong> é um método simples e rápido baseado geralmente em uma soma dos bytes de dados, podendo incluir operações como complemento ou truncamento. Ele é fácil de implementar mesmo em microcontroladores modestos (8 ou 16 bits), porém pode ser enganado por certas combinações de erros, como reordenação de bytes ou alterações múltiplas compensadas.</p>



<p class="wp-block-paragraph">Já o <strong>CRC</strong> é um método mais robusto, baseado em divisão polinomial sobre campos de Galois (GF(2)). Ele é amplamente utilizado em protocolos de comunicação como USB, Ethernet, Modbus e CAN. O CRC possui alta capacidade de detectar erros aleatórios, rajadas de bits corrompidos e alterações múltiplas. A contrapartida está na sua maior complexidade matemática e computacional — fator que será analisado ao longo deste tutorial com foco em microcontroladores.</p>



<p class="wp-block-paragraph">Este artigo prático se propõe a explicar, em detalhes, como calcular <strong>checksums e CRCs em linguagem C</strong>, com exemplos reais aplicáveis a <strong>transferência de dados entre microcontroladores</strong>, como STM32, AVR ou ESP32. Serão apresentadas <strong>fórmulas matemáticas</strong>, implementações passo a passo, estratégias de otimização para arquiteturas embarcadas e técnicas de diagnóstico com osciloscópio e analisador lógico.</p>



<p class="wp-block-paragraph">Ao final, você terá um conjunto completo de ferramentas para incluir verificações de integridade robustas nos seus projetos embarcados, entendendo não apenas o <strong>&#8220;como&#8221;</strong>, mas também o <strong>&#8220;porquê&#8221;</strong> por trás de cada algoritmo.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h2 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4d8.png" alt="📘" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Capítulo 2 – Conceitos Fundamentais</h2>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Bits, Bytes e Endianess</h3>



<p class="wp-block-paragraph">Antes de implementar qualquer mecanismo de verificação de integridade, é fundamental compreender a granularidade com que os dados são manipulados. Em microcontroladores, os dados geralmente são tratados em unidades de <strong>8 bits (1 byte)</strong>, mas isso pode se estender para palavras de 16, 32 ou até 64 bits, dependendo da arquitetura.</p>



<p class="wp-block-paragraph">Outro conceito crucial é o <strong>endianess</strong>, ou ordem dos bytes. Microcontroladores <strong>little-endian</strong> (como os da linha ARM Cortex-M) armazenam o byte menos significativo primeiro, enquanto <strong>big-endian</strong> (como muitos DSPs e alguns processadores de rede) fazem o oposto. Essa diferença afeta diretamente o cálculo de checksums e CRCs, principalmente se os dados são interpretados como inteiros multibyte.</p>



<div class="wp-block-kevinbatdorf-code-block-pro" data-code-block-pro-font-family="Code-Pro-JetBrains-Mono" style="font-size:.875rem;font-family:Code-Pro-JetBrains-Mono,ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,monospace;line-height:1.25rem;--cbp-tab-width:2;tab-size:var(--cbp-tab-width, 2)"><span style="display:block;padding:16px 0 0 16px;margin-bottom:-1px;width:100%;text-align:left;background-color:#2e3440ff"><svg xmlns="http://www.w3.org/2000/svg" width="54" height="14" viewBox="0 0 54 14"><g fill="none" fill-rule="evenodd" transform="translate(1 1)"><circle cx="6" cy="6" r="6" fill="#FF5F56" stroke="#E0443E" stroke-width=".5"></circle><circle cx="26" cy="6" r="6" fill="#FFBD2E" stroke="#DEA123" stroke-width=".5"></circle><circle cx="46" cy="6" r="6" fill="#27C93F" stroke="#1AAB29" stroke-width=".5"></circle></g></svg></span><span role="button" tabindex="0" data-code="// Exemplo de problema com endianess
uint16_t valor = 0x1234;
uint8_t *ptr = (uint8_t *)&valor;
// Em little-endian:
// ptr[0] == 0x34, ptr[1] == 0x12
" style="color:#d8dee9ff;display:none" aria-label="Copy" class="code-block-pro-copy-button"><svg xmlns="http://www.w3.org/2000/svg" style="width:24px;height:24px" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2"><path class="with-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2m-6 9l2 2 4-4"></path><path class="without-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2"></path></svg></span><pre class="shiki nord" style="background-color: #2e3440ff" tabindex="0"><code><span class="line"><span style="color: #88C0D0">//</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">Exemplo</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">de</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">problema</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">com</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">endianess</span></span>
<span class="line"><span style="color: #88C0D0">uint16_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">valor</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0x1234</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #88C0D0">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #81A1C1">*</span><span style="color: #A3BE8C">ptr</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> (uint8_t </span><span style="color: #81A1C1">*</span><span style="color: #D8DEE9FF">)</span><span style="color: #ECEFF4">&amp;</span><span style="color: #88C0D0">valor</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #88C0D0">//</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">Em</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">little-endian:</span></span>
<span class="line"><span style="color: #88C0D0">//</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">ptr[</span><span style="color: #B48EAD">0</span><span style="color: #A3BE8C">]</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">==</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0x34</span><span style="color: #A3BE8C">,</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">ptr[</span><span style="color: #B48EAD">1</span><span style="color: #A3BE8C">]</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">==</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0x12</span></span>
<span class="line"></span></code></pre></div>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Redundância e Integridade</h3>



<p class="wp-block-paragraph">Verificação de integridade depende da introdução de <strong>redundância</strong> no fluxo de dados — ou seja, informações adicionais que não fazem parte do conteúdo útil, mas que ajudam a identificar alterações indesejadas.</p>



<p class="wp-block-paragraph">Isso não é diferente de um CPF ou número de cartão de crédito: os últimos dígitos são calculados a partir dos anteriores, permitindo detectar erros simples de digitação. Em sistemas embarcados, fazemos o mesmo com bytes transmitidos por uma UART, por exemplo.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Tipos de Códigos de Verificação</h3>



<p class="wp-block-paragraph">Os principais mecanismos de verificação utilizados em sistemas embarcados são:</p>



<ol class="wp-block-list">
<li><strong>Paridade</strong>: um único bit adicional que indica se a quantidade de bits &#8216;1&#8217; é par ou ímpar. Detecta <strong>um único bit errado</strong>, mas nada mais. É insuficiente para a maioria das aplicações modernas.</li>



<li><strong>Checksum</strong>: soma simples dos bytes transmitidos, geralmente usando complemento de 8 ou 16 bits. Detecta erros aleatórios simples, mas não é confiável contra certos padrões de erro.</li>



<li><strong>CRC (Cyclic Redundancy Check)</strong>: usa uma divisão polinomial binária para gerar uma assinatura de N bits (CRC-8, CRC-16, CRC-32 etc.). Detecta rajadas, múltiplos bits errados, trocas de ordem e padrões sofisticados de corrupção.</li>
</ol>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Um Exemplo Ilustrativo</h3>



<p class="wp-block-paragraph">Considere o seguinte pacote de dados com 4 bytes:</p>



<div class="wp-block-kevinbatdorf-code-block-pro" data-code-block-pro-font-family="Code-Pro-JetBrains-Mono" style="font-size:.875rem;font-family:Code-Pro-JetBrains-Mono,ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,monospace;line-height:1.25rem;--cbp-tab-width:2;tab-size:var(--cbp-tab-width, 2)"><span style="display:block;padding:16px 0 0 16px;margin-bottom:-1px;width:100%;text-align:left;background-color:#2e3440ff"><svg xmlns="http://www.w3.org/2000/svg" width="54" height="14" viewBox="0 0 54 14"><g fill="none" fill-rule="evenodd" transform="translate(1 1)"><circle cx="6" cy="6" r="6" fill="#FF5F56" stroke="#E0443E" stroke-width=".5"></circle><circle cx="26" cy="6" r="6" fill="#FFBD2E" stroke="#DEA123" stroke-width=".5"></circle><circle cx="46" cy="6" r="6" fill="#27C93F" stroke="#1AAB29" stroke-width=".5"></circle></g></svg></span><span role="button" tabindex="0" data-code="uint8_t dados[4] = {0x12, 0x34, 0x56, 0x78};
" style="color:#d8dee9ff;display:none" aria-label="Copy" class="code-block-pro-copy-button"><svg xmlns="http://www.w3.org/2000/svg" style="width:24px;height:24px" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2"><path class="with-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2m-6 9l2 2 4-4"></path><path class="without-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2"></path></svg></span><pre class="shiki nord" style="background-color: #2e3440ff" tabindex="0"><code><span class="line"><span style="color: #88C0D0">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">dados[</span><span style="color: #B48EAD">4</span><span style="color: #A3BE8C">]</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">{</span><span style="color: #B48EAD">0x12</span><span style="color: #A3BE8C">,</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0x34</span><span style="color: #A3BE8C">,</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0x56</span><span style="color: #A3BE8C">,</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0x78</span><span style="color: #A3BE8C">}</span><span style="color: #81A1C1">;</span></span>
<span class="line"></span></code></pre></div>



<p class="wp-block-paragraph">Se usarmos <strong>checksum</strong> de 8 bits com soma simples, teremos: </p>



<p class="wp-block-paragraph">\[\text{checksum} = (0x12 + 0x34 + 0x56 + 0x78) \mod 256 = 0x12 + 0x34 + 0x56 + 0x78 = 0x01E4 \Rightarrow 0xE4\]



<p class="wp-block-paragraph">Se <strong>qualquer byte for alterado</strong>, a soma mudará e o receptor poderá detectar o erro — <strong>mas se dois bytes forem trocados</strong>, o resultado pode ser o mesmo. Aqui o CRC se mostra superior, pois leva em conta a <strong>posição dos bits e seu valor combinado no tempo</strong>.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h2 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4d8.png" alt="📘" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Capítulo 3 – Cálculo de Checksum Simples</h2>



<p class="wp-block-paragraph">O <strong>checksum</strong> é uma técnica simples, mas eficaz, usada para detectar alterações acidentais em blocos de dados. Em sua forma mais básica, ele consiste na <strong>soma dos valores dos bytes</strong>, truncada ou ajustada para caber em um determinado número de bits (geralmente 8 ou 16). É um método eficiente para microcontroladores com recursos limitados e baixo volume de dados.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Fórmulas Comuns</h3>



<p class="wp-block-paragraph">As variantes mais utilizadas de checksum são:</p>



<ol class="wp-block-list">
<li><strong>Checksum de 8 bits com soma simples</strong>:</li>
</ol>



<p class="wp-block-paragraph">\[\text{Checksum} = \sum_{i=0}^{n-1} D_i \mod 256\]



<ol start="2" class="wp-block-list">
<li><strong>Checksum de 8 bits com complemento de um (One’s complement)</strong>:</li>
</ol>



<p class="wp-block-paragraph">\[\text{Checksum} = \sim \left( \sum_{i=0}^{n-1} D_i \mod 256 \right)\]



<ol start="3" class="wp-block-list">
<li><strong>Checksum de 16 bits</strong>:</li>
</ol>



<p class="wp-block-paragraph">\[\text{Checksum} = \sum_{i=0}^{n/2 &#8211; 1} (D_{2i} \ll 8 + D_{2i+1}) \mod 65536\]



<p class="wp-block-paragraph">A escolha depende da confiabilidade desejada. Checksum de 16 bits é mais resistente a colisões do que o de 8.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Implementação em C</h3>



<h4 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f9ea.png" alt="🧪" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Exemplo 1: Checksum de 8 bits (soma simples)</h4>



<div class="wp-block-kevinbatdorf-code-block-pro" data-code-block-pro-font-family="Code-Pro-JetBrains-Mono" style="font-size:.875rem;font-family:Code-Pro-JetBrains-Mono,ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,monospace;line-height:1.25rem;--cbp-tab-width:2;tab-size:var(--cbp-tab-width, 2)"><span style="display:block;padding:16px 0 0 16px;margin-bottom:-1px;width:100%;text-align:left;background-color:#2e3440ff"><svg xmlns="http://www.w3.org/2000/svg" width="54" height="14" viewBox="0 0 54 14"><g fill="none" fill-rule="evenodd" transform="translate(1 1)"><circle cx="6" cy="6" r="6" fill="#FF5F56" stroke="#E0443E" stroke-width=".5"></circle><circle cx="26" cy="6" r="6" fill="#FFBD2E" stroke="#DEA123" stroke-width=".5"></circle><circle cx="46" cy="6" r="6" fill="#27C93F" stroke="#1AAB29" stroke-width=".5"></circle></g></svg></span><span role="button" tabindex="0" data-code="#include <stdint.h&gt;
#include <stddef.h&gt;

uint8_t checksum8(const uint8_t *dados, size_t tamanho) {
    uint8_t soma = 0;
    for (size_t i = 0; i < tamanho; i++) {
        soma += dados[i];
    }
    return soma; // pode ser usado diretamente ou transmitido como complemento
}
" style="color:#d8dee9ff;display:none" aria-label="Copy" class="code-block-pro-copy-button"><svg xmlns="http://www.w3.org/2000/svg" style="width:24px;height:24px" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2"><path class="with-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2m-6 9l2 2 4-4"></path><path class="without-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2"></path></svg></span><pre class="shiki nord" style="background-color: #2e3440ff" tabindex="0"><code><span class="line"><span style="color: #616E88">#include &lt;stdint.h&gt;</span></span>
<span class="line"><span style="color: #616E88">#include &lt;stddef.h&gt;</span></span>
<span class="line"></span>
<span class="line"><span style="color: #88C0D0">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">checksum8</span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">const</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #81A1C1">*</span><span style="color: #A3BE8C">dados,</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">size_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">tamanho</span><span style="color: #ECEFF4">)</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">{</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #88C0D0">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">soma</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #81A1C1">for</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">size_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">i</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0</span><span style="color: #81A1C1">;</span><span style="color: #D8DEE9FF"> </span><span style="color: #88C0D0">i</span><span style="color: #D8DEE9FF"> </span><span style="color: #81A1C1">&lt;</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">tamanho</span><span style="color: #81A1C1">;</span><span style="color: #D8DEE9FF"> </span><span style="color: #88C0D0">i++</span><span style="color: #ECEFF4">)</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">{</span></span>
<span class="line"><span style="color: #D8DEE9FF">        </span><span style="color: #88C0D0">soma</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">+=</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">dados[i]</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #ECEFF4">}</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #81A1C1">return</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">soma</span><span style="color: #81A1C1">;</span><span style="color: #D8DEE9FF"> </span><span style="color: #88C0D0">//</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">pode</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">ser</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">usado</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">diretamente</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">ou</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">transmitido</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">como</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">complemento</span></span>
<span class="line"><span style="color: #D8DEE9FF">}</span></span>
<span class="line"></span></code></pre></div>



<h4 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f9ea.png" alt="🧪" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Exemplo 2: Checksum de 8 bits com complemento</h4>



<div class="wp-block-kevinbatdorf-code-block-pro" data-code-block-pro-font-family="Code-Pro-JetBrains-Mono" style="font-size:.875rem;font-family:Code-Pro-JetBrains-Mono,ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,monospace;line-height:1.25rem;--cbp-tab-width:2;tab-size:var(--cbp-tab-width, 2)"><span style="display:block;padding:16px 0 0 16px;margin-bottom:-1px;width:100%;text-align:left;background-color:#2e3440ff"><svg xmlns="http://www.w3.org/2000/svg" width="54" height="14" viewBox="0 0 54 14"><g fill="none" fill-rule="evenodd" transform="translate(1 1)"><circle cx="6" cy="6" r="6" fill="#FF5F56" stroke="#E0443E" stroke-width=".5"></circle><circle cx="26" cy="6" r="6" fill="#FFBD2E" stroke="#DEA123" stroke-width=".5"></circle><circle cx="46" cy="6" r="6" fill="#27C93F" stroke="#1AAB29" stroke-width=".5"></circle></g></svg></span><span role="button" tabindex="0" data-code="uint8_t checksum8_complemento(const uint8_t *dados, size_t tamanho) {
    uint8_t soma = 0;
    for (size_t i = 0; i < tamanho; i++) {
        soma += dados[i];
    }
    return ~soma; // complemento de 1
}
" style="color:#d8dee9ff;display:none" aria-label="Copy" class="code-block-pro-copy-button"><svg xmlns="http://www.w3.org/2000/svg" style="width:24px;height:24px" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2"><path class="with-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2m-6 9l2 2 4-4"></path><path class="without-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2"></path></svg></span><pre class="shiki nord" style="background-color: #2e3440ff" tabindex="0"><code><span class="line"><span style="color: #88C0D0">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">checksum8_complemento</span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">const</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #81A1C1">*</span><span style="color: #A3BE8C">dados,</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">size_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">tamanho</span><span style="color: #ECEFF4">)</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">{</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #88C0D0">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">soma</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #81A1C1">for</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">size_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">i</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0</span><span style="color: #81A1C1">;</span><span style="color: #D8DEE9FF"> </span><span style="color: #88C0D0">i</span><span style="color: #D8DEE9FF"> </span><span style="color: #81A1C1">&lt;</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">tamanho</span><span style="color: #81A1C1">;</span><span style="color: #D8DEE9FF"> </span><span style="color: #88C0D0">i++</span><span style="color: #ECEFF4">)</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">{</span></span>
<span class="line"><span style="color: #D8DEE9FF">        </span><span style="color: #88C0D0">soma</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">+=</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">dados[i]</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #ECEFF4">}</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #81A1C1">return</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">~soma</span><span style="color: #81A1C1">;</span><span style="color: #D8DEE9FF"> </span><span style="color: #88C0D0">//</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">complemento</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">de</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">1</span></span>
<span class="line"><span style="color: #D8DEE9FF">}</span></span>
<span class="line"></span></code></pre></div>



<h4 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f9ea.png" alt="🧪" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Exemplo 3: Checksum de 16 bits</h4>



<div class="wp-block-kevinbatdorf-code-block-pro" data-code-block-pro-font-family="Code-Pro-JetBrains-Mono" style="font-size:.875rem;font-family:Code-Pro-JetBrains-Mono,ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,monospace;line-height:1.25rem;--cbp-tab-width:2;tab-size:var(--cbp-tab-width, 2)"><span style="display:block;padding:16px 0 0 16px;margin-bottom:-1px;width:100%;text-align:left;background-color:#2e3440ff"><svg xmlns="http://www.w3.org/2000/svg" width="54" height="14" viewBox="0 0 54 14"><g fill="none" fill-rule="evenodd" transform="translate(1 1)"><circle cx="6" cy="6" r="6" fill="#FF5F56" stroke="#E0443E" stroke-width=".5"></circle><circle cx="26" cy="6" r="6" fill="#FFBD2E" stroke="#DEA123" stroke-width=".5"></circle><circle cx="46" cy="6" r="6" fill="#27C93F" stroke="#1AAB29" stroke-width=".5"></circle></g></svg></span><span role="button" tabindex="0" data-code="uint16_t checksum16(const uint8_t *dados, size_t tamanho) {
    uint16_t soma = 0;
    for (size_t i = 0; i < tamanho; i += 2) {
        uint16_t palavra = dados[i];
        if (i + 1 < tamanho)
            palavra = (palavra << 8) | dados[i + 1];
        else
            palavra <<= 8; // completa com zero se ímpar
        soma += palavra;
    }
    return soma;
}
" style="color:#d8dee9ff;display:none" aria-label="Copy" class="code-block-pro-copy-button"><svg xmlns="http://www.w3.org/2000/svg" style="width:24px;height:24px" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2"><path class="with-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2m-6 9l2 2 4-4"></path><path class="without-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2"></path></svg></span><pre class="shiki nord" style="background-color: #2e3440ff" tabindex="0"><code><span class="line"><span style="color: #88C0D0">uint16_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">checksum16</span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">const</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #81A1C1">*</span><span style="color: #A3BE8C">dados,</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">size_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">tamanho</span><span style="color: #ECEFF4">)</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">{</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #88C0D0">uint16_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">soma</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #81A1C1">for</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">size_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">i</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0</span><span style="color: #81A1C1">;</span><span style="color: #D8DEE9FF"> </span><span style="color: #88C0D0">i</span><span style="color: #D8DEE9FF"> </span><span style="color: #81A1C1">&lt;</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">tamanho</span><span style="color: #81A1C1">;</span><span style="color: #D8DEE9FF"> </span><span style="color: #88C0D0">i</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">+=</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">2</span><span style="color: #ECEFF4">)</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">{</span></span>
<span class="line"><span style="color: #D8DEE9FF">        </span><span style="color: #88C0D0">uint16_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">palavra</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">dados[i]</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">        </span><span style="color: #81A1C1">if</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">i</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">+</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">1</span><span style="color: #D8DEE9FF"> </span><span style="color: #81A1C1">&lt;</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">tamanho</span><span style="color: #ECEFF4">)</span></span>
<span class="line"><span style="color: #D8DEE9FF">            </span><span style="color: #88C0D0">palavra</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> (palavra &lt;&lt; </span><span style="color: #B48EAD">8</span><span style="color: #D8DEE9FF">) </span><span style="color: #81A1C1">|</span><span style="color: #D8DEE9FF"> </span><span style="color: #88C0D0">dados[i</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">+</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">1</span><span style="color: #A3BE8C">]</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">        </span><span style="color: #81A1C1">else</span></span>
<span class="line"><span style="color: #D8DEE9FF">            </span><span style="color: #88C0D0">palavra</span><span style="color: #D8DEE9FF"> &lt;&lt;</span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">8</span><span style="color: #81A1C1">;</span><span style="color: #D8DEE9FF"> </span><span style="color: #88C0D0">//</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">completa</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">com</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">zero</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">se</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">ímpar</span></span>
<span class="line"><span style="color: #D8DEE9FF">        </span><span style="color: #88C0D0">soma</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">+=</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">palavra</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">    }</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #81A1C1">return</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">soma</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">}</span></span>
<span class="line"></span></code></pre></div>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Vantagens e Limitações</h3>



<p class="wp-block-paragraph"><strong>Vantagens</strong>:</p>



<ul class="wp-block-list">
<li>Extremamente leve computacionalmente.</li>



<li>Fácil de depurar (visualização direta da soma).</li>



<li>Útil em protocolos simples (ex: comunicação serial básica).</li>
</ul>



<p class="wp-block-paragraph"><strong>Limitações</strong>:</p>



<ul class="wp-block-list">
<li>Pode ser enganado por reordenação de bytes.</li>



<li>Menor capacidade de detecção em caso de múltiplos erros.</li>



<li>Não protege contra rajadas de bits corrompidos.</li>
</ul>



<p class="wp-block-paragraph">Por essas razões, o checksum é mais indicado em <strong>sistemas com baixo ruído, baixa taxa de erro</strong> ou como <strong>camada auxiliar</strong> em conjunto com outros mecanismos de proteção.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h2 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4d8.png" alt="📘" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Capítulo 4 – Introdução ao CRC</h2>



<p class="wp-block-paragraph">O <strong>CRC (Cyclic Redundancy Check)</strong> é um método de verificação de integridade de dados baseado em <strong>aritmética binária modular</strong>, mais especificamente em <strong>divisão polinomial sobre o campo de Galois GF(2)</strong>. Ele é amplamente utilizado por sua capacidade de detectar com alta confiabilidade uma variedade de erros, incluindo <strong>erros únicos, múltiplos, rajadas de bits</strong> e <strong>trocas de posição</strong>.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Representação Polinomial</h3>



<p class="wp-block-paragraph">Diferente do checksum, que trata os dados como números somáveis, o CRC os interpreta como um <strong>polinômio binário</strong>, onde cada bit é um coeficiente (0 ou 1). Por exemplo, o byte <code>0xD2</code> (11010010) é representado como: \(x^7 + x^6 + x^4 + x^1\)</p>



<p class="wp-block-paragraph">O processo de CRC consiste em dividir esse polinômio pelo chamado <strong>polinômio gerador</strong> (ou polinômio divisor), e usar o <strong>resto da divisão</strong> como código de verificação.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Operações em GF(2)</h3>



<p class="wp-block-paragraph">No campo de Galois GF(2), as operações são feitas <strong>bit a bit</strong> com regras simples:</p>



<ul class="wp-block-list">
<li><strong>Adição/Subtração = XOR</strong></li>



<li><strong>Multiplicação = AND com deslocamentos</strong></li>



<li>Não existe “empréstimo” ou “vai-um” como na aritmética decimal.</li>
</ul>



<p class="wp-block-paragraph">Isso simplifica muito a implementação em C, mas exige cuidado no controle dos bits envolvidos.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Processo de Cálculo do CRC</h3>



<ol class="wp-block-list">
<li>O fluxo de dados é estendido com <code>n</code> bits zero (onde <code>n</code> é o grau do polinômio).</li>



<li>A sequência estendida é dividida pelo polinômio gerador (bit a bit).</li>



<li>O <strong>resto</strong> da divisão é o valor do CRC.</li>
</ol>



<p class="wp-block-paragraph">Exemplo com polinômio CRC-4-ITU (𝑥⁴ + 𝑥 + 1):</p>



<div class="wp-block-kevinbatdorf-code-block-pro" data-code-block-pro-font-family="Code-Pro-JetBrains-Mono" style="font-size:.875rem;font-family:Code-Pro-JetBrains-Mono,ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,monospace;line-height:1.25rem;--cbp-tab-width:2;tab-size:var(--cbp-tab-width, 2)"><span style="display:block;padding:16px 0 0 16px;margin-bottom:-1px;width:100%;text-align:left;background-color:#2e3440ff"><svg xmlns="http://www.w3.org/2000/svg" width="54" height="14" viewBox="0 0 54 14"><g fill="none" fill-rule="evenodd" transform="translate(1 1)"><circle cx="6" cy="6" r="6" fill="#FF5F56" stroke="#E0443E" stroke-width=".5"></circle><circle cx="26" cy="6" r="6" fill="#FFBD2E" stroke="#DEA123" stroke-width=".5"></circle><circle cx="46" cy="6" r="6" fill="#27C93F" stroke="#1AAB29" stroke-width=".5"></circle></g></svg></span><span role="button" tabindex="0" data-code="Dados:    11010011101100
Polinômio:     1011  (grau 3, CRC-3)
" style="color:#d8dee9ff;display:none" aria-label="Copy" class="code-block-pro-copy-button"><svg xmlns="http://www.w3.org/2000/svg" style="width:24px;height:24px" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2"><path class="with-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2m-6 9l2 2 4-4"></path><path class="without-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2"></path></svg></span><pre class="shiki nord" style="background-color: #2e3440ff" tabindex="0"><code><span class="line"><span style="color: #88C0D0">Dados:</span><span style="color: #D8DEE9FF">    </span><span style="color: #B48EAD">11010011101100</span></span>
<span class="line"><span style="color: #88C0D0">Polinômio:</span><span style="color: #D8DEE9FF">     </span><span style="color: #B48EAD">1011</span><span style="color: #D8DEE9FF">  (grau </span><span style="color: #B48EAD">3</span><span style="color: #A3BE8C">,</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">CRC-3</span><span style="color: #D8DEE9FF">)</span></span>
<span class="line"></span></code></pre></div>



<p class="wp-block-paragraph">O resultado do processo é um valor de 3 bits, que será adicionado ao final da mensagem.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Escolha do Polinômio</h3>



<p class="wp-block-paragraph">A <strong>eficiência do CRC depende criticamente da escolha do polinômio gerador</strong>. Alguns polinômios são padronizados e otimizados para detectar certos tipos de erro:</p>



<figure class="wp-block-table"><table class="has-fixed-layout"><thead><tr><th>Nome</th><th>Grau</th><th>Polinômio (hex)</th><th>Aplicações típicas</th></tr></thead><tbody><tr><td>CRC-8</td><td>8</td><td>0x07</td><td>SMBus, I²C, ATM</td></tr><tr><td>CRC-16-IBM</td><td>16</td><td>0x8005</td><td>Modbus, Bluetooth, USB</td></tr><tr><td>CRC-32</td><td>32</td><td>0x04C11DB7</td><td>Ethernet, ZIP, PNG</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">A implementação de CRC no código C será profundamente influenciada pela escolha desse polinômio, assim como por fatores como endianess, refletir bits ou não (bit reversal), e valores iniciais.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Por que CRC é Melhor que Checksum?</h3>



<p class="wp-block-paragraph">O CRC oferece detecção garantida para:</p>



<ul class="wp-block-list">
<li>Todos os erros de 1 bit</li>



<li>Todos os erros de 2 bits</li>



<li>Todas as rajadas de até <strong>n bits</strong> (onde <em>n</em> = grau do polinômio)</li>



<li>A maioria dos erros múltiplos e sistemáticos</li>
</ul>



<p class="wp-block-paragraph">Em protocolos críticos, como <strong>CAN, USB e Ethernet</strong>, o CRC é preferido por garantir detecção de erros complexos sem aumentar significativamente a sobrecarga de comunicação.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h2 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4d8.png" alt="📘" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Capítulo 5 – Implementando CRC em C</h2>



<p class="wp-block-paragraph">Neste capítulo, exploramos duas abordagens populares para implementar CRCs em C:</p>



<ol class="wp-block-list">
<li><strong>Método bit a bit</strong>, mais didático e direto, mas menos performático.</li>



<li><strong>Método por tabela (lookup table)</strong>, mais rápido, ideal para aplicações em tempo real.</li>
</ol>



<p class="wp-block-paragraph">Ambos podem ser usados com diferentes configurações de CRC (8, 16, 32 bits), dependendo da aplicação e do polinômio.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> CRC Bit a Bit (sem tabela)</h3>



<p class="wp-block-paragraph">A implementação bit a bit simula diretamente a <strong>divisão polinomial</strong> descrita no capítulo anterior. É útil para compreender o funcionamento interno do algoritmo e para aplicações que não exigem alta performance.</p>



<h4 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f9ea.png" alt="🧪" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Exemplo: CRC-8 com polinômio <code>x⁸ + x² + x + 1</code> (0x07)</h4>



<div class="wp-block-kevinbatdorf-code-block-pro" data-code-block-pro-font-family="Code-Pro-JetBrains-Mono" style="font-size:.875rem;font-family:Code-Pro-JetBrains-Mono,ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,monospace;line-height:1.25rem;--cbp-tab-width:2;tab-size:var(--cbp-tab-width, 2)"><span style="display:block;padding:16px 0 0 16px;margin-bottom:-1px;width:100%;text-align:left;background-color:#2e3440ff"><svg xmlns="http://www.w3.org/2000/svg" width="54" height="14" viewBox="0 0 54 14"><g fill="none" fill-rule="evenodd" transform="translate(1 1)"><circle cx="6" cy="6" r="6" fill="#FF5F56" stroke="#E0443E" stroke-width=".5"></circle><circle cx="26" cy="6" r="6" fill="#FFBD2E" stroke="#DEA123" stroke-width=".5"></circle><circle cx="46" cy="6" r="6" fill="#27C93F" stroke="#1AAB29" stroke-width=".5"></circle></g></svg></span><span role="button" tabindex="0" data-code="#include <stdint.h&gt;

uint8_t crc8_bitwise(const uint8_t *dados, size_t tamanho) {
    uint8_t crc = 0x00;
    uint8_t polinomio = 0x07;

    for (size_t i = 0; i < tamanho; i++) {
        crc ^= dados[i];
        for (uint8_t bit = 0; bit < 8; bit++) {
            if (crc &amp; 0x80)
                crc = (crc << 1) ^ polinomio;
            else
                crc <<= 1;
        }
    }
    return crc;
}
" style="color:#d8dee9ff;display:none" aria-label="Copy" class="code-block-pro-copy-button"><svg xmlns="http://www.w3.org/2000/svg" style="width:24px;height:24px" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2"><path class="with-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2m-6 9l2 2 4-4"></path><path class="without-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2"></path></svg></span><pre class="shiki nord" style="background-color: #2e3440ff" tabindex="0"><code><span class="line"><span style="color: #616E88">#include &lt;stdint.h&gt;</span></span>
<span class="line"></span>
<span class="line"><span style="color: #88C0D0">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">crc8_bitwise</span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">const</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #81A1C1">*</span><span style="color: #A3BE8C">dados,</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">size_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">tamanho</span><span style="color: #ECEFF4">)</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">{</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #88C0D0">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">crc</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0x00</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #88C0D0">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">polinomio</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0x07</span><span style="color: #81A1C1">;</span></span>
<span class="line"></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #81A1C1">for</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">size_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">i</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0</span><span style="color: #81A1C1">;</span><span style="color: #D8DEE9FF"> </span><span style="color: #88C0D0">i</span><span style="color: #D8DEE9FF"> </span><span style="color: #81A1C1">&lt;</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">tamanho</span><span style="color: #81A1C1">;</span><span style="color: #D8DEE9FF"> </span><span style="color: #88C0D0">i++</span><span style="color: #ECEFF4">)</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">{</span></span>
<span class="line"><span style="color: #D8DEE9FF">        </span><span style="color: #88C0D0">crc</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">^=</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">dados[i]</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">        </span><span style="color: #81A1C1">for</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">bit</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0</span><span style="color: #81A1C1">;</span><span style="color: #D8DEE9FF"> </span><span style="color: #88C0D0">bit</span><span style="color: #D8DEE9FF"> </span><span style="color: #81A1C1">&lt;</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">8</span><span style="color: #81A1C1">;</span><span style="color: #D8DEE9FF"> </span><span style="color: #88C0D0">bit++</span><span style="color: #ECEFF4">)</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">{</span></span>
<span class="line"><span style="color: #D8DEE9FF">            </span><span style="color: #81A1C1">if</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">crc</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">&amp;</span><span style="color: #D8DEE9FF"> </span><span style="color: #88C0D0">0x80</span><span style="color: #ECEFF4">)</span></span>
<span class="line"><span style="color: #D8DEE9FF">                </span><span style="color: #88C0D0">crc</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> (crc &lt;&lt; </span><span style="color: #B48EAD">1</span><span style="color: #D8DEE9FF">) ^ polinomio</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">            </span><span style="color: #81A1C1">else</span></span>
<span class="line"><span style="color: #D8DEE9FF">                </span><span style="color: #88C0D0">crc</span><span style="color: #D8DEE9FF"> &lt;&lt;</span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">1</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">        }</span></span>
<span class="line"><span style="color: #D8DEE9FF">    }</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #81A1C1">return</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">crc</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">}</span></span>
<span class="line"></span></code></pre></div>



<p class="wp-block-paragraph">Este código percorre cada bit de cada byte, aplicando XOR e realizando a divisão com o polinômio quando necessário.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> CRC com Lookup Table</h3>



<p class="wp-block-paragraph">Para sistemas embarcados mais rápidos, como Cortex-M, o uso de tabelas permite um ganho significativo de desempenho. A ideia é <strong>pré-calcular os efeitos de cada byte</strong> possível e armazenar isso em uma tabela de 256 posições.</p>



<h4 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f9ea.png" alt="🧪" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Exemplo: CRC-8 com lookup table</h4>



<div class="wp-block-kevinbatdorf-code-block-pro" data-code-block-pro-font-family="Code-Pro-JetBrains-Mono" style="font-size:.875rem;font-family:Code-Pro-JetBrains-Mono,ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,monospace;line-height:1.25rem;--cbp-tab-width:2;tab-size:var(--cbp-tab-width, 2)"><span style="display:block;padding:16px 0 0 16px;margin-bottom:-1px;width:100%;text-align:left;background-color:#2e3440ff"><svg xmlns="http://www.w3.org/2000/svg" width="54" height="14" viewBox="0 0 54 14"><g fill="none" fill-rule="evenodd" transform="translate(1 1)"><circle cx="6" cy="6" r="6" fill="#FF5F56" stroke="#E0443E" stroke-width=".5"></circle><circle cx="26" cy="6" r="6" fill="#FFBD2E" stroke="#DEA123" stroke-width=".5"></circle><circle cx="46" cy="6" r="6" fill="#27C93F" stroke="#1AAB29" stroke-width=".5"></circle></g></svg></span><span role="button" tabindex="0" data-code="#include <stdint.h&gt;

static const uint8_t tabela_crc8[256] = {
    // Preenchida com base no polinômio 0x07
    // Pode ser gerada automaticamente (ver capítulo seguinte)
};

uint8_t crc8_tabela(const uint8_t *dados, size_t tamanho) {
    uint8_t crc = 0x00;
    for (size_t i = 0; i < tamanho; i++) {
        crc = tabela_crc8[crc ^ dados[i]];
    }
    return crc;
}
" style="color:#d8dee9ff;display:none" aria-label="Copy" class="code-block-pro-copy-button"><svg xmlns="http://www.w3.org/2000/svg" style="width:24px;height:24px" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2"><path class="with-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2m-6 9l2 2 4-4"></path><path class="without-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2"></path></svg></span><pre class="shiki nord" style="background-color: #2e3440ff" tabindex="0"><code><span class="line"><span style="color: #616E88">#include &lt;stdint.h&gt;</span></span>
<span class="line"></span>
<span class="line"><span style="color: #88C0D0">static</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">const</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">tabela_crc8[</span><span style="color: #B48EAD">256</span><span style="color: #A3BE8C">]</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">{</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #88C0D0">//</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">Preenchida</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">com</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">base</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">no</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">polinômio</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0x07</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #88C0D0">//</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">Pode</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">ser</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">gerada</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">automaticamente</span><span style="color: #D8DEE9FF"> (ver </span><span style="color: #A3BE8C">capítulo</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">seguinte</span><span style="color: #D8DEE9FF">)</span></span>
<span class="line"><span style="color: #D8DEE9FF">};</span></span>
<span class="line"></span>
<span class="line"><span style="color: #88C0D0">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">crc8_tabela</span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">const</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #81A1C1">*</span><span style="color: #A3BE8C">dados,</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">size_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">tamanho</span><span style="color: #ECEFF4">)</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">{</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #88C0D0">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">crc</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0x00</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #81A1C1">for</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">size_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">i</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0</span><span style="color: #81A1C1">;</span><span style="color: #D8DEE9FF"> </span><span style="color: #88C0D0">i</span><span style="color: #D8DEE9FF"> </span><span style="color: #81A1C1">&lt;</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">tamanho</span><span style="color: #81A1C1">;</span><span style="color: #D8DEE9FF"> </span><span style="color: #88C0D0">i++</span><span style="color: #ECEFF4">)</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">{</span></span>
<span class="line"><span style="color: #D8DEE9FF">        </span><span style="color: #88C0D0">crc</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">tabela_crc8[crc</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">^</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">dados[i]]</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #ECEFF4">}</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #81A1C1">return</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">crc</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">}</span></span>
<span class="line"></span></code></pre></div>



<p class="wp-block-paragraph">A tabela pode ser gerada por um script, ou calculada uma única vez durante o setup do sistema.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> CRC-16 (bitwise)</h3>



<p class="wp-block-paragraph">O mesmo conceito se aplica a CRCs de 16 bits. Aqui está um exemplo com o clássico <strong>CRC-16-IBM (polinômio 0x8005, refletido)</strong>:</p>



<div class="wp-block-kevinbatdorf-code-block-pro" data-code-block-pro-font-family="Code-Pro-JetBrains-Mono" style="font-size:.875rem;font-family:Code-Pro-JetBrains-Mono,ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,monospace;line-height:1.25rem;--cbp-tab-width:2;tab-size:var(--cbp-tab-width, 2)"><span style="display:block;padding:16px 0 0 16px;margin-bottom:-1px;width:100%;text-align:left;background-color:#2e3440ff"><svg xmlns="http://www.w3.org/2000/svg" width="54" height="14" viewBox="0 0 54 14"><g fill="none" fill-rule="evenodd" transform="translate(1 1)"><circle cx="6" cy="6" r="6" fill="#FF5F56" stroke="#E0443E" stroke-width=".5"></circle><circle cx="26" cy="6" r="6" fill="#FFBD2E" stroke="#DEA123" stroke-width=".5"></circle><circle cx="46" cy="6" r="6" fill="#27C93F" stroke="#1AAB29" stroke-width=".5"></circle></g></svg></span><span role="button" tabindex="0" data-code="uint16_t crc16_bitwise(const uint8_t *dados, size_t tamanho) {
    uint16_t crc = 0x0000;
    uint16_t polinomio = 0x8005;

    for (size_t i = 0; i < tamanho; i++) {
        crc ^= (dados[i] << 8);
        for (uint8_t bit = 0; bit < 8; bit++) {
            if (crc &amp; 0x8000)
                crc = (crc << 1) ^ polinomio;
            else
                crc <<= 1;
        }
    }
    return crc;
}
" style="color:#d8dee9ff;display:none" aria-label="Copy" class="code-block-pro-copy-button"><svg xmlns="http://www.w3.org/2000/svg" style="width:24px;height:24px" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2"><path class="with-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2m-6 9l2 2 4-4"></path><path class="without-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2"></path></svg></span><pre class="shiki nord" style="background-color: #2e3440ff" tabindex="0"><code><span class="line"><span style="color: #88C0D0">uint16_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">crc16_bitwise</span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">const</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #81A1C1">*</span><span style="color: #A3BE8C">dados,</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">size_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">tamanho</span><span style="color: #ECEFF4">)</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">{</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #88C0D0">uint16_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">crc</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0x0000</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #88C0D0">uint16_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">polinomio</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0x8005</span><span style="color: #81A1C1">;</span></span>
<span class="line"></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #81A1C1">for</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">size_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">i</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0</span><span style="color: #81A1C1">;</span><span style="color: #D8DEE9FF"> </span><span style="color: #88C0D0">i</span><span style="color: #D8DEE9FF"> </span><span style="color: #81A1C1">&lt;</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">tamanho</span><span style="color: #81A1C1">;</span><span style="color: #D8DEE9FF"> </span><span style="color: #88C0D0">i++</span><span style="color: #ECEFF4">)</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">{</span></span>
<span class="line"><span style="color: #D8DEE9FF">        </span><span style="color: #88C0D0">crc</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">^=</span><span style="color: #D8DEE9FF"> (dados[i] &lt;&lt; 8)</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">        </span><span style="color: #81A1C1">for</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">bit</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0</span><span style="color: #81A1C1">;</span><span style="color: #D8DEE9FF"> </span><span style="color: #88C0D0">bit</span><span style="color: #D8DEE9FF"> </span><span style="color: #81A1C1">&lt;</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">8</span><span style="color: #81A1C1">;</span><span style="color: #D8DEE9FF"> </span><span style="color: #88C0D0">bit++</span><span style="color: #ECEFF4">)</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">{</span></span>
<span class="line"><span style="color: #D8DEE9FF">            </span><span style="color: #81A1C1">if</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">crc</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">&amp;</span><span style="color: #D8DEE9FF"> </span><span style="color: #88C0D0">0x8000</span><span style="color: #ECEFF4">)</span></span>
<span class="line"><span style="color: #D8DEE9FF">                </span><span style="color: #88C0D0">crc</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> (crc &lt;&lt; </span><span style="color: #B48EAD">1</span><span style="color: #D8DEE9FF">) ^ polinomio</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">            </span><span style="color: #81A1C1">else</span></span>
<span class="line"><span style="color: #D8DEE9FF">                </span><span style="color: #88C0D0">crc</span><span style="color: #D8DEE9FF"> &lt;&lt;</span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">1</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">        }</span></span>
<span class="line"><span style="color: #D8DEE9FF">    }</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #81A1C1">return</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">crc</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">}</span></span>
<span class="line"></span></code></pre></div>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Tabela ou Bit a Bit?</h3>



<figure class="wp-block-table"><table class="has-fixed-layout"><thead><tr><th>Critério</th><th>Bit a Bit</th><th>Tabela</th></tr></thead><tbody><tr><td>Velocidade</td><td>Lenta</td><td>Rápida</td></tr><tr><td>Memória RAM/FLASH</td><td>Baixa</td><td>Moderada (256–1024 bytes)</td></tr><tr><td>Facilidade de depurar</td><td>Alta</td><td>Moderada</td></tr><tr><td>Custo de CPU</td><td>Alto</td><td>Baixo</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">Se seu projeto roda em um <strong>MCU de 8 bits com 2KB de flash</strong>, use a versão bit a bit. Para <strong>MCUs com 32KB+ e necessidade de tempo real</strong>, a versão com tabela é recomendada.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h2 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4d8.png" alt="📘" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Capítulo 6 – Otimizações para Microcontroladores</h2>



<p class="wp-block-paragraph">Enquanto as implementações bit a bit e com tabela são funcionais em qualquer sistema, o contexto de <strong>microcontroladores</strong> exige atenção especial à eficiência — seja em termos de <strong>tempo de execução</strong>, <strong>uso de memória RAM/flash</strong>, ou <strong>consumo de energia</strong>. Este capítulo apresenta estratégias específicas para adaptar e otimizar algoritmos de CRC a diferentes arquiteturas embarcadas.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Arquiteturas: 8, 16 e 32 bits</h3>



<p class="wp-block-paragraph">A arquitetura do microcontrolador afeta diretamente a forma como os dados são processados. Um MCU de 32 bits (como os STM32 Cortex-M) pode processar palavras inteiras em uma única instrução, enquanto um ATmega328 (8 bits) precisará de múltiplas operações para lidar com valores de 16 ou 32 bits.</p>



<p class="wp-block-paragraph"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4a1.png" alt="💡" class="wp-smiley" style="height: 1em; max-height: 1em;" /> <strong>Dica</strong>: Prefira CRCs de 8 bits em sistemas de 8 bits, e use CRC-16 ou CRC-32 apenas se necessário.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Endianess e Espelhamento de Bits</h3>



<p class="wp-block-paragraph">Alguns algoritmos de CRC (como o CRC-16-CCITT ou o CRC-32 IEEE) especificam que os bits dos dados e/ou o próprio CRC devem ser <strong>espelhados</strong> (bit reflection), ou que os bytes devem ser processados em ordem inversa (little-endian).</p>



<h4 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f9ea.png" alt="🧪" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Espelhamento de bits (bit reversal):</h4>



<div class="wp-block-kevinbatdorf-code-block-pro" data-code-block-pro-font-family="Code-Pro-JetBrains-Mono" style="font-size:.875rem;font-family:Code-Pro-JetBrains-Mono,ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,monospace;line-height:1.25rem;--cbp-tab-width:2;tab-size:var(--cbp-tab-width, 2)"><span style="display:block;padding:16px 0 0 16px;margin-bottom:-1px;width:100%;text-align:left;background-color:#2e3440ff"><svg xmlns="http://www.w3.org/2000/svg" width="54" height="14" viewBox="0 0 54 14"><g fill="none" fill-rule="evenodd" transform="translate(1 1)"><circle cx="6" cy="6" r="6" fill="#FF5F56" stroke="#E0443E" stroke-width=".5"></circle><circle cx="26" cy="6" r="6" fill="#FFBD2E" stroke="#DEA123" stroke-width=".5"></circle><circle cx="46" cy="6" r="6" fill="#27C93F" stroke="#1AAB29" stroke-width=".5"></circle></g></svg></span><span role="button" tabindex="0" data-code="uint8_t refletir8(uint8_t b) {
    uint8_t r = 0;
    for (int i = 0; i < 8; i++) {
        if (b &amp; (1 << i)) r |= (1 << (7 - i));
    }
    return r;
}
" style="color:#d8dee9ff;display:none" aria-label="Copy" class="code-block-pro-copy-button"><svg xmlns="http://www.w3.org/2000/svg" style="width:24px;height:24px" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2"><path class="with-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2m-6 9l2 2 4-4"></path><path class="without-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2"></path></svg></span><pre class="shiki nord" style="background-color: #2e3440ff" tabindex="0"><code><span class="line"><span style="color: #88C0D0">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">refletir8</span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">b</span><span style="color: #ECEFF4">)</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">{</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #88C0D0">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">r</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #81A1C1">for</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">int</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">i</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0</span><span style="color: #81A1C1">;</span><span style="color: #D8DEE9FF"> </span><span style="color: #88C0D0">i</span><span style="color: #D8DEE9FF"> </span><span style="color: #81A1C1">&lt;</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">8</span><span style="color: #81A1C1">;</span><span style="color: #D8DEE9FF"> </span><span style="color: #88C0D0">i++</span><span style="color: #ECEFF4">)</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">{</span></span>
<span class="line"><span style="color: #D8DEE9FF">        </span><span style="color: #81A1C1">if</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">b</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">&amp;</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">1</span><span style="color: #D8DEE9FF"> &lt;&lt; </span><span style="color: #A3BE8C">i</span><span style="color: #ECEFF4">))</span><span style="color: #D8DEE9FF"> r </span><span style="color: #81A1C1">|</span><span style="color: #D8DEE9FF">= (1 &lt;&lt; (7 </span><span style="color: #A3BE8C">-</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">i</span><span style="color: #D8DEE9FF">))</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">    }</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #81A1C1">return</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">r</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">}</span></span>
<span class="line"></span></code></pre></div>



<p class="wp-block-paragraph"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4a1.png" alt="💡" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Alguns microcontroladores ARM (ex: Cortex-M3+) oferecem a instrução <strong>RBIT</strong> que inverte os bits de um registrador de forma rápida. Use-a via inline assembly quando possível:</p>



<div class="wp-block-kevinbatdorf-code-block-pro" data-code-block-pro-font-family="Code-Pro-JetBrains-Mono" style="font-size:.875rem;font-family:Code-Pro-JetBrains-Mono,ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,monospace;line-height:1.25rem;--cbp-tab-width:2;tab-size:var(--cbp-tab-width, 2)"><span style="display:block;padding:16px 0 0 16px;margin-bottom:-1px;width:100%;text-align:left;background-color:#2e3440ff"><svg xmlns="http://www.w3.org/2000/svg" width="54" height="14" viewBox="0 0 54 14"><g fill="none" fill-rule="evenodd" transform="translate(1 1)"><circle cx="6" cy="6" r="6" fill="#FF5F56" stroke="#E0443E" stroke-width=".5"></circle><circle cx="26" cy="6" r="6" fill="#FFBD2E" stroke="#DEA123" stroke-width=".5"></circle><circle cx="46" cy="6" r="6" fill="#27C93F" stroke="#1AAB29" stroke-width=".5"></circle></g></svg></span><span role="button" tabindex="0" data-code="__asm__(&quot;rbit %0, %1&quot; : &quot;=r&quot;(resultado) : &quot;r&quot;(valor));
" style="color:#d8dee9ff;display:none" aria-label="Copy" class="code-block-pro-copy-button"><svg xmlns="http://www.w3.org/2000/svg" style="width:24px;height:24px" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2"><path class="with-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2m-6 9l2 2 4-4"></path><path class="without-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2"></path></svg></span><pre class="shiki nord" style="background-color: #2e3440ff" tabindex="0"><code><span class="line"><span style="color: #88C0D0">__asm__(</span><span style="color: #88C0D0">&quot;rbit %0, %1&quot;</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">:</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">&quot;</span><span style="color: #A3BE8C">=r</span><span style="color: #ECEFF4">&quot;</span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">resultado</span><span style="color: #ECEFF4">)</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">:</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">&quot;</span><span style="color: #A3BE8C">r</span><span style="color: #ECEFF4">&quot;</span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">valor</span><span style="color: #ECEFF4">)</span><span style="color: #D8DEE9FF">)</span><span style="color: #81A1C1">;</span></span>
<span class="line"></span></code></pre></div>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Lookup Table Compacta (nibble-based)</h3>



<p class="wp-block-paragraph">Se a memória FLASH é limitada, mas o desempenho precisa melhorar, uma boa alternativa é usar uma <strong>tabela reduzida de 16 entradas</strong> baseada em nibbles (4 bits), em vez de 256:</p>



<div class="wp-block-kevinbatdorf-code-block-pro" data-code-block-pro-font-family="Code-Pro-JetBrains-Mono" style="font-size:.875rem;font-family:Code-Pro-JetBrains-Mono,ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,monospace;line-height:1.25rem;--cbp-tab-width:2;tab-size:var(--cbp-tab-width, 2)"><span style="display:block;padding:16px 0 0 16px;margin-bottom:-1px;width:100%;text-align:left;background-color:#2e3440ff"><svg xmlns="http://www.w3.org/2000/svg" width="54" height="14" viewBox="0 0 54 14"><g fill="none" fill-rule="evenodd" transform="translate(1 1)"><circle cx="6" cy="6" r="6" fill="#FF5F56" stroke="#E0443E" stroke-width=".5"></circle><circle cx="26" cy="6" r="6" fill="#FFBD2E" stroke="#DEA123" stroke-width=".5"></circle><circle cx="46" cy="6" r="6" fill="#27C93F" stroke="#1AAB29" stroke-width=".5"></circle></g></svg></span><span role="button" tabindex="0" data-code="static const uint8_t crc_nibble[16] = { /* valores pré-calculados */ };

uint8_t crc8_nibble(const uint8_t *dados, size_t tamanho) {
    uint8_t crc = 0;
    for (size_t i = 0; i < tamanho; i++) {
        crc ^= dados[i];
        crc = (crc_nibble[crc &gt;&gt; 4] ^ crc_nibble[crc &amp; 0x0F]);
    }
    return crc;
}
" style="color:#d8dee9ff;display:none" aria-label="Copy" class="code-block-pro-copy-button"><svg xmlns="http://www.w3.org/2000/svg" style="width:24px;height:24px" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2"><path class="with-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2m-6 9l2 2 4-4"></path><path class="without-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2"></path></svg></span><pre class="shiki nord" style="background-color: #2e3440ff" tabindex="0"><code><span class="line"><span style="color: #88C0D0">static</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">const</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">crc_nibble[</span><span style="color: #B48EAD">16</span><span style="color: #A3BE8C">]</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">{</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">/</span><span style="color: #81A1C1">*</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">valores</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">pré-calculados</span><span style="color: #D8DEE9FF"> </span><span style="color: #81A1C1">*</span><span style="color: #A3BE8C">/</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">}</span><span style="color: #81A1C1">;</span></span>
<span class="line"></span>
<span class="line"><span style="color: #88C0D0">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">crc8_nibble</span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">const</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #81A1C1">*</span><span style="color: #A3BE8C">dados,</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">size_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">tamanho</span><span style="color: #ECEFF4">)</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">{</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #88C0D0">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">crc</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #81A1C1">for</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">size_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">i</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0</span><span style="color: #81A1C1">;</span><span style="color: #D8DEE9FF"> </span><span style="color: #88C0D0">i</span><span style="color: #D8DEE9FF"> </span><span style="color: #81A1C1">&lt;</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">tamanho</span><span style="color: #81A1C1">;</span><span style="color: #D8DEE9FF"> </span><span style="color: #88C0D0">i++</span><span style="color: #ECEFF4">)</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">{</span></span>
<span class="line"><span style="color: #D8DEE9FF">        </span><span style="color: #88C0D0">crc</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">^=</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">dados[i]</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">        </span><span style="color: #88C0D0">crc</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> (crc_nibble[crc </span><span style="color: #81A1C1">&gt;&gt;</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">4</span><span style="color: #A3BE8C">]</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">^</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">crc_nibble[crc</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">&amp;</span><span style="color: #D8DEE9FF"> </span><span style="color: #88C0D0">0x0F]</span><span style="color: #D8DEE9FF">)</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #ECEFF4">}</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #81A1C1">return</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">crc</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">}</span></span>
<span class="line"></span></code></pre></div>



<p class="wp-block-paragraph">Essa técnica é um <strong>compromisso ideal</strong> entre espaço e velocidade, especialmente útil em sensores ou módulos de comunicação compactos.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Uso de Periféricos de CRC</h3>



<p class="wp-block-paragraph">Alguns microcontroladores modernos oferecem <strong>periféricos dedicados de CRC</strong>, como o <strong>CRC Engine dos STM32</strong>. Isso libera a CPU para outras tarefas.</p>



<h4 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f9ea.png" alt="🧪" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Exemplo: STM32 HAL (CRC-32 por hardware)</h4>



<div class="wp-block-kevinbatdorf-code-block-pro" data-code-block-pro-font-family="Code-Pro-JetBrains-Mono" style="font-size:.875rem;font-family:Code-Pro-JetBrains-Mono,ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,monospace;line-height:1.25rem;--cbp-tab-width:2;tab-size:var(--cbp-tab-width, 2)"><span style="display:block;padding:16px 0 0 16px;margin-bottom:-1px;width:100%;text-align:left;background-color:#2e3440ff"><svg xmlns="http://www.w3.org/2000/svg" width="54" height="14" viewBox="0 0 54 14"><g fill="none" fill-rule="evenodd" transform="translate(1 1)"><circle cx="6" cy="6" r="6" fill="#FF5F56" stroke="#E0443E" stroke-width=".5"></circle><circle cx="26" cy="6" r="6" fill="#FFBD2E" stroke="#DEA123" stroke-width=".5"></circle><circle cx="46" cy="6" r="6" fill="#27C93F" stroke="#1AAB29" stroke-width=".5"></circle></g></svg></span><span role="button" tabindex="0" data-code="#include &quot;stm32f4xx_hal.h&quot;

uint32_t calcular_crc_hw(const uint8_t *dados, size_t tamanho) {
    return HAL_CRC_Calculate(&amp;hcrc, (uint32_t *)dados, tamanho / 4);
}
" style="color:#d8dee9ff;display:none" aria-label="Copy" class="code-block-pro-copy-button"><svg xmlns="http://www.w3.org/2000/svg" style="width:24px;height:24px" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2"><path class="with-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2m-6 9l2 2 4-4"></path><path class="without-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2"></path></svg></span><pre class="shiki nord" style="background-color: #2e3440ff" tabindex="0"><code><span class="line"><span style="color: #616E88">#include &quot;stm32f4xx_hal.h&quot;</span></span>
<span class="line"></span>
<span class="line"><span style="color: #88C0D0">uint32_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">calcular_crc_hw</span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">const</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #81A1C1">*</span><span style="color: #A3BE8C">dados,</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">size_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">tamanho</span><span style="color: #ECEFF4">)</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">{</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #81A1C1">return</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">HAL_CRC_Calculate</span><span style="color: #ECEFF4">(&amp;</span><span style="color: #88C0D0">hcrc,</span><span style="color: #D8DEE9FF"> (uint32_t </span><span style="color: #81A1C1">*</span><span style="color: #ECEFF4">)</span><span style="color: #A3BE8C">dados,</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">tamanho</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">/</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">4</span><span style="color: #D8DEE9FF">)</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">}</span></span>
<span class="line"></span></code></pre></div>



<p class="wp-block-paragraph">Esse recurso é ideal para comunicações de alto volume ou validação de firmware.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Benchmark e Profiling</h3>



<p class="wp-block-paragraph">Recomenda-se medir o tempo de execução real com ferramentas como:</p>



<ul class="wp-block-list">
<li><strong>SysTick</strong> ou <strong>DWT_CYCCNT</strong> (nos Cortex-M)</li>



<li><strong>Analisador lógico</strong> externo com pino de GPIO para marcação de tempo</li>



<li><strong>Visualização via RTT ou UART debug</strong></li>
</ul>



<p class="wp-block-paragraph">Isso ajuda a decidir se o ganho com tabelas ou hardware justifica o custo de memória.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h2 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4d8.png" alt="📘" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Capítulo 7 – Integração com Protocolos de Comunicação</h2>



<p class="wp-block-paragraph">A aplicação real de algoritmos de verificação de integridade ocorre no contexto de <strong>protocolos de comunicação</strong>, como UART, SPI, I2C, CAN e USB. Cada protocolo possui suas próprias exigências, mas todos compartilham a necessidade de validar os dados recebidos.</p>



<p class="wp-block-paragraph">Este capítulo aborda como <strong>enquadrar pacotes de dados</strong>, calcular/verificar CRC ou checksum, e lidar com erros de transmissão de forma robusta, segura e eficiente.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Estrutura de Pacotes com Checksum/CRC</h3>



<p class="wp-block-paragraph">Um frame típico de dados pode conter os seguintes campos:</p>



<figure class="wp-block-table"><table class="has-fixed-layout"><thead><tr><th>Campo</th><th>Tamanho</th><th>Descrição</th></tr></thead><tbody><tr><td>Início (header)</td><td>1 byte</td><td>Identificador fixo, ex: <code>0xAA</code></td></tr><tr><td>ID</td><td>1 byte</td><td>ID do dispositivo ou comando</td></tr><tr><td>Tamanho</td><td>1 byte</td><td>Número de bytes úteis</td></tr><tr><td>Dados</td><td>N bytes</td><td>Conteúdo principal</td></tr><tr><td>Verificação</td><td>1–4 bytes</td><td>Checksum ou CRC (ex: CRC-16)</td></tr></tbody></table></figure>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Enviando Dados com CRC (UART como exemplo)</h3>



<div class="wp-block-kevinbatdorf-code-block-pro" data-code-block-pro-font-family="Code-Pro-JetBrains-Mono" style="font-size:.875rem;font-family:Code-Pro-JetBrains-Mono,ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,monospace;line-height:1.25rem;--cbp-tab-width:2;tab-size:var(--cbp-tab-width, 2)"><span style="display:block;padding:16px 0 0 16px;margin-bottom:-1px;width:100%;text-align:left;background-color:#2e3440ff"><svg xmlns="http://www.w3.org/2000/svg" width="54" height="14" viewBox="0 0 54 14"><g fill="none" fill-rule="evenodd" transform="translate(1 1)"><circle cx="6" cy="6" r="6" fill="#FF5F56" stroke="#E0443E" stroke-width=".5"></circle><circle cx="26" cy="6" r="6" fill="#FFBD2E" stroke="#DEA123" stroke-width=".5"></circle><circle cx="46" cy="6" r="6" fill="#27C93F" stroke="#1AAB29" stroke-width=".5"></circle></g></svg></span><span role="button" tabindex="0" data-code="void enviar_pacote_uart(uint8_t id, uint8_t *dados, uint8_t tamanho) {
    uint8_t pacote[64];
    uint8_t idx = 0;

    pacote[idx++] = 0xAA;           // Header
    pacote[idx++] = id;
    pacote[idx++] = tamanho;

    for (uint8_t i = 0; i < tamanho; i++)
        pacote[idx++] = dados[i];

    uint16_t crc = crc16_bitwise(pacote, idx);
    pacote[idx++] = crc &gt;&gt; 8;
    pacote[idx++] = crc &amp; 0xFF;

    HAL_UART_Transmit(&amp;huart1, pacote, idx, HAL_MAX_DELAY);
}
" style="color:#d8dee9ff;display:none" aria-label="Copy" class="code-block-pro-copy-button"><svg xmlns="http://www.w3.org/2000/svg" style="width:24px;height:24px" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2"><path class="with-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2m-6 9l2 2 4-4"></path><path class="without-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2"></path></svg></span><pre class="shiki nord" style="background-color: #2e3440ff" tabindex="0"><code><span class="line"><span style="color: #88C0D0">void</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">enviar_pacote_uart</span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">id,</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #81A1C1">*</span><span style="color: #A3BE8C">dados,</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">tamanho</span><span style="color: #ECEFF4">)</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">{</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #88C0D0">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">pacote[</span><span style="color: #B48EAD">64</span><span style="color: #A3BE8C">]</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #88C0D0">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">idx</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0</span><span style="color: #81A1C1">;</span></span>
<span class="line"></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #88C0D0">pacote[idx++]</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0xAA</span><span style="color: #81A1C1">;</span><span style="color: #D8DEE9FF">           </span><span style="color: #88C0D0">//</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">Header</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #88C0D0">pacote[idx++]</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">id</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #88C0D0">pacote[idx++]</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">tamanho</span><span style="color: #81A1C1">;</span></span>
<span class="line"></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #81A1C1">for</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">i</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0</span><span style="color: #81A1C1">;</span><span style="color: #D8DEE9FF"> </span><span style="color: #88C0D0">i</span><span style="color: #D8DEE9FF"> </span><span style="color: #81A1C1">&lt;</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">tamanho</span><span style="color: #81A1C1">;</span><span style="color: #D8DEE9FF"> </span><span style="color: #88C0D0">i++</span><span style="color: #ECEFF4">)</span></span>
<span class="line"><span style="color: #D8DEE9FF">        </span><span style="color: #88C0D0">pacote[idx++]</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">dados[i]</span><span style="color: #81A1C1">;</span></span>
<span class="line"></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #88C0D0">uint16_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">crc</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">crc16_bitwise</span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">pacote,</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">idx</span><span style="color: #ECEFF4">)</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #88C0D0">pacote[idx++]</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">crc</span><span style="color: #D8DEE9FF"> </span><span style="color: #81A1C1">&gt;&gt;</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">8</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #88C0D0">pacote[idx++]</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">crc</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">&amp;</span><span style="color: #D8DEE9FF"> </span><span style="color: #88C0D0">0xFF</span><span style="color: #81A1C1">;</span></span>
<span class="line"></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #88C0D0">HAL_UART_Transmit(</span><span style="color: #ECEFF4">&amp;</span><span style="color: #88C0D0">huart1,</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">pacote,</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">idx,</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">HAL_MAX_DELAY</span><span style="color: #D8DEE9FF">)</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">}</span></span>
<span class="line"></span></code></pre></div>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Recebendo e Verificando Pacote</h3>



<div class="wp-block-kevinbatdorf-code-block-pro" data-code-block-pro-font-family="Code-Pro-JetBrains-Mono" style="font-size:.875rem;font-family:Code-Pro-JetBrains-Mono,ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,monospace;line-height:1.25rem;--cbp-tab-width:2;tab-size:var(--cbp-tab-width, 2)"><span style="display:block;padding:16px 0 0 16px;margin-bottom:-1px;width:100%;text-align:left;background-color:#2e3440ff"><svg xmlns="http://www.w3.org/2000/svg" width="54" height="14" viewBox="0 0 54 14"><g fill="none" fill-rule="evenodd" transform="translate(1 1)"><circle cx="6" cy="6" r="6" fill="#FF5F56" stroke="#E0443E" stroke-width=".5"></circle><circle cx="26" cy="6" r="6" fill="#FFBD2E" stroke="#DEA123" stroke-width=".5"></circle><circle cx="46" cy="6" r="6" fill="#27C93F" stroke="#1AAB29" stroke-width=".5"></circle></g></svg></span><span role="button" tabindex="0" data-code="bool verificar_pacote_uart(uint8_t *pacote, uint8_t tamanho_total) {
    if (pacote[0] != 0xAA) return false;

    uint16_t crc_recebido = (pacote[tamanho_total - 2] << 8) |
                            (pacote[tamanho_total - 1]);

    uint16_t crc_calculado = crc16_bitwise(pacote, tamanho_total - 2);

    return (crc_recebido == crc_calculado);
}
" style="color:#d8dee9ff;display:none" aria-label="Copy" class="code-block-pro-copy-button"><svg xmlns="http://www.w3.org/2000/svg" style="width:24px;height:24px" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2"><path class="with-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2m-6 9l2 2 4-4"></path><path class="without-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2"></path></svg></span><pre class="shiki nord" style="background-color: #2e3440ff" tabindex="0"><code><span class="line"><span style="color: #88C0D0">bool</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">verificar_pacote_uart</span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #81A1C1">*</span><span style="color: #A3BE8C">pacote,</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">tamanho_total</span><span style="color: #ECEFF4">)</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">{</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #81A1C1">if</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">pacote[0]</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">!=</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0xAA</span><span style="color: #ECEFF4">)</span><span style="color: #D8DEE9FF"> </span><span style="color: #81A1C1">return</span><span style="color: #D8DEE9FF"> false</span><span style="color: #81A1C1">;</span></span>
<span class="line"></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #88C0D0">uint16_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">crc_recebido</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> (pacote[tamanho_total </span><span style="color: #A3BE8C">-</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">2</span><span style="color: #A3BE8C">]</span><span style="color: #D8DEE9FF"> &lt;&lt; </span><span style="color: #B48EAD">8</span><span style="color: #D8DEE9FF">) </span><span style="color: #81A1C1">|</span></span>
<span class="line"><span style="color: #D8DEE9FF">                            </span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">pacote[tamanho_total</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">-</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">1</span><span style="color: #A3BE8C">]</span><span style="color: #ECEFF4">)</span><span style="color: #81A1C1">;</span></span>
<span class="line"></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #88C0D0">uint16_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">crc_calculado</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">crc16_bitwise</span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">pacote,</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">tamanho_total</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">-</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">2</span><span style="color: #ECEFF4">)</span><span style="color: #81A1C1">;</span></span>
<span class="line"></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #81A1C1">return</span><span style="color: #D8DEE9FF"> (crc_recebido </span><span style="color: #A3BE8C">==</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">crc_calculado</span><span style="color: #D8DEE9FF">)</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">}</span></span>
<span class="line"></span></code></pre></div>



<p class="wp-block-paragraph">Este método permite que o receptor descarte imediatamente pacotes inválidos, evitando interpretar dados corrompidos ou acionar comandos incorretos.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Integração com SPI e I2C</h3>



<p class="wp-block-paragraph">Em protocolos síncronos como <strong>SPI</strong> e <strong>I2C</strong>, o CRC pode ser aplicado da mesma forma. A diferença está no controle de fluxos e timeouts, que devem ser tratados separadamente.</p>



<p class="wp-block-paragraph">Exemplo: ao enviar 16 bytes via I2C com um <strong>checksum final</strong>, o receptor pode calcular o checksum local e compará-lo assim que a transferência for concluída.</p>



<p class="wp-block-paragraph">Para I2C, o cálculo pode ser feito no <code>HAL_I2C_SlaveRxCpltCallback()</code> e o pacote rejeitado se inválido.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Detecção e Reação a Erros</h3>



<p class="wp-block-paragraph">Após detectar um erro, o receptor pode:</p>



<ul class="wp-block-list">
<li><strong>Descartar o pacote</strong> silenciosamente (modo passivo).</li>



<li><strong>Solicitar retransmissão</strong> (modo ativo, usando ACK/NACK).</li>



<li><strong>Acionar mecanismos de segurança</strong> (desabilitar hardware, resetar canal).</li>
</ul>



<p class="wp-block-paragraph">Em sistemas críticos (ex: controle de motor ou comandos de parada de emergência), a <strong>resposta ao erro</strong> é tão importante quanto a detecção em si.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Aplicação em Protocolos Existentes</h3>



<figure class="wp-block-table"><table class="has-fixed-layout"><thead><tr><th>Protocolo</th><th>Tipo de verificação usado</th></tr></thead><tbody><tr><td><strong>Modbus RTU</strong></td><td>CRC-16 (0x8005)</td></tr><tr><td><strong>CAN</strong></td><td>CRC-15 (hardware)</td></tr><tr><td><strong>USB</strong></td><td>CRC-5, CRC-16 (em hardware)</td></tr><tr><td><strong>Ethernet</strong></td><td>CRC-32 (em hardware)</td></tr><tr><td><strong>UART custom</strong></td><td>Checksum simples ou CRC-16</td></tr></tbody></table></figure>



<p class="wp-block-paragraph">O conhecimento de CRC permite implementar protocolos <strong>customizados</strong> ou depurar protocolos padrão com precisão.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h2 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4d8.png" alt="📘" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Capítulo 8 – Casos de Estudo e Testes</h2>



<p class="wp-block-paragraph">Neste capítulo, aplicamos os conceitos de checksum e CRC em cenários reais de comunicação entre microcontroladores, usando ferramentas de debug como osciloscópios, analisadores lógicos e UARTs em modo de diagnóstico. O objetivo é demonstrar como validar a transmissão de dados, localizar erros e garantir a integridade das mensagens trocadas entre dispositivos.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Estudo de Caso: Comunicação entre Dois STM32 via UART</h3>



<h4 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f3af.png" alt="🎯" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Objetivo</h4>



<p class="wp-block-paragraph">Transmitir um pacote com dados simulados de sensor entre dois microcontroladores <strong>STM32</strong>, usando <strong>CRC-16</strong> para verificação de integridade.</p>



<h4 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f9f1.png" alt="🧱" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Configuração do pacote:</h4>



<figure class="wp-block-table"><table class="has-fixed-layout"><thead><tr><th>Campo</th><th>Tamanho</th><th>Descrição</th></tr></thead><tbody><tr><td>Header</td><td>1 byte</td><td><code>0xAA</code></td></tr><tr><td>ID</td><td>1 byte</td><td><code>0x01</code></td></tr><tr><td>Dados</td><td>4 bytes</td><td>Ex: temperatura, etc.</td></tr><tr><td>CRC</td><td>2 bytes</td><td>CRC-16-IBM</td></tr></tbody></table></figure>



<h4 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4df.png" alt="📟" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Código do Transmissor (STM32 HAL):</h4>



<div class="wp-block-kevinbatdorf-code-block-pro" data-code-block-pro-font-family="Code-Pro-JetBrains-Mono" style="font-size:.875rem;font-family:Code-Pro-JetBrains-Mono,ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,monospace;line-height:1.25rem;--cbp-tab-width:2;tab-size:var(--cbp-tab-width, 2)"><span style="display:block;padding:16px 0 0 16px;margin-bottom:-1px;width:100%;text-align:left;background-color:#2e3440ff"><svg xmlns="http://www.w3.org/2000/svg" width="54" height="14" viewBox="0 0 54 14"><g fill="none" fill-rule="evenodd" transform="translate(1 1)"><circle cx="6" cy="6" r="6" fill="#FF5F56" stroke="#E0443E" stroke-width=".5"></circle><circle cx="26" cy="6" r="6" fill="#FFBD2E" stroke="#DEA123" stroke-width=".5"></circle><circle cx="46" cy="6" r="6" fill="#27C93F" stroke="#1AAB29" stroke-width=".5"></circle></g></svg></span><span role="button" tabindex="0" data-code="uint8_t dados[] = { 0xAA, 0x01, 0x10, 0x20, 0x30, 0x40 };
uint16_t crc = crc16_bitwise(dados, 6);
dados[6] = crc &gt;&gt; 8;
dados[7] = crc &amp; 0xFF;

HAL_UART_Transmit(&amp;huart1, dados, 8, HAL_MAX_DELAY);
" style="color:#d8dee9ff;display:none" aria-label="Copy" class="code-block-pro-copy-button"><svg xmlns="http://www.w3.org/2000/svg" style="width:24px;height:24px" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2"><path class="with-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2m-6 9l2 2 4-4"></path><path class="without-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2"></path></svg></span><pre class="shiki nord" style="background-color: #2e3440ff" tabindex="0"><code><span class="line"><span style="color: #88C0D0">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">dados[]</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">{</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0xAA</span><span style="color: #A3BE8C">,</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0x01</span><span style="color: #A3BE8C">,</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0x10</span><span style="color: #A3BE8C">,</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0x20</span><span style="color: #A3BE8C">,</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0x30</span><span style="color: #A3BE8C">,</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0x40</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">}</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #88C0D0">uint16_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">crc</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">crc16_bitwise</span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">dados,</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">6</span><span style="color: #ECEFF4">)</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #88C0D0">dados[6]</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">crc</span><span style="color: #D8DEE9FF"> </span><span style="color: #81A1C1">&gt;&gt;</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">8</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #88C0D0">dados[7]</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">crc</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">&amp;</span><span style="color: #D8DEE9FF"> </span><span style="color: #88C0D0">0xFF</span><span style="color: #81A1C1">;</span></span>
<span class="line"></span>
<span class="line"><span style="color: #88C0D0">HAL_UART_Transmit(</span><span style="color: #ECEFF4">&amp;</span><span style="color: #88C0D0">huart1,</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">dados,</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">8</span><span style="color: #A3BE8C">,</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">HAL_MAX_DELAY</span><span style="color: #D8DEE9FF">)</span><span style="color: #81A1C1">;</span></span>
<span class="line"></span></code></pre></div>



<h4 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4df.png" alt="📟" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Código do Receptor:</h4>



<div class="wp-block-kevinbatdorf-code-block-pro" data-code-block-pro-font-family="Code-Pro-JetBrains-Mono" style="font-size:.875rem;font-family:Code-Pro-JetBrains-Mono,ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,monospace;line-height:1.25rem;--cbp-tab-width:2;tab-size:var(--cbp-tab-width, 2)"><span style="display:block;padding:16px 0 0 16px;margin-bottom:-1px;width:100%;text-align:left;background-color:#2e3440ff"><svg xmlns="http://www.w3.org/2000/svg" width="54" height="14" viewBox="0 0 54 14"><g fill="none" fill-rule="evenodd" transform="translate(1 1)"><circle cx="6" cy="6" r="6" fill="#FF5F56" stroke="#E0443E" stroke-width=".5"></circle><circle cx="26" cy="6" r="6" fill="#FFBD2E" stroke="#DEA123" stroke-width=".5"></circle><circle cx="46" cy="6" r="6" fill="#27C93F" stroke="#1AAB29" stroke-width=".5"></circle></g></svg></span><span role="button" tabindex="0" data-code="uint8_t buffer[8];
HAL_UART_Receive(&amp;huart2, buffer, 8, HAL_MAX_DELAY);

if (verificar_pacote_uart(buffer, 8)) {
    // Dados válidos: processar
} else {
    // Erro detectado: rejeitar pacote
}
" style="color:#d8dee9ff;display:none" aria-label="Copy" class="code-block-pro-copy-button"><svg xmlns="http://www.w3.org/2000/svg" style="width:24px;height:24px" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2"><path class="with-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2m-6 9l2 2 4-4"></path><path class="without-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2"></path></svg></span><pre class="shiki nord" style="background-color: #2e3440ff" tabindex="0"><code><span class="line"><span style="color: #88C0D0">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">buffer[</span><span style="color: #B48EAD">8</span><span style="color: #A3BE8C">]</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #88C0D0">HAL_UART_Receive(</span><span style="color: #ECEFF4">&amp;</span><span style="color: #88C0D0">huart2,</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">buffer,</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">8</span><span style="color: #A3BE8C">,</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">HAL_MAX_DELAY</span><span style="color: #D8DEE9FF">)</span><span style="color: #81A1C1">;</span></span>
<span class="line"></span>
<span class="line"><span style="color: #81A1C1">if</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">verificar_pacote_uart(buffer,</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">8</span><span style="color: #ECEFF4">)</span><span style="color: #D8DEE9FF">) </span><span style="color: #ECEFF4">{</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #88C0D0">//</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">Dados</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">válidos:</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">processar</span></span>
<span class="line"><span style="color: #ECEFF4">}</span><span style="color: #D8DEE9FF"> </span><span style="color: #81A1C1">else</span><span style="color: #D8DEE9FF"> </span><span style="color: #ECEFF4">{</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #88C0D0">//</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">Erro</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">detectado:</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">rejeitar</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">pacote</span></span>
<span class="line"><span style="color: #ECEFF4">}</span></span>
<span class="line"></span></code></pre></div>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Verificação com Analisador Lógico</h3>



<p class="wp-block-paragraph">Conectando um <strong>analisador lógico</strong> (como Saleae Logic) aos pinos TX/RX, podemos:</p>



<ul class="wp-block-list">
<li>Visualizar o conteúdo de cada byte</li>



<li>Comparar o CRC enviado com o CRC esperado</li>



<li>Confirmar se houve falha de transmissão ou erro de sincronismo</li>
</ul>



<p class="wp-block-paragraph"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4a1.png" alt="💡" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Utilize <strong>marcação de tempo com pino GPIO</strong> para registrar o momento de recepção e depuração:</p>



<div class="wp-block-kevinbatdorf-code-block-pro" data-code-block-pro-font-family="Code-Pro-JetBrains-Mono" style="font-size:.875rem;font-family:Code-Pro-JetBrains-Mono,ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,monospace;line-height:1.25rem;--cbp-tab-width:2;tab-size:var(--cbp-tab-width, 2)"><span style="display:block;padding:16px 0 0 16px;margin-bottom:-1px;width:100%;text-align:left;background-color:#2e3440ff"><svg xmlns="http://www.w3.org/2000/svg" width="54" height="14" viewBox="0 0 54 14"><g fill="none" fill-rule="evenodd" transform="translate(1 1)"><circle cx="6" cy="6" r="6" fill="#FF5F56" stroke="#E0443E" stroke-width=".5"></circle><circle cx="26" cy="6" r="6" fill="#FFBD2E" stroke="#DEA123" stroke-width=".5"></circle><circle cx="46" cy="6" r="6" fill="#27C93F" stroke="#1AAB29" stroke-width=".5"></circle></g></svg></span><span role="button" tabindex="0" data-code="HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_SET);   // início
verificar_pacote_uart(buffer, 8);
HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_RESET); // fim
" style="color:#d8dee9ff;display:none" aria-label="Copy" class="code-block-pro-copy-button"><svg xmlns="http://www.w3.org/2000/svg" style="width:24px;height:24px" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2"><path class="with-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2m-6 9l2 2 4-4"></path><path class="without-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2"></path></svg></span><pre class="shiki nord" style="background-color: #2e3440ff" tabindex="0"><code><span class="line"><span style="color: #88C0D0">HAL_GPIO_WritePin(GPIOB,</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">GPIO_PIN_0,</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">GPIO_PIN_SET</span><span style="color: #D8DEE9FF">)</span><span style="color: #81A1C1">;</span><span style="color: #D8DEE9FF">   </span><span style="color: #88C0D0">//</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">início</span></span>
<span class="line"><span style="color: #88C0D0">verificar_pacote_uart(buffer,</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">8</span><span style="color: #D8DEE9FF">)</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #88C0D0">HAL_GPIO_WritePin(GPIOB,</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">GPIO_PIN_0,</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">GPIO_PIN_RESET</span><span style="color: #D8DEE9FF">)</span><span style="color: #81A1C1">;</span><span style="color: #D8DEE9FF"> </span><span style="color: #88C0D0">//</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">fim</span></span>
<span class="line"></span></code></pre></div>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Injeção de Erros para Testes</h3>



<p class="wp-block-paragraph">Para verificar a robustez da verificação, pode-se <strong>forçar erros</strong> intencionais:</p>



<div class="wp-block-kevinbatdorf-code-block-pro" data-code-block-pro-font-family="Code-Pro-JetBrains-Mono" style="font-size:.875rem;font-family:Code-Pro-JetBrains-Mono,ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,monospace;line-height:1.25rem;--cbp-tab-width:2;tab-size:var(--cbp-tab-width, 2)"><span style="display:block;padding:16px 0 0 16px;margin-bottom:-1px;width:100%;text-align:left;background-color:#2e3440ff"><svg xmlns="http://www.w3.org/2000/svg" width="54" height="14" viewBox="0 0 54 14"><g fill="none" fill-rule="evenodd" transform="translate(1 1)"><circle cx="6" cy="6" r="6" fill="#FF5F56" stroke="#E0443E" stroke-width=".5"></circle><circle cx="26" cy="6" r="6" fill="#FFBD2E" stroke="#DEA123" stroke-width=".5"></circle><circle cx="46" cy="6" r="6" fill="#27C93F" stroke="#1AAB29" stroke-width=".5"></circle></g></svg></span><span role="button" tabindex="0" data-code="buffer[3] ^= 0xFF;  // inverte um byte do meio
" style="color:#d8dee9ff;display:none" aria-label="Copy" class="code-block-pro-copy-button"><svg xmlns="http://www.w3.org/2000/svg" style="width:24px;height:24px" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2"><path class="with-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2m-6 9l2 2 4-4"></path><path class="without-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2"></path></svg></span><pre class="shiki nord" style="background-color: #2e3440ff" tabindex="0"><code><span class="line"><span style="color: #88C0D0">buffer[3]</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">^=</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0xFF</span><span style="color: #81A1C1">;</span><span style="color: #D8DEE9FF">  </span><span style="color: #88C0D0">//</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">inverte</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">um</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">byte</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">do</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">meio</span></span>
<span class="line"></span></code></pre></div>



<p class="wp-block-paragraph">O sistema deve rejeitar esse pacote com erro de CRC.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Exemplo com SPI</h3>



<p class="wp-block-paragraph">No caso de comunicação <strong>SPI entre um mestre e um escravo</strong>, o cálculo do CRC pode ser incluído no final do frame de envio. O escravo valida o CRC antes de processar o comando:</p>



<div class="wp-block-kevinbatdorf-code-block-pro" data-code-block-pro-font-family="Code-Pro-JetBrains-Mono" style="font-size:.875rem;font-family:Code-Pro-JetBrains-Mono,ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,monospace;line-height:1.25rem;--cbp-tab-width:2;tab-size:var(--cbp-tab-width, 2)"><span style="display:block;padding:16px 0 0 16px;margin-bottom:-1px;width:100%;text-align:left;background-color:#2e3440ff"><svg xmlns="http://www.w3.org/2000/svg" width="54" height="14" viewBox="0 0 54 14"><g fill="none" fill-rule="evenodd" transform="translate(1 1)"><circle cx="6" cy="6" r="6" fill="#FF5F56" stroke="#E0443E" stroke-width=".5"></circle><circle cx="26" cy="6" r="6" fill="#FFBD2E" stroke="#DEA123" stroke-width=".5"></circle><circle cx="46" cy="6" r="6" fill="#27C93F" stroke="#1AAB29" stroke-width=".5"></circle></g></svg></span><span role="button" tabindex="0" data-code="// Transmissão SPI: [CMD][DATA][CRC_H][CRC_L]
" style="color:#d8dee9ff;display:none" aria-label="Copy" class="code-block-pro-copy-button"><svg xmlns="http://www.w3.org/2000/svg" style="width:24px;height:24px" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2"><path class="with-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2m-6 9l2 2 4-4"></path><path class="without-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2"></path></svg></span><pre class="shiki nord" style="background-color: #2e3440ff" tabindex="0"><code><span class="line"><span style="color: #88C0D0">//</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">Transmissão</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">SPI:</span><span style="color: #D8DEE9FF"> [CMD]</span><span style="color: #ECEFF4">[</span><span style="color: #D8DEE9FF">DATA</span><span style="color: #ECEFF4">][</span><span style="color: #D8DEE9FF">CRC_H</span><span style="color: #ECEFF4">][</span><span style="color: #D8DEE9FF">CRC_L</span><span style="color: #ECEFF4">]</span></span>
<span class="line"></span></code></pre></div>



<p class="wp-block-paragraph">O mestre calcula o CRC e transmite; o escravo recalcula com os dados recebidos e compara.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Diagnóstico via UART Debug</h3>



<p class="wp-block-paragraph">Para microcontroladores que não possuem analisador lógico, é possível <strong>logar os valores de CRC</strong> via uma UART secundária:</p>



<div class="wp-block-kevinbatdorf-code-block-pro" data-code-block-pro-font-family="Code-Pro-JetBrains-Mono" style="font-size:.875rem;font-family:Code-Pro-JetBrains-Mono,ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,monospace;line-height:1.25rem;--cbp-tab-width:2;tab-size:var(--cbp-tab-width, 2)"><span style="display:block;padding:16px 0 0 16px;margin-bottom:-1px;width:100%;text-align:left;background-color:#2e3440ff"><svg xmlns="http://www.w3.org/2000/svg" width="54" height="14" viewBox="0 0 54 14"><g fill="none" fill-rule="evenodd" transform="translate(1 1)"><circle cx="6" cy="6" r="6" fill="#FF5F56" stroke="#E0443E" stroke-width=".5"></circle><circle cx="26" cy="6" r="6" fill="#FFBD2E" stroke="#DEA123" stroke-width=".5"></circle><circle cx="46" cy="6" r="6" fill="#27C93F" stroke="#1AAB29" stroke-width=".5"></circle></g></svg></span><span role="button" tabindex="0" data-code="printf(&quot;CRC calculado: 0x%04X\n&quot;, crc_calculado);
printf(&quot;CRC recebido:  0x%04X\n&quot;, crc_recebido);
" style="color:#d8dee9ff;display:none" aria-label="Copy" class="code-block-pro-copy-button"><svg xmlns="http://www.w3.org/2000/svg" style="width:24px;height:24px" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2"><path class="with-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2m-6 9l2 2 4-4"></path><path class="without-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2"></path></svg></span><pre class="shiki nord" style="background-color: #2e3440ff" tabindex="0"><code><span class="line"><span style="color: #88C0D0">printf</span><span style="color: #D8DEE9FF">(</span><span style="color: #88C0D0">&quot;CRC calculado: 0x%04X\n&quot;</span><span style="color: #88C0D0">,</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">crc_calculado</span><span style="color: #D8DEE9FF">)</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #88C0D0">printf</span><span style="color: #D8DEE9FF">(</span><span style="color: #88C0D0">&quot;CRC recebido:  0x%04X\n&quot;</span><span style="color: #88C0D0">,</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">crc_recebido</span><span style="color: #D8DEE9FF">)</span><span style="color: #81A1C1">;</span></span>
<span class="line"></span></code></pre></div>



<p class="wp-block-paragraph">Essa técnica é extremamente útil durante testes de integração.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Conclusões dos Testes</h3>



<ul class="wp-block-list">
<li><strong>Verificações de CRC são determinísticas e confiáveis</strong></li>



<li>Erros comuns são facilmente detectados (bit flip, byte omitido, byte extra)</li>



<li>A implementação correta exige atenção a <strong>ordem dos bytes</strong> e <strong>inicialização do CRC</strong></li>



<li>Em sistemas críticos, os testes de injeção de falhas são obrigatórios</li>
</ul>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h2 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4d8.png" alt="📘" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Capítulo 9 – Considerações Finais</h2>



<p class="wp-block-paragraph">Ao longo deste tutorial, percorremos desde os conceitos mais básicos de verificação de integridade até implementações robustas e testadas de <strong>checksum</strong> e <strong>CRC</strong> em sistemas embarcados. Com isso, fica claro que garantir a integridade dos dados em comunicação entre microcontroladores <strong>não é uma opção</strong>, mas uma <strong>exigência fundamental</strong> para a confiabilidade de qualquer sistema crítico.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Recomendações de Projeto</h3>



<ol class="wp-block-list">
<li><strong>Escolha o algoritmo conforme o risco e o custo do erro</strong>:
<ul class="wp-block-list">
<li>Checksum simples é aceitável em links de baixa taxa e com baixo risco.</li>



<li>CRC-8 é excelente para sensores e barramentos curtos (I2C, UART).</li>



<li>CRC-16 é adequado para protocolos robustos como Modbus, SPI industriais.</li>



<li>CRC-32 deve ser considerado em transferências de firmware ou redes.</li>
</ul>
</li>



<li><strong>Evite reinvenções</strong>: use algoritmos padronizados sempre que possível (ex: CRC-16-IBM, CRC-CCITT, CRC-32 IEEE).</li>



<li><strong>Teste seu algoritmo com vetores conhecidos</strong>: use ferramentas como <a href="https://reveng.sourceforge.io/">reveng</a> ou geradores online de CRC para validar sua implementação.</li>



<li><strong>Documente as configurações do CRC</strong>:
<ul class="wp-block-list">
<li>Polinômio utilizado</li>



<li>Valor inicial (seed)</li>



<li>Inversão de entrada/saída (refin, refout)</li>



<li>XOR final</li>
</ul>
</li>
</ol>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Automatização de Testes</h3>



<p class="wp-block-paragraph">É recomendável incorporar testes automatizados no seu projeto para validar transmissões com e sem erro. Por exemplo:</p>



<div class="wp-block-kevinbatdorf-code-block-pro" data-code-block-pro-font-family="Code-Pro-JetBrains-Mono" style="font-size:.875rem;font-family:Code-Pro-JetBrains-Mono,ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,monospace;line-height:1.25rem;--cbp-tab-width:2;tab-size:var(--cbp-tab-width, 2)"><span style="display:block;padding:16px 0 0 16px;margin-bottom:-1px;width:100%;text-align:left;background-color:#2e3440ff"><svg xmlns="http://www.w3.org/2000/svg" width="54" height="14" viewBox="0 0 54 14"><g fill="none" fill-rule="evenodd" transform="translate(1 1)"><circle cx="6" cy="6" r="6" fill="#FF5F56" stroke="#E0443E" stroke-width=".5"></circle><circle cx="26" cy="6" r="6" fill="#FFBD2E" stroke="#DEA123" stroke-width=".5"></circle><circle cx="46" cy="6" r="6" fill="#27C93F" stroke="#1AAB29" stroke-width=".5"></circle></g></svg></span><span role="button" tabindex="0" data-code="void teste_crc(void) {
    uint8_t dado[] = { 0x01, 0x02, 0x03 };
    uint16_t crc = crc16_bitwise(dado, 3);
    assert(crc == 0xXXXX); // valor esperado
}
" style="color:#d8dee9ff;display:none" aria-label="Copy" class="code-block-pro-copy-button"><svg xmlns="http://www.w3.org/2000/svg" style="width:24px;height:24px" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2"><path class="with-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2m-6 9l2 2 4-4"></path><path class="without-check" stroke-linecap="round" stroke-linejoin="round" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2"></path></svg></span><pre class="shiki nord" style="background-color: #2e3440ff" tabindex="0"><code><span class="line"><span style="color: #88C0D0">void</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">teste_crc</span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">void</span><span style="color: #ECEFF4">)</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">{</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #88C0D0">uint8_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">dado[]</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">{</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0x01</span><span style="color: #A3BE8C">,</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0x02</span><span style="color: #A3BE8C">,</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0x03</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">}</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #88C0D0">uint16_t</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">crc</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">=</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">crc16_bitwise</span><span style="color: #ECEFF4">(</span><span style="color: #88C0D0">dado,</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">3</span><span style="color: #ECEFF4">)</span><span style="color: #81A1C1">;</span></span>
<span class="line"><span style="color: #D8DEE9FF">    </span><span style="color: #88C0D0">assert(crc</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">==</span><span style="color: #D8DEE9FF"> </span><span style="color: #B48EAD">0</span><span style="color: #A3BE8C">xXXXX</span><span style="color: #D8DEE9FF">)</span><span style="color: #81A1C1">;</span><span style="color: #D8DEE9FF"> </span><span style="color: #88C0D0">//</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">valor</span><span style="color: #D8DEE9FF"> </span><span style="color: #A3BE8C">esperado</span></span>
<span class="line"><span style="color: #D8DEE9FF">}</span></span>
<span class="line"></span></code></pre></div>



<p class="wp-block-paragraph">Frameworks como <strong>Unity (C)</strong> ou <strong>Ceedling</strong> são boas opções para testes automatizados em ambientes embarcados.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Alternativas Avançadas</h3>



<p class="wp-block-paragraph">Se o projeto exige ainda mais confiabilidade, considere algoritmos que <strong>detectam e corrigem erros</strong>, como:</p>



<ul class="wp-block-list">
<li><strong>Código de Hamming</strong>: permite correção de 1 bit e detecção de 2.</li>



<li><strong>Reed-Solomon</strong>: usado em CDs, QR codes, comunicação por rádio e memória NAND.</li>



<li><strong>CRC com hardware</strong>: presente em muitos MCUs modernos, acelera o processo com confiabilidade industrial.</li>
</ul>



<p class="wp-block-paragraph">Essas técnicas requerem mais memória e CPU, mas são fundamentais em <strong>sistemas médicos, aeroespaciais, automotivos</strong> ou com comunicação de longa distância.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f4cc.png" alt="📌" class="wp-smiley" style="height: 1em; max-height: 1em;" /> Fechamento</h3>



<p class="wp-block-paragraph">O uso adequado de checksums e CRCs eleva o seu projeto de &#8220;funcional&#8221; a <strong>confiável e seguro</strong>, protegendo contra ruídos, falhas de hardware e bugs silenciosos que poderiam comprometer sua aplicação. O conhecimento e implementação criteriosa dessas técnicas fazem parte da <strong>caixa de ferramentas essencial de qualquer desenvolvedor de sistemas embarcados</strong>.</p>



<p class="wp-block-paragraph">Este tutorial oferece a base prática e teórica para que você aplique, teste e refine algoritmos de verificação de integridade com confiança.</p>



<hr class="wp-block-separator has-alpha-channel-opacity"/><p>The post <a href="https://mcu.tec.br/algoritimos/como-calcular-crc-e-checksum-em-c-para-comunicacao-entre-microcontroladores/">Como Calcular CRC e Checksum em C para Comunicação entre Microcontroladores</a> first appeared on <a href="https://mcu.tec.br">MCU & FPGA</a>.</p>]]></content:encoded>
					
		
		
		<post-id xmlns="com-wordpress:feed-additions:1">308</post-id>	</item>
	</channel>
</rss>
