-
Thread
Funktion mit bool als Parameter
ein "enum" odersowas, fehlt mir aber noch etwas Erfahrung... Evtl. lässt sich für "speed" ein einzelnes Bit definieren? [C] unsigned char Set_Speed(unsigned char speed) { if (speed == 1){ CLKPR=(1<<CLKPCE); CLKPR=0x00; } else{ CLKPR=(1<<CLKPCE); CLKPR=(1<<CLKPS2 |
gesetzt Flags &= ~FLAG1; // Flag1 rücksetzen ... etc. Dadurch nutzt man die Bits in Flags optimal aus. Aber um welchen Preis? Bei jedem Zugriff, ob Abfrage, ob Setzen, ob Löschen artet das in einer UND/ODER/NICHT Orgie aus (ok, etwas übertrieben). Das kostet erstens Programmspeicher
-
Thread
STM32 USB Übertragungsproblem mit Code von S.F.
macht: [c] // For devices with 2x16 bits/word access schema // (e.g. STM32L0x2, STM32L0x3, STM32F0x2, STM32F303xD and xE) #define UMEM_SHIFT 0 #define UMEM_FAKEWIDTH uint16_t // For devices with 1x16 bits
_t)0x04000000U) /* Bit 2 */ [/c] Oder du hast andere Header.
-
Thread
3 kleine Fragen zu i2c
den Master ausbremsen kann. Das ist, wenn der Slave auf das Datenpaket vom Master sein Acknowledge-Bit schickt, und dann den Pegel auf Low lässt. Durch den Pullup/Open Drain ist dann eine weitere Kommunikation nicht mehr möglich. Aber das lässt sich lösen, in dem man den watchdog-timer mit der I2C-Kommunikation
Busteilnehmer ausbremst kommt auf die Programmierung an. Die AT-Megas haben einige Interrupts, auch beim I2C (TWI), also RX-Complete und TX-complete, sinnvoll verwendet gibt das kaum Last. Schickst Du den Controller in Warteschleifen zum Abfragen von Statusbits sieht die Sache anders aus.
-
Thread
RLC Messung mit AVR
Hi, 1. Adresse des AD5933 mit zusatz bit zum schreiben 0x1A auf i2c Bus senden 2. Commando 0xB0 senden. (Register Pointer) 3. Registeradresse senden 4. Adresse des AD5933 mit zusatz bit zum lesen 0x1B auf i2c bus senden 5. Registerwert
(void) { i2c_start(); i2c_write(0x1B); // Standardadresse des AD5934 0b0001101+1Bit=lesen; delay_us(50); // als "Ersatz" für Acknowledge-Bit vom AD5934 data=i2c_read(0); // Master empfängt
-
Thread
Attiny clock & Fuse Bits
MUSS man bei Benutzung des internen Oszillators mit seinem Mittelwert "rechnen". Mit dem FUSE-Bit CKDIV8 stellst du ein, ob der µC mit den vollen (UNGEFÄHR!) 8 MHz des internen Oszillators arbeitet, oder mit 1/8 davon (1 MHz). Bei Auslieferung ist das FUSE-Bit auf 1/8 eingestellt. Abgleichen
hier schon mehrere Takte benötigt, da du, um einen Wert von 2.000.000 feststellen zu können eine 32 Bit Variable benötigt, der AVR jedoch eine 8 Bit-Architektur hat und daher jedes Byte einzeln berechnen muss. Zudem brauchst du noch einige Takte um zu prüfen, ob der richtige Wert erreicht wurde, so dass
-
Thread
[Selbstbau CPU] Welche Befehle machen eine CPU "praktisch"?
Bauform B. schrieb im Beitrag #7001951: > c-hater schrieb im Beitrag #7001918: > Den kannst du wirklich mit einzelnen Gattern nachbauen. Und der > Befehlssatz ist so einfach dass du keinen Assembler brauchst ;) Na gut, > PDP8 ist noch einfacher
Barrel-Shifter (der mehr als eine Position auf einmal schieben kann), rotieren oder ein SHR, wo das vorderste Bit repliziert wird (für 2er-Komplement praktisch) Befehle um einzelne Bits zu setzen/löschen braucht man nicht zwingend. Wenn gerechnet werden soll braucht es mindestens die Addition mit Carry-Flag
-
Thread
"Gruppierung" von Pins
ist, deshalb habe ich es erwähnt. Der TO belegt eine Menge Pins. Und die muss er auch noch alle einzeln ansteuern. Wenn er eine Port-Erweiterung wie den besagten PCF-8574 nutzt, kann er das BIT-Array mit 1 Befehl via Libs / I2C an den Chip senden. Das spart Code ohne Ende. Und Speicher ist Knapp in
Schlaumaier schrieb im Beitrag #6779712: > Der TO belegt eine Menge Pins. Und die muss er auch noch alle einzeln > ansteuern. Wenn er eine Port-Erweiterung wie den besagten PCF-8574 > nutzt, kann er das BIT-Array mit 1 Befehl via Libs / I2C an den Chip > senden. Das spart Code ohne Ende. Und Speicher
-
Thread
Anzahl verwendeter Bitstellen mit C-Preprocessor ermittelbar?
Mit dem Pre-prozessor fällt mir nichts ein, mit C++ und rkcursiven Templates schon: [c] /* Recursives template */ template<unsigned long VALUE> class GetBits { public: static constexpr uint8_t Bits = 1 + GetBits<VALUE/2>::Bits;}; /* Rekursionsende */ template<> class GetBits<0> { public: static constexpr uint8_t Bits = 0;}; /* beispiel */ int bits = GetBits<12345>::Bits; [/c] Wird komplett vom Compiler berechnet, am Ende steht da nur noch eine Zahl im Code. Wenn
-
Thread
Hammond B3 Clone mit ATMega
upper und lower Manual gleichzeitg anliegen, macht zusammen 8 Zeilen und 16 Spalten = 24 Pinne. Der µC hält nach wie sich die Signale verändern und erzeugt daraus die jeweilige Differenz. Die Daten gehen denn als 1-Byte Nachrichten an den Aux. Aufbau: 1 Bit Taste gedrückt oder losgelassen + 1 Bit upper
zur Verfügung; mit weniger Pins für alle Peripherie passt vielleicht das ganze System in einem einzelnen uC.
-
Thread
MCP2515 - Nachricht empfangen - und dann? :)
im Interrupt des µC sofort auslesen und in SRAM puffern (FIFO,FILO) damit das Empfangsfach des MCP schnell wieder frei ist - empfangene Nachricht im Interrupt des µC "abchecken" ob von Bedeutung, erst dann in SRAM übernehmen
LCD aktualisiert, dann können ~16 CanMsgs eingehen, bevor erneut nachgesehen wird. (Annahmen: 125kBit/s; kurze Botschaften: ~80Bit; -> ~16CanMsg pro 10ms). Diese 16 müssen dann natürlich zwischengepuffert werden. > In C programmierst Du 1. schneller und 2. wesentlich bugfreier. Volle Zustimmung.
-
Thread
stm32 harte nuß !
GPIO_Init(BUTTON_PORT, &gpio); } int button_pressed (void) { if (GPIO_ReadInputDataBit(BUTTON_PORT, BUTTON_PIN) == Bit_RESET) { return 0; } return 1; } [/c] und ersetze Deine Abfrage durch: if (button_pressed ()) .... P.S. Auch für die LED kann
GPIO_Speed_50MHz; GPIO_Init(LED_PORT, &gpio); } void led_on (uint16_t led) { GPIO_WriteBit(LED_PORT, led, SET); } void led_off (uint16_t led) { GPIO_WriteBit(LED_PORT, led, RESET); } [/c] Dann reduziert sich Deine main() auf: [c] button_init(); led_init();
-
Thread
Atmega8 Uart
Hi >z.B. das a wird zum q und das c wird zum s. Das ist definitiv ein Baudraten-Problem. Stoppbit wird als Bit7 empfangen. Wird vielleicht auch b zu r oder d zu t? MfG Spess
spess53 schrieb: > Findest du es wirklich sinnvoll, Bits, die als 'Read Only' deklariert > sind, zu beschreiben? Bei einem Mega8 ist es vielleicht nicht so sinnvoll, denn da kann man die einzelnen UCSRA Flags via SBI/CBI erreichen. Aber bei einem Mega168
-
Thread
AD-Werte auf LCd ausgeben
hin. Der Rest wird ziemlich sicher passen) und hier [C] #define LCD_PORT PORTA /**< port for the LCD lines */ #define LCD_DATA0_PORT LCD_PORT /**< port for 4bit data bit 0 */ #define LCD_DATA1_PORT LCD_PORT /**< port for 4bit
Hallo, [c] #define LCD_PORT PORTD /**< port for the LCD lines */ #define LCD_DATA0_PORT LCD_PORT /**< port for 4bit data bit 0 */ #define LCD_DATA1_PORT LCD_PORT /**< port for 4bit
-
Thread
C oder Pascal
Ich habe mit der freien Mega8-Version von AVRCo angefangen und nachdem der uC ausgereizt war die Profiversion gekauft .... 100% Hobby ! @nicht jetzt: es gibt 64Bit-Variablen
@ W.S. (Gast) >Und was wird irgendwann mal aus einem 128 Bit Integer? >long long long int? Ey maaaan, led me dell you this way [reggae] Ive been coding C a lalalala long a lalalala long a lalalala long long le long long long C'mon [/reggae]
-
Thread
Strukturierte AVR-Assembler-Programmierung Gesperrt
lesbar und zu pflegen (auch von anderen). Sinnlos. Da kann man auch gleich eine Hochsprache ala C oder Pascal nehmen, die machen das wenigstens richtig. >Der Programmierer hat dabei weiterhin wie bisher (hoffentlich) volle >Kontrolle über jedes Register und jedes Bit des jeweiligen >AVR-µControllers
statt RJMP erzwingen kann (wenn dann nicht der Assembler zu große Sprungweite reklamiert). Auch 16-Bit-Abfragen (statt bisher 8-Bit-Abfragen) hatte ich angedacht. Solche Details für Verbesserungen und Erweiterungen hätte ich in der Tat gerne hier diskutiert (deshalb urspünglich in "Projekte & Code
-
Thread
ADC + ATMEGA8 + Spannung messen
Versuchs mal hier: http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#16-Bit_Portregister_.28ADC.2C_ICR1.2C_OCR1.2C_TCNT1.2C_UBRR.29 und hier: http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#ADC_.28Analog_Digital_Converter.29 Da steht eigendlich alles drinn
. Wenn Du den ADC-Wert nicht als 16-Bit-Wert auslesen willst, sondern die beiden Ergebnis-Teilregister einzeln weiterverarbeiten willst, dann muss trotzdem erst ADCL in eine entsprechende 8-Bit-Variable geladen werden und dann ADCH. >
-
Thread
10bit Wert => 4x 7 Segment
Spaltenbearbeitung im Editor. 0-1023 erst in binär umrechnen lassen und damit habe ich meinen Eingang der CASE Abfrage. Das Ergebnis habe ich mir aus Kontanten zusammen gebaut. [vhdl]c_null : std_logic_vector := "0000001"; -- low active LEDs c_eins : std_logic_vector := "1001111"; c_zwei : std_logic_vector := "0010010"; -- usw. CASE WHEN "0000000000" => s_leds <= c_null & c_null & c_null & c_null; WHEN "0000000001" => s_leds <= c_null & c_null & c_null & c_eins; -- usw. LED0 <= s_leds( 5 DOWNTO 0); LED1 <= s_leds( 6 DOWNTO 11); LED2 <= s_leds(12 DOWNTO
-
Thread
Weidereinstig Mikrocontroller - welche Familie, welche Tools ?
ist das aber nicht. Daher: Probiers aus. Meiner Meinung nach sind die technischen Daten der µC fast irrelevant, kannst eh fast mit allem alles lösen. Das ist Hobby, das muss Spass machen. Was bringt dir der beste µC, wenn das Arbeiten damit keinen Spass bringt.
nicht so schlecht. Mir gefiel damals das durchdachtere Design besser (machte irgendwie einen echten 32 Bit-Ansatz neu entwickelter Chips und kein aufgebohrtes 16 Bit Design bei den ersten STM32). Aktuell arbeite ich mich gerade in die steinalten STM32F103C8T6 ein. Warum? Der Chinamann steckt sie mir für
-
Thread
Embedded C - Firmware Umbau
Profis gelegt haben. Wenn dann Fehler auftreten, warst Du es und nicht das RTOS. :-P Ich würd kein C nehmen, sonder EC++, also embedded C++, auch wenn du keine dynamischen Objekte benutzt ist C++ durch seine festere Typensicherheit, Überlagerungsmöglichkeit von Funktionen, Inline u.s.w. die bessere
verwendet wird oder Methode 4 statt 7. Das erste kann man schnell umbauen, dass zweite klingt nach C und größeren Problemen. (Falls es C ist, solltest Du die Sprache nicht nennen :-) No N. schrieb im Beitrag #7575531: > da nicht einzelne Module/Komponenten getestet werden können, > sondern nur
-
Thread
Ereignisse zählen und mit Vorgabe pro Minute vergleichen.
Fehler drin (Second im addBit ist falsch), neu: [c] uint8_t eventBuffer[8]; uint8_t start, end; uint8_t second void addBit( uint8_t bitValue ) { // end eins hochzählen und ggf im Ringpuffer "umbrechen" end = (end
<< bitOfs); } /* jede Sekunde */ ISR(..timer...) { if ( getKey() ) { addBit( getKey() ); } } [/c]
-
Thread
Spannungsindikator mit Bargraph-LED realisieren_02
Hi. Jeder Akku soll einzeln angezeigt werden, deswegen benötige ich dann für 2 Akkus auch 20 statt nur 10 Pin für die Graphen. Jetzt aber ein schönes Problem: Hier erst einmal der einfache Programmablauf [c] Config
darfst da nicht mehr als 5V drauf geben! Wenn du da mit 12V drauf fährst, dann ruinierst du den µC!
-
Thread
AVR Synthesizer mit ATxmega128A1
spezielle Funktion, die Word mit Byte Multipliziert hat, und als Ergebnis kam Word raus (die untersten 8Bit des 24Bit Ergebnisses werden ignoriert) Ich habe auch mit einem Filter experimentiert, der so auschaute: [code] v0 = R*C*v0 + C*in - C*v1; v1 = R*C*v1 + C*v0; output = v1; C = Cutoff (0.
temperature = (((uint32_t)358*result_)/calval_) - (273+temp_offset); return ( temperature); } [/C] Am Anfang wird der ADC initialisiert und die Calibration Bytes für den Temperatur Sensor gesetzt. Danach folgt die Abfrage der 12Bit breiten Sensor Daten im ADC Daten Register und die Um- rechnung
-
Thread
i2c Slave Problem
wie stelle ich das an was in dem 2.absatz des auszuges aus dem user manual steht????also nur einzelne bits ändern und die bits 5,6 und 7 nicht "anfassen"! im forum bei der sensorkommunikation über spi standen so befehle wie: bit_setzen(data,(1<<5)); -> ist das bei i2c ähnlich? bin über jede
überhaupt Zugriff auf das Register zu bekommen, muss ich vorher noch in einem anderen Register ein Bit auf "1" setzen um überhaupt Zugriff auf dem EEPROM zu haben. initI2c(); startI2c(0x70); writeI2c(0x0A); // Registeradresse wo Bit4 auf 1 soll writeI2c(0x10); // beschreibe Bit4
-
Thread
Cmount-Kamera für getriggerte Videoerfassung
Sony-Chip 1/3", Progressive Scan + 1024x768 Pixel 4.65 x 4.65µm, bis 30 Bilder/s, 0.15 lx + SNR 9 bit bei 25°C, Verstärkung 0 dB + ca. 500 mA bei 5 VDC + Belichtungszeit 1/10000 bis 30 s + Offset 0 bis 511 + Sättigung 0 bis 200 % Die billigere CMOS-Ausführung hat + Micron-Chip MT9M131 1/3", Progressive Scan + 1280x1024 Pixel 3.6 x 3.6µm, bis 24 Bilder/s, 0.5 lx + SNR 8 bit bei 25°C, Verstärkung 0 dB + ca. 250 mA bei 5 VDC + Belichtungszeit 1/10000 bis 4 s + Offset ?? + Sättigung ?? So gesehen könnte die doppelt so teure CCD-Ausführung Vorteile haben. Falls man
-
Thread
Wachsender LED-Balken
richtig setzen und > fertig. Sehr sinniger Vorschlag zur Vorbereitung auf eine Prüfung in der C-Programmierung gefordert wird. Es ist auch in C nicht schwer ... ... wenn man regelmässig seine Übungen gemacht hat.
anktuelle Anzahl der leuchtenen LED`s. Diese wird nun je nachdem in welchem Unterprogramm (oder ohne einzelne Unterprogramm nach Status Status&0x80) verringert oder erhöht und ausgegeben. Sobald eine Bestimmte Zahl erreicht ist wird einfach auf Null gesetzt und Status Bit 0 umgedreht.
-
Thread
C - Schnelle Datenauswertung auf PC - Multi-Threading?
Tips benötigen könnte (ich zähle auf euch :D): Der Mikrocontroller sendet ADC-Daten (105 KSp/s, 24-Bit/32-Bit)per UDP an meinen PC (Ist ein 24-Bit ADC (ADS1271), dessen Daten auf 32-Bit erweitert werden). Diese werden erst in einem Array gespeichert (Umwandlung in 32-Bit-Datentyp) und anschließend zum
www.purebasic.com/german/index.php Die Sprache hat nur minimale Geschwindigkeitseinbusen gegenüber gutem C Code und für Multithreading schreibt man eine ganz normale Funktion und führt sie mit einer Befehlszeile lediglich asynchron zum Hauptprogramm aus. Es kann auch sehr einfach auf C - Bibliotheken zugegriffen
-
Thread
SCANDISK und große Festplatten
Der Fenstermanager von XP ist auch ziemlich 'rudimentär' (noch schlimmer als der von 7) Achja: 64bit XP ist ne furchtbare Krücke, Windows 7 64bit ist mittlerweile sogar auf den Consumer-PCs Diese Liste lässt sich nach belieben fortsetzen
Abdul K. (ehydra) schrieb: > Installer gibs auch ohne sinnvollen Abfragen! Also mir sind Installer MIT sinnvollen Abfragen lieber. :) > .. Du hast nicht > verstanden was ich wollte. Nämlich: Manche durchaus brauchbare Programme > werden von ansonsten ahnungslosen
-
Thread
Ermitteln ob Zeit zwischen zwei Uhrzeiten ist
Mit den paar Float-Operationen wird man bei angemessener Aufrufhäufigkeit trotzdem selbst einen 8-Bit µC nicht wirklich fordern können. Allenfalls einer Leere im Flash lässt sich damit wirkungsvoll entgegen treten.
[c]if (h == 22){ stop = 1; } if (h == 7){ stop = 0; }[/c]
-
Thread
Verständnisprobleme synchron, asynchron
[c] if clk'event and clk='1'then case statussenden is when 0 => if txstart='1' then -- Warten auf Start und starten. serout<='0'; statussenden<=1; [/c] Das Problem dabei
-- bei einem positiven Kameraclock wird das Fifo din mit Daten gefüllt. -- Es handelt sich um 12-Bit-Messwerte, es wird aber auf 16-Bit aufgerundet. var2<='1'; din<="0000"&kamungh&kamungl; wr_en<='1'; end if; end if; end process; wr_clk<=not clkkam; -- Der Schreib-Clock für das Fifo
-
Thread
6fach SPI-Slave in CPLD oder FPGA?
aber keinen Überblick über die heutigen Möglichkeiten. Meine Anforderungen in Stichpunkten: 1. 16Bit Datenbus, einige Adress- und Steuerleitungen zu einem µC (@ 3,3V) 2. 6 unabhängige SPI-Slaves mit Datenrate um 8 .. 16MHz (SPI-Master @ 5V) 3. SPI-Frame besteht aus 32Bits 4. niedrige Verlusstleistung
testen, bevor Du den Baustein wählst. Der Teufel steckt wohl eher im Detail, z.B. im Interface uC und FPGA. Wenn die Busbreite z.B. 8 Bit ist, dann siehst Du vom uC aus mindesten 6 x 4 = 24 verschiedene 8 Bit Register welche Du schreiben und Lesen mußt. Schreiben ist vielleicht weniger das Problem
-
Thread
Wittig(welec) DSO W20xxA Hardware
kommen mir deswegen Timing-Probleme beim Auslesen der ADCs vor, wobei ich auf das falsch-Auslesen einzelner Bits tippen würde. Wenn man die binären Werte der falschen Samples unter der Annahme betrachtet, daß (meistens) ein einzelnes Bit falsch ist, ließe sich dann eine fehlerfreie Kurve rekonstruiren?
kommen mir deswegen Timing-Probleme > beim Auslesen der ADCs vor, wobei ich auf das falsch-Auslesen einzelner > Bits tippen würde. Wenn man die binären Werte der falschen Samples unter > der Annahme betrachtet, daß (meistens) ein einzelnes Bit falsch ist, > ließe sich dann eine fehlerfreie Kurve rekonstruiren
-
Thread
Frage zum Fading von LED's
Auch dein PC hat nur einen Timer, und da blinkt und dreht sich auch alles. Irgendetwas auf deinem uC ist das Hauptprogramm, und irgendetwas anderes sind Interrupt-Routinen. Soft-PWM kann man sowohl im Hauptprogramm (synchronisiert sich durch Abfrage des aktuellen Timer-Standes) als auch in einer
sehe. Und dann gehts nach dem if einfach > weiter mit Menu - Abfrage und so weiter - stimmt eigentlich ganz > logisch. Genau., Der springende Punkt ist die Denkweise. Betrachte das Flag als Benachrichtigung: Es ist ein Ereignis eingetreten. Der µC testet
-
Thread
AVRStudio6.1 Compiler meckert (warnt) bei Struct-Pointer-Übergabe
du jedes einzelne C-File, jedes einzelne Header-File durch und fragst dich bei jedem #include 'Brauch ich den da drinnen?', 'Wird hier, in diesem File, irgendetwas verwendet, was diesen #include notwendig machen würde
, S0/1 den Speedmode des ADC und darauf für das CSV-Format mit Semikolon getrennt der 16Bit ADC-Wert und Timestamp kommen. Was ich also erwarte und in 50% der Fälle erhalte: z.B. [c] M0;C0;S0;113D;3131 [/c] Was ich bekomme (nach hier 11 Requests): [c]M0;C0;S0;113D;3131 M0;C0;S0;113E
-
Thread
Interrupt mittels Flag erkenne, kein jump an die Interrupt Vector Addr.
(1<<INT0) | (1<<INT1); //INT0 und INT1 aktivieren sei(); [/c] Das ich das EICRA beschreiben muss ist definitiv klar, aber muss ich auch die Bits im EIMSK setzen? oder bestimme ich damit das gesprungen wird? Ich möchte nur, dass das Flag gesetzt wird.
zu tun, sondern damit, dass man die Bits, die man nicht verändern möchte, auf 0 belässt, was beim Zusammensetzen von Registerwerten über OR automatisch geschieht. Klar, wer mit den Bit-Set/Bit-Clear-Assemblerbefehlen einzelne Bits anspricht
-
Thread
Haussteuerung, Strommessung AC
Und der kostet gerade mal 3 Euro 50! http://www.schukat.com/schukat/pdf.nsf/index/E317DD3156863523C125731A00415F5C/$file/AC-102020Jun-06.pdf So-nun habe ich lt. Datenblatt also 20 A am Wandler und somit bei diesem speziellem damit einen Ausgang von 2V und 20 mA bei einem Lastwiderstand von 100 Ohm
von 10 kHz Wenn du schneller als 200 mal pro Sekunde abfragst schon, wenn du langsamer bist ist der MIttelwert jedoch 0. Eigentlich brauchst du einen schnelle Präzisionsgleichrichter vorweg, http://sound.westhost.com/appnotes/an001.htm (Die Massezeichen
-
Thread
Wo gibt es günstige USB-Dongle(Kopierschutz)
int main() { //AA B0 C3 8A string msg; msg = "B0"; int i; msg = "AA" + msg; i=0; for(i=0; i<5; i++); msg += "C3"; string hard = "Didn't get that.";
mit eigener Software ausgestattet und ohne Treiber/Software schnell zu verwenden mit Beispiele in C/C++ und Excel Basic auch. Grüße Karsten
-
Thread
Ein Interrupt stört den anderen
//phase A rückkopplung break; } zahl++; if(zahl==6) zahl=0; } [c] [/c]
=5; while(bit_is_clear(ACSR, ACO)) {} MotorStep(5); ADMUX=1; while(bit_is_set(ACSR, ACO)) {} MotorStep(6); ADMUX=0; while(bit_is_clear(ACSR, ACO)) {} } } void
-
Thread
AVR/C: Bits in Register in einem Schritt löschen und andere setzen
Hallo, ich möchte gerne auf einem ATmega 328p im Register TCCR2B die Bits CS22 und CS20 setzen und die Bits CS21 und WGM22 löschen. Ich kann das in zwei Schritten mittels [c] TCCR2B |= ((1<<CS22|(1<<CS20)); TCCR2B &= ~((1<<WGM22)|(1<<CS21)); [/c] bewerkstelligen. Der
wobei der Schreiber hier eine Fehler gemacht hat. > Löschen immer noch mit dem > <reg> &= <reg> ~<bit-mask> Naja eigentlich [c]<reg> &= ~<bit-mask>[/c], das was du schreibst ist ja aufgelöst [c]<reg> = <reg> & <reg> ~<bit-mask>[/c].
-
Thread
PWM-Signal mit AD-Wandler oder mit Frequenzmesser einlesen?
,8 L2: sbrc A,0 rjmp OFF rjmp ON ON: sbi portb,TXD rjmp BitD OFF: cbi portb,TXD rjmp BitD BitD: ldi Delay,38 D5: dec Delay brne D5 lsr A dec Count brne L2 cbi PORTB,TXD
pinb,4 ;PB4 abfragen rjmp Tstop ;Sprung, wenn kein Signal rjmp loopb ;Abfrage wiederholen Tstop: ldi A,0 ;Timer stoppen out TCCR0B,A clr timer
-
Thread
ADC Wert für ARM7 LPC2136 auslesen
; // ADC einschalten AD0_ADCR|=(1<<16); // ADC Burst Modus = Permanente Abfrage ADC_Val = ((ADC_Val >>6) & 0x000003FF); // extract result return(ADC_Val); } [/c] Wo kann der fehler stecken? Am AD Eingang des µC lege ich eine Spannung zwischen 0 und 3V an. Als
; // ADC einschalten AD0_ADCR|=(1<<16); // ADC Burst Modus = Permanente Abfrage } [/c]
-
Thread
µKontroller-Übertragung
die 8 bit in das uart-senderegister schieben und der rest macht dein µC, wenn du die UART richtig konfiguriert hast und das sollte im datenblatt stehen. und ansonsten zum 8051 sollte es einige beispiele geben zur benutzung der UART-schnittstelle in C bei deinem µC2 musst du die UART-schnittstelle konfigurieren und dann entweder ein bit pollen (ständig abfragen), ob was im empfangen wurde oder eben auch ein interrupt auslösen lassen, wenn die schnittstelle
-
Thread
Atmega16
Porta.1 = 0 Goto Anfang Der Compiler liefert zwei Mal : Invalid Datatype Doch wie muss ich ein Bit angeben. Ein Byte ist mit einem % gekennzeichnet, hexadezimal mit & aber wie sieht das bei einem Bit aus. Und noch was. muss ich beim Atmega16 beide Gnd's(pin 11,pin31) anschliessen, oder gehört
haben solltest, kannst ja mal mailen oder einfach hier im board fragen. Hier gibts echt ein paar µC Gods! Gruss Alex
-
Thread
Char in 2 Hälften teilen
Hi. Ich mache gerade meine ersten gehversuche mit µCs und C. Im Tutorial habe ich was gefunden wie man einzelne Bits von Ports und registern setzen, löschen oder abfragen kann. Gibt es etwas vergleichbares auch mit 4 Bit? Ich möchte das High- und das Low Nibble
gast wrote: > Das Zeichen ist 0x0d und ich möchte das High-Nibble um eins erhöhen. [c] uint8_t c = 0x0d; c = ((c & 0xf0) + 1) | (c & 0x0f); [/c] > Wie kann ich in einer If oder case abfrage rausfinden, ob das Low-Nibble > z.B. 7 ist? [c] if ((c & 0x0f) == 7) {
-
Thread
Hystere-routine mit Psoc -µC
schau doch mal in die datasheets der einzelnen usermodule. da sind beispielcodes dabei wie man den jeweiligen ADC/DAC anspricht. die hysterese sind dann nur noch paar if abfragen
den zweiten Teil dann komplett getrennt. So wie sich das Problem darstellt, hat es auch mit PSoC ansich nichts zu tun. Ist ein reines C-Problem. Gruß - Abdul
-
Thread
Problem mit PWM bei 7-Seg LCD
Ein bitweises Exklusiv-ODER ("^") eines Portregisters mit 0xFF macht nichts anderes als jedes einzelne Bit dieses Registers zu invertieren (jedes Bit wird mit "1" Exklusiv-ODER-verknüpft, es ändert also seinen Zustand unabhängig vom Ausgangswert; aus 0 wird 1 und umgekehrt). Wenn in PORTB vorher 0xBB
eventuell ins Schleudern mit der Portinvertierung. Du musst vor einer Aktualisierung jeweils das Common-Bit abfragen und entsprechend entweder die Bitmaske oder die invertierte Bitmaske an (z.B.) PB6...0 ausgeben. Da darf dann eben kein Interrupt dazwischenhauen. Und genau das ist innerhalb der ISR gewährleistet
-
Thread
Falsche Anzeige nach Spannungsverlust
"system.h"// Beinhaltet grundlegende Definitionen und Funktionen #include "bits.h" // Definiert die einzelnen Bits #include "lcd.h" // Funktionen für das LCD-Display #include "delay.h" // Funktionen zur Zeitverzögerung /* ** Definitionen */ #define B1 (PINA
UCSR1A = 0b00000000; UCSR1B = (1<<TXEN1)|(1<<RXEN1); // Senden und Empfangen UCSR1C = (1<<UCSZ11)|(1<<UCSZ10); // UCSR1B = UCSR1B | 0b00011000; // Ermögliche Empfangen und Senden (Bit3 = 1, Bit4 = 1) // UCSR1C = UCSR1C | 0b10000110; // Setze Frame Format: 8 data (Bit1 = 1
-
Thread
Wittig(welec) DSO W20xxA Open Source Firmware (Teil4) Gesperrt
Flankentrigger der in Abhängigkeit von Low/High eines anderen Kanals steht, so könnte man z.B. bei I2C aufs Start Bit triggern.
noch nicht fertig wärend ich die nächste Flanke anfordere, es wurden Bits verschluckt. Also bitte anpassen, in Zeile 41 von tc_vars.h: [c] #define SPI_DELAY16 175 // >150 us for shifting out a 16 bit value [/c] Zur Sicherheit habe ich in hardware_t.cpp in Zeile
-
Thread
AT91SAM7X schwächelt
AD_WertSPI=0; for (zaehlerSPI = 3;zaehlerSPI >= 1;zaehlerSPI--) { AT91F_SPI_Enable(AT91C_BASE_SPI0); // Einschalten des SPI0 AT91F_SPI_PutChar(AT91C_BASE_SPI0,SendeWert,0); // senden von Wert "SendeWert" = 255 (8bit)/ Dummy Wert AD_WertSPI |= (AT91F_SPI_GetChar(AT91C_BASE_SPI0) & 0xFF); // nur 8bit interessieren nicht die 16bit des Registers AD_WertSPI <<= 8; // Wert in AD_Wert verschieben rprintf("Ergebnis: %x\n",AD_WertSPI);
-
Thread
ad-wert ausgabe an lcd
wie soll ich den ad-gewandelten wert weiter verarbeiten. auf eine Riesentabelle wo ich jedes einzelne bit des wertes abfrage, hab ich eigentlich weniger lust..wären ja etwa 1024 möglichkeiten!!(10Bit A/D) hat jemand von euch schon erfahrungen damit gemacht?? danke schon im voraus für eure mithilfe
Programm immer in der einen Schleife!(NextSub) Meine Überlegung: Du setzt oben ja das Carry Bit.. dann überprüfst du ob es 0 wird. (Dies sollte passieren sobald Hexzahl - 10 = neg. Wert ist) Jedoch bin ich mir nicht sicher ob er dann das Carry Bit wechselt, also von 1 -> 0 oder ob er es einfach
-
Thread
Frequenzmessung, diesmal aber anders...
Was genau willst Du denn messen ? Die Dauer des Paketes ? eine einzelne Periode ? jede einzelne Periode ? Wie hoch muß die Auflösung sein ? Wie auch immer, besorge Dir schon einmal einen Quarz mit 16MHz.
Datasheet lese: welchen timer benutzt du? beim timer 1 kann das problem darin bestehen, das er 16-bit hat - der µC braucht zum lesen und ins register schreiben 2x so lang als beim 8-bit timer... vllt. geht es sich ja mit den zeiten so aus, das du den 8-bit timer verwendest... vllt. hat ich geholfen