-
Thread
I2C Bus wird nicht freigegeben nach i2c_start()
Man sieht auf den Shots 2 bis 4 doch NACKs oder? NACK == high, ACK == low ?
Alex schrieb im Beitrag #2367189: > NACK == high, ACK == low ? ACK ;-) ich merk es mir so: wenn keiner etwas macht, ist der Bus high durch den Pullup, also ist high NACK. Wenn sich einer angesprochen fühlt, wird er aktiv und erzeugt ein low.
-
Thread
Rundenzähler Carrera
Müßte in if (resetdruecken == LOW) { nicht noch mehr passieren?
möchte if (millis()-rundenAnfang[0]<200 || millis()-rundenAnfang[1]<200) digitalWrite(LEDPIN,HIGH); else digitalWrite(LEDPIN,LOW); } [/c] Dieser Sketch ist so wie gepostet für die Erfassung von zwei Fahrzeugen vorgesehen. Eine Erweiterung auf mehr Fahrzeuge (4 bis 6) wäre am einfachsten
-
Thread
Unbenutzte AVR-Pins wie beschalten (EMV)?
gibt es noch die internen Dioden als Schutz. Und wenn die Software bei einem "freien Pin" auf ein Low, High oder eine Flanke reagiert ist es ein Softwarefehler und kein EMV-Problem! avr
Pull-Up hart an VCC - Eingang ohne Pull-Up hart an VCC - Eingang ohne Pull-Up hart an GND - Ausgang Low offen - Ausgang High offen - Ausgang Low an Gnd - Ausgang High an VCC durchzumessen. Dazu brauchst Du nur einen Widerstand, den Du zwischen Versorgungsspannung und VCC-Pin schaltest. Parallel zum
-
Thread
Tastenschlagzeug mit NXP LPC 935 selber bauen
Wie verhält sich der Signalzustand wenn auf der UART ein Signal ausgegeben wird: 1) geht der High-Pegel auf Low Pegel wenn ein Zeichen gesendet wird? 2) oder geht der Low Pegel auf High Pegel wenn ein Zeichen gesendet wird? Anders gesagt, wenn das Startbit kommt war das Signal zuvor noch auf
Wie verhält sich der Signalzustand wenn auf der UART ein Signal > ausgegeben wird: > 1) geht der High-Pegel auf Low Pegel wenn ein Zeichen gesendet wird? > 2) oder geht der Low Pegel auf High Pegel wenn ein Zeichen gesendet > wird? > > Anders gesagt, wenn das Startbit kommt war das Signal zuvor
-
Thread
Modelbau
B Bit 0 ; -> Ausgang (der Schaltausgang) ist an Port B Bit 1 ;Warten auf 2,5msec. HIGH (Merkmal für Alte übertragung abgeschlossen, Neue Übertragung folgt) ;Wenn HIGH 2,5msec lang anliegt wird weitergesprungen und im folgenden auf LOW gewartet ;Sollte vor den 2,5msec das Signal LOW
2,5ms? Der komplette Impuls für jeden Kanal ist maximal 2ms lang. Am einfachsten ist: Prüfen ob Low am Eingang anliegt. Solange da Low anliegt, weiter prüfen. Zähler starten, wenn kein Low mehr anliegt. Zählen, solange High anliegt. Sobald wieder Low anliegt Zählerinhalt sichern und beim 2. Kanal
-
Thread
Geschwindigkeit Arduino > C
einmal gleich doppelt? [c] void loop() { for(;;){ #ifdef USE_ARDUINO digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level) digitalWrite(13, LOW); // turn the LED off by making the voltage LOW #else PORTB |= (1<<PB5); PORTB &= ~(1<<PB5); #endif }
Male hintereinander ausführen um den Einfluss der Schleife los zu werden. [c] digitalWrite(13, LOW); delayMicroseconds(10); digitalWrite(13, HIGH); digitalWrite(13, LOW); digitalWrite(13, HIGH); digitalWrite(13, LOW); digitalWrite(13, HIGH); digitalWrite(13, LOW); delayMicroseconds
-
Thread
Taste in ISR entprellen
Vorgehensweise etwas auszusetzen? Funktionieren tut die Sache prima. [c] #define keyStateIdle_low 1 // pushbutton = active low #define keyStateIdle_high 0 // pushbutton = active high #define keyStateStable 15 // represents the number of stable samples #define sampleTime
idle state of the pushbutton highCounter ++; // count the low-samples else { highCounter = 0; // reset lowCounter while pushbutton is not stable sample = 0;
-
Thread
LCD KS0073 am AVRATMega128
putch(byte_high); // Ausgeben auf Uart für Debug! // Dann unteres Nibble byte_low &= ~0x0f; //oberes Nibble löschen LCD_PORT = byte_low; //unteres Nibbel Ausgeben LCD_Enable(); putch(byte_low
(); putch(byte_high); // Ausgeben auf UART für Debug! char byte_low = byte_high; //Sichern für unteres Nibble // Oberes Nibble zuerst ausgeben byte_high = byte_high>>4; //Wert ins untere Nibble schieben.
-
Thread
HC595 ansteuern in C
ISR, nach Übertragung aller Bytes deaktivierst du den SPI Interrupt und setzt den SS Pin kurz auf Low und gleich wieder auf High. Solange SS auf Low ist wird der aktuelle Kontext der Register an deren Ausgängen angezeigt, sprich dein LED Muster. Wenn SS auf Low geht so werden einerseits die Ausgänge
Daten senden. Erst wenn diese komplette über DATA/CLOCK gesendet wurden wird ENABLE wiederum kurz von High nach Low nach Highgepulst,und schon leuchten die nächste Zeit die LEDs im neuen Muster. Dies geht mit der Beschaltung aus dem Wiki nicht. Dort müsste man entwerder ENABLE auf Low setzen und somit
-
Thread
Navilock NL550ers GPS "zerschossen"?
So, ich versuch das jetzt mal zu beschreiben: Auf ein langes 5V high folgt 300us low 100us high 200us low 100us high 200us low 100us high 100us low 300us high 300us low 100us high 100us low 100us high 500us low
schrieb im Beitrag #2323043: > So, ich versuch das jetzt mal zu beschreiben: > > Auf ein langes 5V high folgt > 300us low > 100us high > 200us low > 100us high > 200us low > 100us high > 100us low > 300us high > 300us low > 100us high > 100us low > 100us
-
Thread
LCD im 4-Bit Modus mit microchip 16F818 in C
output_high(E); output_low(E); Daten(0,1,1,0); output_high(E); output_low(E); // bis hier [/c] Danach ist die Initialisation zu Ende. Da würd ich auch nochmal ein paar ms warten. Die
output_high(RS); // rs high um zu schreiben delay_us(1); output_low(E); Daten(0,0,1,1); // die ersten 4 bit output_high(E); delay_us(1); output_low(E)
-
Thread
Mit Arduino und Schieberegister 74HCT595
setze -DataPin HIGH. -Clock Takt -DataPIN LOW -Clock Takt -DataPin HIGH. -Clock Takt -DataPIN LOW -Clock Takt -DataPin HIGH. -Clock Takt -DataPIN LOW -Clock Takt -DataPin HIGH. -Clock Takt -DataPIN LOW -
draufhat, kriegt einen Knoten im Kopf. Ausserdem redet man ständig aneinander vorbei. -DataPin HIGH. -Clock Takt -DataPIN LOW -Clock Takt -DataPin HIGH. -Clock Takt -DataPIN LOW -Clock Takt -DataPin HIGH. -Clock Takt -DataPIN LOW -Clock Takt -DataPin HIGH. -Clock Takt -DataPIN LOW -
-
Thread
Arduino Timer für Campingwaschmaschine
DISPLAY_I2C_ADDRESS)) { Serial.println("SSD1306 nicht gefunden"); } } int taktstate = LOW; int relay1state = HIGH; //Die Relais schalten bei LOW ein und bei HIGH aus, Anfangswert daher HIGH int relay2state = HIGH; int potiWert = 0; long Einschaltdauer = 0; int Einschaltdauer_now; int Minutendauer = 0; int taktwert = LOW; int startwert = HIGH; //Die Buttons schaltem gg GND, Anfangswert daher HIGH int relaywert = LOW; int relay1wert = LOW; int relay2wert = LOW; int
-
Thread
MOSFET Dimensionierung für Signalwandlung
Dann müsste man die Eigenschaften des Ausgangs der Signalquelle ausmessen, d.h. Ausgangsimpedanz bei High und Ausgangsimpedanz bei Low. Dabei würde man in diesem Fall sehen, dass letztere bei Low relativ niedrig ist, bei High aber sehr hoch und würde zu dem Schluss kommen, dass es sich um einen Open-Kollektor
einfach wie es > scheint. Eigentlich schon. 1) Du misst ohne Last die Spannung am Ausgang bei High und bei Low. 2) Du hängst als Last einen Widerstand nach Ground und misst dann bei Ausgabe von High-Pegel die Spannung am Ausgang. Die Impedanz des High-Treibers und der Widerstand bilden dann einen
-
Thread
Inverse Logik?`
ganz anders aus. Die normale Funktion (Low=Aus; High=An), bleibt hierbei erhalten. Man muss diesen Anschluss nur benutzen.
" bedeutet aber gleichzeitig, entweder jemand hat keine Ahnung, oder die LED ist intern mit High verbunden. High auf beiden Seiten entspricht einer Differenz von Null also Dunkelheit. Low auf der anderen Seite bedeutet die volle Differenz aus high minus low, wobei dem einen oder anderen schon mal
-
Thread
EADOGM162W-A-Anzeige mit XMEGA
Data Bit 6 (PC5) #define LCD_D7 PIN4_bm // Data Bit 7 (PC4) // Helper macros #define LCD_E_HIGH() (PORTC.OUTSET = LCD_E) #define LCD_E_LOW() (PORTC.OUTCLR = LCD_E) #define LCD_RS_HIGH() (PORTC.OUTSET = LCD_RS) #define LCD_RS_LOW() (PORTC.OUTCLR = LCD_RS) // Function Prototypes void lcd_init
to the LCD void lcd_send_data(uint8_t data) { LCD_RS_HIGH(); // Data mode lcd_send_nibble(data >> 4); // Send high nibble lcd_send_nibble(data & 0x0F); // Send low nibble _delay_us(100); // Wait for the data to execute } // Send a nibble
-
Thread
Bewegungssensor für Fahrrad Alarm
hat D1? Ansonsten: Wenn du D1 brückst, hast du einen Pullup von 1k. Das reicht für einen guten High-Pegel, aber möglicherweise kann der 393 das nicht auf Low ziehen...
Man nehme einen Pullup von 1MΩ, dann fließen dauerhaft max 3µA [3V]. Ein MC (ATtiny13) schaltet bei High noch 3kΩ parallel (wetting current). Der MC kann dann noch aus den Pulsen ein dauerhaftes High oder Low machen (retriggerbarer Monoflop).
-
Thread
NodmCU ESP8266 nicht zu flashen
GPIO15 und GPIO2 sind genau verkehrt. Wo high sein sollte ist low und umgekehrt. GPIO0 wechselt bei drücken des Flashtasters von high nach low.
Boot Modes GPIO15 | GPIO0 | GPIO2 | MODE LOW | LOW | HIGH | Serial Programming LOW | HIGH | HIGH | Boot from flash HIGH | ANY | ANY | Boot from Sd-Card Wenigstens GPIO0 macht was es soll beim Taster drücken. R2 ist vom ESP
-
Thread
Atmega2560 startet nicht
void setup() { pinMode(PIN_LED, OUTPUT); } void loop() { digitalWrite(PIN_LED, HIGH); delay(500); digitalWrite(PIN_LED, LOW); delay(500); }
display.begin(SSD1306_SWITCHCAPVCC, 0x3C); } void loop() { digitalWrite(PIN_LED,HIGH); delay(200); digitalWrite(PIN_LED,LOW); // display.clearDisplay(); // display.setTextSize(1); // display.setTextColor(WHITE,BLACK); // display.setCursor(0,0); // display.print(zahl)
-
Thread
Arduino mit WTV020-M01
startSoundInBackground(0); delay(12000); } void resetModule(){ digitalWrite(resetPin, HIGH); digitalWrite(resetPin, LOW); delay(5); digitalWrite(resetPin, HIGH); digitalWrite(clockPin,HIGH); // * Wait * delay(500); } void startSoundInBackground(int soundNumber
delay(3000); delay(2000); } void resetModule(){ digitalWrite(resetPin, HIGH); digitalWrite(resetPin, LOW); delay(5); digitalWrite(resetPin, HIGH); digitalWrite(clockPin,HIGH); // * Wait * delay(700); // * Volume has to be "FULL VOLUME" 7 (Hardware
-
Thread
[OSX] ESP8266- Hochladen mit Arduino IDE Schlägt fehl
010 2 Jump start 011 3 Boot from flash memory 100 4 SDIO low speed V2 101 5 SDIO high speed V1 110 6 SDIO low speed V1 111 7 SDIO high speed V2 [/pre] => Bootmodus 1 und 3 sind die die du brauchst. => Pullup an GPIO2
nenne: http://stefanfrings.de/esp8266/index.html#fwupdate Zitat: [pre] Normaler Start: GPIO0 = High oder offen GPIO1 (TxD) = High durch Widerstand oder offen GPIO2 = High durch Widerstand oder offen GPIO15 = Low ... Nach dem Start können diese Pins jedoch als frei programmierbare I/O Anschlüsse
-
Thread
Aus 2 char ein unsigned int erzeugen
Ich möchte Daten von den Ports einlesen. Der Datenbus ist 8 Bit breit. Zuerst übertrage ich das Low-Byte und anschließend das High-Byte. Danach möchte ich das Low-Byte und High-Byte zusammenfassen zu einem unsigned int. Hier mein Quellcode: bit status; char low_byte, high_byte; if(status == LOW_BYTE) { low_byte = PINC; status = HIGH_BYTE; } else { high_byte = PINC; ptr_datenpuffer[i] = high_byte; ptr_datenpuffer[i] = ptr_datenpuffer[i] << 8; ptr_datenpuffer
-
Thread
programmierung arduino schalter
(ledPin3, LOW); digitalWrite(ledPin4, LOW); digitalWrite(ledPin1, HIGH); delay(800); digitalWrite(ledPin1, LOW); delay(50); } if (buttonState == HIGH) { digitalWrite(ledPin2, HIGH
(ledPin3, HIGH); delay(800); digitalWrite(ledPin3, LOW); delay(50); } if (buttonState == HIGH) { digitalWrite(ledPin2, HIGH); digitalWrite(ledPin1, LOW); digitalWrite(ledPin3, LOW
-
Thread
Wer macht bei Arduino eigentlich die Qualitätssicherung?
sich auf deine Meldung: > du kennst doch die Doku https://www.arduino.cc/reference/en/ > Dort ist High und Low dokumentiert. High ist alles was größer 0 ist. Jetzt hast du die Dokumentation von true und false zitiert. Ist das das gleiche wie HIGH und LOW? Ich vermute erstmal nicht. MfG, Arno
keinen gemeinsamen bool Datentype in der C und C++ >Welt. Sonst hätte man ihn evtl. verwendet, statt HIGH und LOW. Nein. Auch dort gilt: In Java und damit in Processsing gibt es "boolean". Hätte man sich an den C++ Syntax angelehnt, wäre es "bool" gewesen. Die Verwendung von HIGH und LOW ist unter
-
Thread
NAND mit TAmega32 ansteuern
Bitoperationen sind jetzt i.O. Sieh Dir mal im Datenblatt das Timing genau an (Fig. 17): 1. CLE=LOW, CE=HIGH, WE=HIGH, ALE=LOW, RE=HIGH 2. CE=WE=LOW, CLE=HIGH 3. DDRA=Alles auf Ausgang, 0x90 auf IO0..7 (PORTA0..7) 4. WE=HIGH 5. CLE=HIGH u.s.w. Deine Sequenz ist falsch. Du programmierst: CE=HIGH, WE=HIGH, CLE=LOW, PORTA=0x90 u.s.w. Das passt nicht.
-
Thread
if befehl eingeben
(richtungB, HIGH); if (richtungA, HIGH); { digitalWrite(laserPin,HIGH);// Anweisungsblock für wahr delay(100); } digitalWrite (bremseA, LOW); //Bremse lösen digitalWrite (bremseB, LOW
(bremseA, LOW);//Bremse lösen digitalWrite(bremseB, LOW); delay(1000);//1Sekunde fahren digitalWrite(bremseA, HIGH);//Bremsen Motor aus digitalWrite(bremseB, HIGH); } Ich versuche mich
-
Thread
Problem beim Upload via Bootloader auf Atmega328PB
erzwingen. Wie Du schon schriebst, haben frühere Versionen von der Uploader die Leitung eben solange auf Low gehalten, bis endlich die Gegenstelle ein High meldet. Ein µC auf Low kann aber kein High senden. Nun aber hat es sich herumgesprochen (und das war auch zu Modemzeiten schon so), dass man die Betriebssystemfunktionen
geben sollen. Doch, wie beschrieben leider! Die Abstimmung Kondensator, externer Widerstand nach High und interner Widerstand des ResetPins sind ungenügend. Zunächst ist der Kondensator ungeladen, weil beide Seiten High, dann wird das Ende am Programmer auf Low gezogen, wodurch der -ungeladene- Kondensator
-
Thread
7 Segmentanzeige (4stellig) am Arduino Mega 2560 Rev.3
Programm bzw. Sketch per Programmierung des Arduino erledigen, indem ich das jeweils betroffene Bit auf LOW oder HIGH stelle ?
ansteuerung(10); else ansteuerung(tausender); digitalWrite(transistorpin4, LOW); delay(2); digitalWrite(transistorpin4, HIGH); } void ansteuerung(int a) { delay(2); for (int j=6; j>=0; j--) digitalWrite(pin[6-j], bitRead(segmente2[a], j)==1?HIGH:LOW);
-
Thread
HD44780 kompatibles Display - Initialisierung klappt nicht
----------------- // LOW PORTD &= ~(1<<RS) // RS LOW |(1<<RW); // RW LOW // DB7 HIGH // DB6 HIGH // DB5 HIGH // DB4 HIGH // HIGH PORTD |= (1<<DB7) |(1<<DB6)
ist: // RS LOW // RW High // DB7 High // DB6 High // DB5 Low // DB4 High
-
Thread
Assembler und NOP
if-Abfrage zwischendrin habe (ob Pin high oder low), möchte ich dass beide Wege (also if und else) gleich lang sind, also die Laufzeit gleich bleibt, egal ob ein high oder ein low am Pin anliegt, daher brauche ich auch dort mehrere NOP-Befehle
dem Bespiel aus, wo ich nur den SCK-Pegel ändere, z.B. [c] PINA = (1<<PA4); //CLK toggeln (auf high) NOP_12mal(); //high-CLK-Signal mind. 0.6us = 12 Befehle //3. Adressbit senden (high, nicht verändern) PINA = (1<<PA4); //CLK toggeln (auf low) NOP_26mal(); //low-CLK-Signal
-
Thread
mein glcd zeigt nichts an
Datenausgabe: Statusabfrage Bit 0 und 1 Daten auf Datenport CD = low CE = low CE = high CD = high Status lesen (Bit 0 und 1 oder Bit 3 (Auto-Write)): WR = high RD = low CE = low Abfrage von Bit 0 und 1 oder Bit 3 auf high in einer Schleife CE = high RD = high WR = low MfG Andi
-
Thread
INT0 INT1 sperren und freigeben
Ich habe nicht verstanden. Ein Iterrupt wird gerufen, wenn ein high-low Flanke vorkommt. Aber ich möchte, die Zeit zwischen low-high und high-low Flanke messen.
konfigurieren, dass sie bei jeder Flanke auslöst. Ein Blick auf den Input-Pin sagt dir dann ob es eine High-Low oder eine Low-High Flanke war.
-
Thread
uC Input Problem - GPIO
= 1+ high_zaehler; } else if(zustand == LOW){ low_zaehler = 1 + low_zaehler; } } else if((GP2DAT & 0x01) != zustand){ if(zustand == HIGH){ low_zaehler = 1 + low_zaehler
){ if((GP2DAT & 0x01) == zustand){ if(zustand == HIGH){ high_zaehler = 1+ high_zaehler; } else if(zustand == LOW){ low_zaehler = 1 + low_zaehler; } } else if((GP2DAT & 0x01) != zustand){ tastgrad = (float)(high_zaehler
-
Thread
Tiny15 zur Relaissteuerung
mein N-HexFet durch ist, aber ohne Tiny tut sich nichts. ;-) Also liegt es am Tiny selber. Habe ich High mit Low verwechselt?
an PB3(Pin2) und LED an PB0(Pin5) Config Portb.3 = Output Config Portb.0 = Output 'LED Ein (HIGH) Portb.0 = 1 'Warte 1500 ms Waitms 1500 'LED Aus (Low) Portb.0 = 0 'Relais Ein (HIGH) Portb.3 = 1 'Warte 500 ms Waitms 500 'LED Ein (HIGH) Portb.0 = 1 'Relais Aus (Low) Portb
-
Thread
Shutdown Active High
#5572466: > einem Lichtsensor Aha! Toll! Appment schrieb im Beitrag #5572466: > Shutdown Active High Und was ist daran unklar?
Spannungen > über einen uC auslesen möchte. Jetzt hat dieser Lichtsensor einen Pin > "Shutdown Active High". > Was bedeutet der denn nun genau? Wenn an diesem Pin low anliegt, arbeitet der Sensor im Normalbetrieb. Wird dieser Pin auf high gelegt, wird der Sensor in einen Stromsparmodus gehen, er wird
-
Thread
Bit-Banging UNI/O-Bus EEPROM mit Arduino-Uno [Fehlschlag]
OUTPUT); pinState = PINSTOUT; } // Set bus pin to output // Set pinState global to output // Low to High transition digitalWrite(BUSPIN, HIGH); // High to Low transition escaping THDR pulse /* Bit Period*/ delayMicroseconds(TE / 2); // Half-Bit-Period digitalWrite(BUSPIN, LOW); /
welche. [code] Wenn 1. Mal nachsehen 2. mal nachsehen -> Schlussfolgerung Low Low keine Flanke, Pin durchgehend low Low High steigende Flanke High Low fallende Flanke
-
Thread
Servoansteuerung mit Timer (ATmega32)
während den ca. 20 ms Wartezeit etwas anderes gemacht werden { PORTB |= 1<<PINB0; //PWM HIGH Signal } ISR(TIMER1_COMPB_vect) //ISR für Timer B { PORTB &= ~(1<<PINB0); //PWM LOW Signal } [/c] DANKE noch mal! mfg thomas
)! Ablauf dann: Count von 0 bis MATCH -> PD5 = HIGH Count von MATCH bis TOP -> PD5 = LOW usw. Um den Servo links/rechts drehen zu lassen, veränderst Du im normalen Programmablauf einfach den MATCH in OCR1A - fertig! Eleganter geht's nicht mehr
-
Thread
Power-down mit Taster
bestimmte Voraussetzungen an den External Interrupt gestellt werden. Der Interrupt löst bei einem LOW oder HIGH Level am Pin aus, nicht bei einer Flanke.
while(1) { if(!(PINB & (1 << PINB2)) // gedrückt? { // ja => Bit löschen: Ausgabe LOW: LED an (active-low) PORTB &= ~(1 << PB1); } else { // nein => Bit setzen: Ausgabe HIGH: LED aus (active-low) PORTB |= (1 << PB1); } } } [/C] Die
-
Thread
DOG-M Display über SPI
gesamten Source. Hast du schonmal versucht deinen Takt "umzutauschen". Also anzunehmen das die Daten bei High->Low (jetzt ist wenn ich das richtig sehe Low->High) übernommen werden?
schwachen Akku also sind die Werte nicht exact. Am Programmer angeschlossen (vom PC getrennt) liegt high bei 2,8V und low bei 0V. Abgekoppelt liegt high bei 4,6V und low bei 1,8V! Die meisten anderen getesteten Ports erzeugen fast 0V bei low. Ist das eine Eigenheit des MISO Ports? Ich habe dazu nirgends
-
Thread
Bustreiber vom 8085 low-actice
Hallo, das stammt aus TTL Zeiten. Dort haben unbeschaltete Eingänge HIGH Pegel. Da bedeutet die einzige möglichkeit zuverlässig zu erkennen ob eine Signal anliegt ist der LOW Pegel, weil der nur vorkommen kann wenn das Signal aktiv runtergezogen wird. Eckhard
Eckhard schrieb im Beitrag #2129769: > Dort haben unbeschaltete Eingänge HIGH Pegel. Nur, damit keine Gerüchte aufkommen, es ist ein undefinierter Pegel; weder 'low' noch 'high' aber sehr empfänglich für Störimpulse. Daher dürfen TTL-Eingänge niemals offen gelassen werden
-
Thread
Seltsames Verhalten bei Arbeit mit LevelShifter
Roland M. schrieb im Beitrag #7571346: > der ESP sendet mittels > digitalWrite(D7, HIGH); 3.3V Dieser "Pegelwandler" sollte besser "Low-Übertrager" heißen. Denn ein High-Pegel wird durch ihn einfach gar nicht übertragen, der stellt sich allein durch die beidseitigen Pullups ein.
mogelt > sich irgendwie hoch... Das heißt also, dass bei meinem LevelShifter der Wechsel von HIGH auf LOW funktioniert, aber von LOW auf HIGH nur mit quasi Müh und Not, hab ich das so richtig verstanden ? Um es kurz zu sagen : Ich brauche einen Pegelwandler, der 3.3V in 5V "korrekt "konvertieren
-
Thread
binärwert in Hex wert umwandeln
> 9 && DataADCHighLow <= 16) UARTTXBuff[7] = DataADCHighLow + '7'; if( DataADCLowHigh <= 9) UARTTXBuff[8] = DataADCLowHigh +'0'; else if ( DataADCLowHigh > 9 && DataADCLowHigh <= 16) UARTTXBuff[8] = DataADCLowHigh + '7'; if( DataADCLowLow <= 9)
-
Thread
Problem mit Servoansteuerung mit einem PIC!
T1_INTERNAL | T1_DIV_BY_4); set_timer1(0); //timer wird auf 0 gesetzt output_high(PIN_C2); //ausgang wird auf high gesetzt while(true) { if(get_timer1() >= pos) //wenn pos >= timer wert output_low(PIN_C2); // ausgang auf low setzen if(get_timer1
pin_high(); if(zaehler==wertservo) pin_low(); if(zaehler==20000) zaehler=0; zaehler++; } [/c]
-
Thread
Frage zur Betriebsspannung messen
beendet ist //Ergebnisse des ADC zwischenspeichern. Wichtig: zuerst ADCL auslesen, dann ADCH adc_low = ADCL; adc_high = ADCH; adc_result = (adc_high<<8) | adc_low; //Gesamtergebniss der ADC-Messung //adc_result = adc; vcc = 1125300L / adc_result; //Versorgungsspannung in mV berechnen
beendet ist //Ergebnisse des ADC zwischenspeichern. Wichtig: zuerst ADCL auslesen, dann ADCH adc_low = ADCL; adc_high = ADCH; adc_result = (adc_high<<8) | adc_low; //Gesamtergebniss der ADC-Messung //adc_result = adc; vcc = 1125300L / adc_result; //Versorgungsspannung in mV berechnen
-
Thread
NAND Gatter 74LS00 in Monoflop eines Kabeltesters
ist. > Kabeltester_Seite_3_Monoflop.jpg Von IC8B Eingang gehen Widerstände nur nach Masse (low), keiner nach plus (high). Ein nicht an +5V angeschlossener Eingang eine 74LS Schaltkreises ist kein gutes high. Und low wird es nur, wenn R22 niederohmig (<330 Ohm) ist. Die Schaltung ist
Michael B. schrieb im Beitrag #6520062: > Von IC8B Eingang gehen Widerstände nur nach Masse (low), keiner nach > plus (high). > > Ein nicht an +5V angeschlossener Eingang eine 74LS Schaltkreises ist > kein gutes high. > > Und low wird es nur, wenn R22 niederohmig (<330 Ohm) ist. > >
-
Thread
HD44780+PIC18F25k22 Rise Time Probleme?
(); LCD_RW_SetLow();} #define TRIGGER {TEST_Trigger_SetHigh(); TEST_Trigger_SetLow();} [/c]
Timing. #define TRIGGER {TEST_Trigger_SetHigh(); TEST_Trigger_SetLow();}
-
Thread
Grafikdisplay, Probleme mit Timer Interrupt
_FRAME_SET_LOW; for (int n=1;n<240;n++) //nun das ganze für die übrigen 239 Zeilen { WDH3224_LOAD_SET_HIGH; WDH3224_LOAD_SET_LOW; for (int i=0;i<40;i++) { WDH3224_CLOCK_SET_HIGH
nun das ganze für die übrigen 239 Zeilen > { > WDH3224_LOAD_SET_HIGH; > WDH3224_LOAD_SET_LOW; > > > > WDH3224_CLOCK_SET_HIGH; > WDH3224_DATA_PORT = LCD_STACK[n][i] >> 4; > WDH3224_CLOCK_SET_LOW; > > WDH3224_CLOCK_SET_HIGH
-
Thread
Flipflopfragerei
müssen >die Eingänge dann immer irgendwie mit der Masse verbunden sein? Nöö, das wäre ja immer LOW. Sie müssen mit einer definierte Spannung verbunden sein. Im einfachsten Fall Masse = LOW oder VCC = High. Oder einem Ausgang eines anderen Logik-Ics. >Das kapiere ich grade nicht. Wenn ich doch
über Vcc geht oder halt umgedreht, je nachdem, ob ich die Grundstellung des Anschlusses S oder R auf LOW oder auf HIGH haben will? Will ich ihn auf HIGH haben in der Grundstellung, dann muss ich den Schalter dann gegen GCC stellen, weil das HIGH ja dann von der Vcc-Seite herkommen tut, oder?
-
Thread
enc28j60 LanController initialisieren auf ARM7
aussagefähig. Kannst du ein Bild einer kompletten Sequenz aufnehmen, ich hoffe man erkennt was. Von CS von High to Low bis CS von Low to High! und natürlich die passende Codezeile dazu nennen. Stephan PS: Wie steht denn das Reg. CSR1 wenn du es nach der Enable Funktion liest?
sein. Schau dir das Bild an: 1: Takt -> haben wir 8 Stück 2: mosi -> 1 Takt -> Datel Leitung Low 2 Takt -> Datel Leitung High 3 Takt -> Datel Leitung Low 4 Takt -> Datel Leitung High 5 Takt -> Datel Leitung Low 6 Takt -> Datel Leitung Low 7 Takt -> Datel Leitung Low 8 Takt -> Datel
-
Thread
millis denkproblem Gesperrt
schrieb im Beitrag #6558692: > // if the LED is off turn it on and vice-versa: > if (ledState == LOW) { > ledState = HIGH; > } else { > ledState = LOW; > } Sowas finde ich immer irgendwie unfassbar, unfasslich... ledState = not ledState;
machen, aber nicht bei einer Definition, die du nicht unter deiner Kontrolle hast. In Arduino.h ist LOW und HIGH wie folgt definiert: #define HIGH 0x1 #define LOW 0x0 Mit 'int ledState' ergibt dein Vorschlag beim Wechsel LOW->HIGH ein ledState = 0xFFFF, und damit würde eine möglicherweise im Code