TEXTに投稿されたコード一覧

TEXT 女の子が主人公の異世界モノ

http://ncode.syosetu.com/n9612l/

http://ncode.syosetu.com/n0122ci/

http://ncode.syosetu.com/n6517bw/

http://ncode.syosetu.com/n7061cc/

http://ncode.syosetu.com/n1875cc/

http://ncode.syosetu.com/n6475db/

http://ncode.syosetu.com/n7975cr/

http://ncode.syosetu.com/n9734bb/

http://ncode.syosetu.com/n1075co/

http://ncode.syosetu.com/n4269cp/

http://ncode.syosetu.com/n7763bs/

http://ncode.syosetu.com/n7798n/

http://ncode.syosetu.com/n1990bq/

http://ncode.syosetu.com/n3112j/

TEXT ソラトニワ自動再生

//ソラトニワ自動再生
OPTION EXPLICIT

DIM BROWSER

//ウインドウのハンドルを取得する
BROWSER=GETID("インターネットラジオのソラトニワステーション原宿、銀座、梅田の再生ページです。 ソラトニワ | soraxniwa - Internet Explorer", "IEFrame", -1)

//1秒待ち
SLEEP(1)

//ウインドウをアクティブにする
CLKITEM(BROWSER, "インターネットラジオのソラトニワステーション原宿、銀座、梅田の再生ページです。 ソラトニワ | soraxniwa - Internet Explorer", CLK_ACC)

//更新ボタンを押す
CLKITEM(BROWSER, "最新の情報に更新 (F5)", CLK_BTN)

SLEEP(10)
//一時停止ボタンがあれば
while !CHKIMG("pause1.bmp") and !CHKIMG("pause2.bmp")
	print "再生クリック"
	CLKITEM(BROWSER, "play", CLK_BTN)
	SLEEP(5)
	//再生状態にならなかったら
	if !CHKIMG("pause1.bmp") and !CHKIMG("pause2.bmp")
		//F5キー
		CLKITEM(BROWSER, "最新の情報に更新 (F5)", CLK_BTN)
		SLEEP(10)
	endif
wend
print "再生されました"

TEXT Verilog code for fixed-point 16-bit 4-tap FIR filter module (state machine version)

// Fixed-point 16 bit 4-tap FIR filter module [state machine version] -----------------------
module FIRfilterS (
  input wire[15:0] indata,
  input wire update,
  input wire clk,
  output wire [15:0] outdata
  );
  parameter NTAPS = 4;
  wire signed [15:0] coef[NTAPS-1:0];
  reg  signed [15:0] buff[NTAPS-1:0];
  reg  signed [15:0] outreg,mul_in1,mul_in2;
  wire signed [31:0] mul_out;
  reg  signed [31:0] addreg;
  integer statecnt,rptr,wptr;
  reg inprocess;
  assign outdata = outreg;

  // coefficients --------------- change here
  assign coef[0] = 16'h2000;
  assign coef[1] = 16'h2000;
  assign coef[2] = 16'h2000;
  assign coef[3] = 16'h2000;
  // ------------------------------

  // initital register settings
  initial begin
    rptr <= 0;
    wptr <= 0;
    inprocess <= 0;
    statecnt <= NTAPS*4+1;
  end
  // mulitplication module
  multiplier mul(.clk(clk),.a(mul_in1),.b(mul_in2),.p(mul_out));
    // Optimized 'black-box' module : p = a * b
    //    input clk
    //    input [15:0] a
    //    input [15:0] b
    //    output [31:0] p

  // internal calculations
  always @(posedge clk) begin
    // inpute detection
    if(update==1 && inprocess==0) begin
      buff[wptr] <= indata;
      statecnt <= 0;
      rptr <= wptr;
      addreg <= 0;
      inprocess <= 1;
    end
    // processing state machine
    if(statecnt<NTAPS*4) begin
      if(statecnt%4==0) begin // input data to multiplier
        mul_in1 <= buff[rptr];
        mul_in2 <= coef[statecnt>>4];
      end
      if(statecnt%4==3) begin // get data from multiplier and accumulate
        addreg <= addreg + mul_out;
        rptr <= (rptr+NTAPS-1)%NTAPS;
      end
      statecnt <= statecnt+1;
    end
    if(statecnt==NTAPS*4) begin // output data
      outreg <= addreg>>>15;
      wptr <= (wptr+1)%NTAPS;
      statecnt <= statecnt+1;
    end
    if(statecnt==NTAPS*4+1 && inprocess==1 && update==0) begin
      inprocess <= 0;
    end
  end
endmodule

TEXT Verilog code for 16-bit signed fixed-point N-tap FIR filter module

// Fixed-point 16 bit N-tap FIR filter module -----------------------------
module FIRfilter #(
  parameter NTAPS = 4
  )
  (
  input wire[15:0] indata,
  input wire update,
  input wire inputmode,
  output wire[15:0] outdata
  );
  reg [15:0] coef[NTAPS-1:0];        // coefficients
  wire signed [31:0] mulline[NTAPS-1:0];  // input multiplied with coefficients
  reg  signed [31:0] addline[NTAPS-1:0];  // adder buffer

  // input control
  integer n;
  always @(posedge update) begin
    // coefficients input mode
    if(inputmode==1) begin
      for(n=0;n<NTAPS-1;n=n+1) begin
        coef[NTAPS-n-1] <=coef[NTAPS-n-2];
      end
      coef[0] <= indata;
    end
    // nomal input mode
    else begin
      addline[0] <= mulline[0];
      for(n=0;n<NTAPS-1;n=n+1) begin
        addline[n+1] <= addline[n]+mulline[n+1]; // accumulation
      end
    end
  end
  // multiplication
  genvar i;
  generate
  for(i=0;i<NTAPS;i=i+1) begin : genfil
    multiplier mul(.clk(update),.a(indata),.b(coef[i]),.p(mulline[i]));
    // Optimized 'black-box' module : p = a * b
    //    input clk
    //    input [15:0] a
    //    input [15:0] b
    //    output [31:0] p
  end
  endgenerate
  // output assignment
  assign outdata = addline[NTAPS-1]>>>15;

endmodule

TEXT VGAコントローラ

circuit vga_ctrl
{
	instrin htimming; // 25MHz
	output h_sync, v_sync;
	output h_en, v_en;
	output h_count<10>, v_count<10>;

	input iR<4>, iG<4>, iB<4>;
	output oR<4>, oG<4>, oB<4>;

	reg_wr h_tim<10>, v_tim<10>;
	reg_ws h_sync_reg, v_sync_reg;
	reg_wr h_en_reg, v_en_reg;

	instrself vtimming;

	par{
		h_sync = h_sync_reg;
		v_sync = v_sync_reg;

		h_en = h_en_reg;
		v_en = v_en_reg;

		h_count = h_tim - (96+48+1);
		v_count = v_tim - (2+33+1);

		if(h_en & v_en){
			oR = iR; oG = iG; oB = iB;
		}
		else{
			oR = 0; oG = 0; oB = 0;
		}
	}

	instruct htimming par{

		any{
			h_tim==0  : h_sync_reg := 0;
			h_tim==96 : par{
				h_sync_reg := 1;
				vtimming();
			}
			h_tim==(96+48)     : h_en_reg := 1;
			h_tim==(96+48+640) : h_en_reg := 0;
		}

		if(h_tim==(800-1)) h_tim := 0;
		else h_tim++;
	}

	instruct vtimming par{

		any{
			v_tim==0 : v_sync_reg := 0;
			v_tim==2 : v_sync_reg := 1;
			v_tim==(2+33)     : v_en_reg := 1;
			v_tim==(2+33+480) : v_en_reg := 0;
		}

		if(v_tim==(525-1)) v_tim := 0;
		else v_tim++;
	}
}

TEXT ModelSimでVHDLのRAM初期化

-- ファイルからRAMへのデータ初期化
procedure ReadFileh(
	file_name : in string;
	ram_name : in string;
	ram_size : in integer;
	ram_width : in integer) is
file infile : TEXT open read_mode is file_name;
variable l : line;
variable data : std_logic_vector(ram_width-1 downto 0);
begin
	for I in 0 to ram_size-1 loop
		readline(infile, l);
		hread(l, data);
		signal_force(ram_name & "(" & str(I) & ")", str(data), 0 ns, deposit, open, 0);
	end loop;
end;

-- 使い方
	ReadFileh("cgram.dat", "/pu/ppu1/main_cgram/ram0/cells", 256, 16);

TEXT 【HSP3】HSP3x64サポートの為の関数呼び出しアセンブリv2(これはひどい)

; masm64 (x64)
;.686
;.mmx
;.xmm
;.model flat
;_TEXT64 segment page public use64 'CODE'
;		align 16

; fastcall!!
;PUBLIC C call_extfunc64
.code
align 16
PUBLIC call_extfunc64
call_extfunc64 PROC	

	; rcx = 第1引数(関数のポインタ)
	; rdx = 第2引数(引数が入ったINT64の配列)
	; r8 =  第3引数(引数情報(int=0,double(float)=1)が入ったINT64の配列)
	; r9 =  第4引数(引数の数)
	; rax = 戻り値

; レジスタの退避
	push r12
	push r13
	push r14
	push r15

; 引数が0~4の時はサイズ40
; 5以降は 16ずつ増える
; 5-6  56
; 7-8  72
; 9-10 88

; r10~r11はテンポラリ用
; r12 は関数のアドレス保持に使用中の為
; r13 をサイズ保持用レジスタ
; r14 をrdx退避使用
	mov r14, rdx
; r15 は引数の数で、使用中
	mov r13, 40
; if r13 <= 4
	cmp r13, 4
	jbe JMP1
; 5以上の処理
;(d+=8*(num-4))
	mov r10, r9
	sub r10, 4
; 掛け算*8なので算術シフトする
	shl r10, 3
	add r13, r10
;if d\16 == 0 : d+=8
	mov rax, r13
	cdq
	and	rdx, 15
	add	rax, rdx
	and	rax, 15
	sub	rax, rdx
	cmp rax, 0
	jne JMP1
	add r13, 8
JMP1:
; 復元(r14->rdx)
	mov rdx, r14
	mov r11, r13

	sub rsp, r11

; コピー
	mov r12, rcx
	mov r13, rdx
	mov r14, r8
	mov r15, r9

; r10-r11 レジスタ (テンポラリ用レジスタ)
; 0クリア
;	xor r10, r10
;	xor r11, r11

; 引数1~4の時はレジスタに格納、5以降はスタック

; 第1引数
; if num > 0
	cmp r15, 0
	jg FLAG1
	jmp FLAG1END
FLAG1:
; r14のポインタからr10 レジスタに中身コピー
	mov r10, qword ptr [r14+0]
; int or double?
	cmp r10, 0
	je FLAG1INT
	; doubleなのでxmm?へ
	movq xmm0, qword ptr [r13+0]
	jmp FLAG1END
FLAG1INT:
	mov rcx, qword ptr [r13+0]
FLAG1END:

; 第2引数
; if num > 1
	cmp r15, 1
	jg FLAG2
	jmp FLAG2END
FLAG2:
; r14のポインタからr10 レジスタに中身コピー
	mov r10, qword ptr [r14+8]
; int or double?
	cmp r10, 0
	je FLAG2INT
	; doubleなのでxmm?へ
	movq xmm1, qword ptr [r13+8]
	jmp FLAG2END
FLAG2INT:
	mov rdx, qword ptr [r13+8]
FLAG2END:

; 第3引数
; if num > 2
	cmp r15, 2
	jg FLAG3
	jmp FLAG3END
FLAG3:
; r14のポインタからr10 レジスタに中身コピー
	mov r10, qword ptr [r14+16]
; int or double?
	cmp r10, 0
	je FLAG3INT
	; doubleなのでxmm?へ
	movq xmm2, qword ptr [r13+16]
	jmp FLAG3END
FLAG3INT:
	mov r8, qword ptr [r13+16]
FLAG3END:

; 第4引数
; if num > 3
	cmp r15, 3
	jg FLAG4
	jmp FLAG4END
FLAG4:
; r14のポインタからr10 レジスタに中身コピー
	mov r10, qword ptr [r14+24]
; int or double?
	cmp r10, 0
	je FLAG4INT
	; doubleなのでxmm?へ
	movq xmm3, qword ptr [r13+24]
	jmp FLAG4END
FLAG4INT:
	mov r9, qword ptr [r13+24]
FLAG4END:

; 第5引数以降
; if num < 5 : CALLFUNCに飛ぶ
	cmp r15, 5
	jl CALLFUNC
; ↓5以降はRSPスタックに積む(後ろから積む)
	mov r10, r15
	jmp PUSHCHECK
	PUSHSTACK:
		;push qword ptr [r13+r10*8]
		mov	rax, qword ptr [r13+r10*8]
		mov	qword ptr [rsp+r10*8], rax
	PUSHCHECK:
		dec	r10
		; ~0~3の時は抜ける
		cmp r10, 3
		jg PUSHSTACK
; ↑

CALLFUNC:
; 呼出
	mov r13, r11
	call r12
	mov r11, r13

; 終了
	add	rsp, r11

; レジスタ後始末
	pop r15
	pop r14
	pop r13
	pop r12

	ret

call_extfunc64 ENDP
;
End

TEXT 【HSP3】HSP3x64サポートの為の関数呼び出しアセンブリ(適当)

; masm64 (x64)
;.686
;.mmx
;.xmm
;.model flat
;_TEXT64 segment page public use64 'CODE'
;		align 16

; fastcall!!
;PUBLIC C call_extfunc64
.code
PUBLIC call_extfunc64
call_extfunc64 PROC

	; rcx = 第1引数(関数のポインタ)
	; rdx = 第2引数(引数が入ったINT64の配列)
	; r8 =  第3引数(引数情報(int=0,double(float)=1)が入ったINT64の配列)
	; r9 =  第4引数(引数の数)
	; rax = 戻り値

	sub rsp, 72

; レジスタの退避
	push r12
	push r13
	push r14
	push r15

; コピー
	mov r12, rcx
	mov r13, rdx
	mov r14, r8
	mov r15, r9

; r10-r11 レジスタ
; 0クリアする。いらない気がする。
	xor r10, r10
	xor r11, r11

; 引数1~4の時はレジスタに格納、5以降はスタック

; 第1引数
; if num > 0
	cmp r15, 0
	jg FLAG1
	jmp FLAG1END
FLAG1:
	mov r10, qword ptr [r14+0]
; int or double?
	cmp r10, 0
	je FLAG1INT
	; doubleなのでxmm?へ
	movq xmm0, qword ptr [r13+0]
	jmp FLAG1END
FLAG1INT:
	mov rcx, qword ptr [r13+0]
FLAG1END:

; 第2引数
; if num > 1
	cmp r15, 1
	jg FLAG2
	jmp FLAG2END
FLAG2:
	mov r10, qword ptr [r14+8]
; int or double?
	cmp r10, 0
	je FLAG2INT
	; doubleなのでxmm?へ
	movq xmm1, qword ptr [r13+8]
	jmp FLAG2END
FLAG2INT:
	mov rdx, qword ptr [r13+8]
FLAG2END:

; 第3引数
; if num > 2
	cmp r15, 2
	jg FLAG3
	jmp FLAG3END
FLAG3:
	mov r10, qword ptr [r14+16]
; int or double?
	cmp r10, 0
	je FLAG3INT
	; doubleなのでxmm?へ
	movq xmm2, qword ptr [r13+16]
	jmp FLAG3END
FLAG3INT:
	mov r8, qword ptr [r13+16]
FLAG3END:

; 第4引数
; if num > 3
	cmp r15, 3
	jg FLAG4
	jmp FLAG4END
FLAG4:
	mov r10, qword ptr [r14+24]
; int or double?
	cmp r10, 0
	je FLAG4INT
	; doubleなのでxmm?へ
	movq xmm3, qword ptr [r13+24]
	jmp FLAG4END
FLAG4INT:
	mov r9, qword ptr [r13+24]
FLAG4END:

; 第5引数以降
; if num < 5 : CALLFUNCに飛ぶ
	cmp r15, 5
	jl CALLFUNC
; ↓5以降はRSPスタックに積む(後ろから積む)
	mov r11, r15
	jmp PUSHCHECK
	PUSHSTACK:
		;push qword ptr [r13+r11*8]
		mov	rax, qword ptr [r13+r11*8]
		mov	qword ptr [rsp+r11*8], rax
	PUSHCHECK:
		dec	r11
		; ~0~3の時は抜ける
		cmp r11, 3
		jg PUSHSTACK
; ↑

; eax0クリア
	xor eax, eax

CALLFUNC:
; 呼出
	call r12

; レジスタ後始末
	pop r15
	pop r14
	pop r13
	pop r12

; 終了
	add	rsp, 72
	ret

call_extfunc64 ENDP
;
End

TEXT sdram_ctrl.sflp

/*
	SDRAM Controller 2007/2/14

	IS42S16400
		1M Words x 16 bits x 4 Banks (64Mbit)

	clock 50 MHz
		bank<2> adrs<20> data<16>

	QuartusII 7.2 177LC 125DLR
*/

circuit sdram_ctrl
{
	output CSn, RASn, CASn, WEn;
	output LDM, HDM;
	output DEn; // Write data output enable
	output BA<2>, A<12>;
	input Din<16>;
	output Dout<16>;

	instrin write(adrs, wdata);
	input wdata<16>, adrs<22>;
	instrin read(adrs);
	output rdata<16>, ack;

	output err;
	reg_wr err_reg;

	reg_wr BA_reg<2>;
	reg_ws A_reg<12>;
//	reg_ws LDM_reg, HDM_reg;
	reg_ws RASn_reg, CASn_reg, WEn_reg, DEn_reg;

	reg_ws reset;
	reg_wr adrs_reg<22>, rdata_reg<16>, wdata_reg<16>;

	instrself com_NOP, com_PRE, com_REF, com_MRS, com_ACT, com_WRITE, com_READ;

	stage_name init { task do(); }
	stage_name refresh { task do(); }
	stage_name refresh_cnt { task do(); }
	stage_name swrite { task do(adrs_reg, wdata_reg); }
	stage_name sread { task do(adrs_reg); }

	par{
		if(reset){
			reset := 0b0;
			generate init.do();
		}

		ack = ^(init.do | sread.do | swrite.do);

		CSn = 0b0;
		LDM = 0b0; // LDM_reg;
		HDM = 0b0; // HDM_reg;
		RASn = RASn_reg;
		CASn = CASn_reg;
		WEn = WEn_reg;
		DEn = DEn_reg;
		BA = BA_reg;
		A = A_reg;

		Dout = wdata_reg;

		rdata = rdata_reg;

		// for debug
		any{
			init.do & (sread.do | swrite.do) : err_reg := 0b1;
			sread.do & swrite.do : err_reg := 0b1;
			(sread.do & read) | (swrite.do & write) : err_reg := 0b1;
		}
		err = err_reg;
	}

	instruct read par{
		generate sread.do(adrs);
	}

	instruct write par{
		generate swrite.do(adrs, wdata);
	}

	instruct com_NOP par{
		RASn_reg := 0b1;
		CASn_reg := 0b1;
		WEn_reg  := 0b1;
	}

	// Trp 20 ns
	instruct com_PRE par{
		RASn_reg := 0b0;
		CASn_reg := 0b1;
		WEn_reg  := 0b0;
	}

	// Trc 70 ns
	instruct com_REF par{
		RASn_reg := 0b0;
		CASn_reg := 0b0;
		WEn_reg  := 0b1;
	}

	// Trc 10 ns
	instruct com_MRS par{
		RASn_reg := 0b0;
		CASn_reg := 0b0;
		WEn_reg  := 0b0;
	}

	// Trcd 20 ns
	instruct com_ACT par{
		RASn_reg := 0b0;
		CASn_reg := 0b1;
		WEn_reg  := 0b1;
	}

	instruct com_WRITE par{
		RASn_reg := 0b1;
		CASn_reg := 0b0;
		WEn_reg  := 0b0;
	}

	instruct com_READ par{
		RASn_reg := 0b1;
		CASn_reg := 0b0;
		WEn_reg  := 0b1;
	}

	stage init {
		reg_wr init_count<16>, count<6>; // use <14>
		state_name st_PON,st_PALL,st_wPALL1,st_wPALL2,st_REF,st_wREF,st_MRS,st_wMRS;
		first_state st_PON;
		state st_PON par{
			com_NOP();
			init_count++;
			if(init_count==0x2710) goto st_PALL; // 200 us
		}
		state st_PALL par{
			com_PRE();
			A_reg := 0b010000000000; // All banks
			goto st_wPALL1;
		}
		state st_wPALL1 par{
			com_NOP();
			goto st_wPALL2;
		}
		state st_wPALL2 par{
			count++;
			if(/&count) goto st_REF;
		}
		state st_REF par{
			count++;
			if(count<2:0>==0b000) com_REF();
			else com_NOP();
			if(/&count) goto st_wREF;
		}
		state st_wREF par{
			goto st_MRS;
		}
		state st_MRS par{
			com_MRS();
			BA_reg := 0b00;
			A_reg := 0b00000 || 0b010 || 0b0000; // CAS 2 Burst 1
		//	LDM_reg := 0b0;
		//	HDM_reg := 0b0;
			goto st_wMRS;
		}
		state st_wMRS par{
			com_NOP(); // 4回以上
			count++;
			if(count<3>) relay refresh_cnt.do();
		}
	}

// 3 clk
	stage swrite {
		state_name st_ACT, st_WRITEA, st_w1;
		first_state st_ACT;
		state st_ACT if(^refresh.do){
			com_ACT();
			BA_reg := adrs_reg<21:20>;
			A_reg := adrs_reg<19:8>;
			DEn_reg := 0b0;
			goto st_WRITEA;
		}
		state st_WRITEA par{
			com_WRITE();
			A_reg := 0b0100 || adrs_reg<7:0>;
			goto st_w1;
		}
		state st_w1 par{
			com_NOP();
			DEn_reg := 0b1;
			goto st_ACT;
			finish;
		}
	}

// 5 clk
	stage sread {
		state_name st_ACT,st_READA,st_w0,st_w1,st_w2;
		first_state st_ACT;
		state st_ACT if(^refresh.do){
			com_ACT();
			BA_reg := adrs_reg<21:20>;
			A_reg := adrs_reg<19:8>;
			goto st_READA;
		}
		state st_READA par{
			com_READ();
			A_reg := 0b0100 || adrs_reg<7:0>;
			goto st_w0;
		}
		state st_w0 par{
			com_NOP();
			goto st_w1;
		}
		state st_w1 par{
			goto st_w2; // オートプリチャージ
		}
		state st_w2 par{ // CL 2
			rdata_reg := Din;
			goto st_ACT;
			finish;
		}
	}

	stage refresh_cnt {
		reg_wr refresh_time<7>;
		reg_wr notused;
		state_name st1,st2;
		first_state st1;
		if(notused) finish;
		state st1 if(^refresh.do){
			refresh_time++;
			if(/&refresh_time) goto st2;
		}
		state st2 if(^(sread.do | swrite.do)){
			generate refresh.do();
			goto st1;
		}
	}

// 3 clk
// read と refresh が同時に起動しても refresh を優先
	stage refresh {
		reg_wr refresh_A<14>;
		state_name st_ACT, st_PRE, st_wPRE;
		first_state st_ACT;
		state st_ACT par{
			com_ACT();
			BA_reg := refresh_A<1:0>;
			A_reg := refresh_A<13:2>;
			goto st_PRE;
		}
		state st_PRE par{
			com_PRE();
			A_reg := 0b010000000000;
			refresh_A++;
			goto st_wPRE;
		}
		state st_wPRE par{
			com_NOP();
			goto st_ACT;
			finish;
		}
	}

}

TEXT VHDLモジュール接続

  component COUNT10
    port(
      RSTn : in  std_logic;
      CLK  : in  std_logic;
      TOD  : out std_logic_vector(3 downto 0)
    );
  end component;

中略

  CNT10 : COUNT10
    port map(
      RSTn => RSTn,
      CLK  => DCLK,
--    TOD => CBIT,
      TOD(0)  => CBIT(0),
      TOD(1)  => CBIT(1),
      TOD(2)  => CBIT(2),
      TOD(3)  => CBIT(3)
    );
Total Pages: 1 / 512345

よく投稿されているコード

タグ

最近投稿されたコード