Electrical Engineering V2

[S31-Syntax]

[QUOTE=DrDevil;42839238]Go buy one of those 1000-packs of headers on ebay. I bought mine 3 years ago and I still didn't run out.[/QUOTE]

I'm off to find the wizard, the wonderful wizard of bulk.

[Chryseus]

[QUOTE=Van-man;42839059]Around the same quality of a average modern smartphone.[/QUOTE]

In that case pretty much anything will do, although it depends on how much gain is needed, NE5532 is a popular low cost op-amp with good noise performance, if you want really audiophile grade get a OP275.

[Metallics]

[QUOTE=Nightrazr;42832428]What would be a good basis for a custom carputer? I've been looking at the R-Pi but I've been told it's a rather wonky piece of work for that goal as it has no ACPI.

Also; I want to figure out how to work with parking sensors, y'know those ultrasonic ones.

How would I go about finding out how they work and how I can implement them in my own things?[/QUOTE]

Buy one and play with it. They aren't terribly complex to interface with, I had reasonable success doing distance measurements with one of these
[url]http://www.maxbotix.com/documents/MB1000_Datasheet.pdf[/url]

Which are fairly cheap, just make sure if you have more than one you do some sort of time division multiplexing on them, as if you have them on together you tend to get interfering reflections, they're also very sensitive to objects in the peripheral field.

[pentium]

That feeling when you are halfway through cutting out an IC package to solder in a new one...when you realize you're cutting out the wrong chip...

[alexaz]

Can you take a 230 to 12 V torroidal transformer and then add a 6V tap by scraping off some insulation in the middle of the secondary and solder another wire? Does it work that way and is it dangerous?

[Chryseus]

[QUOTE=alexaz;42853052]Can you take a 230 to 12 V torroidal transformer and then add a 6V tap by scraping off some insulation in the middle of the secondary and solder another wire? Does it work that way and is it dangerous?[/QUOTE]

Yes you can do that, assuming the secondary is a single layer and wound on top of the primary.
Easiest way to test is to connect a meter to one side of the secondary and using a sharp probe tip scratch away a small bit of insulation until you make contact. make sure it's not the primary first by checking the resistance.

[TCWilliamson]

[QUOTE=Chryseus;42854137]make sure it's not the primary first by checking the resistance.[/QUOTE]
That is the most important part there... BAAAAADDD things happen when you don't do that.

[BooTs]

I am currently majoring in Electronics Engineering and our instructor just assigned us to find something we want to make whether it be from a kit or something from scratch, we have a lot of resources at my school so we can make our own cases and everything for it. Any suggestions for something that is cool, useful and not super hard to make?

[LoneWolf_Recon]

[QUOTE=BooTs;42857236]I am currently majoring in Electronics Engineering and our instructor just assigned us to find something we want to make whether it be from a kit or something from scratch, we have a lot of resources at my school so we can make our own cases and everything for it. Any suggestions for something that is cool, useful and not super hard to make?[/QUOTE]

How about a [URL="http://www.stefanv.com/electronics/retronome.html"]drum machine?[/URL] Or a [URL="http://www.discovercircuits.com/P/pwr-actodc.htm"]bench supply?[/URL] Or a [URL="http://www.talkingelectronics.com/projects/Spy%20Circuits/SpyCircuits-1.html"]minature FM bug transmitter?[/URL] Or a [URL="http://www.circuitstoday.com/10w-amplifier-using-tda2003"]sound amp?[/URL]
Or a [URL="http://www.robotroom.com/Weather-Station.html"]weather monitoring station?[/URL]

[S31-Syntax]

Okay so I'm messing around with the RTC module I got... Stuck some headers on that badboy, hooked it all up, grabbed some arduino example code for it from sparkfun, and loaded it up.
At first, all I got was literal gibberish, like special characters that couldn't be decoded.
After dicking with the baud rate I got it to come in in english.

However, now, it works fine up until I give it the command to change the time, then it goes nuts and every command returns a superlong string of more gibberish special characters.

The fuck did I do to it.

[r0b0tsquid]

I made a VGA signal generator on my FPGA! But it doesn't have enough memory for a framebuffer :v:

So I drew a little font:
[img]http://i.imgur.com/K04fFUL.png[/img]
(Use it if you want! It's based on my handwriting, sorry...)

Used some C++ and Python magic to turn that into a .coe file for the Xilinx tools, wrote some simple logic, replaced that logic cause it didn't work, and it now displays the Wikipedia page on VGA!

[img]http://i.imgur.com/mLhMdlR.jpg[/img]

There's no processor in there at the moment, that's just a static text screen buffer.

Sync on the top, video signal on the bottom:

[img]http://i.imgur.com/3txZSqy.jpg[/img]

[Lily]

I've always wanted to see if its actually possible to make custom PCI cards that arent fuckall expensive

Specially fully programmable, it would be absolutely amazing for fuckery

[Chryseus]

[QUOTE=Tobba;42874814]I've always wanted to see if its actually possible to make custom PCI cards that arent fuckall expensive

Specially fully programmable, it would be absolutely amazing for fuckery[/QUOTE]

Something simple sure, but anything complicated and you're talking 4 or more layer boards which is expensive.

[Angus725]

[QUOTE=Tobba;42874814]I've always wanted to see if its actually possible to make custom PCI cards that arent fuckall expensive

Specially fully programmable, it would be absolutely amazing for fuckery[/QUOTE]

I think these are for PCIE based cards development:
[url]http://www.altera.com/education/univ/materials/boards/de4/unv-de4-board.html[/url]

Expensive as hell. Heard of some guys at my university doing research with them; think they were making them into automatically re-programmable hardware accelerators for scientific computing.

@r0b0tsquid:

Working on a tetris game due in 2ish weeks, using 2 FSMs with 14 states or so each, will probably end up with 2k+ lines of verilog.

Work in progress code:

module VGADATAPATH
(
clock,
input_state, //Main FSM inputs
new_block,

block_shape, //current updating block
block_location_x,
block_location_y,
block_color,

next_block_shape, // next block selector
next_block_color,

score, //score

memory_access, //Memory addresser

memory_color, //Memory return

pixel_x, //output data
pixel_y,
color_out,
plot,
datapathState
);

parameter	BLOCKSIZE = 3'd15, // 16x16 block sizes
				GRID_LOCATION_X = 9'd80,
				GRID_LOCATION_Y = 7'd0,
				NEXTBLOCK_LOCATION_X = 9'd35,
				NEXTBLOCK_LOCATION_Y = 7'd80,
				SCORE_LOCATION_X = 9'd35,
				SCORE_LOCATION_Y = 7'd160,
				BLANK_COLOR = 3'b000;

input clock; //clock_50
input [2:0]input_state; //Main FSM inputs
input new_block;

input [15:0]block_shape; //current updating block
input [3:0]block_location_x;
input [4:0]block_location_y;
input [2:0]block_color;

input [15:0]next_block_shape; // next block selector
input [2:0]next_block_color;

input [15:0]score;

input [2:0]memory_color; //Memory return

output reg [7:0]memory_access; //Memory addresser

output reg [9:0]pixel_x; //output data
output reg [7:0]pixel_y;
output reg [2:0]color_out;
output reg plot;
output [3:0]datapathState;
assign datapathState = internal_state;
// state discriptions
// 
// input_state:
//		00	A	x
//		01	B	block_update
//		10	C	full_refresh (eg, row deletion, newgame, etc)
//		11	D	gameover
//		
//	new_block:
//		0		next block has NOT changed
//		1		next block CHANGED
//
//
// Internal_state:
//		0000	A	idle
//		0001	B	block_update_erase
//		0010	C	block_update_draw
//		0011	D	next_block_erase
//		0100	E	next_block_draw
//		0101	F	full_refresh
//		0110	G	gameover
//		0111	H	score_erase
//		1000	I	score_draw
//		1001	J	
//		1010	K	
//		1011	L	loadgame
//		1100	M	
//		1101	N	
//		1110	O	
//		1111	P	
parameter	A = 4'b0000,
				B = 4'b0001,
				C = 4'b0010,
				D = 4'b0011,
				E = 4'b0100,
				F = 4'b0101,
				G = 4'b0110,
				H = 4'b0111,
				I = 4'b1000,
				J = 4'b1001,
				K = 4'b1010,
				L = 4'b1011,
				M = 4'b1100,
				N = 4'b1101,
				O = 4'b1110,
				P = 4'b1111;

reg [15:0]last_block_shape;
reg [3:0]last_block_location_x; //might be better in RAM
reg [5:0]last_block_location_y;
reg [2:0]last_block_color;

reg [3:0]counter4bit;
reg [9:0]add_to_x;
reg [7:0]add_to_y;

reg [3:0]internal_state;

initial
begin
	input_state <= 2'b11;
	internal_state <= 4'b0;
	add_to_x <=0;
	add_to_y <=0;
	counter15 <=0;
end



always@(posedge clock)
begin

	case(internal_state)
		A: //Idle
			begin
			
			
			if (input_state == 2'b01 & new_block)//block update, new block created
				internal_state <= B;//should be D
				
			else if (input_state == 2'b01 & ~new_block)//block update, no new block
			begin
				internal_state <= B;
				add_to_x <= 0;
				add_to_y <= 0;
			end
				
			else if (input_state == 2'b10)//full_refresh
				internal_state <= F;
				
			else if (input_state == 2'b01) //gameover
				internal_state <= G;
				
			else
			begin
				internal_state <= 4'b0000;
			end
			
			
			end
			
		B: //block_update_erase
			begin
				pixel_x <= GRID_LOCATION_X + last_block_location_x * BLOCKSIZE + add_to_x;
				pixel_y <= GRID_LOCATION_Y + last_block_location_y * BLOCKSIZE + add_to_y;
				if (last_block_shape[counter4bit])
				begin
					if (add_to_y < BLOCKSIZE)
					begin
						plot <= 1;
						color_out <= BLANK_COLOR;
						if (add_to_x < BLOCKSIZE)
							add_to_x <= add_to_x + 1;
						else
						begin
							if (add_to_x == BLOCKSIZE & add_to_y == BLOCKSIZE)
							begin
									plot <=0;
								add_to_x <=0;
								add_to_y <=0;
								counter4bit<=0;
								internal_state <= C;
							
							end
							else
							begin
								add_to_y <= add_to_y + 1;
								add_to_x <= 0;
							end
						end
						counter4bit <= counter4bit +1;
					end
					else
					begin
						plot <=0;
						add_to_x <=0;
						add_to_y <=0;
						counter4bit<=0;
						internal_state <= C;
					end
				end
			end
			
		C: //block_update_draw
			begin
				pixel_x <= GRID_LOCATION_X + block_location_x * BLOCKSIZE + add_to_x;
				pixel_y <= GRID_LOCATION_Y + block_location_y * BLOCKSIZE + add_to_y;
				if (last_block_shape[counter4bit])
				begin
					if (add_to_y < BLOCKSIZE)
					begin
						plot <= 1;
						color_out <= block_color;
						if (add_to_x < BLOCKSIZE)
							add_to_x <= add_to_x + 1;
						else
						begin
							if (add_to_x == BLOCKSIZE & add_to_y == BLOCKSIZE)
								plot <=0;
							add_to_y <= add_to_y + 1;
							add_to_x <= 0;
						end
					end
					else
					begin
						plot <=0;
						add_to_x <=0;
						add_to_y <=0;
						counter4bit <= 0;
						internal_state <= A;
					end
				end
				last_block_location_x <= block_location_x;
				last_block_location_y <= block_location_y;
				last_block_color <= block_color;
				last_block_shape <= block_shape;
			end
			
		D: //newblock_update_erase
			begin
				
			
			end
			
		E: //newblock_update_draw
			begin
			
			
			end
			
		F:	//full_refresh
			begin
			
			
			end
			
		G:	//gameover
			begin
			
			
			end
			
		H: //score_erase
			begin
			
			
			end
			
		I: //score_draw
			begin
			
			
			end
		J: //
			begin
			
			
			end
		K: //
			begin
			
			
			end
		L: //loadgame
			begin
			
			
			end
		endcase
end





endmodule

module MainFSM
(
keyboard,
reset,
pause,
clock,
reduced_clock,

memory_read_address,
memory_read_data,

memory_write_address,
memory_write_data,
memory_write_enable,

state_output,  //Main FSM state_output
new_block,		//new block generation

block_shape, //current updating block
block_location_x,
block_location_y,
block_color,

next_block_shape, // next block selector
next_block_color,

score

);

parameter	BLOCKSIZE = 3'd3, // 3x3 block sizes
				GRID_CENTER_LOCATION_X = 4'b4,
				GRID_CENTER_LOCATION_Y = 5'0,
				GRID_SIZE_X = 4'd10,
				GRID_SIZE_Y = 5'd20,
				SCORE_LOCATION_X = 9'd35,
				SCORE_LOCATION_Y = 7'd160,
				BLANK_COLOR = 3'b000;

input [3:0]keyboard;
input reset;
input pause;
input clock;
input reduced_clock;

output reg [7:0]memory_read_address;
input [2:0]memory_read_data;

output reg [7:0]memory_write_address;
output reg [2:0]memory_write_data;
output reg memory_write_enable;

output reg [1:0]state_output;  //Main FSM state_output
output reg new_block;		//new block generation

output reg [15:0]block_shape; //current updating block
output reg [3:0]block_location_x;
output reg [4:0]block_location_y;
output reg [2:0]block_color;

output reg [15:0]next_block_shape; // next block selector
output reg [2:0]next_block_color;

output reg [15:0]score;


reg [3:0]internal_state;
// Internal_state
//		0000	A	loadgame
//		0001	B	start
//		0010	C	new_block
//		0011	D	new_block_legal_check
//		0100	E	new_block_memory_write
//		0101	F	new_block_draw
//		0110	G	move_block
//		0111	H	move_block_legal_check
//		1000	I	move_block_memory_write
//		1001	J	move_block_draw
//		1010	K	row_check
//		1011	L	remove_row_memory_write
//		1100	M	remove_row_draw
//		1101	N	game_over
//		1110	O	rotate_block_legal_check
//		1111	P	
parameter	A = 4'b0000,
				B = 4'b0001,
				C = 4'b0010,
				D = 4'b0011,
				E = 4'b0100,
				F = 4'b0101,
				G = 4'b0110,
				H = 4'b0111,
				I = 4'b1000,
				J = 4'b1001,
				K = 4'b1010,
				L = 4'b1011,
				M = 4'b1100,
				N = 4'b1101,
				O = 4'b1110,
				P = 4'b1111;
				

initial
begin
	internal_state <=4'b0000;
	counter_x <= 0;
	counter_y <= 0;
end

reg [1:0]counter_x;
reg [1:0]counter_y;

always@(posedge clock)
begin
	case (internal_state)
	A:
	begin //not done
		//		0000	A	loadgame
		internal_state <= B;
	end
	B:
	begin //not done
		//		0001	B	start
		internal_state <= C;
	end
	C:
	begin //not done
		//		0010	C	new_block
		block_shape <= BLOCK_T_1;
		block_color <= 3'b101;
		internal_state <= D;
	end
	D:
	begin //not done
		internal_state <= E;
		counter_x <= 0;
		counter_y <= 0;
		//		0011	D	new_block_legal_check
	end
	E:
	begin
	if (block_shape[{counter_x,counter_y}])
		begin
		memory_write_address <= {GRID_CENTER_LOCATION_X + counter_x,GRID_CENTER_LOCATION_Y + counter_y};
		memory_write_data <= block_color;
		memory_write_enable <= 1'b1;
		end
	else
		memory_write_enable < 1'b0;
		
	if (counter_y < BLOCKSIZE)
	begin
		if (counter_x < BLOCKSIZE)
			counter_x <= counter_x + 1;
		else
		begin
			if (counter_x == BLOCKSIZE & counter_y == BLOCKSIZE)
			begin
				memory_write_enable <= 1'b0;
				internal_state <= F;
				counter_x <=0;
				counter_y <=0;
			end
			else
			begin
				counter_y <= counter_y + 1;
				counter_x <= 0;
			end
			
		end
	end
	else
		begin
			memory_write_enable <= 1'b0;
			internal_state <= F;
			counter_x <=0;
			counter_y <=0;
		end
		//		0100	E	new_block_memory_write
	end
	F:
	begin
		if (new_block == 1'b0)
		begin
			block_location_x <= GRID_CENTER_LOCATION_X - x_corner;
			block_location_y <= GRID_CENTER_LOCATION_Y - y_corner;
			state_output <= 2'b01;
			new_block <= 1'b1;
		end
		else
		begin
			internal_state <= G;
			state_output <= 2'b00;
		end
		

		//		0101	F	new_block_draw
	end
	
	G:
	begin
		//		0110	G	move_block
		// if keyboard presses something do different stuff
		internal_state <= H;
	end
	H:
	begin
		//		0111	H	move_block_legal_check
		if (block_location_y >= 6'b18)
			internal_state <= K;
		else
		begin
			block_location_y <= block_location_y + 1;
			internal_state <= I;
			
			
			
		end
	end
	
	I:
	begin
		begin
	if (block_shape[{counter_x,counter_y}])
		begin
		memory_write_address <= {counter_x+block_location_x,counter_y+block_location_y};
		memory_write_data <= block_color;
		memory_write_enable <= 1'b1;
		end
	else
		memory_write_enable < 1'b0;
		
	if (counter_y < BLOCKSIZE)
	begin
		if (counter_x < BLOCKSIZE)
			counter_x <= counter_x + 1;
		else
		begin
			if (counter_x == BLOCKSIZE & counter_y == BLOCKSIZE)
			begin
				memory_write_enable <= 1'b0;
				internal_state <= ;
				counter_x <=0;
				counter_y <=0;
			end
			else
			begin
				counter_y <= counter_y + 1;
				counter_x <= 0;
			end
			
		end
	end
	else
		begin
			memory_write_enable <= 1'b0;
			internal_state <= J;
			counter_x <=0;
			counter_y <=0;
		end
		//		1000	I	move_block_memory_write
	end
	J:
	begin
		begin
		if (new_block == 1'b0)
		begin
			block_location_x <= block_location_x + x_corner;
			block_location_y <= GRID_CENTER_LOCATION_Y - y_corner;
			state_output <= 2'b01;
			new_block <= 1'b1;
		end
		else
		begin
			internal_state <= K;
			state_output <= 2'b00;
		end
		
		//		1001	J	move_block_draw
	end
	K:
	begin
		//		1010	K	row_check
	end
	L:
	begin
		//		1011	L	remove_row_memory_write
	end
	M:
	begin
		//		1100	M	remove_row_draw
	end
	N:
	begin
		//		1101	N	game_over
	end
	O:
	begin
		//		1110	O	rotate_block_legal_check
	end
	P:
	begin
		//		1111	P	
	end
	
reg [1:0]x_corner, y_corner;
find_top_left topleft(block_shape, x_corner, y_corner);






	endcase

end



parameter 
BLOCK_0_1 = 16'b0000011001100000,

BLOCK_I_1 = 16'b0000111100000000,
BLOCK_I_2 = 16'b0010001000100010,

BLOCK_S_1 = 16'b0000001101100000,
BLOCK_S_2 = 16'b0010001100010000,

BLOCK_Z_1 = 16'b0000011000110000,
BLOCK_Z_2 = 16'b0001001100100000,

BLOCK_L_1 = 16'b0000011101000000,
BLOCK_L_2 = 16'b0010001000110000,
BLOCK_L_3 = 16'b0001011100000000,
BLOCK_L_4 = 16'b0110001000100000,

BLOCK_J_1 = 16'b0000011100010000,
BLOCK_J_2 = 16'b0011001000100000,
BLOCK_J_3 = 16'b0100011100000000,
BLOCK_J_4 = 16'b0010001001100000,

BLOCK_T_1 = 16'b0000011100100000,
BLOCK_T_2 = 16'b0010001100100000,
BLOCK_T_3 = 16'b0010011100000000,
BLOCK_T_4 = 16'b0010011000100000;


endmodule


module find_top_left
(input [15:0]block_shape,
output reg [1:0]x_corner,
output reg [1:0]y_corner
);
always@(*)
begin
case (block_shape)
	BLOCK_0_1:
		begin
		x_corner = 2'b01;
		y_corner = 2'b01;
		end
	BLOCK_I_1:
			begin
		x_corner = 2'b00;
		y_corner = 2'b01;
		end
	BLOCK_I_2:
			begin
		x_corner = 2'b10;
		y_corner = 2'b00;
		end

	BLOCK_S_1:
			begin
		x_corner = 2'b01;
		y_corner = 2'b01;
		end
	BLOCK_S_2:
			begin
		x_corner = 2'b10;
		y_corner = 2'b00;
		end

	BLOCK_Z_1://not done
			begin
		x_corner = 2'b01;
		y_corner = 2'b01;
		end
	BLOCK_Z_2://not done
			begin
		x_corner = 2'b01;
		y_corner = 2'b01;
		end

	BLOCK_L_1://not done
			begin
		x_corner = 2'b01;
		y_corner = 2'b01;
		end
	BLOCK_L_2://not done
			begin
		x_corner = 2'b01;
		y_corner = 2'b01;
		end
	BLOCK_L_3://not done
			begin
		x_corner = 2'b01;
		y_corner = 2'b01;
		end
	BLOCK_L_4://not done
			begin
		x_corner = 2'b01;
		y_corner = 2'b01;
		end

	BLOCK_J_1://not done
			begin
		x_corner = 2'b01;
		y_corner = 2'b01;
		end
	BLOCK_J_2://not done
			begin
		x_corner = 2'b01;
		y_corner = 2'b01;
		end
	BLOCK_J_3://not done
			begin
		x_corner = 2'b01;
		y_corner = 2'b01;
		end
	BLOCK_J_4://not done
			begin
		x_corner = 2'b01;
		y_corner = 2'b01;
		end

	BLOCK_T_1:
			begin
		x_corner = 2'b01;
		y_corner = 2'b01;
		end
	BLOCK_T_2:
			begin
		x_corner = 2'b10;
		y_corner = 2'b00;
		end
	BLOCK_T_3:
			begin
		x_corner = 2'b01;
		y_corner = 2'b00;
		end
	BLOCK_T_4:
			begin
		x_corner = 2'b01;
		y_corner = 2'b00;
		end


parameter 
BLOCK_0_1 = 16'b0000011001100000,

BLOCK_I_1 = 16'b0000111100000000,
BLOCK_I_2 = 16'b0010001000100010,

BLOCK_S_1 = 16'b0000001101100000,
BLOCK_S_2 = 16'b0010001100010000,

BLOCK_Z_1 = 16'b0000011000110000,
BLOCK_Z_2 = 16'b0001001100100000,

BLOCK_L_1 = 16'b0000011101000000,
BLOCK_L_2 = 16'b0010001000110000,
BLOCK_L_3 = 16'b0001011100000000,
BLOCK_L_4 = 16'b0110001000100000,

BLOCK_J_1 = 16'b0000011100010000,
BLOCK_J_2 = 16'b0011001000100000,
BLOCK_J_3 = 16'b0100011100000000,
BLOCK_J_4 = 16'b0010001001100000,

BLOCK_T_1 = 16'b0000011100100000,
BLOCK_T_2 = 16'b0010001100100000,
BLOCK_T_3 = 16'b0010011100000000,
BLOCK_T_4 = 16'b0010011000100000;

end

endmodule

etc

[pentium]

[QUOTE=Tobba;42874814]I've always wanted to see if its actually possible to make custom PCI cards that arent fuckall expensive

Specially fully programmable, it would be absolutely amazing for fuckery[/QUOTE]

I had a friend who asked the same thing today. He wondered what a hardware Javascript accelerator for Firefox would look like besides an FPGA on a PCI prototype board.

[BooTs]

[QUOTE=LoneWolf_Recon;42857491]How about a [URL="http://www.stefanv.com/electronics/retronome.html"]drum machine?[/URL] Or a [URL="http://www.discovercircuits.com/P/pwr-actodc.htm"]bench supply?[/URL] Or a [URL="http://www.talkingelectronics.com/projects/Spy%20Circuits/SpyCircuits-1.html"]minature FM bug transmitter?[/URL] Or a [URL="http://www.circuitstoday.com/10w-amplifier-using-tda2003"]sound amp?[/URL]
Or a [URL="http://www.robotroom.com/Weather-Station.html"]weather monitoring station?[/URL][/QUOTE]

Sorry, I didn't really specify on how simple they had to be. Basically I just started the course, I just finished the DC class and am now in a Digital Class. So anything that'd I'd have to program wouldn't work. Just something simple but fun.

[LoneWolf_Recon]

[QUOTE=BooTs;42886046]Sorry, I didn't really specify on how simple they had to be. Basically I just started the course, I just finished the DC class and am now in a Digital Class. So anything that'd I'd have to program wouldn't work. Just something simple but fun.[/QUOTE]

The Sound Amp, Bench Supply and FM Bug transmitter may work for you, you can also try some shenanigans with the [URL="http://www.instructables.com/id/47-projects-to-do-with-a-555/"]555[/URL].

[BooTs]

[QUOTE=LoneWolf_Recon;42886902]The Sound Amp, Bench Supply and FM Bug transmitter may work for you, you can also try some shenanigans with the [URL="http://www.instructables.com/id/47-projects-to-do-with-a-555/"]555[/URL].[/QUOTE]

Oh! So a 555 is basically a timer? That is actually very interesting. I just bought a new PC and the only thing I don't like about it is that my case is dark. Maybe I could try to make something to lighten it up but in a creative way.

[Lily]

[QUOTE=Chryseus;42875083]Something simple sure, but anything complicated and you're talking 4 or more layer boards which is expensive.[/QUOTE]

I actually wonder if you could get something like a legacy VGA device and a USB host controller under a multifunction device to fit in a 2 layer board, think intel remote management interface, its not really necessary to get a lot of bandwidth for that either, so you could probably pull any latency value you want out of your ass

[editline]17th November 2013[/editline]

Apparently, standard latency is 32 cycles, even with the maximum of 255, you'd have serious issues finishing a transaction in 255 cycles with crappy hardware

[editline]17th November 2013[/editline]

It is apparently possible however, I'll have to actually do some research I guess

[chaz13]

I think my shitty soldering iron might be short-circuiting but I'm not certain, is there a way to check that doesn't involve blowing the fuse/tripping the circuit breaker?

[DrLuke]

[QUOTE=chaz13;42891184]I think my shitty soldering iron might be short-circuiting but I'm not certain, is there a way to check that doesn't involve blowing the fuse/tripping the circuit breaker?[/QUOTE]

Don't solder on live circuits

[chaz13]

I don't mean the circuit, I think the the iron itself might be broken but I'm not too sure. Can't just plug it in and see because I've got a few housemates working on their pc's who wouldn't appreciate the circuit breaker tripping :smile:

[DrLuke]

[QUOTE=chaz13;42891326]I don't mean the circuit, I think the the iron itself might be broken but I'm not too sure. Can't just plug it in and see because I've got a few housemates working on their pc's who wouldn't appreciate the circuit breaker tripping :smile:[/QUOTE]

You could try using your multimeter to see if there is any obvious short circuit fault.

[Chryseus]

In my experience the fuse in the plug will blow before the breaker is able to trip.

[ben1066]

[QUOTE=Tobba;42874814]I've always wanted to see if its actually possible to make custom PCI cards that arent fuckall expensive

Specially fully programmable, it would be absolutely amazing for fuckery[/QUOTE]

[url]http://www.latticesemi.com/en/Products/DevelopmentBoardsAndKits/LatticeECP3VersaDevelopmentKit.aspx[/url]

That is only about 200$ I think the cheapest PCIe dev board.

[Ddrl46]

Modified my Basetech bench power supply a little bit to speed up the voltage and current readout, since it uses a standard 7107 IC all I had to do was put a resistor in parallel with the resistor in the RC oscillator the chip uses. In this case I put a 100k resistor in parallel with R1 and R2 on the display pcb.

Video comparing the modified voltage readout and the un-modified current readout:
[video=youtube;IMBA3A-RFv0]http://www.youtube.com/watch?v=IMBA3A-RFv0[/video]

[alexaz]

So i'v been trying to build the god damn linear regulator once more.
[img]http://i.imgur.com/6D8a4II.png[/img]

With really small loads the output is okay, however with 10 ohms the red waveform is Q1's collector and red is emitter. Not something i'd like to call a linear regulator's output.

[img]http://i.imgur.com/HqDTa63.png[/img]

[DrLuke]

Add a decoupling cap to the input aswell

[alexaz]

Did try from 1 uf to 1400 uf. All it does is reduce it, not get rid of it.

[Chryseus]

160kHz oscillation is either:
External noise being amplified by the op-amp due to insufficient high frequency rejection, or possibly noise injected from a switching supply if that's what your using to test the regulator.
Oscillation from the op-amp feedback loop itself, although I'm somewhat dubious this is the case.

Try add 10nF to ground on your reference input.