-
Thread
Erbitte Hilfe bei RFID Projekt Tierchip von Streunerkatzen auslesen
Ich habe die wichtigsten mal ausgelötet. Auf meinem WL-134 ist der im Schaltplan mit 47p bezifferte C18 tatsächlich 150n. C13, C14, C16 und C20 sind wirklich 10n, C15 ist 22n, und C17 und C19 sind beide 47p, wie im Schaltplan angegeben. Auch C7-C12 haben auf der Platine vermessen (die Leiterbahn zwischen
habe die wichtigsten mal ausgelötet. Auf meinem WL-134 ist der im > Schaltplan mit 47p bezifferte C18 tatsächlich 150n. C13, C14, C16 und > C20 sind wirklich 10n, C15 ist 22n, und C17 und C19 sind beide 47p, wie > im Schaltplan angegeben. Auch C7-C12 haben auf der Platine vermessen Vielen Dank
-
Thread
Speicherfragmentierung kein Thema mehr?
malloc()-Implementierung so erwartet: [pre] $ pwd /usr/src/contrib/jemalloc/src $ wc -l *.c 2365 arena.c 2 atomic.c 142 base.c 90 bitmap.c 395 chunk.c 197 chunk_dss.c 210 chunk_mmap.c 563 ckh.c 1673 ctl.c 39 extent.c 2 hash.c 313 huge.c 1873 jemalloc.c 2 mb.c 160 mutex.c 1283 prof.c 190 quarantine.c 67 rtree.c 549 stats.c 476 tcache.c 107 tsd.c 657 util.c 11355 total
-
Thread
indizierte addressierung
des Adresszeigers (also Z) auf die einzelnen Bytes zuzugreifen. Dazu wird die Wortadresse um ein Bit nach links geschoben (was einer Multiplikation mit 2 entspricht). Wenn das LSB jetzt 0 ist, wird auf das erste Byte zugegriffen, wenn es 1
es aber, einzeln auf Low- und High-Byte der Worte zuzugreifen, indem er die Adresse künstlich verlängert und 'rechts' vom LSB ein zusätzliches Bit einfügt, mit dem er entscheidet, ob das Low- oder das High-Byte angesprochen
-
Thread
Übertragungsprotokoll
detektieren das da irgendwelche Daten auf der Leitung liegen. Zum generieren, synchronisieren auf einzelne Bits. 1 Byte: Sync. Zum Synchronisieren auf ein Byte 1 Byte: Absenderadresse. Also nur für kleine Netze mit maximal 255 Teilnehmern 1 Byte: Zieladdresse 1 Byte: "Zwischenziel"adresse. falls Multihop
so schnell daß eine Abfrage in kürzeren Intervallen als Minuten überhaupt Sinn macht. Ich sehe also keine besonders hohen Datenströme auf dich zu kommen. Als Messwertauflösung reicht eine Tiefe von 7 Bit durchaus aus, wenns
-
Thread
C: Variablen in Bedingungsanweisungen definieren
abgesehen, wo ist der Sinn darin, einen Konstanten Wert in eine Variable zu packen, und drumherum eine Abfrage auf den Wert ebendieser Variable zu machen? Ein [c]printf("1\n");[/c] hätte den (gewünschten) Effekt ebenso.
nicht. Heiko L. schrieb im Beitrag #6027753: > Jetzt kommt Poker: > According to the 1999 ISO C standard (C99), size_t is an unsigned > integer type of at least 16 bit (see sections 7.17 and 7.18.3). > > Was glaubst du, wie groß der ist? Ja und nu? Was hat das nun mit C++ zu tun? mh
-
Thread
Atmega8 und I2C-Display startet nicht
Byte das am LCD ansteht nur durch Ver-odern > und Ver-undung geändert werden soll. Ok. Also so: [c] void I2C_Write_4Bit_Set(int cmd) { int Data; //Low-Nibble Data=((cmd&0b00001111)<<4); Data|=(1<<2)|(1<<3); //Led=1,E=1 I2C_Send_Data(Data,2); Data&=~(1<<2); //E=0 I2C_Send_Data(Data,
data) { I2C_Write_4Bit_Ram(data); } void LCD_Print_String(const char *s) { while(*s) LCD_Print_Char(*s++); } int main(void) { LCD_Print_String("1234"); } [/c] muss funktionieren, es sei denn,
-
Thread
AVR Atmega ports register
Andererseits ist es einfacher und schneller einen Port abzufragen/auszugeben als jedes Bit einzeln. Für die Shift Register (74...) könnte ein Pin verwendet werden der ein Hardware Shift Register enthält (Spi,Uart,I2c) Das macht die Ein/Ausgabe weniger aufwendig.
nur bei 200mA wird aber wahrscheinlich aber größer werden. Bzgl. der Schnelligkeit der Input Abfrage: Über die direkte Abfrage der einzelnen Ports bzw Register an. (DDR, PORT, PIN) habe ich erheblich an Reduzierung der Zykluszeit gewonnen (Der Faktor lag fast im 8x fachen Bereich.) Ferner habe
-
Thread
Evaluation neuer Mikrocontroller: ARM? Gesperrt
würde ich mich nicht darauf verlassen, dass die lange > lieferbar wären, da sie doch sehr stark an einzelne Gerätegenerationen > (Smartphone, Navigationssysteme) gebunden sind. Die OMAP meinte ich oben auch nicht, sondern eher die C2000-Serie. Die reicht evtl. für die Anforderungen und die Architektur
Multiplikation d.h. das Teil wäre hier zu 60% ausgelastet (ohne FPU). Empfehlung: AVR32 in Form des UC3C http://www.atmel.com/dyn/corporate/view_detail.asp?ref=&FileName=UC3_Automotive_f2.html&SEC_NAME= 5V, 125 °C und hat zur Not auch eine FPU.
-
Thread
MMC SD library FAT16 FAT32 read write
Hallo, [c] loop_until_bit_is_set(SPSR,SPIF) [/c] ist ein Makro aus der avr-libc, SPSR ist ein Register und SPIF ist ein Bit in dem Register. Das Makro ist sehr schnell, daher benutze ich es. Dahinter steckt
bei mir hat er probleme mit [c]loop_until_bit_is_set(SPSR,SPIF);[/C] hab jetzt auch mal hardware SPI getestet, bitte hilft mir wer
-
Thread
Wittig(welec) DSO W20xxA Open Source Firmware (Teil3) Gesperrt
alles gut aus. Vielen Dank nochmal! Beste Grüße, rowue PS: Kennt sich hier jmd. etwas mit C unter Windows aus? Ich bräuchte etwas Hilfe bei der Abfrage des Nutzer/Klarnamens unter Windows (das, was mensch mit getpwuid(getuid()) unter Unix/Linux macht)
damit es auch alle nachbauen können … aber erst muß ich es zum Laufen bringen… Ich hab die BF20_prev_c17 drauf und den LTC2612 (14bit DAC) gegen den LTC2602 (16bit DAC) ausgetauscht – dieser DAC ist nur für Kanal 1 und Kanal 2 zuständig, bei Kanal 3 und 4 habe ich keine Änderungen gemacht. Die Spannung
-
Thread
SP14Q002-A1 aus eBay - Erfahrungsaustausch
@formtapez das ist völlig normal mit den Artefakten. Wenn Du es später mit dem mC programmierst mußt Du erst das Status Flag abfragen. Abfrage des Status Flags: A0 RD WR 0 0 1 Bit 7 6 5 4 3 2 1 0 x ? x x x x x x x=don't care Wenn ?=0 dann busy Wenn ?=
@bse: Ich habe die LCD Platine an einen C167CR (16-bit)mikrocontroller angeschlossen. Aber auch einen 8-bit controller sollte kein Problem sein. Grüße Mark.
-
Thread
MSP430 4kHz Takt 5 Takte ausgeben aber wie???
und dann brauchst Du noch ein globales Flag, das Du auf die Geschwindigkeit einstellst. Also z.B. c = 98 bei steigend und c = 10 bei fallend. Und in der Timer Routine setzt Du dann nach der Abfrage von i: CCR0 += c. der Flo
) !=0) // Abfrage Pin 5.3 clock = 98; // 780kHz/2/98= 4kHz if ((P5IN & BIT4) !=0) // Abfrage Pin 5.4 clock = 10; // 780kHz/2/10= 40kHz } #pragma vector=TIMERA0_VECTOR __interrupt void Timer_A
-
Thread
Statemachine Anfängerfrage
= TagNacht; DaWeg_old = DaWeg; } [/c]
Vorgänger hat doch echt sequenziell abgearbeitet und so Zeit vertrödelt, war aber auf dem CBM (6502 8-bit 32KB Ram 1 MHz) :) Am µC mache ich es ja so, im IRQ wird gezählt lcd_upd-- wann 330ms um sind wenn 0 LCD refresh, im loop ist es ja egal wann genau der stattfindet, nur wenn er erfolgt ist wird lcd_upd
-
Thread
Werte schnell vergleichen
> Zielplattform 8-Bit AVR mit 16-Bit TCB
Beitrag #7839388: > Kommt also immer auf die Hardware an. Ist bekannt: >> Zielplattform > 8-Bit AVR mit 16-Bit TCB
-
Thread
ADC mit ATmega8A
Konvertierung warten return ADCH; // ADC auslesen und zurückgeben (8bit, ansonsten ADCW) }[/C]
überschreibst du alle anderen Einstellungen in ADMUX. ADMUX =~(1<<MUXn|...|1<<MUX0); // alle MUX-Bits löschen ADMUX |= mux; // MUX-Bits setzen Ich hoffe das stimmt so, da meine C-Kenntnisse etwas rudimentär sind. MfG Spess
-
Thread
Raspberry Pi: Werte vom Temperaturlogger in SQL oder RoundRobin DB speichern?
Hi Bernd, Bernd Schuster schrieb im Beitrag #3664274: > @Karl & c-hater: komplexe DB Abfragen wie die genannte benötige ich > wahrscheinlich gar nicht, bzw. kann mir das aktuell nicht vorstellen. Es > geht rein um die Aufzeichnung und Darstellung von Temperaturkurven
Datenmaterial zu finden und auszufiltern, c-hater schrieb im Beitrag #3664881: > Wenn du zu blöd bist, den Sinn hinter solchen Abfragen zu erkennen, nur > als Stichworte: Wackelkontakt, Kabelbruch... Na ja, deine Aussage bezog sich darauf
-
Thread
struct array in Flash setzen
Kannst du mir auch sagen wie ich da noch ein Array reinpacke und initialisiere? Denn wenn ich einfach [c] uint16_t* MeinArray; [/c] will ich später ja die einzelnen Einträge wieder herauslesen: [c] Game GetGame(uint8_t modi) { Game temp; temp.time = pgm_read_word (&(Games[modi].time))
Zeiger aus dem Flash lesen, der auf das Flash-Array zeigt und das ganze zu einem Zeiger casten: [c]uint16_t *ptr = (uint16_t*)pgm_read_word(&(Games[modi].data));[/c] 2. Die einzelnen Einträge im Array auslesen damit sie im Ram sind und die Adresse vom ersten Eintrag speichern [c] uint16_t value
-
Thread
bool[8] in uint8_t umwandeln
notwendig für ein Array) Einheit > ist ein Byte. Das scheint universell zu sein oder? Mein 64 bit Desktop kann scheinbar auch einzelne bytes adressieren, ebenso wie mein MC. Btw, wenn ein einzelner bool arr[0]=true (z.B. alle bits gesetzt) und uint8_t *pointer die gleiche Größe haben, ist es
N. N. schrieb im Beitrag #5496565: > Das scheint universell zu sein oder? Mein 64 bit Desktop kann scheinbar > auch einzelne bytes adressieren, ebenso wie mein MC. C(++) definiert das Byte als die kleinste adressierbare Einheit. Ein char ist immer genau ein Byte groß. Die Anzahl
-
Thread
Timer Problem
man die einzelnen Bits ja mit z.B. TCNT0 |=(1<<Bitname); nur bei den Bit´s steht im Tutorial kein Name. Heisst das ich kann nur indirekt drauf zugreifen durch TCNT0 |=0xff; Es macht zwar keinen direkten
Hallo, naja, wie sollte ein Bit im TCNT0 auch sinnvoll heißen? Die Namen sollen das Ganze ja nur lesbarer machen, wenn Du auf andere Bits unbedingt einzeln zugreifen willst, kannst Du so machen, wie Du schreibst oder Du benutzt die
-
Thread
Embedded C - mit UART senden
gerade dabei es umzuschreiben. Dabei habe ich zu folgenden Programmzeilen eine Frage: mov SBUF0, #0C9h ; Byte senden jnb TI0, $ ; Transmit Flag abfragen clr TI0 ; Flag löschen jmp Loop Da ich viele unterschiedliche Bytes senden muss, wollte ich wissen ob ich in embedded c
RAM (upper IRAM) bit d; // ein Bit im Bitbereich (20H) des 8051 [/c] Wobei ein Datenfeld ganz einfach so aussieht: char s[6]; Damit hast du ein Array das 6 Byte aufnehmen kann. Jetzt einfach
-
Thread
LCD 1x16 HD44870 kompatibel will einfach nicht mit der library von Peter Fleury funktionieren
/**< pin for 4bit data bit 3 */ #define LCD_RS_PIN 1 /**< pin for RS line */ #define LCD_E_PIN 0 /**< pin for Enable line */ [/c] Die lcd.c Datei musste ich mehr
her, wäre sowas möglich?? [c] Bits.b0 = 0 Bits.b1 = 1 Bits.b2 = 0 . . . [/c] Und was macht dieser Zusatz?? [c] __attribute__((__packed__)); [/c] ----------------------------------------------------------------- Und
-
Thread
A/D Wandler mir 64 eingängen
Die Aufgabe ist ziemlich diffus gestellt. So eine ATMega16 schafft 8 Kanäle mit 10 Bit oder bei Oversampling auch noch etwas mehr. Takt netto dann bis grob 1 kHz. Dann müßte man mehrere davon per SPI kaskadiert abfragen und noch per USB versenden. Multiplexer als Alternative kosten
live. Und dafür suche ich Lösungen." 8* ein ATMEGA16 mit 8 ADC im eigene Multiplex und auf 10 Bit eingestellt ergäbe bei 2,5 V Referenspannung netto 8,7 Bit Auflösung oder ca. 2,5 mV. Und einige hundert Abfragen/s sind da machbar. Zudem benötigt man ja noch Anschlußbuchsen und Überspannungsdioden
-
Thread
Interrupt verhalten bei STM32F103
definiert sind. Strg-Mausklick auf TIM4 sollte sie öffnen. In der Datei suchst du dann nach "CC1OF". [c] /******************** Bit definition for TIM_SR register *******************/ ... #define TIM_SR_CC1OF_Pos (9U) #define TIM_SR_CC1OF_Msk (0x1U << TIM_SR_CC1OF_Pos) [/c] Folglich muss deine Code-Zeile so lauten: [c] TIM4->SR &= ~(1<<TIM_SR_CC1OF_Pos); [/c] oder: [c] TIM4->SR &= ~TIM_SR_CC1OF_Msk; [/c] oder: [c] CLEAR_BIT(TIM4->SR, TIM_SR_CC1OF_Msk) [/c
-
Thread
Frage zur Länge i2c auf Platine.
sind u.a. 7 32polig Messerleisten aufgelötet, in diese werden dann Einzelplatinen mit jeweils einem i2c 16bit-Portexpander MCP23017 aufgesteckt werden wird. Ebenso wird ein 4 Zeiliges LCD mittels Flachbandkabel, ca. 60cm, mit dem i2c verbunden werden. Meine Frage nun zum i2c. Der Bus auf Hauptplatine
Signale in Augenschein zu nehmen und mögliche Probleme zu erkennen, achte auch auf die Pegel der ACK-bits eines jeden einzelnen Teilnehmers, achte darauf dass Low wirklich ausreichend Low ist, bei längeren Strecken miss auch mal am anderen Ende des Kabels.
-
Thread
Einzelbits in Byte Namen zuweisen und auswerten
Hallo, wie kann ich in C die 8 Bits eines Bytes mit Namen versehen und diese dann gezielt mit dem Namen lesen, setzen, löschen? uint8_t Status; Status soll bestehen aus: Platzhalter0 für bit0 Platzhalter1 für bit1 .
Was du suchst, nennt sich bit-field. https://microchipdeveloper.com/c:bits-bools-and-bit-fields
-
Thread
Switch Case und Character
> > Ich würde die 8 Bit für das Muster ja einfach in einem uint8_t speichern > statt in einem Array aus char. Zumal man diese 8Bit als Konstante auch so schreiben kann: [c]muster = 0b01101001;[/c] Und damit optisch jedes einzelne Bit sehen kann;
-
Thread
mehrere µC an einem Takt?
alle anderen parallel zu dem ersten. Wolfram Fischer schrieb im Beitrag #5989732: > der Erste µC entscheidet was wer machen soll und die 8 Sklaven (I2C) > machen was sie sollen, wie in jeder Fa. :-) Wenn Takt gemeinsam ist, dann statt I2C lieber USART in 9-bit-Mode. Das geht deutlich schneller
Bernd K. schrieb im Beitrag #5990126: > Den µC der gleichzeitig(!) 18 ADC-Kanäle > sampelt Mit welcher Geschwindigkeit? Wenn man von einem bestimmten Peripherietyp sehr viel braucht könnte man mit einzelnen, großen Controllern in der Tat nicht
-
Thread
Timer1 abfragen und dekrementieren
durch [C] Timer = 0; [/C] ersetzt. Macht nämlich im Endeffekt genau dasselbe, nur gehts schneller. Und dienstbeflissen wie Compiler nun mal sind, versuchen sie immer die schnellste Lösung zu finden :-)
Ah, 1,2,3 sind PNGs? Dann Speicher ich die mal als 1.png 2.png und 3.png [C] // Timer1 nullen TCNT1 = 0; // steigende Flanke von dem Komparator warten while (!(PIND & (1 << PD1))) {} while ((PIND & (1 << PD1))) {} // Timer abfragen
-
Thread
Abstand zwischen zwei Flanken wird nicht korrekt ermittelt
beide Interrupts zeitgleich anliegen, wird daher zuerst INT0 > aufgerufen, so dass deine oberen 8bit von den Pseudo-16bit veraltet und > somit falsch sind. Ich habe jetzt im Timer-INT ebenfalls die anderen Interrupts gesperrt: [c] ISR(TIMER0_OVF_vect) { uint8_t tmp_sreg; tmp_sreg =
Identifizierung des Paketbeginns ist das völlig ausreichend. Und das LowByte kann ich für die Erkennung der einzelnen Bits nutzen, das passt vom Wertebereich her! TOP, vielen Dank für eure Hilfe! Viele Grüße Klaus P.S. Ich würde normalerweise auch einen 16-Bit-Timer für die Geschichte verwenden. Und auch
-
Thread
Atmega Taster einlesen und in Register schreiben funktioniert nicht wie geplant
es das interne Register? Verstehe ich nicht so ganz. Aber gut. Nachdem ich nun den nächsten Pin abfrage, funktioniert der Erste zwar, wenn ich den zweiten Taster drücke, setzt es Pin 1 zurück. Also Ta0 = 0x01, Ta1 = 0x02 und beide zusammen sollten dann 0x03 ergeben. Macht es aber nicht. [c]
Taster Fragt ab einzelnen Taster ab und entprellt diesen auch gleich. Funktion Taster abfragen Schleife, die nacheinander die 8 Taster abfragt, den Rückgabewert dann in einem Array zwischenspeichert. UND DANN ERST
-
Thread
über SPI in Flash Daten ablegen
hoffentlich vorher gelöschten) Block im Flash zu schreiben. Die SPI Einheit wird in spi1_init() in spi1.c initialisiert. Der Aufruf erfolgt in der main() Funktion: [c]spi1_init(MODE_0, BITS8, false, 4);[/c] Bei meiner Konfiguration (SSP_PCLK = PCLK = CCLK) führt das zu einer Taktrate von 18MHz.
Kann mir hier jemand sagen wie das mit den einzelnen Bits der Register aussieht? Sind die Bits, z.B. CPHA und CPOL vom SPI Control Register Bits zum abfragen oder muss ich die je nach belieben einfach nur setzen oder auch nicht? Komme bei der Initialisierung
-
Thread
Buch für C-Einstieg
? Natürlich wird man nicht jede beliebige "fette" C++-Klassenbibliothek auf jeden 8-Bit-µC portieren können, dem sind natürlich Grenzen sowohl bei der Codegröße als auch dem verfügbaren RAM gesetzt. Obendrein wird nicht jedes C++-Sprachfeature von
C++-Features auf den Ressourcenverbrauch auswirkt? Wenn es ein gutes Buch mit dem Titel "C++-Programmierung auf 8-Bit-Mikrocontrollern für C++-Unkundige" gäbe, in dem alles Relevante (und nur
-
Thread
I2C Display einfache Frage
[c]#define sda_low() { i2c_port &= ~(1<<sda_bit); i2c_ddr |= (1<<sda_bit); }[/c] wäre besser auf [c]#define sda_low() do{ i2c_port &= ~(1<<sda_bit); i2c_ddr |= (1<<sda_bit); }while(0)[/c] zu ersetzen
Befehl (Command) ist und dass danach weitere Befehle folgen können. Technischer Hintergrund: Das Bit 7 (Co-Bit) ist auf 1 gesetzt, was signalisiert, dass weitere Steuerbytes folgen können. Bit 6 (D/C#-Bit) ist auf 0, was den Modus auf "Kommando" festlegt. Vergleich: 0x00: Nur ein einzelner Befehl
-
Thread
DCF77 Uhr in C mit ATtiny26
timeflags & (1<< ONE_MINUTE )) TCNT0 = (u16)(256 - T0COUNTMIN); // reload per minute: -234[/c] Warum wird immer auf unsigned int gecastet? Ist doch nur ein 8 bit Timer.
i]); // set bit [/c] Peter
-
Thread
ATtiny84 Pin Change Interrupt
du in der ISR auf 10 Zählen, ein Flag setzen wenn die 10 erreicht ist und dieses in der Mainloop abfragen. Ist es gesetzt, dann lass den µC was tun. Wenn nicht, schicke in wieder in den Schlaf.
in der ISR auf 10 Zählen, ein Flag setzen wenn die 10 > erreicht ist und dieses in der Mainloop abfragen. Ist es gesetzt, dann > lass den µC was tun. Wenn nicht, schicke in wieder in den Schlaf. Ja das wäre grundsätzlich eine Idee aber eben auf den Fall das er 95% schlafen soll, doch iwie nur ein
-
Thread
ATmega8 und UART => Code bringt Einsteiger zum Verzweifeln
[c] while (!(UCSRA & (1<<TXC))); //Warte, bis Senden komplett [/c]Dann sollte man das Bit vorher aber auch mal löschen.
// data ausgeben > UCSRA|=(1<<TXC); // --> kommt das hier hin? > } > [/c] Nachdenken! Was zeigt dein das TXC Bit in UCSRA an? Welchen Zweck hat das Abfragen des Bits? Wann wird man es daher zurücksetzen? > Aber so logisch macht das der ATmega nicht. Natürlich
-
Thread
for Schleife in C
Aus der FPGA-Ecke kommend würde ich sagen: damit verschenkt man ein komplettes Flipflop. Denn mit 8 Bit kann man zuverlässig 256 Zustände darstellen. Den vorgeschlagenen 257. Zustand braucht man dafür nicht... ;-) Auf einem 8-Bit µC würde ich das so angehen (inklusive der Kommentare!): [c] for
Ich würde von einem Compiler anno 2019 erwarten, dass er das hier für einen 8-Bit-Controller so _optimiert_, dass intern auch mit 8 Bit gerechnet werden: [c]for (uint16_t i = 0; i < 256; i++) {...}[/c] Also, dass diese Schleife (die besser lesbar ist) letztlich den selben Code
-
Thread
[AVR-C] Port an Funktion übergeben
Ich möchte ab und an den Zustand einzelner Pins an verschiedenen Ports abfragen. Dazu EINE Funktion schreiben die ich dann jeweils mit den Parametern Port und Pin_nummer aufrufe und die mir als ergebnis "1" oder "0" zurückgibt.
die beiden FUnktionen kannte ich noch nicht. Verweise ich mit SFR_BYTE direkt auf die einzelnen "Geräte" im Controller? _BV gibt mir dann das gewünschte Bit in dem vorangegangenen Byte aus? Gibt das Makro dann eine 1 bzw 0 zurück? Man je mehr ich versuche meine Idee zu verwirklichen um so
-
Thread
Denkfehler bei Matrixtastatur?
Hast Du schon mal einen einzelnen Schalter an einen uC angeschlossen und per Software ausgewertet? Oder ist dies Dein erstes Projekt? Willst Du was lernen oder nur ein Ergebnis haben?
der Pull UP > Wiederstand gesetzt! > > Es wird an PORTC3 keine 0 angelegt! Und wenn Du PortC3 mit einem Draht auf GND ziehst (zuerst von PortC0 trennen), kannst Du das 0 lesen? Tipp: Schreib mal die direkten Werte in den Sourcecode statt den Bit-Operationen. Und mit direkten Zuweisungen
-
Thread
LCD Anzeige wird nicht gelöscht
) { lcd_cmd(0x08); // LCD ausschalten } void lcd_send(char data) { char rs = PORTD; // Abfrage ob RS 0 oder 1 rs &= 4; // RS auf 1 setzen um Daten senden zu können char tmp = data; tmp &= 0xf0; // Erst die obere Bits aufbereiten und schicken tmp|=rs; PORTD = tmp; PORTD |= (1<<PD3
der 4 hier [c] rs &= 4; [/c] ist inakzeptabel. Überall anders hast du (1<<PD2) benutzt. Warum nicht hier? Dann würde man auch aus 5 Schritten Entfernung erkennen können, was hier wirklich passiert - nämlich den
-
Thread
Eingangsport auslesen und in den Ausgang(port) schreiben
usw.. übergeben. Man müsste wohl sonst den Code in kopfzermarternden Adressangaben schreiben, aus C64er Zeit mir noch gut bekannt... Was ich nicht verstehe ist hier : IN R24, PINB ; die Bits vom PortB ins allgemeine Register R24 OUT PORTC, r24 ; schreiben wir nach PortC Wie
Hi >Was ich nicht verstehe ist hier : >IN R24, PINB ; die Bits vom PortB ins allgemeine Register R24 >OUT PORTC, r24 ; schreiben wir nach PortC >Wie kommt der Progcounter nach der Abarbeitung der out ... Anweisung >wieder zurück in die In... Anweisung
-
Thread
SysTick (1ms) Uptime Design-Frage
Main" und hat entweder auf den SysTick oder auf verfügbare Daten reagiert. Zusätzlich hatten die einzelnen Module noch eigene Timeouts, bzgl. Peripherie (USB/UART/I²C/SPI). Nun wollt ich das alles besser strukturieren und es evtl. effizienter gestalten.
[c] typedef uint16_t TickType; /* ob 16 oder 32 Bit*/ #define MAX_TICKS (50000) /* Maximalwert des Timers. Deutlich unter dem Überlauf */ typedef struct /* Struktur der Timer, wenn
-
Thread
Zwei analog Eingänge nacheinander abfragen
folgendem Problem nichts finden können : Ich möchte an einem ATMEGA8 den ADC0 und den ADC1 nacheinander abfragen. Einer ist kein Problem.( btw : Ich habe erst vor kurzem mit C und Mikrocontrollern angefangen... ). Ich hab mir gedacht, nach der ersten Messung einfach das ADMUX Register entsprechend zu ändern,
ADMUX&=~( (1<<MUX0)|(1<<MUX1)|(1<<MUX2)|(1<<MUX3) ); Blöder Fehler. Normalerweise setze ich nur einzelne Bits auf Null. Nicht gleich vier auf einmal. Danke trotzdem. Wenn ihr nicht gesagt hättet, das das eigentlich gehen müßte, hätte ich den Fehler nie gefunden...
-
Thread
Datenstruktur für ein Displaybuffer in C
die Datenmenge im Ram zu halten. Ich dachte > an ein Array der Dimension 20x14. Leider unterstützt C jedoch kein > Bit-Array. Nicht direkt, aber es geht trotzdem in C, siehe [[Bitmanipulation]]. [c] #define N_LINES 20 #define N_COLUMNS 14 uint16 display[NUM_LINES]; [/c] Da passen
Du wirst ja die 7 Zeilen multiplexen. Dann sollte man das für die Anzeige optimieren, also 7 * 40 Bit = 7 * 5 Byte. [c] uint8_t disp_buff[7][5]; [/c]
-
Thread
STM32 EXTI-Entprellung mit HAL
sinvollen Grund, einen Taster einen Interrupt auslösen zu lassen, betrachte ich das Aufwecken des μC aus einem Sleep-Mode heraus. Nach dem Aufwachen erfolgt die weitere Abfrage und Entprellung dann wie üblich im Ticker-Interrupt. Falls das Prellen schon beim Wakeup stört (was üblicherweise nicht
bit */ EXTI_ClearITPendingBit(PLAY_EXTI_LINE); if (!fastFlags.PlayUpdate) { fastFlags.PlayUpdate = TRUE; } } } [/c] triggert die Routine genau einmal. Ich halte von HAL nicht
-
Thread
warnung:"[variable]may be used uninizialized"
case '?': //? meint abfrage des channels 0...7 usart_puts( "Schalte nach #" ); usart_putc( Line[1] ); uasrt_puts( "#\r" ); switch(Line[1]){ [/C] dann erzählt dir der µC, was
rauskommt. Hast du eh gesehen, dass die 2te Ausgabe kein uart_puts sondern ein uart_putc (ein einzelnes Zeichen) ist? [C] case '?': //? meint abfrage des channels 0...7 usart_puts( "Schalte nach #" ); // <- String S usart_putc( Line[1] );
-
Thread
AD Wandlung beim Mega103
Also ich habe die Signale an PINF0 (Kanal 1) und an PINF1 (Kanal2) liegen. Wenn ich die Kanäle einzeln abfrage funktioniert alles einwandfrei, nur nicht, wenn ich Sie hintereinander abfrage. Die SIgnal liegen normal auf 0 Volt und ändern sich bei Bewegungserfassung bis maximal 5 Volt. Die Signale beobachte
überprüfen was eigentlich gerade für ein Wert angezeigt werden muß. Problem ist als, wenn ich Sie einzeln abfrage sind sie richtig, frage ich sie direkt hintereinander ab, wird bei beiden Kanälen der angezeigt der zuerst aufgerufen wurde, wenn ich eine Pause von 1ms zwischen den beiden Aufrufen startet
-
Thread
Kein Bild bei eigenem VGA
Für das Bild musst du die einzelnen Bits des DA-Wandlers entsprechend setzen, aber nur innerhalb des sichtbaren Bereichs. Man sieht auch was wenn man die außerhalb gesetzt lässt aber einige Monitore skalieren dann das Bild nicht richtig
); [/vhdl] Das ist ja jetzt ein Array mit den "Abmaßen" 16x9 und jede Stelle beinhaltet 5 Bits oder sehe ich das falsch? weil Vivado spuckt mir den Fehler hier aus: [Synth 8-691] width mismatch in association of array element 0; element has 5 bits, expression has 8 bits ["C:/Users/Daniel/
-
Thread
Wert des ADC an USART ausgeben
UCSRC richten; Datenformat einstellen: 8 Datenbits, 1 Stopp-Bit */ UCSRB |= (1<<TXEN); // Sender aktivieren } /* ### Initialisierung des 16-Bit Timer1 - 9-Bit PWM-Mode - Fast-PWM - Vorteiler von 1024 --> 15,625 kHz
0; // Variable 'ADC0_interrupt' zurücksetzen } } return 0; } [/c]
-
Thread
Suche einen kleinstmöglichen 4 to 1 mux
Port wird auf Ausgang gestellt die beiden anderen sind Eingaenge Dann kann man immer 2 Tasten abfragen, dann den naechsten Port auf Ausgang und 0 ausgeben und die beiden anderen abfragen Mit 3 Ports kann man dann 6 Tasten abfragen ohne Multiplexer.
> Ich habe 4 Taster doch nur 3 pins am uC. Mit 3 Pins kannst du 6 Taster abfragen. Abschnitt: 4. Matrizen mit weniger Portpins. https://www-user.tu-chemnitz.de/~heha/Mikrocontroller/Tastenmatrix.htm