Forum: FPGA, VHDL & Co. Daten von FLASH in 2 BRAM schreiben


Daten von FLASH in 2 BRAM schreiben
von Igor (Gast)

Angehängte Dateien:
Lesenswert?
• ▲
▼ 
Hallo,

ich habe wie schon in einem anderem Thread beschrieben einen Flash 
controller geschrieben der auch soweit funktioniert. Ich möchte jetzt 
die Daten von Flash in 2 BRAM schreiben, und zwar soll er in den 1.BRAM 
schreiben während er den 2. BRAM ausließt und dann wieder umgekehrt 
schreibt er in den 2 BRAM und ließt den 1 BRAM aus. (Beim ersten 
durchlauf ließt er logischer weiße nichts aus da noch keine daten 
geschrieben wurden)

Ich habe ein ZUSTANDSAUTOMATEN den ich für das Auslesen von FLASH und 
gleichzeitig für das schreiben in den ersten BRAM verwende und ein 
zweiten ZUSTANDSAUTOMATEN der den BRAM ausließt.

Zudem eine Schalter der die Enable Signal für die BRAMs  umschaltet.

So leider habe ich irgendwo ein Fehler und bitte euch daher vielleicht 
mal mir ein Tipp zu geben.


Laut Simulation sollten die Schreibe und lesen Zugriffe passen.

P.s Wie kann ich in der Simulation die Daten vom FLASH simulieren?


1
----------------------------------------------------------------------------------

2
-- Company: 

3
-- Engineer: 

4
-- 

5
-- Create Date:    17:15:57 12/21/2009 

6
-- Design Name: 

7
-- Module Name:    FLASH_CONTROLLER - Behavioral 

8
-- Project Name: 

9
-- Target Devices: 

10
-- Tool versions: 

11
-- Description: 

12
--

13
-- Dependencies: 

14
--

15
-- Revision: 

16
-- Revision 0.01 - File Created

17
-- Additional Comments: 

18
--

19
----------------------------------------------------------------------------------

20
library IEEE;

21
use IEEE.STD_LOGIC_1164.ALL;

22
use IEEE.STD_LOGIC_ARITH.ALL;

23
use IEEE.STD_LOGIC_UNSIGNED.ALL;

24
25
---- Uncomment the following library declaration if instantiating

26
---- any Xilinx primitives in this code.

27
--library UNISIM;

28
--use UNISIM.VComponents.all;

29
30
entity FLASH_CONTROLLER is

31
    Port (           

32
          ----------------------- NUR FÜR SIMULATION----------------------------------

33
          ----------------------- KANN ENTFERNT WERDEN--------------------------------

34
          DA_H          : out std_logic_vector(7 downto 0);  

35
          DA_L          : out std_logic_vector(7 downto 0);

36
          DATA_EN_H      : out std_logic;

37
          DATA_EN_L        : out std_logic;

38
          BYTE_SR        : out std_logic;

39
          ADD_ZE        : out std_logic;

40
          ADD_V          : out std_logic;

41
          ADD_EN         : out std_logic;

42
          

43
          BRAM_WR_RD_ENABLE                                : out std_logic;

44
          BRAM_R_ADD_COUNT_ENABLE                         :out std_logic;

45
          BRAM_R_ADD_COUNT_VOLL                          : out std_logic;

46
          BRAM_R_ADD                                  : out std_logic_VECTOR(13 downto 0):="11111111111111";

47
          BRAM_R_ADD_ZERO                              : out std_logic;  

48
49
          BRAM_CLK_1                                  : out std_logic;  

50
          BRAM_A_1                                    : out std_logic_VECTOR(13 downto 0);

51
          BRAM_IN_DA_1                                  : out std_logic_vector  (11 downto 0);

52
          BRAM_OUT_DA_1                                :out  std_logic_vector  (11 downto 0);

53
          BRAM_WR_ENABLE_1                              : out std_logic_vector (0 downto 0);

54
55
          BRAM_CLK_2                                  : out std_logic;  

56
          BRAM_A_2                                    :out std_logic_VECTOR(13 downto 0);

57
          BRAM_IN_DA_2                                :out std_logic_vector  (11 downto 0);  

58
          BRAM_OUT_DA_2                                : out std_logic_vector  (11 downto 0);

59
          BRAM_WR_ENABLE_2                              :out std_logic_vector (0 downto 0);

60
61
          DA_FROM_FLASH                                : out std_logic_vector (11 downto 0);   

62
          

63
          

64
          

65
          

66
          

67
          ----------------------------------------------------------------------------

68
          

69
          -------------------------STUER-UND DATENSIGNALE----------------------------

70
  

71
          BRAM_ADD_EN      : out std_logic;

72
          BRAM_WEAEN      : out std_logic_vector(0 downto 0);

73
          BADD          : out std_logic_VECTOR(13 downto 0):="00000000000000";

74
          

75
          --READ_BRAM_CLK                              : in std_logic;

76
          FLASH_ENABLE                          : in   std_logic;                   -- ENABLE SIGNAL FÜR ZUSTANDSAUTOMATEN,WANN DARF DER AUTOMAT LOSLAUFEN WANN SOLL ER SCHLAFEN

77
          FLASH_RESET                            : in  STD_LOGIC;                   -- FLASH RESET VON MASTER RESET

78
          FLASH_CLK                             : in  STD_LOGIC;                  -- 40 MHZ TAKT 25 ns

79
          FLASH_ADD                            : out std_logic_vector (23 downto 0);    -- FLASH ADDRESSEN

80
          FLASH_RP                              : out  std_logic;                    -- CHIP RESET,DIENT ZUR BESCHÜTZUNG DER DATEN WENN GESCHRIEBEN WIRD(DA ABER NUR GELSEN WIRD KANN AUF 1 GESETZT WERDEN)  

81
          FLASH_CE                              : out std_logic;                   -- CHIP ENABLE

82
          FLASH_OE                              : out std_logic;                    -- OUT ENABLE

83
          FLASH_DATA                            : in STD_LOGIC_vector (7 downto 0);      -- DATEN DIE IM FLASH EINGEBRANNT WURDEN (MIT IMPACT)

84
          AUSGABE_DATEN_BRAM                      : out std_logic_vector (11 downto 0);   

85
          DATAOUT                              : out std_logic_vector (11 downto 0));   -- EINGEBRANNTE DATEN WERDEN HIER AUSGELESEN(DA 12 BIT BREITE DATEN;WIRD 2 BYTE ZUSSAMENGGESCHRIEBEN)

86
          

87
          ----------------------------------------------------------------------------

88
end FLASH_CONTROLLER;

89
90
architecture Behavioral of FLASH_CONTROLLER is

91
92
COMPONENT SINGLE_RAM_1

93
  port (

94
        clka: IN std_logic;

95
        rsta: IN std_logic;

96
        wea: IN std_logic_VECTOR(0 downto 0);

97
        addra: IN std_logic_VECTOR(13 downto 0);

98
        dina: IN std_logic_VECTOR(11 downto 0);

99
        douta: OUT std_logic_VECTOR(11 downto 0));

100
End component;

101
102
COMPONENT SINGLE_RAM_2

103
  port (

104
        clka: IN std_logic;

105
        rsta: IN std_logic;

106
        wea: IN std_logic_VECTOR(0 downto 0);

107
        addra: IN std_logic_VECTOR(13 downto 0);

108
        dina: IN std_logic_VECTOR(11 downto 0);

109
        douta: OUT std_logic_VECTOR(11 downto 0));

110
End component;

111
---------------------------------------------

112
-- HIFSSIGNAL FÜR FLASH AUSLESEN

113
Signal A                                  : std_logic;

114
Signal CE,OE,RP                             : std_logic;

115
Signal ADD                                : std_logic_vector(23 downto 0):="000000000000000000000000";

116
Signal DATA_ENABLE_HI,DATA_ENABLE_LOW              : std_logic;

117
Signal DA_HI                              : std_logic_vector(7 downto 0);

118
Signal DA_LOW                              : std_logic_vector (7 downto 0);

119
Signal BYTE_SCHREIBEN                        : std_logic;

120
Signal ADD_COUNT_ENABLE,ADD_VOLL,ADD_ZERO            : std_logic;

121
-----------------------------------------------------------------------------------------

122
-- HILFSSIGNAL FÜR SCHREIBEN AUF BRAM

123
Signal BRAM_WRITE_ADD_COUNT_ENABLE                        : std_logic;

124
Signal BRAM_WRTIE_ADD                                : std_logic_VECTOR(13 downto 0):="11111111111111";  

125
Signal BRAM_WRITE_ENABLE                              : std_logic;

126
Signal BRAM_WEA                                    : std_logic_vector(0 downto 0);

127
Signal BRAM_WRITE_OR_READ_ENABLE                         : std_logic:='0';

128
Signal WRITE_OR_READ_COUNTER                            : integer range 0 to 2:=0;

129
130
131
-- HILFSSIGNAL FÜR LESEN DER BRAM

132
133
134
Signal BRAM_READ_ADD_COUNT_ENABLE                         : std_logic;

135
Signal BRAM_READ_ADD_COUNT_VOLL                          : std_logic:='0';

136
Signal BRAM_READ_ADD                                  : std_logic_VECTOR(13 downto 0):="00000000000000";

137
Signal BRAM_READ_ADD_ZERO                              : std_logic;  

138
139
Signal BRAM_CLOCK_1                                  : std_logic;  

140
Signal BRAM_ADD_1                                    : std_logic_VECTOR(13 downto 0);

141
Signal BRAM_IN_DATA_1                                : std_logic_vector  (11 downto 0);

142
Signal BRAM_OUT_DATA_1                                : std_logic_vector  (11 downto 0);

143
Signal BRAM_WRITE_ENABLE_1                              : std_logic_vector (0 downto 0);

144
145
Signal BRAM_CLOCK_2                                  : std_logic;  

146
Signal BRAM_ADD_2                                    : std_logic_VECTOR(13 downto 0);

147
Signal BRAM_IN_DATA_2                                : std_logic_vector  (11 downto 0);  

148
Signal BRAM_OUT_DATA_2                                : std_logic_vector  (11 downto 0);

149
Signal BRAM_WRITE_ENABLE_2                              : std_logic_vector (0 downto 0);

150
151
Signal DATA_FROM_FLASH                                : std_logic_vector (11 downto 0); 

152
153
-----------------------------------------------------------------------------------------------

154
155
-------------------------------- ZUSTANDSAUTOMAT_FLASH_BRAM_SCHRREIBEN ----------------------------------------------

156
type STATE_TYPE_WRITE is (Grundzustand,Add_Zahlen,Warten_01,Warten_02,Warten_03,Warten_0,Warten_1,Warten_2,Lesen_0,Anlegen_1,Lesen_1,Anlegen_2,Lesen_2,Anlegen_3,Lesen_3,Anlegen_4,Lesen_4,Anlegen_5,Lesen_5,Anlegen_6,Lesen_6,Anlegen_7,Lesen_7,Schlafen); 

157
Signal naechster_zustand: STATE_TYPE_WRITE;

158
Signal aktueller_zustand: STATE_TYPE_WRITE:=Schlafen;

159
160
-----------------------------------------------------------------------------------------------

161
162
-------------------------------- ZUSTANDSAUTOMAT_BRAM_LESEN ----------------------------------------------

163
type STATE_TYPE_READ is (Sleep,BRAM_1_AUSLESEN,WARTEN_LESEN_1,ADD_ANLEGEN_LESEN,WARTEN_AUF_SCHREIBEN); 

164
Signal naechster_zustand_lesen: STATE_TYPE_READ;

165
Signal aktueller_zustand_lesen: STATE_TYPE_READ:=Sleep;

166
  

167
-----------------------------------------------------------------------------------------------

168
169
begin

170
171
172
  DATAOUT <=  DATA_FROM_FLASH; 

173
174
175
  FLASH_LESEN_BRAM_SCHRIEBEN_ZUSTAND_WEITERGEBEN:process (FLASH_CLK,FLASH_RESET)

176
    begin

177
      if FLASH_RESET = '1' then

178
        aktueller_zustand<=Schlafen;--Grundzustand;

179
      elsif rising_edge(Flash_CLK) then

180
        aktueller_zustand <= naechster_zustand;

181
      end if;

182
  end process FLASH_LESEN_BRAM_SCHRIEBEN_ZUSTAND_WEITERGEBEN;

183
  ---------------------------------------------

184
  

185
  Zustandsautomat_Write:process (aktueller_zustand,ADD_VOLL,FLASH_ENABLE) 

186
  begin

187
  case aktueller_zustand is

188
    -----------------------------------------------------------

189
    when Schlafen       =>  BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     

190
                    BRAM_WRITE_ENABLE        <= '0';  

191
                                    

192
                    ADD_COUNT_ENABLE   <= '0';       --  DIESER ZUSTAND LÄßT DEN SPEICHER NICHT AUSLESEN

193
                    ADD_ZERO       <= '0';       -- BIS DAS ENABLE SINGAL VOM EINGANG KOMMT, DANN

194
                    BYTE_SCHREIBEN    <= '0';      -- STARTET DER AUTOMAT LOS DEN FLASH SPEICHER AUSZU-

195
                    DATA_ENABLE_HI    <= '0';      -- LESEN

196
                    DATA_ENABLE_LOW  <= '0';      --

197
                    CE            <=  '0';      --

198
                    OE            <=  '0';      --

199
                    RP            <=  '0';      --        

200
                    if FLASH_ENABLE = '0' then      --

201
                    naechster_zustand <= Schlafen;  --  

202
                    else                    --

203
                    naechster_zustand <=Grundzustand;--

204
                    end if;                  --

205
    -----------------------------------------------------------

206
    when Grundzustand =>          

207
                    ADD_COUNT_ENABLE   <= '0';       --  HIER STARTET DER ZUSTANDSAUTOMAT WENN ER ZUM ERSTEN MAL 

208
                    ADD_ZERO       <= '1';        -- GESTARTET WIRD ODER WENN DIE FLASH ADDRESSE VOLL GELAUFEN

209
                    BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     

210
                    BRAM_WRITE_ENABLE        <= '0';

211
                    

212
                    if ADD_VOLL='1' then          -- IST. HIER WIRD DIE FALSH ADDRESSE WIEDER AUF NULL ZURÜCK-

213
                      BYTE_SCHREIBEN    <= '1';      -- GESETZT ODER FÄNGT MIT DER NULL AN.

214
                    else                    -- AUßERDEM WIRD HIER DURCH BYTE SCHREIBEN DATEN AUSGE-

215
                      BYTE_SCHREIBEN    <= '0';      -- GEBEN WENN 

216
                    end if;                  --

217
                    DATA_ENABLE_HI    <= '0';      -- 

218
                    DATA_ENABLE_LOW  <= '0';      --

219
                    CE            <=  '1';      --

220
                    OE            <=  '1';      --

221
                    RP            <=  '1';      --  

222
                    naechster_zustand <= Warten_0;  --

223
    -----------------------------------------------------------                                      --  

224
    

225
    -----------------------------------------------------------

226
    

227
    when Warten_0   =>     BRAM_WRITE_ADD_COUNT_ENABLE <='0';       

228
                    BRAM_WRITE_ENABLE        <= '0';

229
                    if ADD_VOLL='1' then

230
                      BRAM_WRITE_ADD_COUNT_ENABLE <='1';

231
                    else

232
                      BRAM_WRITE_ADD_COUNT_ENABLE <='0';

233
                    end if;

234
                    ADD_COUNT_ENABLE   <= '0';       

235
                    ADD_ZERO       <= '0';         

236
                    BYTE_SCHREIBEN    <= '0';

237
                    DATA_ENABLE_HI    <= '0';

238
                    DATA_ENABLE_LOW  <= '0';

239
                    CE            <=  '0';

240
                    OE            <=  '0';

241
                    RP            <=  '1';

242
                    naechster_zustand <= Warten_1;

243
        

244
    when Warten_1    =>    BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     

245
                    BRAM_WRITE_ENABLE        <= '0';

246
                    

247
                    ADD_COUNT_ENABLE   <= '0'; 

248
                    ADD_ZERO       <= '1'; 

249
                    BYTE_SCHREIBEN    <= '0';

250
                    DATA_ENABLE_HI    <= '0';

251
                    DATA_ENABLE_LOW  <= '0';

252
                    CE            <=  '0';

253
                    OE            <=  '0';

254
                    RP            <=  '1';

255
                    naechster_zustand <= Warten_2;

256
    

257
    when Warten_2    =>    BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     

258
                    BRAM_WRITE_ENABLE        <= '0';

259
                    

260
                    ADD_COUNT_ENABLE   <= '0'; 

261
                    ADD_ZERO       <= '0'; 

262
                    BYTE_SCHREIBEN    <= '0';

263
                    DATA_ENABLE_HI    <= '0';

264
                    DATA_ENABLE_LOW  <= '0';

265
                    CE            <=  '0';

266
                    OE            <=  '0';

267
                    RP            <=  '1';

268
                    naechster_zustand <= Lesen_0;

269
    

270
    -------------------------------------------------------------

271
    -------------------------------------------------------------

272
    when Add_Zahlen =>    BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     

273
                    BRAM_WRITE_ENABLE        <= '0';

274
                    

275
                    ADD_COUNT_ENABLE   <= '1';       -- DIESER ZUSTAND ZÄHLT DIE ADDRESSE WEITER DA DIE FLASH    

276
                    ADD_ZERO       <= '0';       -- ADDRESSE NOCH NICHT VOLLGELAUFEN IST. BENÖTIGT WIRD 

277
                    BYTE_SCHREIBEN    <= '1';      -- DIESER ZUSTAND UM DEN CACHE SPEICHER VOM FALSH NEU ZU

278
                    DATA_ENABLE_HI    <= '0';      -- LADEN

279
                    DATA_ENABLE_LOW  <= '0';      --

280
                    CE            <=  '1';      --

281
                    OE            <=  '1';      --

282
                    RP            <=  '1';      --

283
                    naechster_zustand <= Warten_01;  --  

284
    

285
    

286
    

287
    when Warten_01    =>    BRAM_WRITE_ADD_COUNT_ENABLE <='1';                     

288
                    BRAM_WRITE_ENABLE      <= '0';

289
                    --BRAM_TAKT_20MHZ  <= '0';

290
                    ADD_COUNT_ENABLE   <= '0'; 

291
                    ADD_ZERO       <= '0'; 

292
                    BYTE_SCHREIBEN    <= '0';

293
                    DATA_ENABLE_HI    <= '0';

294
                    DATA_ENABLE_LOW  <= '0';

295
                    CE            <=  '0';

296
                    OE            <=  '0';

297
                    RP            <=  '1';

298
                    naechster_zustand <= Warten_02;

299
    

300
    when Warten_02    =>    BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     

301
                    BRAM_WRITE_ENABLE        <= '1';

302
                    --BRAM_TAKT_20MHZ  <= '0';

303
                    ADD_COUNT_ENABLE   <= '0'; 

304
                    ADD_ZERO       <= '0'; 

305
                    BYTE_SCHREIBEN    <= '0';

306
                    DATA_ENABLE_HI    <= '0';

307
                    DATA_ENABLE_LOW  <= '0';

308
                    CE            <=  '0';

309
                    OE            <=  '0';

310
                    RP            <=  '1';

311
                    naechster_zustand <= Warten_03;  

312
    

313
    when Warten_03    =>    BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     

314
                    BRAM_WRITE_ENABLE        <= '0';

315
                    --BRAM_TAKT_20MHZ  <= '0';

316
                    ADD_COUNT_ENABLE   <= '0'; 

317
                    ADD_ZERO       <= '0'; 

318
                    BYTE_SCHREIBEN    <= '0';

319
                    DATA_ENABLE_HI    <= '0';

320
                    DATA_ENABLE_LOW  <= '0';

321
                    CE            <=  '0';

322
                    OE            <=  '0';

323
                    RP            <=  '1';

324
                    naechster_zustand <= Lesen_0;

325
    ------------------------------------------------------------

326
    

327
    

328
    

329
    

330
    

331
    when Lesen_0      =>  BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     

332
                    BRAM_WRITE_ENABLE        <= '0';

333
                    

334
    

335
                    ADD_COUNT_ENABLE   <= '0'; 

336
                    ADD_ZERO       <= '0'; 

337
                    BYTE_SCHREIBEN    <= '0';

338
                    DATA_ENABLE_HI    <= '1';

339
                    DATA_ENABLE_LOW  <= '0';

340
                    CE            <=  '0';

341
                    OE            <=  '0';

342
                    RP            <=  '1';

343
                    if ADD_VOLL = '1' then

344
                    naechster_zustand <= Grundzustand;  

345
                    else

346
                    naechster_zustand <= Anlegen_1;

347
                    end if;

348
                    

349
      

350
    when Anlegen_1       =>  BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     

351
                    BRAM_WRITE_ENABLE        <= '0';

352
                    

353
                    ADD_COUNT_ENABLE   <= '1'; 

354
                    ADD_ZERO       <= '0'; 

355
                    BYTE_SCHREIBEN    <= '0';

356
                    DATA_ENABLE_HI    <= '0';

357
                    DATA_ENABLE_LOW  <= '0';

358
                    CE            <=  '0';

359
                    OE            <=  '0';

360
                    RP            <=  '1';          

361
                    naechster_zustand <= Lesen_1;

362
                    

363
    

364
    when Lesen_1      =>  BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     

365
                    BRAM_WRITE_ENABLE        <= '0';

366
                    

367
    

368
                    ADD_COUNT_ENABLE   <= '0'; 

369
                    ADD_ZERO       <= '0'; 

370
                    BYTE_SCHREIBEN    <= '0';

371
                    DATA_ENABLE_HI    <= '0';

372
                    DATA_ENABLE_LOW  <= '1';

373
                    CE            <=  '0';

374
                    OE            <=  '0';

375
                    RP            <=  '1';

376
                    if ADD_VOLL = '1' then

377
                    naechster_zustand <= Grundzustand;  

378
                    else

379
                    naechster_zustand <= Anlegen_2;

380
                    end if;

381
                      

382
    when Anlegen_2      =>  BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     

383
                    BRAM_WRITE_ENABLE        <= '0';

384
                    --BRAM_TAKT_20MHZ  <= '1';

385
                    ADD_COUNT_ENABLE   <= '1'; 

386
                    ADD_ZERO       <= '0'; 

387
                    BYTE_SCHREIBEN    <= '1';

388
                    DATA_ENABLE_HI    <= '0';

389
                    DATA_ENABLE_LOW  <= '0';

390
                    CE            <=  '0';

391
                    OE            <=  '0';

392
                    RP            <=  '1';          

393
                    naechster_zustand <= Lesen_2;

394
                    

395
    when Lesen_2      =>  BRAM_WRITE_ADD_COUNT_ENABLE <='1';                     

396
                    BRAM_WRITE_ENABLE        <= '0';

397
                    

398
                    ADD_COUNT_ENABLE   <= '0'; 

399
                    ADD_ZERO       <= '0'; 

400
                    BYTE_SCHREIBEN    <= '0';

401
                    DATA_ENABLE_HI    <= '1';

402
                    DATA_ENABLE_LOW  <= '0';

403
                    CE            <=  '0';

404
                    OE            <=  '0';

405
                    RP            <=  '1';

406
                    if ADD_VOLL = '1' then

407
                    naechster_zustand <= Grundzustand;  

408
                    else

409
                    naechster_zustand <= Anlegen_3;

410
                    end if;

411
                    

412
      

413
    when Anlegen_3       =>  BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     

414
                    BRAM_WRITE_ENABLE        <= '1';

415
                    

416
                    ADD_COUNT_ENABLE       <= '1'; 

417
                    ADD_ZERO       <= '0'; 

418
                    BYTE_SCHREIBEN    <= '0';

419
                    DATA_ENABLE_HI    <= '0';

420
                    DATA_ENABLE_LOW  <= '0';

421
                    CE            <=  '0';

422
                    OE            <=  '0';

423
                    RP            <=  '1';          

424
                    naechster_zustand <= Lesen_3;

425
                    

426
    

427
    when Lesen_3      =>  BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     

428
                    BRAM_WRITE_ENABLE        <= '0';

429
                    

430
                    ADD_COUNT_ENABLE       <= '0'; 

431
                    ADD_ZERO       <= '0'; 

432
                    BYTE_SCHREIBEN    <= '0';

433
                    DATA_ENABLE_HI    <= '0';

434
                    DATA_ENABLE_LOW  <= '1';

435
                    CE            <=  '0';

436
                    OE            <=  '0';

437
                    RP            <=  '1';

438
                    if ADD_VOLL = '1' then

439
                    naechster_zustand <= Grundzustand;  

440
                    else

441
                    naechster_zustand <= Anlegen_4;

442
                    end if;

443
                      

444
    when Anlegen_4      =>  BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     

445
                    BRAM_WRITE_ENABLE        <= '0';

446
                    

447
    

448
                    ADD_COUNT_ENABLE   <= '1'; 

449
                    ADD_ZERO       <= '0'; 

450
                    BYTE_SCHREIBEN    <= '1';

451
                    DATA_ENABLE_HI    <= '0';

452
                    DATA_ENABLE_LOW  <= '0';

453
                    CE            <=  '0';

454
                    OE            <=  '0';

455
                    RP            <=  '1';          

456
                    naechster_zustand <= Lesen_4;

457
                    

458
    when Lesen_4      =>  BRAM_WRITE_ADD_COUNT_ENABLE <='1';                     

459
                    BRAM_WRITE_ENABLE        <= '0';

460
                    

461
    

462
                    ADD_COUNT_ENABLE   <= '0'; 

463
                    ADD_ZERO       <= '0'; 

464
                    BYTE_SCHREIBEN    <= '0';

465
                    DATA_ENABLE_HI    <= '1';

466
                    DATA_ENABLE_LOW  <= '0';

467
                    CE            <=  '0';

468
                    OE            <=  '0';

469
                    RP            <=  '1';

470
                    if ADD_VOLL = '1' then

471
                    naechster_zustand <= Grundzustand;  

472
                    else

473
                    naechster_zustand <= Anlegen_5;

474
                    end if;

475
                    

476
      

477
    when Anlegen_5       =>  BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     

478
                    BRAM_WRITE_ENABLE        <= '1';

479
                    

480
                    ADD_COUNT_ENABLE   <= '1'; 

481
                    ADD_ZERO       <= '0'; 

482
                    BYTE_SCHREIBEN    <= '0';

483
                    DATA_ENABLE_HI    <= '0';

484
                    DATA_ENABLE_LOW  <= '0';

485
                    CE            <=  '0';

486
                    OE            <=  '0';

487
                    RP            <=  '1';          

488
                    naechster_zustand <= Lesen_5;

489
                    

490
    

491
    when Lesen_5      =>  BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     

492
                    BRAM_WRITE_ENABLE        <= '0';

493
                    

494
                    ADD_COUNT_ENABLE       <= '0'; 

495
                    ADD_ZERO       <= '0'; 

496
                    BYTE_SCHREIBEN    <= '0';

497
                    DATA_ENABLE_HI    <= '0';

498
                    DATA_ENABLE_LOW  <= '1';

499
                    CE            <=  '0';

500
                    OE            <=  '0';

501
                    RP            <=  '1';

502
                    if ADD_VOLL = '1' then

503
                    naechster_zustand <= Grundzustand;  

504
                    else

505
                    naechster_zustand <= Anlegen_6;

506
                    end if;

507
                      

508
    when Anlegen_6      =>  BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     

509
                    BRAM_WRITE_ENABLE        <= '0';

510
                    

511
                    ADD_COUNT_ENABLE   <= '1'; 

512
                    ADD_ZERO       <= '0'; 

513
                    BYTE_SCHREIBEN    <= '1';

514
                    DATA_ENABLE_HI    <= '0';

515
                    DATA_ENABLE_LOW  <= '0';

516
                    CE            <=  '0';

517
                    OE            <=  '0';

518
                    RP            <=  '1';          

519
                    naechster_zustand <= Lesen_6;

520
                    

521
    when Lesen_6      =>  BRAM_WRITE_ADD_COUNT_ENABLE <='1';                     

522
                    BRAM_WRITE_ENABLE        <= '0';

523
                    

524
                    ADD_COUNT_ENABLE   <= '0'; 

525
                    ADD_ZERO       <= '0'; 

526
                    BYTE_SCHREIBEN    <= '0';

527
                    DATA_ENABLE_HI    <= '1';

528
                    DATA_ENABLE_LOW  <= '0';

529
                    CE            <=  '0';

530
                    OE            <=  '0';

531
                    RP            <=  '1';

532
                    if ADD_VOLL = '1' then

533
                    naechster_zustand <= Grundzustand;  

534
                    else

535
                    naechster_zustand <= Anlegen_7;

536
                    end if;

537
                    

538
      

539
    when Anlegen_7       =>  BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     

540
                    BRAM_WRITE_ENABLE        <= '1';

541
                    

542
                    ADD_COUNT_ENABLE   <= '1'; 

543
                    ADD_ZERO       <= '0'; 

544
                    BYTE_SCHREIBEN    <= '0';

545
                    DATA_ENABLE_HI    <= '0';

546
                    DATA_ENABLE_LOW  <= '0';

547
                    CE            <=  '0';

548
                    OE            <=  '0';

549
                    RP            <=  '1';          

550
                    naechster_zustand <= Lesen_7;

551
                    

552
    

553
    when Lesen_7      =>  BRAM_WRITE_ADD_COUNT_ENABLE <='0';                     

554
                    BRAM_WRITE_ENABLE  <= '0';

555
                    

556
                    ADD_COUNT_ENABLE   <= '0'; 

557
                    ADD_ZERO       <= '0'; 

558
                    BYTE_SCHREIBEN    <= '0';

559
                    DATA_ENABLE_HI    <= '0';

560
                    DATA_ENABLE_LOW  <= '1';

561
                    CE            <=  '0';

562
                    OE            <=  '0';

563
                    RP            <=  '1';

564
                    if FLASH_ENABLE = '1' then

565
                      if ADD_VOLL = '1' then

566
                      naechster_zustand <= Grundzustand;  

567
                      else

568
                      naechster_zustand <= Add_Zahlen;

569
                      end if;

570
                    else

571
                      naechster_zustand <= schlafen;

572
                    end if;

573
        

574
    end case;

575
  end process Zustandsautomat_Write;

576
  -------------------------------------------------  

577
  FLASH_ADDRESSEN_AUSLESEN: process (FLASH_CLK)

578
  begin

579
        

580
    if falling_edge(FLASH_CLK) then

581
      if ADD_COUNT_ENABLE = '1' then

582
        ADD<=ADD+1;

583
      elsif ADD_ZERO = '1' then

584
        ADD <= "000000000000000000000000";

585
      else

586
        ADD <= ADD;

587
      end if;

588
    end if;

589
  end process FLASH_ADDRESSEN_AUSLESEN;

590
  -------------------------------------------------  

591
  TEST: process (FLASH_CLK) 

592
  begin

593
    if rising_edge(FLASH_CLK) then

594
      if ADD = "000000000100000110011101"  then

595
        ADD_VOLL<='1';

596
      else 

597
        ADD_VOLL<='0';

598
      end if;

599
    end if;

600
  end process TEST;

601
  -------------------------------------------------

602
  FLASH_DATEN_EINLESEN_HI_BITS: process (FLASH_CLK)

603
  begin

604
    if falling_edge(FLASH_CLK) then

605
      if DATA_ENABLE_HI = '1' then

606
        DA_HI<=FLASH_DATA;

607
      else

608
        DA_HI<=DA_HI;

609
      end if;

610
    end if;

611
  end process FLASH_DATEN_EINLESEN_HI_BITS;

612
  -------------------------------------------------

613
  FLASH_DATEN_EINLESEN_LOW_BITS: process (FLASH_CLK)

614
  begin

615
    if falling_edge(FLASH_CLK) then

616
      if DATA_ENABLE_LOW = '1' then

617
        DA_LOW<=FLASH_DATA;

618
      else

619
        DA_LOW<=DA_LOW;

620
      end if;

621
    end if;

622
  end process FLASH_DATEN_EINLESEN_LOW_BITS;

623
  -------------------------------------------------

624
  BYTE_ZUSAMENSETZEN: process (FLASH_CLK)

625
  begin

626
    if falling_edge (FLASH_CLK) then

627
      if BYTE_SCHREIBEN  = '1' then

628
        DATA_FROM_FLASH <= DA_HI(3 downto 0) & DA_LOW; 

629
      end if;

630
    

631
    end if;

632
  end process BYTE_ZUSAMENSETZEN;

633
  

634
  -----------------------------------------------------

635
  

636
  

637
  -- BRAM ADD COUNTER UND WRITE ENABLE -----------------------

638
639
  BRAM_WRITE_ADD_ZAHLEN:process (FLASH_CLK)

640
  begin

641
    if falling_edge (FLASH_CLK) then

642
       if BRAM_WRITE_ADD_COUNT_ENABLE = '1' then

643
        BRAM_WRTIE_ADD <=BRAM_WRTIE_ADD+1;

644
      elsif ADD_ZERO = '1' then

645
        BRAM_WRTIE_ADD    <= "11111111111111";

646
      else

647
        BRAM_WRTIE_ADD <=BRAM_WRTIE_ADD;

648
      end if;

649
    end if;

650
  end process BRAM_WRITE_ADD_ZAHLEN;

651
  

652
  BRAM_WRITE_ENABLE_ANLEGEN:process (FLASH_CLK)

653
  begin

654
    if falling_edge (FLASH_CLK) then

655
       if BRAM_WRITE_ENABLE = '1' then

656
        BRAM_WEA <="1";

657
      else

658
        BRAM_WEA <="0";

659
      end if;

660
    end if;

661
  end process BRAM_WRITE_ENABLE_ANLEGEN;

662
663
664
665
666
667
  ----------------------------------------------------------------------

668
669
  ----------------------------------------------------------------------

670
  ----------------------------------------------------------------------

671
  FLASHDATEN_INS_RAM_UEBERNEHMEN_COUNTER: process (ADD_VOLL)

672
  begin

673
    if ADD_VOLL ='1' then

674
      WRITE_OR_READ_COUNTER <= WRITE_OR_READ_COUNTER + 1;

675
    elsif WRITE_OR_READ_COUNTER > 1 then

676
      WRITE_OR_READ_COUNTER <= 0;  

677
    else

678
      WRITE_OR_READ_COUNTER <= 1;

679
    end if;

680
  end process FLASHDATEN_INS_RAM_UEBERNEHMEN_COUNTER;

681
682
683
  BRAM_WRITE_OR_READ_ENABLE <= '1' when WRITE_OR_READ_COUNTER = 1 else-- überflüssig, ist gleich sezten

684
                      '0' when WRITE_OR_READ_COUNTER = 0 else

685
                      '1';

686
  -----------------------------------------------------------------------                  

687
688
689
690
691
  ----------------------------- UMSCHLATER FÜR BRAM's------------------------------------

692
  ---------------------------------------------------------------------------------------------------------------

693
  BRAM_CLOCK_1       <= FLASH_CLK;

694
                

695
  BRAM_ADD_1         <= BRAM_WRTIE_ADD      when BRAM_WRITE_OR_READ_ENABLE = '1' else       

696
                  BRAM_READ_ADD      when BRAM_WRITE_OR_READ_ENABLE = '0' ;

697
  

698
  BRAM_WRITE_ENABLE_1   <= BRAM_WEA          when BRAM_WRITE_OR_READ_ENABLE = '1' else   

699
                  "0"            when BRAM_WRITE_OR_READ_ENABLE = '0' else

700
                  "0";

701
  

702
  BRAM_IN_DATA_1     <= DATA_FROM_FLASH;    

703
  ---------------------------------------------------------------------------------                              

704
  BRAM_CLOCK_2       <= FLASH_CLK;

705
                  

706
  

707
  BRAM_ADD_2         <= BRAM_READ_ADD      when BRAM_WRITE_OR_READ_ENABLE = '1' else       

708
                  BRAM_WRTIE_ADD      when BRAM_WRITE_OR_READ_ENABLE = '0' ;

709
  

710
  BRAM_WRITE_ENABLE_2   <= "0"            when BRAM_WRITE_OR_READ_ENABLE = '1' else   

711
                  BRAM_WEA          when BRAM_WRITE_OR_READ_ENABLE = '0' else

712
                  "0";

713
  

714
  BRAM_IN_DATA_2     <= DATA_FROM_FLASH;              

715
  

716
  -----------------------------------------------------------------------------------

717
    

718
  AUSGABE_DATEN_BRAM  <=  BRAM_OUT_DATA_1     when BRAM_WRITE_OR_READ_ENABLE = '1' else   

719
                  BRAM_OUT_DATA_2     when BRAM_WRITE_OR_READ_ENABLE = '0';  

720
  ---------------------------------------------------------------------------------

721
722
723
724
725
726
727
---------------------------------------------------------------------------------------------------------------

728
----------------------------------ZUSTANDSAUTOMAT FÜR BRAM LESEN-----------------------------------------------

729
---------------------------------------------------------------------------------------------------------------

730
---------------------------------------------------------------------------------------------------------------

731
732
  BRAM_LESEN_ZUSTAND_WEITERGEBEN:process (FLASH_CLK,FLASH_RESET)

733
    begin

734
      if FLASH_RESET = '1' then

735
        aktueller_zustand_lesen<=Sleep;

736
      elsif rising_edge(FLASH_CLK) then

737
        aktueller_zustand_lesen <= naechster_zustand_lesen;

738
        

739
      end if;

740
  end process BRAM_LESEN_ZUSTAND_WEITERGEBEN;  

741
  

742
743
  Zustandsautomat_Read:process (aktueller_zustand_lesen,BRAM_READ_ADD_COUNT_VOLL,ADD_VOLL,FLASH_ENABLE) 

744
  begin

745
  case aktueller_zustand_lesen is

746
    -----------------------------------------------------------

747
    when Sleep                =>  BRAM_READ_ADD_COUNT_ENABLE    <= '0';  

748
                          BRAM_READ_ADD_ZERO         <= '1';  

749
                          if FLASH_ENABLE = '1' then      

750
                            naechster_zustand_lesen <= ADD_ANLEGEN_LESEN;

751
                          else

752
                            naechster_zustand_lesen <= Sleep;  

753
                          end if;

754
                          

755
    when ADD_ANLEGEN_LESEN      =>  BRAM_READ_ADD_COUNT_ENABLE    <= '0';  

756
                          BRAM_READ_ADD_ZERO         <= '1';  

757
                          naechster_zustand_lesen <= WARTEN_LESEN_1;  

758
                    

759
760
    when BRAM_1_AUSLESEN         =>  BRAM_READ_ADD_COUNT_ENABLE    <= '1';  

761
                          BRAM_READ_ADD_ZERO         <= '0';  

762
                        

763
                          if BRAM_READ_ADD_COUNT_VOLL = '1' then

764
                            naechster_zustand_lesen <= WARTEN_AUF_SCHREIBEN;  

765
                          else

766
                            naechster_zustand_lesen <=WARTEN_LESEN_1;

767
                          end if;

768
    

769
    when WARTEN_LESEN_1         =>  BRAM_READ_ADD_COUNT_ENABLE      <= '0';  

770
                          BRAM_READ_ADD_ZERO           <= '0';  

771
                          naechster_zustand_lesen       <= BRAM_1_AUSLESEN;  

772
                    

773
    

774
    

775
    when WARTEN_AUF_SCHREIBEN     =>  BRAM_READ_ADD_COUNT_ENABLE    <= '0';  

776
                          BRAM_READ_ADD_ZERO         <= '0';  

777
                          if ADD_VOLL = '1' then 

778
                            naechster_zustand_lesen <= Sleep;  

779
                          else

780
                            naechster_zustand_lesen <=WARTEN_AUF_SCHREIBEN;

781
                          end if;                

782
      

783
  end case;

784
  end process Zustandsautomat_Read;

785
  

786
  

787
  RAM_READ_ADD_ZAHLEN:process (FLASH_CLK)

788
  begin

789
    if falling_edge (FLASH_CLK) then

790
       if BRAM_READ_ADD_COUNT_ENABLE = '1' then

791
        BRAM_READ_ADD <= BRAM_READ_ADD+1;

792
      elsif BRAM_READ_ADD_ZERO = '1' then

793
        BRAM_READ_ADD <= "00000000000000";

794
      elsif ADD_VOLL ='1' then

795
        BRAM_READ_ADD <= "00000000000000";

796
      else

797
        

798
        BRAM_READ_ADD <= BRAM_READ_ADD;  

799
      end if;

800
    end if;

801
  end process RAM_READ_ADD_ZAHLEN;

802
  

803
  RAM_READ_ADD_VOLL:process (FLASH_CLK)

804
  begin

805
    if rising_edge (FLASH_CLK) then

806
      if BRAM_READ_ADD > "10000011001101" then

807
        BRAM_READ_ADD_COUNT_VOLL <= '1';

808
      else

809
        BRAM_READ_ADD_COUNT_VOLL <= '0';

810
      end if;

811
    end if;

812
  end process RAM_READ_ADD_VOLL;

813
  

814
  -----------------------------------------------------------------------------------------------------------

815
  -----------------------------------------------------------------------------------------------------------

816
    

817
  --------------NUR FÜR SIMULATION---------------------

818
  -----------------------------------------------------

819
  DATA_EN_H      <= DATA_ENABLE_HI; 

820
  DATA_EN_L      <= DATA_ENABLE_LOW; 

821
  DA_H          <= DA_HI;

822
  DA_L          <= DA_LOW;      

823
  BYTE_SR        <= BYTE_SCHREIBEN;    

824
  ADD_ZE           <= ADD_ZERO;

825
  ADD_V          <= ADD_VOLL;

826
  ADD_EN        <= ADD_COUNT_ENABLE;     

827
  BRAM_ADD_EN      <=  BRAM_WRITE_ADD_COUNT_ENABLE;

828
  BRAM_WEAEN      <= BRAM_WEA;

829
  BADD          <= BRAM_WRTIE_ADD;

830
  

831
  BRAM_WR_RD_ENABLE  <= BRAM_WRITE_OR_READ_ENABLE;

832
  

833
  

834
  BRAM_R_ADD_COUNT_ENABLE   <=  BRAM_READ_ADD_COUNT_ENABLE;                

835
  BRAM_R_ADD_COUNT_VOLL    <=  BRAM_READ_ADD_COUNT_VOLL  ;                                    

836
  BRAM_R_ADD            <=  BRAM_READ_ADD;                                

837
  BRAM_R_ADD_ZERO        <=  BRAM_READ_ADD_ZERO;                        

838
  

839
  BRAM_CLK_1            <=  BRAM_CLOCK_1  ;                                

840
  BRAM_A_1              <=  BRAM_ADD_1;                

841
  BRAM_IN_DA_1          <=  BRAM_IN_DATA_1;                                  

842
  BRAM_OUT_DA_1          <=  BRAM_OUT_DATA_1;                

843
  BRAM_WR_ENABLE_1        <=  BRAM_WRITE_ENABLE_1;                  

844
845
  BRAM_CLK_2            <=  BRAM_CLOCK_2;                

846
  BRAM_A_2              <=  BRAM_ADD_2  ;                

847
  BRAM_IN_DA_2          <=  BRAM_IN_DATA_2;                

848
  BRAM_OUT_DA_2          <=  BRAM_OUT_DATA_2;                

849
  BRAM_WR_ENABLE_2           <=  BRAM_WRITE_ENABLE_2;                

850
851
  DA_FROM_FLASH          <= DATA_FROM_FLASH  ;

852
  

853
  --------------------------------------------------------

854
    

855
  ------------------------------------------------------

856
  ---------------------HILFSSIGNALE---------------------

857
  --DATA_FROM_FLASH <= DATAOUT  ;  

858
  FLASH_RP <= RP;

859
  FLASH_CE  <= CE;

860
  FLASH_OE  <= OE;

861
  FLASH_ADD <=ADD;

862
  

863
  -------------------------------------------------

864
865
  

866
  --------------PORT MAPPING ----------------

867
  

868
  RAM_EINLESEN_1:SINGLE_RAM_1

869
   

870
  PORT MAP (  clka  => BRAM_CLOCK_1,

871
          rsta  => FLASH_RESET,

872
          addra => BRAM_ADD_1,

873
          wea   => BRAM_WRITE_ENABLE_1,

874
          dina  => BRAM_IN_DATA_1,

875
          douta => BRAM_OUT_DATA_1);

876
877
878
  RAM_EINLESEN_2:SINGLE_RAM_2

879
   

880
  PORT MAP (  clka  => BRAM_CLOCK_2,

881
          rsta  => FLASH_RESET,

882
          addra => BRAM_ADD_2,

883
          wea   => BRAM_WRITE_ENABLE_2,

884
          dina  => BRAM_IN_DATA_2,

885
          douta => BRAM_OUT_DATA_2);

886
end Behavioral;


  


  




  

    Beitrag melden Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Daten von FLASH in 2 BRAM schreiben
  


  

    

      von
      
        D. I. (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Für das was du vorhast scheint mir der Automat deutlich übertrieben zu 
sein.

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Daten von FLASH in 2 BRAM schreiben
  


  

    

      von
      
        Igor (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
So ich denke ich habe den Fehler gefunden weiß nur noch nicht wieso der 
kommt. Wenn ein Trigger signal kommt (hier FLASH_ENABLE) dann startet 
der Automat den Flash zu lesen und in den Bram zu schreiben. Wenn das 
Zweite trigger Signal wieder kommt dann soll das ganze wieder loslaufen 
nur das er in das Zweite Bram schreibt. Beim dritten trigger Signal 
wieder anders rum usw.

Dafür habe ich ein Counter der zwischen 0 und 1 gesetzt wird wenn die 
Flash Add voll gelaufen ist (ADD_VOLL)...

Hier der Code dazu

1
FLASHDATEN_INS_RAM_UEBERNEHMEN_COUNTER: process (ADD_VOLL)

2
  begin

3
    if ADD_VOLL='1' then

4
      WRITE_OR_READ_COUNTER <= WRITE_OR_READ_COUNTER + 1;

5
    elsif WRITE_OR_READ_COUNTER > 1 then

6
      WRITE_OR_READ_COUNTER <= 0;  

7
    else

8
      WRITE_OR_READ_COUNTER <= 1;

9
    end if;

10
  end process FLASHDATEN_INS_RAM_UEBERNEHMEN_COUNTER;

11
12
13
  BRAM_WRITE_OR_READ_ENABLE <= '1' when WRITE_OR_READ_COUNTER = 1 else

14
                      '0' when WRITE_OR_READ_COUNTER = 0 else

15
                      '1';



BRAM_WRITE_OR_READ_ENABLE  benutze ich dann als umschalter, aber das 
funktioniert nicht . Wieso ?


Gruß

Igor

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Daten von FLASH in 2 BRAM schreiben
  


  

    

      von
      
        Igor (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Bzw. gibt es eine bessere alternative wie ich auf ein Trigger Signal 
reagiere.

Also ich bekomme ein Trigger Signal damit muss mein zweites Signal auf 1 
gehen bis wieder ein Trigger Signal kommt dann muss mein zweites Signal 
auf 0 gehen und immer hin und her switchen abhängig von Trigger Signal.


Ich habs über ein Counter gemacht, gibt es dazu eine bessere 
Alternative?



Gruß



Igor

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  







      

      



  

    Re: Daten von FLASH in 2 BRAM schreiben
  


  

    

      von
      
        Igor (Gast)
      
      


      
    


    

      
    

    

    

  
  


  

  Lesenswert?
  

  •
  
  ▲  
  

  ▼  
  		
  

  


  

      
Hat sich erledigt, hab ein anderen Weg gefunden!


Gruß


Igor

  


  




  

    Beitrag melden Bearbeiten Löschen Markierten Text zitieren Antwort Antwort mit Zitat
  








    

    

       Thread beobachten

      |
         Seitenaufteilung abschalten

    

        


Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.



  Bestehender Account

  


  
  

  
    

      

        
          
        
        
          
        
      

      

        
          
        
        
          
        
      

    


    
    
    





  Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!

  Mit Google-Account einloggen
  





  Noch kein Account? Hier anmelden.