Wie kann man in VHDL eine mehrstellige Zahl in einzelne Ziffern aufteilen?

Hier ist etwas Pseudocode.

Nehmen wir zuerst die links von der Dezimalstelle, die maximale Zahl ist$15_{10}$=> 2 Dezimalstellen.

signal ex : sfixed(4 downto -4);

temp <= ex(4 downto 0);
L_0 <= temp mod 10;
temp <= temp/10;
L_1 <= temp mod 10;

Beispiel:
ex=$12_{10}$=$1100_{2}$

temp <= 12
L_0 <= 12 mod 10 = 2
temp <= 12/10    = 1
L_1 <= 1 mod 10  = 1

Und dann die rechts, kleinste Zahl => 0,0625 => 4 Dezimalstellen. Gleiche Methode wie zuvor, nur mit multiplizieren$625_{10}$bevor du anfängst. Weil$0001_{2}$in binär übersetzt zu$.0625_{10}$in dezimal. So sollte die Bitbreite von temp sein$ceil(log_2(625×15))=$ 14 Bit weil$15_{10}$Ist$1111_{2}$was dein höchster Wert ist.

signal ex : sfixed(4 downto -4);

temp <= ex(0 downto -4);
temp <= temp*625

R_3 <= temp mod 10;
temp <= temp/10;
R_2 <= temp mod 10;
temp <= temp/10;
R_1 <= temp mod 10;
temp <= temp/10;
R_0 <= temp mod 10;

Beispiel:
ex=$0.1875_{10}$=$0011_{2}$

temp <= 3 = 0011
temp <= 3*625 = 11101010011        = 1875

R_3 <= 1875 mod 10                 = 5
temp <= 1875/10                    = 187
R_2 <= 187 mod 10                  = 7
temp <= 187/10                     = 18
R_1 <= 18 mod 10                   = 8
temp <= 18/10                      = 1
R_0 <= 1 mod 10                    = 1

Und es sollte so angezeigt werden:

$L_1 L_0 . R_0 R_1 R_2 R_3$

Alle konstanten Divisionen durch 10 können durch eine Multiplikation mit ersetzt werden$\frac{1}{10}$. Es ist also nicht zu ineffizient zu implementieren. Ich bin mir ziemlich sicher, dass der Modulo-Operator in der Standardbibliothek enthalten ist.

Wenn Sie 6 Bits für die rechte Seite des Dezimalpunkts verwenden. Dann sollte die Bitbreite für temp sein$ceil(log2(63×15625))$= 20 Bit . Dies ist wahrscheinlich nicht der effizienteste Weg, es ist ein Weg, den ich mir gerade selbst ausgedacht habe. Es sollte ohne größere Probleme funktionieren.

Da dies auf einem FPGA erfolgt, können Sie die Multiplikation parallelisieren, für R3, R2, R1 und R0 ihre Temperatur mit 1 multiplizieren,$\frac{1}{10}$,$\frac{1}{100}$Und$\frac{1}{1000}$So erhalten Sie die Werte sofort statt seriell. Und dann benutze den Mod 10 auf ihnen.

BEARBEITEN

Mishyoshi gab mir eine Idee, wie dies auf andere Weise gelöst werden könnte.$L_0$Und$L_1$werden wie zuvor gelöst, aber die$R_{0..3}$kann auf andere, effizientere Weise erfolgen.

signal ex : sfixed(4 downto -4);

signal temp : sfixed(4 downto -4); 
//We need 4 to the left of the decimal point because then we can capture
//all the single digits

temp <= "0000" & ex(0 downto -4);
temp <= temp*10;

R_0 <= temp(3 downto 0); //Copy the 4 MSB bits 
temp <= "0000" & temp(-1 downto -4); //Delete the 4 MSB bits
temp <= temp*10;
R_1 <= temp(3 downto 0);
temp <= "0000" & temp(-1 downto -4);
temp <= temp*10;
R_2 <= temp(3 downto 0);
temp <= "0000" & temp(-1 downto -4);
temp <= temp*10;
R_3 <= temp(3 downto 0);

Beispiel:
ex=$0.1875_{10}$=$0011_{2}$

signal temp : sfixed(4 downto -4);

temp <= "0000" & "0011"                     = 0000.0011 = 3
temp <= 3*10                           = 30 = 0001.1110 
R_0 <= "0001.1110"(3 downto 0)              = 0001 = 1
temp <= "0000" & temp(-1 downto -4)         = 0000.1110
temp <= 14*10                         = 140 = 1000.1100
R_1 <= "1000.1100"(3 downto 0)              = 1000 = 8
temp <= "0000" & "1100"                     = 0000.1100
temp <= 12*10                         = 120 = 0111.1000
R_2 <= "0111.1000"(3 downto 0)              = 0111 = 7
temp <= "0000" & "1000"                     = 0000.1000
temp <= 8*10                           = 80 = 0101.0000
R_3 <= "0101.0000"(3 downto 0)              = 0101 = 5

Wie Sie sehen können, dreht sich alles darum, die Bits an die "Einer"-Stelle zu bringen, die 4 Bits links vom Dezimalkomma.

Dafür werden viel weniger Bits benötigt. In dieser anderen Lösung können Sie sie, wie Mishyoshi sagte, in eine Pipeline stecken.