צג HDMI שני ל-Raspberry Pi3 באמצעות ממשק DPI ולוח FPGA

סרטון זה מציג: לוח Raspberry Pi3, המחובר אליו באמצעות מחבר GPIO הוא לוח FPGA Mars Rover2rpi (Cyclone IV), אליו מחובר צג HDMI. הצג השני מחובר דרך מחבר ה-HDMI הסטנדרטי של ה-Raspberry Pi3. הכל עובד יחד כמו מערכת מוניטור כפול.

הבא אני אספר לך איך זה מיושם.

ללוח Raspberry Pi3 הפופולרי יש מחבר GPIO שדרכו ניתן לחבר כרטיסי הרחבה שונים: חיישנים, לדים, דרייברים של מנוע צעד ועוד. התפקוד המדויק של כל פין במחבר תלוי בתצורת היציאה. תצורת GPIO ALT2 מאפשרת לך להעביר את המחבר למצב ממשק DPI, Display Parallel Interface. ישנם כרטיסי הרחבה לחיבור מסכי VGA דרך DPI. עם זאת, ראשית, מסכי VGA כבר אינם נפוצים כמו HDMI, ושנית, הממשק הדיגיטלי יותר ויותר טוב מהממשק האנלוגי. יתר על כן, ה-DAC על לוחות הרחבת VGA כאלה מיוצר בדרך כלל בצורה של שרשראות R-2-R ולעתים קרובות לא יותר מ-6 ביטים לצבע.

במצב ALT2, לפיני מחברי GPIO יש את המשמעות הבאה:

כאן צבעתי את פיני ה-RGB של המחבר באדום, ירוק וכחול בהתאמה. אותות חשובים נוספים הם האותות V-SYNC ו-H-SYNC, כמו גם CLK. תדר השעון של CLK הוא התדר שבו ערכי פיקסלים יוצאים למחבר; זה תלוי במצב הווידאו שנבחר.

כדי לחבר צג HDMI דיגיטלי, עליך ללכוד את אותות DPI של הממשק ולהמיר אותם לאותות HDMI. זה יכול להיעשות, למשל, באמצעות סוג כלשהו של לוח FPGA. כפי שמתברר, לוח Mars Rover2rpi מתאים למטרות אלו. למען האמת, האפשרות העיקרית לחיבור לוח זה באמצעות מתאם מיוחד נראית כך:

לוח זה משמש להגדלת מספר יציאות GPIO ולחיבור התקנים היקפיים נוספים לפטל. במקביל, 4 אותות GPIO עם חיבור זה משמשים לאותות JTAG, כך שהתוכנה מ-Raspberry יכולה לטעון את קושחת FPGA ל-FPGA. בגלל זה, החיבור הסטנדרטי הזה לא מתאים לי; 4 אותות DPI נושרים. למרבה המזל, למסרקים הנוספים על הלוח יש pinout תואם פטל. אז אני יכול לסובב את הלוח 90 מעלות ועדיין לחבר אותו לפטל שלי:

כמובן שתצטרכו להשתמש במתכנת JTAG חיצוני, אבל זו לא בעיה.

עדיין יש בעיה קטנה. לא כל פין FPGA יכול לשמש ככניסת שעון. ישנן רק כמה סיכות ייעודיות שניתן להשתמש בהן למטרות אלו. אז התברר כאן שאות GPIO_0 CLK לא מגיע לכניסת FPGA, שיכולה לשמש ככניסת שעון FPGA. אז עדיין הייתי צריך לשים חוט אחד על הצעיף. אני מחבר את GPIO_0 ואת אות KEY[1] של הלוח:

עכשיו אני אספר לכם קצת על פרויקט FPGA. הקושי העיקרי ביצירת אותות HDMI הוא תדרים גבוהים מאוד. אם אתה מסתכל על ה-pinout של מחבר HDMI, אתה יכול לראות שאותות ה-RGB הם כעת אותות דיפרנציאליים טוריים:

השימוש באות דיפרנציאלי מאפשר לך להילחם בהפרעות במצב נפוץ בקו השידור. במקרה זה, קוד שמונה הסיביות המקורי של כל אות צבע מומר ל-TMDS של 10 סיביות (Transition-minimaled differential signaling). זוהי שיטת קידוד מיוחדת להסיר את רכיב ה-DC מהאות ולמזער את מיתוג האות בקו דיפרנציאלי. מכיוון שכעת צריך להעביר 10 ביטים על הקו הטורי עבור בייט אחד של צבע, מסתבר שמהירות השעון של הסדרת חייבת להיות גבוהה פי 10 ממהירות השעון הפיקסלים. אם ניקח לדוגמא את מצב הווידאו 1280x720 60Hz, אז תדר הפיקסלים של מצב זה הוא 74,25 מגה-הרץ. ה- Serializer צריך להיות 742,5 מגה-הרץ.

FPGAs רגילים, למרבה הצער, אינם מסוגלים לכך. עם זאת, למזלנו, ל-FPGA יש פיני DDIO מובנים. אלו מסקנות שהן כבר, כביכול, 2-to-1 סדרה. כלומר, הם יכולים להוציא שני ביטים ברצף על הקצוות העולים ויורדים של תדר השעון. זה אומר שבפרויקט FPGA אתה יכול להשתמש לא ב-740 מגה-הרץ, אלא ב-370 מגה-הרץ, אבל אתה צריך להשתמש ברכיבי פלט DDIO ב-FPGA. כעת 370 מגה-הרץ הוא כבר תדר בר-השגה לחלוטין. למרבה הצער, מצב 1280x720 הוא הגבול. לא ניתן להשיג רזולוציה גבוהה יותר ב-Cyclone IV FPGA שלנו המותקן על לוח Mars Rover2rpi.

אז, בתכנון, תדר הפיקסלים הקלט CLK עובר ל-PLL, שם הוא מוכפל ב-5. בתדר זה, ה-R, G, B מומרים לזוגות סיביות. זה מה שמקודד ה-TMDS עושה. קוד המקור ב-Verilog HDL נראה כך:

module hdmi(
	input wire pixclk,		// 74MHz
	input wire clk_TMDS2,	// 370MHz
	input wire hsync,
	input wire vsync,
	input wire active,
	input wire [7:0]red,
	input wire [7:0]green,
	input wire [7:0]blue,
	output wire TMDS_bh,
	output wire TMDS_bl,
	output wire TMDS_gh,
	output wire TMDS_gl,
	output wire TMDS_rh,
	output wire TMDS_rl
);

wire [9:0] TMDS_red, TMDS_green, TMDS_blue;
TMDS_encoder encode_R(.clk(pixclk), .VD(red  ), .CD({vsync,hsync}), .VDE(active), .TMDS(TMDS_red));
TMDS_encoder encode_G(.clk(pixclk), .VD(green), .CD({vsync,hsync}), .VDE(active), .TMDS(TMDS_green));
TMDS_encoder encode_B(.clk(pixclk), .VD(blue ), .CD({vsync,hsync}), .VDE(active), .TMDS(TMDS_blue));

reg [2:0] TMDS_mod5=0;  // modulus 5 counter
reg [4:0] TMDS_shift_bh=0, TMDS_shift_bl=0;
reg [4:0] TMDS_shift_gh=0, TMDS_shift_gl=0;
reg [4:0] TMDS_shift_rh=0, TMDS_shift_rl=0;

wire [4:0] TMDS_blue_l  = {TMDS_blue[9],TMDS_blue[7],TMDS_blue[5],TMDS_blue[3],TMDS_blue[1]};
wire [4:0] TMDS_blue_h  = {TMDS_blue[8],TMDS_blue[6],TMDS_blue[4],TMDS_blue[2],TMDS_blue[0]};
wire [4:0] TMDS_green_l = {TMDS_green[9],TMDS_green[7],TMDS_green[5],TMDS_green[3],TMDS_green[1]};
wire [4:0] TMDS_green_h = {TMDS_green[8],TMDS_green[6],TMDS_green[4],TMDS_green[2],TMDS_green[0]};
wire [4:0] TMDS_red_l   = {TMDS_red[9],TMDS_red[7],TMDS_red[5],TMDS_red[3],TMDS_red[1]};
wire [4:0] TMDS_red_h   = {TMDS_red[8],TMDS_red[6],TMDS_red[4],TMDS_red[2],TMDS_red[0]};

always @(posedge clk_TMDS2)
begin
	TMDS_shift_bh <= TMDS_mod5[2] ? TMDS_blue_h  : TMDS_shift_bh  [4:1];
	TMDS_shift_bl <= TMDS_mod5[2] ? TMDS_blue_l  : TMDS_shift_bl  [4:1];
	TMDS_shift_gh <= TMDS_mod5[2] ? TMDS_green_h : TMDS_shift_gh  [4:1];
	TMDS_shift_gl <= TMDS_mod5[2] ? TMDS_green_l : TMDS_shift_gl  [4:1];
	TMDS_shift_rh <= TMDS_mod5[2] ? TMDS_red_h   : TMDS_shift_rh  [4:1];
	TMDS_shift_rl <= TMDS_mod5[2] ? TMDS_red_l   : TMDS_shift_rl  [4:1];
	TMDS_mod5 <= (TMDS_mod5[2]) ? 3'd0 : TMDS_mod5+3'd1;
end

assign TMDS_bh = TMDS_shift_bh[0];
assign TMDS_bl = TMDS_shift_bl[0];
assign TMDS_gh = TMDS_shift_gh[0];
assign TMDS_gl = TMDS_shift_gl[0];
assign TMDS_rh = TMDS_shift_rh[0];
assign TMDS_rl = TMDS_shift_rl[0];

endmodule

module TMDS_encoder(
	input clk,
	input [7:0] VD,	// video data (red, green or blue)
	input [1:0] CD,	// control data
	input VDE,  	// video data enable, to choose between CD (when VDE=0) and VD (when VDE=1)
	output reg [9:0] TMDS = 0
);

wire [3:0] Nb1s = VD[0] + VD[1] + VD[2] + VD[3] + VD[4] + VD[5] + VD[6] + VD[7];
wire XNOR = (Nb1s>4'd4) || (Nb1s==4'd4 && VD[0]==1'b0);
wire [8:0] q_m = {~XNOR, q_m[6:0] ^ VD[7:1] ^ {7{XNOR}}, VD[0]};

reg [3:0] balance_acc = 0;
wire [3:0] balance = q_m[0] + q_m[1] + q_m[2] + q_m[3] + q_m[4] + q_m[5] + q_m[6] + q_m[7] - 4'd4;
wire balance_sign_eq = (balance[3] == balance_acc[3]);
wire invert_q_m = (balance==0 || balance_acc==0) ? ~q_m[8] : balance_sign_eq;
wire [3:0] balance_acc_inc = balance - ({q_m[8] ^ ~balance_sign_eq} & ~(balance==0 || balance_acc==0));
wire [3:0] balance_acc_new = invert_q_m ? balance_acc-balance_acc_inc : balance_acc+balance_acc_inc;
wire [9:0] TMDS_data = {invert_q_m, q_m[8], q_m[7:0] ^ {8{invert_q_m}}};
wire [9:0] TMDS_code = CD[1] ? (CD[0] ? 10'b1010101011 : 10'b0101010100) : (CD[0] ? 10'b0010101011 : 10'b1101010100);

always @(posedge clk) TMDS <= VDE ? TMDS_data : TMDS_code;
always @(posedge clk) balance_acc <= VDE ? balance_acc_new : 4'h0;

endmodule

לאחר מכן צמדי המוצא מוזנים ליציאת DDIO, אשר מייצרת ברצף אות של סיביות אחת בקצוות העולים ויורדים.

ניתן לתאר את DDIO עצמו עם קוד Verilog הבא:

module ddio(
	input wire d0,
	input wire d1,
	input wire clk,
	output wire out
	);

reg r_d0;
reg r_d1;
always @(posedge clk)
begin
	r_d0 <= d0;
	r_d1 <= d1;
end
assign out = clk ? r_d0 : r_d1;
endmodule

אבל סביר להניח שזה לא יעבוד ככה. עליך להשתמש במגה-פונקציית ALTDDIO_OUT של Alter כדי לאפשר למעשה את רכיבי הפלט של DDIO. הפרויקט שלי משתמש ברכיב הספרייה ALTDDIO_OUT.

כל זה אולי נראה קצת מסובך, אבל זה עובד.

אתה יכול להציג את כל קוד המקור שנכתב ב-Verilog HDL כאן ב-github.

הקושחה המהודרת עבור ה-FPGA מובזקת לתוך שבב EPCS המותקן על לוח Mars Rover2rpi. לפיכך, כאשר מופעל מתח על לוח ה-FPGA, ה-FPGA יאותחל מזיכרון הבזק ויתחיל.

עכשיו אנחנו צריכים לדבר קצת על התצורה של הפטל עצמו.

אני עושה ניסויים ב-Raspberry PI OS (32 סיביות) המבוססים על דביאן באסטר, גרסה: אוגוסט 2020,
תאריך פרסום: 2020-08-20, גרסת ליבה: 5.4.

אתה צריך לעשות שני דברים:

• ערוך את קובץ config.txt;
• צור תצורת שרת X לעבודה עם שני צגים.

בעת עריכת קובץ /boot/config.txt אתה צריך:

1. השבת את השימוש ב-i2c, i2s, spi;
2. אפשר מצב DPI באמצעות שכבת-על dtoverlay=dpi24;
3. הגדר מצב וידאו 1280×720 60Hz, 24 סיביות לפיקסל ב-DPI;
4. ציין את המספר הנדרש של framebuffers 2 (max_framebuffers=2, רק אז יופיע המכשיר השני /dev/fb1)

הטקסט המלא של קובץ config.txt נראה כך.

# For more options and information see
# http://rpf.io/configtxt
# Some settings may impact device functionality. See link above for details

# uncomment if you get no picture on HDMI for a default "safe" mode
#hdmi_safe=1

# uncomment this if your display has a black border of unused pixels visible
# and your display can output without overscan
disable_overscan=1

# uncomment the following to adjust overscan. Use positive numbers if console
# goes off screen, and negative if there is too much border
#overscan_left=16
#overscan_right=16
#overscan_top=16
#overscan_bottom=16

# uncomment to force a console size. By default it will be display's size minus
# overscan.
#framebuffer_width=1280
#framebuffer_height=720

# uncomment if hdmi display is not detected and composite is being output
hdmi_force_hotplug=1

# uncomment to force a specific HDMI mode (this will force VGA)
#hdmi_group=1
#hdmi_mode=1

# uncomment to force a HDMI mode rather than DVI. This can make audio work in
# DMT (computer monitor) modes
#hdmi_drive=2

# uncomment to increase signal to HDMI, if you have interference, blanking, or
# no display
#config_hdmi_boost=4

# uncomment for composite PAL
#sdtv_mode=2

#uncomment to overclock the arm. 700 MHz is the default.
#arm_freq=800

# Uncomment some or all of these to enable the optional hardware interfaces
#dtparam=i2c_arm=on
#dtparam=i2s=on
#dtparam=spi=on

dtparam=i2c_arm=off
dtparam=spi=off
dtparam=i2s=off

dtoverlay=dpi24
overscan_left=0
overscan_right=0
overscan_top=0
overscan_bottom=0
framebuffer_width=1280
framebuffer_height=720
display_default_lcd=0
enable_dpi_lcd=1
dpi_group=2
dpi_mode=87
#dpi_group=1
#dpi_mode=4
dpi_output_format=0x6f027
dpi_timings=1280 1 110 40 220 720 1 5 5 20 0 0 0 60 0 74000000 3

# Uncomment this to enable infrared communication.
#dtoverlay=gpio-ir,gpio_pin=17
#dtoverlay=gpio-ir-tx,gpio_pin=18

# Additional overlays and parameters are documented /boot/overlays/README

# Enable audio (loads snd_bcm2835)
dtparam=audio=on

[pi4]
# Enable DRM VC4 V3D driver on top of the dispmanx display stack
#dtoverlay=vc4-fkms-v3d
max_framebuffers=2

[all]
#dtoverlay=vc4-fkms-v3d
max_framebuffers=2

לאחר מכן, עליך ליצור קובץ תצורה עבור שרת X כדי להשתמש בשני צגים על שני מאפי מסגרת /dev/fb0 ו-/dev/fb1:

קובץ התצורה שלי /usr/share/x11/xorg.conf.d/60-dualscreen.conf הוא כזה

Section "Device"
        Identifier      "LCD"
        Driver          "fbturbo"
        Option          "fbdev" "/dev/fb0"
        Option          "ShadowFB" "off"
        Option          "SwapbuffersWait" "true"
EndSection

Section "Device"
        Identifier      "HDMI"
        Driver          "fbturbo"
        Option          "fbdev" "/dev/fb1"
        Option          "ShadowFB" "off"
        Option          "SwapbuffersWait" "true"
EndSection

Section "Monitor"
        Identifier      "LCD-monitor"
        Option          "Primary" "true"
EndSection

Section "Monitor"
        Identifier      "HDMI-monitor"
        Option          "RightOf" "LCD-monitor"
EndSection

Section "Screen"
        Identifier      "screen0"
        Device          "LCD"
        Monitor         "LCD-monitor"
EndSection

Section "Screen"
        Identifier      "screen1"
        Device          "HDMI" 
	Monitor         "HDMI-monitor"
EndSection

Section "ServerLayout"
        Identifier      "default"
        Option          "Xinerama" "on"
        Option          "Clone" "off"
        Screen 0        "screen0"
        Screen 1        "screen1" RightOf "screen0"
EndSection

ובכן, אם זה עדיין לא מותקן, אז אתה צריך להתקין את Xinerama. אז שטח שולחן העבודה יורחב במלואו לשני מסכים, כפי שמוצג בסרטון ההדגמה למעלה.

זה כנראה הכל. כעת, בעלי Raspberry Pi3 יוכלו להשתמש בשני מסכים.

ניתן למצוא תיאור ודיאגרמת מעגלים של לוח Mars Rover2rpi תסתכל כאן.

מקור: www.habr.com