-
Thread
Referenzspannungsquellen - Die-Bilder
Diese ADR1000 ist weder bei Analogdevices, noch bei Digikey zu finden...
Hier haben wir nun eine LTZ1000A, die Variante mit einem höheren Wärmewiderstand zum Gehäuse: https://www.richis-lab.de/REF44.htm Die LTZ1000A ist vor allem interessant im Vergleich zum LT1088, zur ADR1000 und zur ADR1001.
-
Thread
Lattice Diamond: UART Receiver Siganl Wegoptimiert
BASE (32'h0000), //GPIO .S1_BASE (32'h4000), // UART .S2_BASE (32'h1000), //EBR .S3_BASE (32'h5000) ) wb_arb ( .clk(clk_125), .rstn(core_rst_n), // PCIe Master .m0_dat_i(pcie_dat_o), .m0_dat_o(pcie_dat_i), .m0_adr_i(pcie_adr
(32'h0000), // UART Slave .S1_BASE (32'h0800), // GPIO .S2_BASE (32'h1000), //EBR .S3_BASE (32'h5000) ) wb_arb ( .clk(clk_125), .rstn(core_rst_n), // PCIe Master .m0_dat_i(pcie_dat_o), .m0_dat_o(pcie_dat_i), .m0_adr_i(pcie_adr
-
Thread
Speichermapping 74138
> ADDR0 ist dann von 0000h-0FFFh Gaaaanz genua ;-)) ADR1 von 1000-1FFF usw. bis ADR15 von F000-FFFF ADR16 bis 23 sind dann noch mit niederwertigeren Adressleitungen verknüpft und haben entsprechend kleineren Umfang.
A11 bewirkt, dass der jeweilige ADR-Ausgang nur alle 100h aktiv wird. ADR16 0111 XXXX 1111 1000 70F8, 16 mal alle 100h bis 7FF8 für ADR7 low und nochmal für ADR8 low ADR16 1000 XXXX 1111 1000 80F8, 16
-
Thread
I2C meldet status 0x38
/ Arbitration lost // TWI Master Transmitter staus codes #define TWI_MTX_ADR_ACK 0x18 // SLA+W has been tramsmitted and ACK received #define TWI_MTX_ADR_NACK 0x20 // SLA+W has been tramsmitted and NACK received #define TWI_MTX_DATA_ACK 0x28 // Data byte
Aus Ulrichs Code #define MOTOR_ADR 0x70
-
Thread
arduino oder GCC Programmierung
(i2cAdr); return (bool) Wire.endTransmission(); } bool busy(byte i2cAdr) // ACKNOWLEDGE POLLING { Wire.beginTransmission(i2cAdr); return bool(Wire.endTransmission()); } bool
(i2cAdr); return ! bool(Wire.endTransmission()); } bool ready(byte i2cAdr) // ACKNOWLEDGE POLLING { Wire.beginTransmission(i2cAdr); return ! (bool)Wire.endTransmission(); } [/
-
Thread
Vref für ADC und Konstantstromquelle in einem?
einer geeigneten Referenzspannungsquelle und einer Konstantstromquelle um mit einem PT100 oder PT1000 Temperaturen zu erfassen. Dazu habe ich den ADR291 gefunden, in dessen Datenblatt auch eine Anwendung als CCS vorgeschlagen wird. Da ich auch eine Vref brauche habe ich mir überlegt ob man das nicht
ständige Referenzspannung. Allerdings wird die wohl nicht 2,5V werden, sondern eher 1V. Dafür hab ich den ADR130 gefunden. Der scheint mir aber schlechter/ungenauer bezüglich Langzeitstabilität und drift, sowie Genauigkeit zu sein. Ausserdem benötigt er um einiges mehr strom (ADR130:80µA; ADR291: 12µA). Darum
-
Thread
EleLa - Elektronik Lagerverwaltung ab V2.0
VARCHAR(255)) 18:15:54 CreateNewField (kiste,Handbuch,VARCHAR(250)) 18:15:54 CreateIndex (bauteillager,Adr_ID) 18:15:54 CreateIndex (bauteiladr,Adr_ID) 18:15:54 CreateIndex (adr,ID_ID) 18:15:54 CreateIndex (adr,Lieferant) 18:15:54 CreateIndex (adr,Hersteller) 18:15:54 CreateIndex (adr,[ID_ID, Bezeichnung
habe die SQL Abfrage mal so abgeändert: [code]SELECT * FROM bestellen WHERE ((Status = 0 And (Lief1_Adr_ID = :AdrID OR Lief2_Adr_ID = :AdrID)) OR (Status > 0 AND (UseLief12 = 0 AND (UseLief12 = 1 AND Lief1_Adr_ID = :AdrID) OR (UseLief12 = 2 AND Lief2_Adr_ID = :AdrID))) ) AND (Archiv=0 OR Archiv
-
Thread
Denkfehler mit PCA9536 (Problem)
while(1) { // Die o/p pins auf Hoch Stellen i2c_start(adr1_w); // adr1_w - 0x82 = Schreib Modus i2c_write(0x01); // Index auf OUTPUT DATA stellen i2c_write(0x0F); // Alle Port Pins hochstellen i2c_stop(); _delay_ms(1000); // Die o/p pins auf Null Stellen i2c_start(adr1_w); // 0x82 = Schreib Modus i2c_write(0x01); // Index auf OUTPUT DATA stellen i2c_write(0x00); // Alle Port Pins nullstellen i2c_stop(); _delay_ms(1000); } }
-
Thread
Attiny85, suche Möglichkeit zur Kommuikation/Daten auslesen
10007000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF90 :10008000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF80 :10009000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF70 :1000A000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF60 :1000B000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF50 :1000C000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF40 :1000D000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF30 :1000E000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF20
FFFF FFFFFFFFFFFFFFFF FC ^ ^ ^ ^ | | | | Adr_0 Adr_1 Adr_2 Adr_3 (Gilt für integer) | | | | Ausgelesenes EEPROM nach programmieren: :10 0000 00 1838 BB00 23FF 7FFF FFFFFFFFFFFFFFFF 4D [/c] Wie du siehst, zeigt EEPROM
-
Thread
Wie bekommt man bitte zwei DWord in das lds si, rein ?
SUB yPAGEFLIP (pageNum AS INTEGER) DIM adr AS STRING adr = LEFT$(MKL$(CLNG(pageNum) * 16000), 2) DO: LOOP WHILE (INP(&H3DA) AND 1) OUT crtcINDEX2, crtcStartAddressHigh OUT crtcDATA2, ASC(RIGHT$(adr, 1)) OUT crtcINDEX2, crtcStartAddressLow OUT crtcDATA2, ASC(LEFT$(adr, 1)) DO: LOOP UNTIL (INP(&H3DA) AND 8) END SUB SUB yPAGEWORK (pageNum AS INTEGER) yPageSeg = &HA000 + pageNum * 1000 END SUB FUNCTION yPOINT% (x AS INTEGER, y AS INTEGER) OUT gcINDEX
-
Thread
stm32f103-bluepill-peripherie
(uint32_t adresse) { uint32_t data; asm ( "adr r1, adresse " // Lade in r1 den Zeiger auf adresse "ldr r2, [r1] " // lade in r2 die adresse "adr r1, data " // Lade in r1 den Zeiger auf data "ldr r3, [r2] " //
_t read_reg (uint32_t adresse) { > uint32_t data; > asm > ( > "adr r1, adresse " // Lade in r1 den Zeiger auf adresse > "ldr r2, [r1] " // lade in r2 die adresse > "adr r1, data " // Lade in r1 den Zeiger auf data > "ldr r3, [r2] "
-
Thread
Langzeitdriftarmer 3,3V Spannungsregler für 100mA gesucht
Temperaturkompensation in der Schaltung auffangen kann. Die Drift-Eigenschaften sollten sich ungefähr am ADR06 orientieren: http://www.analog.com/static/imported-files/data_sheets/ADR01_02_03_06.pdf Also die üblichen 50ppm nach 1000 Stunden. Andere Tricks, wie ratiometrische Messung unter Einbeziehung
fixfertigen Dreibeinreglers. Falls das nicht möglich ist, würde ich wieder zur lokalen Speisung mit ADR02 und OPamp übergehen.
-
Thread
unverstänliche Effekte beim Schreiben ins EEPROM
delay.h> #include <stdlib.h> #include <avr/iom644p.h> #include <avr/eeprom.h> uint16_t adr[1000] EEMEM; // EEPROM-Adressen // testweise sollen zwei x-beliebige Zahlen u. die letzte // Adresse ins EEPROM geschrieben werden - mit zwei Bytes Zwischenraum void zum_eeprom(uint16
; // Index für eeprom-Adresse adr while(1) // Endlosschleife für EEPROM-Einträge { _delay_ms(1000); zum_eeprom(999,n); n=n+1; if (n > 1000) n=0; } /* Ende while
-
Thread
Wie wird eine hochgenaue (absolute) Spannungsreferenz hergestellt?
Die Referenz der Wahl waere LTZ1000, jetzt mit Nachfolger : ADR1000, die Spezialitaet dieser Referenzen : der TempCo von 0.05 ppm/K, resp 0.2ppm/K und seine Anwendung ist auch in den zugehoerigen Application Note erklaert Es hat in
Purzel H. schrieb im Beitrag #7718804: > Die Referenz der Wahl waere LTZ1000, jetzt mit Nachfolger : ADR1000 So wie ich das verstanden habe, ist die Absolutgenauigkeit der LTZ1000 (oder Nachfolger) garnicht so gut (0,8%?). Aber die Langzeitstabilität und Temperaturabhängigkeit
-
Thread
i2c hört auf zu funktionieren
RELEASE BUS)? pseudocode: [c] library_lese_manipuliere_schreibe(){ data=MSS_I2C_write_read (SLAVE_ADR,MSS_I2C_RELEASE_BUS); data_man=manipuliere(data) MSS_I2C_write( SLAVE_ADR,data_man,MSS_I2C_RELEASE_BUS); } [/c]
Funktion kopiert habe. [c]mycopy_lese_manipuliere_schreibe(){ data=MSS_I2C_write_read (SLAVE_ADR,MSS_I2C_RELEASE_BUS); data_man=manipuliere(data) MSS_I2C_write( SLAVE_ADR,data_man,MSS_I2C_RELEASE_BUS); [/c] [c] mycopy_lese_manipuliere_schreibe();//ok mycopy_lese_manipuliere_schreibe()
-
Thread
Zeiger-Problem
1000 POKE Ptr_Reg, PEEK(Adr_Reg) hrr hrrrrr HRRRRRRRRR
>1000 POKE Ptr_Reg, PEEK(Adr_Reg) das ist kein C64...
-
Thread
Schrittmotor Ansteuerung mit L293D
int wert=0; //TWI Portexpander void EXT_INIT_PCA9555(void); EXT_PCA9555_CONF_PORTA(ADR0_PCA9555,PORT_OUT); EXT_PCA9555_CONF_PORTB(ADR0_PCA9555,PORT_OUT); EXT_PCA9555_WRITE_PORTB(ADR0_PCA9555,0x00); EXT_PCA9555_WRITE_PORTA(ADR0_PCA9555,0x00); while(wert<=1000) { EXT_PCA9555_WRITE_PORTB(ADR0_PCA9555,(1<<4)|(0<<5)|(0<<6)|(1<<7));//B aus und D und A ein _delay_ms(15); EXT_PCA9555_WRITE_PORTB(ADR0_PCA9555, (0<<4)|(1<<5)|(0<<6)|(1<<7)); //D aus und C ein _delay_ms(15);
-
Thread
Problem mit SPI Flash AT45DB321D
return SPDR; } void write_page(uint8_t *data, uint16_t page) { uint16_t i; uint32_t adr; adr = (uint32_t)page << 10; CS_FLASH_LOW spi_io(0x82); spi_io(adr>>16); spi_io(adr>>8); spi_io(adr>>0); for (i=0; i<528; i++) { spi_io(data[i])
CS_FLASH_HIGH } void read_page(uint8_t *data, uint16_t page) { uint16_t i; uint32_t adr; adr = (uint32_t)page << 10; CS_FLASH_LOW spi_io(0xD2); spi_io(adr>>16); spi_io(adr>>8); spi_io(adr>>0); spi_io(0); spi_io(0); spi_io(0); spi_io
-
Thread
EleLa - Elektronik Lagerverwaltung ab V1.2.11A26
,Bemerkung,Bemerkung,TEXT) 22:50:48 CreateNewField (param,ValMemo,TEXT) 22:50:48 CreateNewField (adr,Gesperrt,INTEGER) 22:50:48 CreateNewField (adr,Privat,INTEGER) 22:50:48 CreateNewField (adr,Hersteller,INTEGER) 22:50:48 CreateNewField (adr,Lieferant,INTEGER) 22:50:48 CreateNewField (adr,EMail2
bauteil,Info,VARCHAR(255)) 12:32:13 CreateNewField (param,ValMemo,TEXT) 12:32:13 CreateNewField (adr,Gesperrt,INTEGER) 12:32:13 CreateNewField (adr,Privat,INTEGER) 12:32:13 CreateNewField (adr,Hersteller,INTEGER) 12:32:13 CreateNewField (adr,Lieferant,INTEGER) 12:32:13 CreateNewField (adr,EMail2
-
Thread
Wirksamkeit von "Parallelschaltung" dreier LM399 bei xdevs
> Liege ich da komplett falsch, oder spielen da noch andere Effekte eine > Rolle? Da bei LM399/ADR1399 (und ähnliche wie LTZ1000) in derartigen Anwendungen nicht die absolute Spannung, sondern ein anderer Zweck das primäre Ziel ist: Rauschreduktion der (einzelnen) Quellen und (weniger stark)
Temperaturbereich auf nicht messbare Größenordnungen reduzieren. Das hat bei meinen Referenzen (LMx99, LTZ1000, ADR1000) bisher sehr gut funktioniert. -branadic-
-
Thread
-no case static error
subtype adr_type is std_logic_vector(max-1 downto 0); constant a_adr : adr_type := conv_std_logic_vector(16#0000#, max); constant b_adr : adr_type := conv_std_logic_vector(16#F020#, max); begin
subtype adr_type is std_logic_vector(max-1 downto 0); constant a_adr : adr_type := (others => '1'); constant b_adr : adr_type := (others => '0'); begin process (RES_N, CLK) begin
-
Thread
Pointer frei einstellen
So geht es nicht: #include "stdint.h" uintptr_t Adr ; unsigned int * PAdr ; void SetAdr(void){ // set Adr ...} unsigned int Fetch(void){ PAdr = Adr ; // Error uintptr_t cannot assigned unsigned int * return(*PAdr) ; } void Store(unsigned int Val){ *Adr = Val ; } Wie kann ich PAdr setzen?
-
Thread
ATTiny2313 I2C - Master (Peter Fleury) / Slave (jtronics)
main(void) { InitUART (12); while (1) { write_slave(ReceiveByte()); _delay_ms(1000); TransmitByte (read_Attiny0()); _delay_ms(1000); read_Attiny1(); _delay_ms(1000); } } //############# Abfrage einzelner Bytes. uint8_t read_Attiny0(void) { i2c_start_wait(Adr_AttinyI + I2C_WRITE); // Adr_AttinyI ansprechen i2c_write(0); // startadresse zum lesen i2c_rep_start (Adr_AttinyI + I2C_READ ); // Lesen beginnen Byte0 = i2c_readAck(); // Byte empfangen
-
Thread
Min. 16bit ADC Modul für Linearpoti
eine Gewindestange an mit z. B. einer Steigung von >0,5mm. An dem Motor ist ein Istwertgeber mit 1000 Impulsen pro Umdrehung >angeflanscht. Das ergäbe eine Auflösung von 60000/30mm = 2µm. ??? Grundrechenarten? Ich komm da auf 0,5mm / 1000 Pulse = 0,5 um / Puls >Problem wird die Mechanik sein
3ppm/°C -20 °C - 80 °C macht also insg. 1k +- (0.1 + 0.3). RPOTI = 500 ADCCode = 500 * 2^Bits / 1000.4 ADCCode = 500 * 2^Bits / 999.6 Gerechnet würde somit: RPOTI = (500 * 2^Bits / 1000.4) / 2^Bits * 1000 RPOTI = (500 * 2^Bits / 999.6) / 2^Bits * 1000 RPOTI = 500 * 1000 / 1000.4 bzw. 999.6 499.80
-
Thread
IRMP auf einen PIC18F4520 portieren
Du sie wieder? Das müsste eher umgekehrt lauten: [c] i_rc5_adr = irmp_data.address; i_rc5_comm = irmp_data.command; [/c] > h_rc5_adr = i_rc5_adr & 0xFF; > l_rc5_adr = ((i_rc5_adr<<8)&0xFE) | l_rc5_adr; Das verstehe ich ebenso nicht nicht. Wenn Du die adr in zwei Bytes splitten willst, dann bitte so: [c] h_rc5_adr = i_rc5_adr >> 8; // high word l_rc5_adr = i_rc5_adr & 0xFF; // low word [/c] Dassselbe
-
Thread
Umstieg ATmega32 auf AT90CAN128 WinAVR
spart Code und ist übersichtlicher. [c] void temp_channel(uint8_t ch) { if (ch & 0x01) ADR_0 |= (1<<ADR_0_PIN); else ADR_0 &= ~(1<<ADR_0_PIN); if (ch & 0x02) ADR_1 |= (1<<ADR_1_PIN); else ADR_1 &= ~(1<<ADR_1_PIN); if (ch & 0x04) ADR_2 |= (1<<ADR_2_PIN);
es warscheinlich tut. > > [c] > void temp_channel(uint8_t ch) > { > if (ch & 0x01) > ADR_0 |= (1<<ADR_0_PIN); > else > ADR_0 &= ~(1<<ADR_0_PIN); > > if (ch & 0x02) > ADR_1 |= (1<<ADR_1_PIN); > else > ADR_1 &= ~(1<<ADR_1_PIN); > > if (ch & 0x04) > ADR_
-
Thread
Kurioses Verhalten bei EEPROM_UPDATE_BYTE
10007000FFFFFFFFFFFFFFFF18191A1B1C1DFFFFEB :10008000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF80 :10009000FFFFFFFFFFFF1E1F20212223FFFFFFFFA7 :1000A000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF60 :1000B000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF50 :1000C000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF40 :1000D000FFFF2AFFFFFFFFFFFFFFFFFFFFFFFFFF05 :1000E000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF20
10007000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF90 :10008000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF80 :10009000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF70 :1000A000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF60 Er hat die Zahlen an die richtigen Stellen geschrieben! Warum geht das mit adr aber nicht mit receivedBytes ????
-
Thread
Zeitabhängige Spannungssteuerung
0b00010000 #define _TWWC 0b00001000 #define _TWEN 0b00000100 #define _TWIE 0b00000001 uint8_t twiAdr = 0xD0; void twiInitMaster(uint8_t twiAdr); #include <util\delay.h> #include <util\delay.h> //------------------------------------------------------------------------ // twiInitMaster //----
------------------------------------------------------------------- void twiInitMaster(uint8_t twiAdr) { // Clock TWBR=((F_CPU/TWI_CLOCK)-16)*2; // TWI-Status-Register (Vorteiler) TWSR=0; // Bus-Addr TWAR=twiAdr; // Enable TWCR=_TWINT|_TWEN; } //---------------------------
-
Thread
Nachbau N2ADR SDR Transceiver
QEX scheint es N2ADR mit seiner Veröffentlichung ja auch nicht geschafft zu haben. Karsten
Die von N2ADR angekündigte Veröffentlichung ist scheinbar schon auf den Seiten der ARRL verfügbar/herunterladbar. N2ADR kündigt auf seiner Homepage unter http://james.ahlstrom.name/transceiver/index.html eine
-
Thread
Array-Länge flexibel
signal init_state : t_init_states := init_idle; signal init_datas : t_init_datas := ((slv8_adr=>x"00", slv8_dat=>x"42", i_delay=>3), --0 (slv8_adr=>x"01", slv8_dat=>x"14", i_delay=>0), --1 (slv8_adr=>x"42", slv8_dat=>x"23", i_delay=>5) --2 ); [/vhdl]
------------------------------------------------ signal i_delay_counter : integer range 0 to 1000; --maximal 1000 Takte/ms oder so Pause zwischen Werten signal init_state : t_init_states := init_idle; signal init_datas : t_init_datas(0 to 2) := ((slv8_adr=>x"00", slv8_dat=>x"42", i_delay=
-
Thread
BW-CRT-Controller aus Mega8 bauen
(CRT als Master) TWI Stop: Teilt dem Host mit, dass der CRT seine TWI deaktiviert {Host_ADR,W}, CRT_ADR|0|, 0 TWI Start: Teilt dem Host mit, dass der CRT wieder empfangsbereit ist. {Host_ADR,W}, CRT_ADR|1| Bild Neuaufbau anfordern: Der CRT benötigt eine Neuübertragung aller Bilddaten {Host_ADR,W}, CRT_ADR|0|, 1 IR-RC5 Daten: Überträgt den letzten IR-Code {Host_ADR,W}, CRT_ADR|0|, |1|IR_SYSTEM, IR_COMMAND
-
Thread
Problem in Verilog: Simulation läuft,Fit gibt falsches Desi
b0111 && next_adr[18:0]==19'b0000000111111111111)|| (size==4'b1000 && next_adr[18:0]==19'b0000000011111111111)|| (size==4'b1001 && next_adr[18:0]==19'b0000000001111111111)|| (size==4'
=zst4; next_adr = adr; end else begin next_state=zst2; next_adr = adr; end end endcase end always @ (posedge clk, negedge reset) begin
-
Thread
MEGA32 ALU-Problem?
noch ein kleiner Auszug: double temp2_m; long temp_m,cali_temp; unsigned int adr_i,adr_j; // Adressvariablen for(adr_i=0;adr_i<10;adr_i++) { temp_m=0; // löschen damit ODER-Operation möglich adr_j=0; // Adresszeiger cali_temp=0; cali_temp=memo_read(6*adr_i+adr_j); temp_m=cali_temp<<24; // erstes byte --> high-byte adr_j++; cali_temp=0; cali_temp=memo_read(6*adr_i+adr_j); temp_m=temp_m|cali_temp<<16; adr_j++; cali_temp
-
Thread
Dali Kurzadresse vergeben
Shortadressen Format: 0AAAAAAS (AAAAAA = 0 - 63, S = 0/1) Beispiel! gewünschte Adresse: 2 Adr = 2; Adr = Adr << 1; Adr = Adr & 0b01111110; Adr = Adr | 0b00000001; Snd_Dal(0xA3,Adr,SP_COM); DELAY_ms(20) //DTR direkt mit Adresse beschreiben Snd_Dal(0,128,BR_ADR); //Inhalt
unter der alten Adresse erreichen und die Adresse ändern. ZB Alte Adresse: 20 Neue Adresse: 2 Adr = 2; Adr = Adr << 1; Adr = Adr & 0b01111110; Adr = Adr | 0b00000001; Snd_Dal(0xA3,Adr,SP_COM); //DTR direkt mit Adresse beschreiben (jetze übernehmen alle DALI Teilnehmer den Wert in ihr DTR
-
Thread
LM75 am Atmega32
CLEARBIT(PORTA,6);//Relais uart_putc('S'); } } _delay_ms(1000); /* uart_putc('f'); _delay_ms(1000); uart_putc('A'); _delay_ms(1000); uart_putc(uart_getc());*/ } } /* TIMER 0 IR HANDLER */ ISR( TIMER0_OVF_vect
TWCR = (1<<TWINT)|(1<<TWSTO)|(1<<TWEN); } char dat1, dat2; char TWI_empf(unsigned char adres) { TWCR = (1<<TWINT)|(1<<TWSTA)|(1<<TWEN); loop_until_bit_is_set(TWCR, TWINT); TWDR = adres; TWCR = (1<<TWINT)|(1<<TWEN); loop_until_bit_is_set(TWCR, TWINT); TWCR = (1<<TWINT)|(1<<TWEN);
-
Thread
kinderleichtes assemler programieren mit Variabeln + Rechenfunktionen
ldi handelt es sich um ein Macro welches einen 16 Bit wert in ein Index Register lädt. zb. _ldi z,1000 kannst du mit den Befehlen ldi zh,high(1000) und ldi zl, low(1000) ersetzen. Dann kennt es Dein Assembler auch ohne Macro. Klar kannst Du jeden Port nehmen um dein LCD anzusteuern. Aber nebenbei: die
. Ich habe z.B. folgende Macros aus alten .asm Files ausgegraben: [code] .macro SetRamBit ; RamAdr, BitPos .macro SkipIfRamBitSet ; RamAdr, BitPos .macro IncRamAdr ; RamAdr .macro CmpRamAdr ; RamAdr, FixValue etc. [/code] Und ich habe heute noch keinen Problem zu verstehen, was diese Macros
-
Thread
AVR - Software retten
Ich weiß ja nich ob dus siehst und ob das gewollt ist, aber ADR ist blau hinterlegt -> KEINE Variable.. D.h. ADR ist ein Bascom Befehl. Somit kann man da nix mit ADR as Byte definieren.. nenn das mal um.. Was ADR is findest du raus wenn du auf ADR und F1 klickst
Wenn man *Adr* in *adr1* umbenennt, wird das File ohne Fehler compiliert.
-
Thread
Powermessung mit INA219
Power messen und Anzeigen lassen. Die Spannung messe ich so: [c] // Spannungsmessung i2c_start(adr_ina219); // Angabe Adresse i2c_write(0x02); // Register Spannung i2c_stop(); i2c_start(adr_ina219 +1); // Auslesen Adresse + 1 msb_spannung = i2c_readAck
Schema zu verlaufen. Das lohnt sich eine eigene Funktion, z.B.: [c] uint16_t ina219_read( uint8_t adr_ina219, uint8_t reg) { uint16_t value; i2c_start(adr_ina219); // Angabe Adresse i2c_write(reg); i2c_stop(); i2c_start(adr_ina219 +1); // Auslesen Adresse + 1
-
Thread
LSM6DSL Gyro+Accelerometer, Gyro gibt keine Werte aus.
, LSM6DSL_Adr, GYRO_X_REG_L, 1, &Recieve_Buffer[0], 2, I2C_Timeout); Gyro_X = Recieve_Buffer[0] | (Recieve_Buffer[1] << 8); HAL_I2C_Mem_Read(&hi2c1, LSM6DSL_Adr, GYRO_Y_REG_L, 1, &Recieve_Buffer[0], 2, I2C_Timeout
, LSM6DSL_Adr, &Send_Buffer[0], 2, I2C_Timeout); HAL_Delay(50); HAL_I2C_Mem_Read(&hi2c1, LSM6DSL_Adr, GYRO_X_REG_L, 1, &Recieve_Buffer[0], 2, I2C_Timeout); Gyro_X = Recieve_Buffer[0] | (Recieve_Buffer
-
Thread
Text in Variable??
rjmp overflow_ein add ein, temp1 pop temp1 pop temp2 pop temp3 rjmp adr overflow_ein: ldi ein, 0x00 ldi temp1, 0x01 add zen, temp1 pop temp1 pop temp2 pop temp3 rjmp adr
*2) ldi ZH, HIGH(daten*2) rcall lcd_flash_string ; ... alter Code ab adr ...
-
Thread
8051 - Programm und Daten in einem 128kB Chip ohne Overlap
>> das alleine garantiert noch lange nicht (auch wegen ALE-Zeitpunkt), dass >> deshalb das nötige Adr-Setup u Hold-Timing eingehalten wird. >Zumindest für den DS80C320 habe ich das überprüft. Adr-Setup Time (ns) ausreichend? garantiert? Adr-Hold Time (ns) ausreichend? garantiert? bei weiteren
PLD-Code schaltet A16, sobald WR aktiv ist (das an Bus weitergeleitete WR wird nicht verzögert) also: Adr-Setuptime nicht garantiert! Auch Adr-Holdtime ist nicht garantiert.
-
Thread
SRAM wird nicht gelesen vom DE1
Das Problem ist glaube ich ein anderes: Du hast sram_adr : out STD_LOGIC_VECTOR (17 downto 0); sram_io : inout STD_LOGIC_VECTOR (15 downto 0); das geht beides raus an das SRAM. Es ist klar, dass du an sram_adr immer einen Wert angelgst, weil es ist
Dann müsste ich solche Zeiten verschieden festlegen nach Datenblatt: signal we : integer range 0 to 1000 := 0; signal oe usw... Und dann vor jeden Lese/Schreibvogang in dem einen Process ----------------------- if (c<1000) then c <= c+1; else schreibe/lese endif ----------
-
Thread
ADR-Radio wiederbeleben
noch den Sinn nicht. Mit viel Aufwand ein digitales Tonsignal so aufzumodulieren, dass es der alte ADR Receiver wieder dekodieren und als digitales Tonsignal ausgeben kann? Der Clou bei ADR war ja, dass man sehr viele digitale Radiostationen einfach empfangen konnte. Geht heute mit einem DVB-S2 Receiver
noch den Sinn nicht. Es kann eigentlich nur einen Grund geben. Man hat zufaellig noch einen DAR-1000 im Keller. :) Also moeglich ist das bestimmt wenn man die Doku zu ADR auftreiben kann. Aber der Arbeitsaufwand ist sicher nicht unerheblich. Aliexpress hat da kein fertiges Modul fuer.... Vanye
-
Thread
Speichermapping Erklärung
Drösle das ganze von hinten auf. Welche Bedingungen müssen erfüllt sein, damit ADR0 auf Low geht? Welche anderen Leitungen sind für die Bestimmung des Wertes von ADR0 vollkommen irrelevant? Und das machst du mit allen anderen ADR Leitungen ganz genau gleich.
der 138 schon mal garantiert nicht. Es wird also freigeschaltet [code] nnnn nnnn 1111 1000 -> ADR16 nnnn nnnn 1111 1001 -> ADR17 nnnn nnnn 1111 1010 -> ADR18 nnnn nnnn 1111 1011 -> ADR19 nnnn nnnn 1111 1100 -> ADR20 nnnn nnnn 1111 1101 -> ADR21 nnnn nnnn
-
Thread
ic fälschungen im tieferen preissegment
Euro kann doch schon gut an den Billig Replica Dingern verdient werden. Hast du dir die Version ADR445A oder ADR445B geholt? Wenn da drin ein 7805 drin steckt haben die recht viel Gewinn an dir gemacht ;-) Aber du kannst ihn ja mal austesten, vielleicht hat er ja gute Werte.
Hier mal die Variante ADR440BRZ (vor ca. sechs Monaten über Farnell bezogen), die allerdings genauso aussieht.
-
Thread
Tabellen im PIC auslesen
Gleiche bewirken. 2. Ein Label (Unterprogramm) Next_Char gibt es nicht (in deinem Code). 3. AdrH und AdrL wird in deinem Code nirgendwo geändert. Was soll die Routine eigentlich machen? Dem Name nach die Adresse finden oder was sonst. Steffen
kommt denke ich aufs Selbe raus. 2.&3. Das ist nur ein Auszug des Codes. Next_Char incrementiert AdrL und bei Überlauf auch AdrH. Trotzdem danke für die Antwort. Ich poste wenn ich heim komme mal die gesamte Routine.
-
Thread
Pappradio ein günstiges SDR für Kurzwellenhörer
> oh, dann empfehle ich dir Herr XYZ, dich an Dieter zu halten, es gibt > SDR-1000/1500/3000/5000 diese sind von der Firma Flexradio und haben > alle unterschiedlich Eigenschaften und Preisniveau Von Flexradio gibt es weder einen SDR-1000 noch einen Flex-1000. SDR-1000 gab es
>> Von Flexradio gibt es weder einen SDR-1000 noch einen Flex-1000. > deine Aussage kannst du selber nochmal nachlesen Die Aussage "Von Flexradio gibt es weder einen SDR-1000 noch einen Flex-1000" ist nach wie vor richtig. Einen SDR-1000
-
Thread
DDS AD9835 SPI TWI I2C Beispiele ATmega8 Assembler
wurde es ohne Tastatureingaben o.ä. realisiert: ; Frequenz definieren ldi temp1,BYTE1(1000) ldi temp2,BYTE2(1000) ldi temp3,BYTE3(1000) ldi temp4,BYTE4(1000) ; Frequenz im SRAM ablegen STS(adr_FREQUENZ_BYTE0),temp1 STS(adr_FREQUENZ_BYTE1),temp2 STS(adr_FREQUENZ_BYTE2),temp3 STS(adr_FREQUENZ_BYTE3),temp4 ; Frequenz einstellen rcall DDS_FREQUENZ
-
Thread
CRC8 - Zu dumm für die Gegenrechnung?
leider komme ich nach wie vor auf kein schlüssiges Ergebnis: Befehl: s b4 07 s b5 03 p S-Adr R/W ADR S-ADR R/W ADR Binär: 1011010 0 00000111 1011010 1 00000011 Dieser Befehl ließt aus dem RAM den Datenwert. Empfangen wird: 82 39 35 Oder Binär: 1000 0010 0011 1001 0011
hin, dass keine "Division" (=Rest) ausgefuehrt wird: (1011 0100 0000 0111 1011 0101 0000 0011 1000 0010 0011 1001 0011 0101) XOR (1 0000 0111) ~~~ Das XOR sollte MOD heissen. Die "Division" ist uninteressant, es ist der Rest der Division welcher interessiert.
-
Thread
Wann muss die Spannung ganz genau stimmen?
einfach mal die Toleranzen der in hochgenauen Multimetern verwendeten Spannungsreferenzen an: LTZ1000(A): ca. +/-5 % LM199/399(A): ca. +/-2,2 % Selbst die beiden aktuellen Nachfolger der LTZ1000 haben entsprechend Toleranzen: ADR1000: +/-0,76 % ADR1001: +/-1,6 % Die ADR1001 besitzt zusätzlich
Oder wie sonst sollten Multimeter mit den zuvor aufgezählten Referenzen funktionieren? Die LTZ/ADR1000(A) wird sogar für achteinhalbstellige Multimeter eingesetzt.