माई-एचडीएल (MyHDL)

माई-एचडीएल (MyHDL), पाइथन आधारित हार्डवेयर विवरण भाषा (HDL) है।

इस भाषा की कुछ प्रमुख विशेषताएँ ये हैं-
 इससे वीएचडीएल और वेरिलॉग दोनों भाषाओं में कोड निर्मित किया जा सकता है।
 इससे टेस्टबेन्च भी निर्मित किए जा सकते हैं। ) जिसमें टेस्ट-वेक्टर VHDL अथवा वेलिलॉग में हो सकते हैं।
 संकेतों की एक सूची को यह परिवर्तित कर सकता है।
 आउटपुट जाँच को भी रूपान्तरित (कन्वर्ट) कर सकता है। 
 यह वेरिलॉग के साथ सह-सिमुलेशन कर सकता है।
 इसमें एक उन्नत डेटाटाइप प्रणाली है जो पारम्परिक डेटा के प्रकारों से अलग है। माई-एचडीएल का अनुवाद करने वाला औजार स्वतः क्न्वर्शन-फंक्शन लिख देता है यदि लक्ष्य-भाषा को इसकी आवश्यकता होती है।

इसे जॉन डेकालुवे (Jan Decaluwe) ने विकसित किया है।

परिवर्तन के कुछ उदाहरण 

यहाँ माई-एचडीएल से वीएचडीएल तथा/या वेरिलॉग में बदलने के कुछ उदाहरण दिए गए हैं। 

एक छोटा सा संयोजी डिजाइन (combinatorial design)

The example is a small combinatorial design, more specifically the binary to Gray code converter:
def bin2gray(B, G, width):

    """ ग्रे इनकोडर

    B -- input intbv signal, binary encoded
    G -- output intbv signal, gray encoded
    width -- bit width

    """

    @always_comb
    def logic():
        Bext = intbv(0)[width+1:]
        Bext[:] = B
        for i in range(width):
            G.next[i] = Bext[i+1] ^ Bext[i]

    return logic

You can create an instance and convert to Verilog and VHDL as follows:
width = 8

B = Signal(intbv(0)[width:])
G = Signal(intbv(0)[width:])

bin2gray_inst = toVerilog(bin2gray, B, G, width)
bin2gray_inst = toVHDL(bin2gray, B, G, width)

इससे निर्मित वेरिलॉग कोड कुछ इस प्रकार का होता है-
module bin2gray (
    B,
    G
);

input [7:0] B;
output [7:0] G;
reg [7:0] G;

always @(B) begin: BIN2GRAY_LOGIC
    integer i;
    reg [9-1:0] Bext;
    Bext = 9'h0;
    Bext = B;
    for (i=0; i<8; i=i+1) begin
        G[i] <= (Bext[(i + 1)] ^ Bext[i]);
    end
end

endmodule

जो वीएच डीएल कोड ज्नित होता है, वह कुछ ऐसा होता है-
library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.numeric_std.all;
use std.textio.all;

use work.pck_myhdl_06.all;

entity bin2gray is
    port (
        B: in unsigned(7 downto 0);
        G: out unsigned(7 downto 0)
    );
end entity bin2gray;

architecture MyHDL of bin2gray is

begin

BIN2GRAY_LOGIC: process (B) is
    variable Bext: unsigned(8 downto 0);
begin
    Bext := to_unsigned(0, 9);
    Bext := resize(B, 9);
    for i in 0 to 8-1 loop
        G(i) <= (Bext((i + 1)) xor Bext(i));
    end loop;
end process BIN2GRAY_LOGIC;

end architecture MyHDL;

इन्हें भी देखें 
 निःशुल्क ईडीए सॉफ्टवेयरों की तुलना
 ईडीए सॉफ्टवेयरों की तुलना (Comparison of EDA Software)
 इलेक्ट्रॉनिक डिजाइन स्वचालन (EDA)

सन्दर्भ 

हार्डवेयर विवरण भाषाएँ