audio:	PROCESS (reset, clockNC, sensitivityFlag, writeFinish, readFinish2) 
	
	VARIABLE double:		NATURAL RANGE 0 TO 16 	:= 0;
	VARIABLE	state:		NATURAL RANGE 0 TO 2 	:= 0;
	VARIABLE word_state:	NATURAL RANGE 0 TO 2 	:= 0;
	VARIABLE state3:		NATURAL RANGE 0 TO 2		:= 0;
	VARIABLE word_state_sd:	NATURAL RANGE 0 TO 3	:= 0;
	VARIABLE double_sd:		NATURAL RANGE 0 TO 16 	:= 0;
	
	---------------------------------------------------------------------------------------------------------
	-----------------------SD-CARD---------------------------------------------------------------------------
	---------------------------------------------------------------------------------------------------------
	
	BEGIN			
				
		IF reset = '0' THEN
		
			sound <= '0';
			cnt <= 0;
			double := 0;
			word_state := 0;
			state := 0;
			state3 :=0;
			mem_max <= 0;
			mem_addr <= 0;
			mem_addr_old <= 0;
			read_write <= '1';
			RAM_IN <= (OTHERS => '0');
			soft_reset <= '0';
			token_word <= (OTHERS => '0');			
			
			reset_sd <= '0';	
			sdstartread <= '0';	
			sdstartwrite <= '0';
			newNextByte <= '0';
			nextByte <= '0';
			sd_in <= "000000000";
			word_state_sd := 0;
			readNextByte <= '0';
			double_sd := 0;
			
		
		ELSIF clockNC'EVENT AND clockNC = '1' THEN

			soft_reset <= '0';	
		
			IF sd_enable = '1' then
				reset_sd <= '1';			-- Reset aus SD-Karte entfernen, Initialisierung kann beginnen
				
				if sd_init = '1' then	-- Abfrage ob SD-Card Initialisert ist
				
----------LESEN AUS DER SD-Card-------------------------------------------------------------------------------------------------				
					
					if sd_mode = '1' then --Switch oben, es wird gelesen
						
						done_rise2 <= '0';
						done_old2 <= done_pressing;								--wenn done_pressing = 1 -> Taster wurde losgelassen
				
						IF done_old2 = '0' AND done_pressing = '1' THEN		-- Taste wurde gedrückt 
							done_rise2 <= '1';										-- wenn done_rise2 = 1 -> Taste gedrückt, wenn = 0 dann nicht gedrückt
						END IF;
						
						--Token-Signal in Token_Word-Signal übertragen, wenn eine Taste gedrückt wurde und diese Taste ein "Enter" war
						IF done_rise2 = '1' AND (token = "11000000000000" or token = "11011010000000" 
						or token = "11010000000000" or token = "11011011000000" or token = "11011011010000" or token= "11011000000000") THEN
							word_state_sd := 0;
						end if;
									
						CASE word_state_sd IS
							
							WHEN 0 =>
							
								sdstartread <= '1';
								readNextByte <= '1';
								word_state_sd := 1;
								
							WHEN 1 =>
									
								if readFinish = '1' then
												
									Case dout is
							
										when "01000001"	=>	token_word_sd	<="00000000001101";	--	A
										when "01000010"	=>	token_word_sd	<="00000001010111";	--	B
										when "01000011"	=>	token_word_sd	<="00000001110111";	--	C
										when "01000100"	=>	token_word_sd	<="00000000010111";	--	D
										when "01000101"	=>	token_word_sd	<="00000000000001";	--	E
										when "01000110"	=>	token_word_sd	<="00000001110101";	--	F
										when "01000111"	=>	token_word_sd	<="00000000011111";	--	G
										when "01001000"	=>	token_word_sd	<="00000001010101";	--	H
										when "01001001"	=>	token_word_sd	<="00000000000101";	--	I
										when "01001010"	=>	token_word_sd	<="00000011111101";	--	J
										when "01001011"	=>	token_word_sd	<="00000000110111";	--	K
										when "01001100"	=>	token_word_sd	<="00000001011101";	--	L
										when "01001101"	=>	token_word_sd	<="00000000001111";	--	M
										when "01001110"	=>	token_word_sd	<="00000000000111";	--	N
										when "01001111"	=>	token_word_sd	<="00000000111111";	--	O
										when "01010000"	=>	token_word_sd	<="00000001111101";	--	P
										when "01010001"	=>	token_word_sd	<="00000011011111";	--	Q
										when "01010010"	=>	token_word_sd	<="00000000011101";	--	R
										when "01010011"	=>	token_word_sd	<="00000000010101";	--	S
										when "01010100"	=>	token_word_sd	<="00000000000011";	--	T
										when "01010101"	=>	token_word_sd	<="00000000110101";	--	U
										when "01010110"	=>	token_word_sd	<="00000011010101";	--	V
										when "01010111"	=>	token_word_sd	<="00000000111101";	--	W
										when "01011000"	=>	token_word_sd	<="00000011010111";	--	X
										when "01011001"	=>	token_word_sd	<="00000011110111";	--	Y
										when "01011010"	=>	token_word_sd	<="00000001011111";	--	Z
															
															
										when "00110000"	=>	token_word_sd	<="00001111111111";	--	0
										when "00110001"	=>	token_word_sd	<="00001111111101";	--	1
										when "00110010"	=>	token_word_sd	<="00001111110101";	--	2
										when "00110011"	=>	token_word_sd	<="00001111010101";	--	3
										when "00110100"	=>	token_word_sd	<="00001101010101";	--	4
										when "00110101"	=>	token_word_sd	<="00000101010101";	--	5
										when "00110110"	=>	token_word_sd	<="00000101010111";	--	6
										when "00110111"	=>	token_word_sd	<="00000101011111";	--	7
										when "00111000"	=>	token_word_sd	<="00000101111111";	--	8
										when "00111001"	=>	token_word_sd	<="00000111111111";	--	9
										WHEN OTHERS 		=> token_word_sd 	<=(OTHERS => '0');  
										
									End Case;
									word_state_sd := 2;
									double_sd  := 0;
									
								end if;
								
							When 2 =>	
							
								IF double_sd >= 0 AND double_sd < 14 THEN
										
										
									IF token_word_sd(double_sd + 1 DOWNTO double_sd) = "01" THEN											
											
									--Codierung eines "Dits" als Signal mit doppelter Periodendauer der Wortgeschwindigkeit
										IF cnt >= 2 THEN
											cnt <= 0;
											sound <= '0';
											double_sd := double_sd + 2;
										ELSE
											cnt <= cnt + 1;
											sound <= '1';
										END IF;
								
									ELSIF token_word_sd(double_sd +1 DOWNTO double_sd) = "11" THEN																							
											
									--Codierung eines "Dahs" als Signal mit sechsfacher Periodendauer der Wortgeschwindigkeit
									--(3-fache Dit-Länge)
										IF cnt >= 6 THEN
											cnt <= 0;
											sound <= '0';
											double_sd := double_sd + 2;
										ELSE
											cnt <= cnt + 1;
											sound <= '1';
										END IF;
									
									ELSIF token_word_sd(13 DOWNTO 0) = "10000000000000" THEN --Prüfen ob das Tokenwort ein Leerzeichen repräsentiert			
								
									--In kombination mit dem cnt = 6 von "double_sd >= 14" ergibt sich eine Länge von 7 "Dits"! => Pause zwischen Worten
										IF cnt >= 8 THEN 
											cnt <= 0;
											sound <= '0';
											double_sd := 14;	
										ELSE
											cnt <= cnt + 1;								
										END IF;
								
										--wenn im Datenwort nur noch Nullen stehen muss die Leseadresse inkrementiert und anschließend das neue Datenwort ausgelesen werden		
									ELSIF token_word_sd(double_sd +1 DOWNTO double_sd) = "00" AND token_word_sd(13 DOWNTO 0) /= "11000000000000" AND 
										token_word_sd(13 DOWNTO 0) /= "10000000000000" AND token_word_sd(13 DOWNTO 0) /= "11010000000000" AND token_word_sd(13 DOWNTO 0) /= "11011000000000" 
										AND token_word_sd(13 DOWNTO 0) /= "11011010000000" AND token_word_sd(13 DOWNTO 0) /= "11011011000000" AND token_word_sd(13 DOWNTO 0) /= "11011011010000" THEN
																	
												
--				"11000000000000"; -- "ENTER"
--				"11010000000000"; -- "Backspace" 
--				"11011000000000"; -- "Entf"
--				"11011010000000"; -- "Esc"
--				"11011011000000"; -- "left Arrow"											
--				"11011011010000"; -- "Right Arrow"
								
										sound <= '0';
										cnt <= 0;
										double_sd := 14;
										
									END IF;
								END IF;
								
							--Wenn das Datenwort zuende analysiert wurde, wird die Leseadresse inkrementiert und das nächste Datenwort ausgelesen
								IF double_sd >= 14 THEN
									IF cnt >= 6 THEN
										cnt <= 0;
										sound <= '0';
										double_sd := 0;
											
										word_state_sd := 1;
										readNextByte <= '1';
									ELSE
										cnt <= cnt + 1;
											
									END IF;	
								END IF;
							
							WHEN Others =>		
						
						END CASE;
----------SCHREIBEN in die  SD-Card-------------------------------------------------------------------------------------------------				

					elsif sd_mode = '0' then		--Switch unten, es wird geschrieben 					
						word_state_sd := 0;
						
						done_rise2 <= '0';
						done_old2 <= done_pressing;								--wenn done_pressing = 1 -> Taster wurde losgelassen
				
						IF done_old2 = '0' AND done_pressing = '1' THEN		-- Taste wurde gedrückt 
							done_rise2 <= '1';										-- wenn done_rise2 = 1 -> Taste gedrückt, wenn = 0 dann nicht gedrückt
						END IF;
						
						--wurden alle 512 Bytes uebertragen wird auf neue Eingabe gewartet
						if writeFinish = '1' then
							sdstartwrite <= '0';
							newNextByte <= '0';
						end if;
						
						--Daten in den RAM schreiben, wenn eine Taste betätigt wurde und diese Taste KEIN "Enter", "ESC", "Backspace", "left arrow" oder "right arrow" war
						IF (done_rise2 = '1') AND token /= "11000000000000" and token /= "11011010000000" 
						and token /= "11010000000000" and token /= "11011011000000" and token /= "11011011010000"	and token/= "11011000000000" AND word_state = 0 THEN
								
							sdstartwrite <= '1';
							nextByte <= '1';
							sd_in <= token_1;
							
							
						
						--Token-Signal in Token_Word-Signal übertragen, wenn eine Taste gedrückt wurde und diese Taste ein "Enter" war
						ELSIF done_rise2 = '1' AND (token = "11000000000000" or token = "11011010000000" 
						or token = "11010000000000" or token = "11011011000000" or token = "11011011010000" or token= "11011000000000") THEN
							
							nextByte <= '1';
							sd_in <= "000000000";
							
							newNextByte <= '1';
							
						elsif  newNextByte = '0' then
							nextByte <= '0';
						end if;
				
					end if;
				end if;
			
			ELSIF word = '0' THEN
			
				done_rise <= '0';
				done_old <= done_pressing;
					
				IF done_old = '0' AND done_pressing = '1' THEN
					done_rise <= '1';	
				END IF;
				
			
				IF double >= 0 AND double < 14 THEN
					
					--Codierung eines "Dits" als Signal mit doppelter Periodendauer der Wortgeschwindigkeit
					IF token(double + 1 DOWNTO double) = "01" THEN
					
						IF cnt >= 2 THEN
							cnt <= 0;
							sound <= '0';
							double := double + 2;
						ELSE
							cnt <= cnt + 1;
							sound <= '1';
						END IF;
					
					--Codierung eines "Dahs" als Signal mit sechsfacher Periodendauer der Wortgeschwindigkeit
					--(3-fache Dit-Länge)
					ELSIF token(double +1 DOWNTO double) = "11" THEN
					
						IF cnt >= 6 THEN
							cnt <= 0;
							sound <= '0';
							double := double + 2;
						ELSE
							cnt <= cnt + 1;
							sound <= '1';
						END IF;
						
					--Auslesen beenden, wenn nur noch Nullen im Token-Signal gelesen werden	
					ELSE
					
						sound <= '0';
						double := 14;			
					
					END IF;
				
				END IF;