¿Cuál es la motivación para usar Verilog o VHDL sobre C?

¿Cuál es la motivación para usar lenguajes de descripción de hardware (HDL) como Verilog y VHDL sobre lenguajes de programación como C o algún ensamblador?

C y ensamblador son buenos lenguajes para decirle a una CPU qué hacer. Describen acciones que debe realizar secuencialmente una sola máquina de estado.

Los HDL son buenos lenguajes para describir o definir una colección arbitraria de circuitos digitales. Pueden expresar operaciones realizadas en paralelo de formas que los lenguajes de programación no pueden. También pueden describir limitaciones de tiempo para las interfaces entre bloques de formas que los lenguajes de programación no pueden.

Me sorprendió ver discusiones expresando dudas sobre si escribir firmware en C o ensamblado (¿cómo es apropiado ensamblar si no necesariamente tiene una CPU?)

En esa pregunta, lo que se pregunta es: "Si está escribiendo código para un microcontrolador, ¿existe una diferencia real si escribe en ensamblador o C o algún otro lenguaje de alto nivel?".

Dado que está preguntando específicamente acerca de los sistemas con un microcontrolador (una CPU con periféricos), C o ensamblaje son opciones razonables para el desarrollo de firwmare, y los HDL no lo son.

¿Un firmware realmente se puede escribir en HDL o en un lenguaje de programación de software, o es solo otra forma de realizar la misma misión?

Depende del tipo de hardware que tengas. Si tiene una CPU, use un lenguaje de programación. Si tiene un FPGA o está diseñando un ASIC, use un HDL. Si está diseñando una gran cantidad de lógica digital, puede buscar uno de los lenguajes intermedios como SystemVerilog.

He leído que el firmware se quema principalmente en ROM o flash. ¿Cómo se representa allí? En bits, como software? Si es así, ¿cuál es la profunda diferencia? ¿Es la disponibilidad de circuitos adaptados en el caso del firmware?

Creo que te estás obsesionando con el término "firmware". Esta palabra originalmente significaba que el código se ejecutaría en un sistema integrado, que no era accesible para que el usuario final lo cambiara. Si le vende a alguien una PC, existe una gran posibilidad de que el usuario cambie el software que se ejecuta en ella. Si les vendiera un osciloscopio, no querría que cambiaran el código que se ejecuta en el microprocesador interno, por lo que lo llamó firmware.

Los usuarios de FPGA se apropiaron de la palabra "firmware" para la salida de sus diseños, porque es más cambiante que el hardware (cosas que se sueldan entre sí). Pero realmente el "firmware" que configura una FPGA es diferente del "firmware" que corre en una uC. El firmware del uC dirige el uC a través de una serie de estados para realizar su función. El firmware de FPGA define un conjunto de interconexiones entre elementos lógicos y valores que se almacenarán en tablas de búsqueda.

En cualquier caso, el firmware generalmente se almacena como bits en una eeprom (o en un disco en una máquina host que lo descargará cada vez que se reinicie el sistema integrado). Pero eso no los hace similares entre sí.

Para la primera parte de su pregunta, sobre las motivaciones de usar uno u otro: hay una diferencia fundamental entre C y HDL (VHDL/Verilog) . C es un lenguaje de programación de software (como lo es ensamblador), VHDL/Verilog son lenguajes de descripción de hardware . No están destinados al mismo propósito.

C se traduce a código ensamblador (en su forma binaria, es decir, lenguaje de máquina) cuando se compila . Este código es una serie de instrucciones que le indican a la CPU que realice una serie de operaciones básicas (cambiar el valor de un registro, realizar una suma, etc.).

Por otro lado, un HDL se sintetiza en hardware. En VHDL podría, por ejemplo, escribir algo como:

output <= input1 + input2;

(ver también un ejemplo más completo aquí ). Esto se sintetizaría en un sumador (de hardware). Si el código se sintetiza para un FPGA , esto significaría un flujo de bits que puede configurar el FPGA específico para implementar un sumador (como lógica combinacional ).

En realidad, podría diseñar una CPU en VHDL (ver Procesadores de núcleo blando VS Procesadores de núcleo duro ) y escribir el software en C...

Sobre el firmware: en realidad todo depende de cómo definas la palabra. Un firmware puede ser un programa (software) que se ejecuta en un microcontrolador (por ejemplo, escrito en C o ensamblador), o puede ser un flujo de bits para configurar un dispositivo lógico programable (hardware) (CPLD o FPGA). A veces puede ser un paquete que contiene ambos: si toma el firmware de algunos modelos de FritzBox (un módem ADSL), en realidad contienen un sistema Linux completo (escrito en ensamblador, C y muchos otros lenguajes de programación) y un flujo de bits para configurar un FPGA (probablemente sintetizado de VHDL o Verilog).

VHDL y Verilog son más adecuados para describir la concurrencia de hardware

Los electrones pueden fluir al mismo tiempo en cables paralelos, por lo que queremos tener eso en cuenta al diseñar el hardware.

En VHDL, si escribe algo como:

x <= a or b;
y <= a and b;
z <= x xor y;

(fuera de a processo function, que lo marca explícitamente como secuencial), entonces ha codificado el hecho de que:

• x, y, zy son acablesb
• ay bson señales de entrada
• xestá conectado a la salida de un orcircuito, que toma ay bcomo entrada
• y así sucesivamente para las otras líneas

Es fácil ver cómo se sintetizará en hardware real xy yse evaluará al mismo tiempo.

        +-----+
A--+----+     |  X
   |    | OR  +-----+
B----+--+     |     |  +-----+
   | |  +-----+     +--+     |
   | |                 | XOR +-- Z
   | |  +-----+     +--+     |
   | +--+     |  Y  |  +-----+
   |    | AND +-----+
   +----+     |
        +-----+

Luego, cuando llega el momento de simular el circuito, el simulador (que suele ser un programa secuencial) simula la física del circuito de la siguiente manera:

• ha ao ha bcambiado? ¿Sí? Hola, xdepende de a. Actualicemos x_
• ytambién depende de a. Actualiza eso también.
• zdepende xde Actualízalo porque xse actualizó.
• ¿Se ha actualizado algo que xdependa de ( ao )? b¿No? Lo mismo para yy z. OK, hemos terminado con este paso.

Esto conduce a posibles resultados "interesantes" que no tienen un análogo secuencial, pero que representan posibles situaciones físicas:

• x <= not xconduciría a una recursión infinita de la simulación. Los simuladores pueden simplemente cortarse después de cierta profundidad.
• x <= 0; x <= 1conduce a un error (cortocircuito). Esta es una de las razones por las que std_logicexiste.

Aún así, a pesar de que VHDL modela el hardware más de cerca que C, no es en sí mismo una descripción perfectamente detallada del mismo:

• solo un subconjunto de VHDL en sintetizable
• se realizan muchas simplificaciones físicas, en particular que las señales se propagan infinitamente rápido, consulte https://en.wikipedia.org/wiki/Static_timing_analysis TODO tal vez sea posible modelar retrasos en Verilog: http://www.asic-world.com /verilog/gate3.html#Gate_and_Switch_delays

Al final, VHDL proporciona un buen equilibrio entre la funcionalidad del circuito comprensible por humanos de nivel superior y la capacidad de síntesis de nivel inferior.

C, por otro lado, está más enfocado en hablar con la CPU secuencialmente.

Por supuesto, podría codificar un circuito con estructuras C, enumeraciones y matrices, y luego simularlo como lo hace VHDL (esto se parece más o menos a lo que hace el Sistema C , pero nunca lo he probado).

Pero esencialmente estaría reimplementando un simulador VHDL y con un lenguaje más detallado. La herramienta correcta para el trabajo correcto, supongo.

También hay herramientas que convierten C a VHDL https://stackoverflow.com/questions/8988629/can-you-program-fpgas-in-c-like-languages ​​pero esperan un rendimiento más bajo ya que son conversiones difíciles de nivel superior.

1. Depende de tu arquitectura. Si tiene una CPU (o, por lo general, un microcontrolador), debe escribir el firmware en un lenguaje de programación normal (incluido el ensamblaje). Si tiene algo como un FPGA, su firmware debe estar escrito en un HDL. Los HDL no pueden (que yo sepa) generar programas que puedan ser ejecutados eficientemente por una CPU convencional, y un FPGA no ejecuta programas convencionales listos para usar. Sin embargo, podría configurar su FPGA como una CPU y luego ejecutar un programa convencional con eso. Esto requeriría dos capas de firmware, la capa inferior escrita en un HDL para construir la CPU y la capa superior escrita en un lenguaje de programación convencional para ejecutarse en esa CPU.
2. No hay una distinción clara entre firmware y software. En muchos dispositivos, el firmware se almacenaría, por ejemplo, en la memoria flash, pero en un teléfono moderno, casi todo se almacena en la memoria flash, y la distinción entre firmware y software no está clara (la mayoría de la gente probablemente consideraría el código para programar el firmware del procesador de banda base). , y la mayoría de la gente consideraría software de programas de aplicación, pero ¿dónde está el límite exacto?).
3. Como dije en 2, no hay una distinción clara, aparte de la idea de que el firmware es un poco más permanente.

Los HDL se utilizan para describir (sintetizar) el hardware, mientras que el lenguaje de programación se utiliza para programar el hardware ya sintetizado, es decir, la CPU.

Puede obtener versiones de núcleo suave de cpus como VHDL o flujo de bits para sintetizar esa cpu en un FPGA.

Vale la pena mencionar un poco de historia. En las décadas de 1970 y 1980, los microcontroladores todavía eran algo raros y muchos sistemas digitales se diseñaron con circuitos integrados de lógica digital (74HC, etc.). Para ahorrar espacio y costos, se desarrollaron los lenguajes HDL. Se le ocurriría una función lógica y la piratearía en VHDL, luego grabaría un "PLD" con algún tipo de PROM a bordo. Con esto podrías reemplazar todos los circuitos integrados por uno solo.

Luego, en la década de 1990, los microcontroladores EPROM se volvieron más comunes y mucho más asequibles, lo que hizo que el uso de PLD de lógica digital se volviera cada vez más obsoleto. En la década de 2000, las MCU venían con memorias flash en chip que podían reprogramarse fácilmente (borrarse electrónicamente) y esto puso fin en su mayoría al uso de PLD.

El uso de lenguajes HDL se mantuvo, pero se trasladó a proyectos con FPGA especializados, que se usaban principalmente cuando tenía una producción de gran volumen o requisitos de consumo actuales o en tiempo real muy ajustados, por ejemplo, en dispositivos de telecomunicaciones. Sigue siendo así hoy, usará un FPGA cuando tenga requisitos especializados y no espere que la funcionalidad del producto cambie con el tiempo.

Hoy en día, los microcontroladores son ridículamente baratos y más potentes que nunca, por lo que los argumentos en tiempo real para usar FPGA se están volviendo cada vez más irrelevantes. También los SoC/ASIC que combinan núcleos de CPU programables con lógica digital en el mismo chip también son algo comunes, por lo que puede elegir lo que quiera de ambos mundos.

También en particular, la programación en el lenguaje C de "nivel alto" es mucho más compleja que el ensamblador o VHDL, por lo que requiere mucha más educación y experiencia del programador. Esta es una de las razones por las que muchas empresas se mantuvieron alejadas de C en la década de 1990: simplemente era difícil encontrar programadores de C que supieran lo que estaban haciendo y los compiladores de C eran de calidad muy diversa.

Un procesador usa una cantidad modesta de circuitos para realizar una gran cantidad de operaciones, secuencialmente, al permitir que la mayoría de los componentes se usen para realizar diferentes operaciones en diferentes momentos.

Un FPGA contiene una serie de circuitos que no pueden, al menos individualmente, realizar operaciones particularmente sofisticadas, pero todos son capaces de actuar de forma simultánea e independiente.

Supongamos que uno quiere tener un chip que realice una serie de tareas, entre las que se encuentra monitorear 15 entradas y:

• Establecer una salida alta cada vez que todas las entradas han sido estables durante al menos 21 ms y el número de entradas que son altas es un múltiplo de tres
• Establecer la salida baja cada vez que todas las entradas hayan estado estables durante al menos 21 ms y el número de entradas que son altas no sea un múltiplo de tres
• Cambiar la salida de manera arbitraria entre el momento en que cambia cualquier entrada y el momento en que todas las entradas se han mantenido estables durante al menos 20 ms.

Si uno tiene un microcontrolador que está haciendo otras cosas, pero puede dedicar algunos microsegundos cada 20 ms para examinar esas entradas y configurar la salida, entonces la mayoría de los circuitos que usa el microcontrolador para realizar otras tareas también se podrán usar para realizar la tarea indicada. anterior, por lo que será necesario dedicar muy pocos circuitos (aparte de algo de ROM y quizás RAM) a esa tarea. Por otro lado, puede pasar un tiempo entre el momento en que cambia una entrada y el momento en que la salida lo refleja correctamente.

Usando Verilog o VHDL, se podría construir un circuito de hardware que pudiera monitorear continuamente las 15 entradas y realizar el cálculo indicado. Tal dispositivo probablemente podría hacer que la salida produzca una indicación correcta dentro de los 100 ns, órdenes de magnitud más rápido que el microcontrolador, pero la cantidad de circuitos dedicados a esa tarea e inutilizables para cualquier otro propósito sería mucho mayor.