-
Thread
CAN funktioniert , aber nicht im vollen Umfang
irgendeiner Botschaft wird benutzt. Lukas D. schrieb im Beitrag #5135792: > Wie ist j mit den einzelnen Byte verknüpft? Also woher weiß der µC, dass > er von einem Byte zum nächsten gehen soll? Das CANMSG Register besteht eigentlich aus acht Registern hintereinander weg, welches Byte man davon
jenige wo gerade eine neue Nachricht ankommt > und kann weiterwursteln. Keine Schleifen sondern Abfragen, aber ja. Zur Sicherheit teste ich da auch jedes Bit das auslösen könnte: [code] ISR (CAN_INT_vect) { uint8_t canpage; canpage = CANPAGE; // save canpage if(CANSIT2 & (1<<SIT1
-
Thread
STM32: Bitbanding für Arrays?
)) | (value << bit); }[/c] Ist dann sogar portabel und hängt nicht vom Bit-Banding einer spezifischen Hardware ab. Wenn du C++ nutzt, kannst du auch einfach std::bitset nehmen.
) #define bb_offs(array) ((unsigned)(array) - RAM_BASE_BYTES) #define bb_bit(array,bit) bb_ram[bb_offs(array) * 8 + (bit)] bb_bit(ee_fat,123) = ... if (bb_bit(ee_fat,123)) ... [/c]
-
Thread
I2C Konfiguration STM32F4
); I2C_DeInit(I2C1); I2C_InitStructure.I2C_Ack = I2C_Ack_Enable; I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit; I2C_InitStructure.I2C_ClockSpeed = 100000; I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2; I2C_InitStructure.I2C_Mode = I2C_Mode_I2C; I2C_InitStructure.I2C_OwnAddress1 = 0; I2C_Init(I2C1, &I2C_InitStructure); I2C_ITConfig(I2C1, I2C_IT_EVT, ENABLE); I2C_ITConfig
-
Thread
USB Signal über 2 µCs seriell Übertragen
Dann darf "in der Mitte" aber kein USB-Device sitzen, sondern das Signal > muss auf unterster Ebene Bit für Bit getunnelt werden. Gibt es eine Möglichkeit den µC genau das machen zu lassen?
Dieter W. schrieb im Beitrag #5121445: > Wie läuft das denn bei I2C Da ist die Datenrate ganz erheblich geringer als bei USB. I2C arbeitet meistens mit 400 kBit/sec, im Extremfall mit 1 MBit/sec. Hier geht es um etwa das 500fache davon.
-
Thread
Wie Telestar Digibit Twin mit VLC Media Player benutzen?
tcpdump bekomme ich folgendes: (Über VLC) -> zum Telestar digi twin: 0x0020: 0205 ca80 022a 11c3 0d22 545f cb3e 8018 .....*..."T_.>.. 0x0030: 080a c09d 0000 0101 080a 497c b24b 048c ..........I|.K.. 0x0040: 0d38 5345 5455 5020 7274 7370 3a2f 2f31 .8SETUP.rtsp://1 0x0050: 3932 2e31
3237 3530 3026 6665 633d 3334 2670 6964 27500&fec=34&pid 0x00b0: 733d 302c 3137 2c31 382c 3830 302c 3830 s=0,17,18,800,80 0x00c0: 3120 5254 5350 2f31 2e30 0d0a 4353 6571 1.RTSP/1.0..CSeq 0x00d0: 3a20 300d 0a54 7261 6e73 706f 7274 3a20 :.0..Transport:. 0x00e0:
-
Thread
VHDL RAM mit "krummer" Größe (keine 2er-Potenz)
Folgendes Szenario: Ich habe in meinem hypothetischen FPGA noch 10 RAM-Blöcke mit einer breite von je 8-bit und jeweils 1024 Einträgen (=1kB pro Block) übrig und möchte die jetzt zusammenfassen und als 'einen' Speicherblock nutzen. Als Address-Signal habe ich ein 14-bit breites Signal - also genug Zustände
locker selbst so aufdröseln, dass die unteren 10 Bits der Adresse für die RAM-Adressen und die oberen 4 Bit über einen Adressdecoder zur RAM-Selektion verwendet werden.
-
Thread
Arduino DMX 256 Kanäle als Paket senden
; // DMX Bit periods per timer tick bitsLeft >>=2; // 25% CPU usage [/c] Er nutzt hier BEWUßT nur 25% der CPU-Zeit für die DMX-Generierung! [c] while (1) { if (dmxState == 0) { // Next
(12); dmxSendByte(0); [/c] [c] } else { // Now send a channel which takes 11 bit periods if (bitsLeft < 11) break; bitsLeft-=11; dmxSendByte(dmxBuffer[dmxState-1]); } [/c] Er sendet
-
Thread
Was ist die Zukunft? WPF oder WinForms?
Vorteil. Aufgrund eines Projektes welches hohe Timing-Anforderungen mit sich brachte, wurde dies per C/C++ im Qt Framework realisiert. Gruß 6fY
jetzt auch nicht überraschend. Sheeva P. schrieb im Beitrag #5115607: >> Selbst Windows 10 (32-Bit) kann noch Win31-Software von 1993 ausführen. > > Microsoft sagt, daß 16-Bit Programme nicht unter den 64-Bit Versionen > von Windows laufen. Deswegen schrieb ich "(32-Bit)" dazu, und Microsoft
-
Thread
CMU200 Erfahrungen und Modifikationen
verwendeten Stecker sind aus der Metral Serie von Berg/FCI. Die gibts auch für teuer Geld beim blauen C. https://www.conrad.de/de/fci-stiftleiste-praezision-polzahl-gesamt-96-rastermass-2-mm-88953-105lf-1-st-1401746.html#downloadcenter Die genauen Bezeichnungen der einzelnen Stecker auf dem Mainboard
18/O right softkeys: 1E/A, 1F/S, 20/D, 21/F, 22/G, 23/H, 24/J, 25/K, 26/L lower softkeys: 3B/F1, 3C/F2, 3D/F3, 3E/F4, 3F/F5, 40/F6, 41/F7, 42/F8, 0C/- control group: 0E/<--, 52/NumIns 31/N, 30/B 2F/V, 2E/C 2C/Z, 2D/X functon group: 19/P, 1A/[, 1B/] system group: 1B/\, 28/', 27/; number
-
Thread
Hardware-Designtipps des Monats: Vor dem Projektstart
Ich nochmal (..mit dem Blink- LED- Projekt), Du hast genau das ausgesprochen, C123, was ich eigentlich sagen wollte, jedoch zu faul war, es so komplett auszuführen wie Du...! Gruß Holger
schadet es nicht, schon vorher mal was zum Thema gehört und ggf. sogar selber umgesetzt zu haben. uC.net ist kein Consultingbüro.
-
Thread
PIN vs PORT beim OUTPUT
korrekt ist, als auch elektrisch alles passt, dann ist die einzige übrig bleibende Erklärung, dass dein µC kaputt ist.
und extern gegen Plus gezogen. Das kann man zwar abfragen, sowas sollte aber schon in der Schaltung gar nicht möglich sein.
-
Thread
Atmega2560 SPI-Verbindung zu ext. AD-Wandler
Matthias H. (streno) >Das Programm habe ich wie von eprofi übernommen und getestet. die >einzelnen Schritte arbeitet er sauber ab. Dennoch erhalte ich immer >16383 als Data. Dann sit was faul. Auch beimbesten AD-Wandler wackeln die untersten Bits, erst recht bei 14 Bit. Wie sieht dein Hardwareaufbau
read // sign extention tmp &= 0x3FFF; // clear MSBs if (tmp & (1<<13)) tmp |= 0xC000; // copy bit 13 to 14 and 15 return tmp; } int main(void) { // IO init DDRB |= (1<<PB1) | (1<<PB0); // set SCK und SS to output // SPI init SPCR
-
Thread
Übertragungsgeschwindigkeit SPI Bus Arduino Mega
immer noch arg viel undurchschaubares copy&paste Holz. Die Temperaturberechnung ist auch für nen 14Bit-ADC völlig übertrieben. Da reicht die simple Y = aX + b Formel völlig aus. Bei max 0,25°C Auflösung würde ich nur die vollen °C anzeigen. Und double kann der AVR-GCC eh nicht.
noch arg viel undurchschaubares copy&paste Holz. > > Die Temperaturberechnung ist auch für nen 14Bit-ADC völlig übertrieben. > Da reicht die simple Y = aX + b Formel völlig aus. > Bei max 0,25°C Auflösung würde ich nur die vollen °C anzeigen. > Und double kann der AVR-GCC eh nicht. Ja, und wenn
-
Thread
PWM Ausgang erzeugt kein PWM Signal :(
Eingang löst eine ISR aus, hab diese aber einfach um Fehler auszuschliessen jetzt durch eine einfache Abfrage des Eingangs abgeändert. [c] if (GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_2) == 1) { GPIO_ResetBits(GPIOC, GPIO_Pin_5); // LED Einschalten TIM_CtrlPWMOutputs(TIM1, ENABLE) //PA8 Ausgang
wurde immer zurück gesetzt am Ende. Hab es aber jetzt um weitere Fehler auszuschließen durch [c] if (GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_2) == 1) { GPIO_ResetBits(GPIOC, GPIO_Pin_5); // LED Einschalten TIM_CtrlPWMOutputs(TIM1, ENABLE) //PA8 Ausgang } [/c] ersetzt und hab den ganzen
-
Thread
I2C - Pull Up Widerstände
dann aber > 0100 0000 = 0x40 Eben, das Control Byte ist 0x40 und setzt sich zusammen aus der I2C Slave Adresse in den ersten 7 Bit (0b0100000) und dem R/W Bit an unterster Stelle, zusammen [c]0x40 = 0x20 << 1 | RW[/c].
Hi >In Fig 1-2 hat die Slave Adresse 7 Bit, wie es der I2C-Spezifikation >(S.15) entsprich und genau den Wert 0x20. Was da an Bits rangepfriemelt >ist, ändert nichts an dem Wert. >http://i2c2p.twibright.com/spec/i2c.pdf Solange sich
-
Thread
Interrupt Unterschiede beim 8-Bit Timer vom Atmega 128
Option dadurch offen gehalten, dass eben jedes einzelne Bit seinen eigenen symbolischen Namen hat. Und die lange Variante würde eben auch diesen Fall problemlos abdecken, deine hingegen würde dann Mist bauen.
hat sich diese Option dadurch offen gehalten, > dass eben jedes einzelne Bit seinen eigenen symbolischen Namen hat. > > Und die lange Variante würde eben auch diesen Fall problemlos abdecken, > deine hingegen würde dann Mist bauen. Ja, das ist mir bekannt. Dafür
-
Thread
Brainstorming – Funktionsüberwachung einer LED-Beleuchtung
technisch gesehen doch gehen, irgendwo in der Mitte einen Fototransistor zu montieren und jede LED-Reihe einzeln einmal zu kalibrieren. Das kann ein µC mit einem Skript recht bequem machen und dann im EEprom ablegen. 1. LED-Reihe an 2. Wert (Spannungsabfall o.ä.) messen 3. Wert speichern 4. nächste LED
Hi Auch, wenn einzelne LED beim Ausfall noch Strom ziehen, sollte sich der Großteil der defekten LED durch Abschalten/keinen Strom mehr aufnehmen bemerkbar machen. In diesem Fall fließt der Strom dann über eine Z-Diode
-
Artikel
RFM12
Phasenrauschen für 1 MHz Offset. (bw1 = 1 in der RFM12B-Dokumentation) x0 = -107dBc/Hz für max. 86,2 kBit/s x1 = -102dBc/Hz für max. 256 kBit/s Unterspannungs-Detektor und Taktausgangsteiler (LowBatt / µC Clock Control C0xx). {|class="wikitable" rowspan=4|d rowspan=4|divider rowspan=4|Bestimmt den Teilungsfaktor
den letzten Pegel fest Bei entsprechender Füllstands-Einstellung kann man hiermit auch mehr (bspw. 9 Bit) oder weniger (bspw. 7 Bit oder auch jedes Bit einzeln) abholen. Da das Senderegister auf 8 Bit festgelegt ist, hat das meistens keinen Sinn. Die Taktfrequenz darf für das FIFO-Auslesen maximal 2,5
-
Thread
Wie muss man Pervasive Displays beschreiben?
Zweitens ist die Anzahl der gesendeten Bytes für die Zeilen nur 1x 44Byte! versuch das mal so ... [c] ;Zeile zu Linedata int Zeile; for (i=0;i<(Zeile>>2);i++) SPI_8Bit_oCS(0x00);//volle 4 Zeilen zuvor SPI_8Bit_oCS(0x03<<((Zeile & 0x03)<<1)); for (i=0;i<43-(Zeile>>2);i++) SPI_8Bit_oCS(0x00);//
(0x00); //gerade for(sp=0;sp<33;sp++) { SPI_8Bit_oCS(0x00); } cnt++; if (cnt>32) cnt=0; } [/c] Sascha
-
Thread
ds1820 Fragen
durch den Master nicht noch einmal aufgerufen. Dann wäre beides in etwa gleich schnell. Auf die Abfrage einzelner Sensoren lege ich keinen Wert.
Beim ROM-Scan wird jedes Bit 2x gelesen und 1x gesendet, ist also ~ 3mal langsamer. >Auf die Abfrage einzelner Sensoren lege ich keinen Wert. Ein sehr sinnvolles Konzept . . .
-
Thread
Assembler Schleifen Tricks
[c]unsigned toggle (unsigned i) { return i ^ (1u << 15); }[/c] avr-gcc: [avrasm] toggle: subi r25,-128 ret [/avrasm]
In Assembler habe ich schon lange nicht mehr ein ganzes Programm geschrieben. Höchsten ein paar einzelne Zeilen, um es besser zu machen, als C. Das kommt nur noch selten vor, weil der Compiler immer besser wird und die Chips immer schneller.
-
Thread
Uhrzeit + serielle verbindung + Display = Verwirrung.
zeigt diese an. Wie kann ich int = 12 ohne aufteilen senden ? Oder wie kann ich die zahlen werte einzeln abfragen ? Oder geht das einfacher ? Zurzeit versuche ich die zahlen mit Buchstaben gekennzeichnet zusenden. Soll heißen ich sende ein A und 50 ms dann zb eine 1 dann sende ich B wieder 50ms
und durch 10 teile würde ich beide zahlen erhalten nur wie kann ich die zahl vor und nach dem Koma einzeln speichern?
-
Thread
Möglichst kleinen Hash erzeugen?
die Verschaltung des Kabels, indem ich in zwei verschachtelten Schleifen einmal alle Kombinationen abfrage. Dabei wird nur geprüft "Verbindung Ja oder Nein". Für das Ergebnis setze ich in einem uint_32 Array das der ensprechenden Leitung zugeordnete Bit, falls eine Verbindung besteht. Das befüllte Array
... [/c] wobei n die "Stellung" des Sendemuxers ist und die Position des zu setzenden Bits im die Stellung des Empfangsmuxers wiederspiegelt. Nun kam mir in den Sinn, es wäre ganz schön wenn ich im EEprom
-
Artikel
Modellbauservo Ansteuerung
Servomittelstellung bei etwa 1.4ms erreicht wird. Viele programmierbare Fernsteuerungen haben daher für einzelne Servos getrennte Einstellungen und unterscheiden zwischen Standard-Servos und MPX-Servos. Signalerzeugung für 1 Servo (C). Für einen ersten Servotest reicht es aus, ein Servo mit seinem Signaleingang
z.B. anderer Quarz) entsprechend angepasst werden. Signalerzeugung für mehrere Servos mittels Timer (C). Das Prinzip der Servoansteuerung mehrerer Servos besteht darin, dass die Pulse für die einzelnen Servos nacheinander generiert werden. Dazu wird mit einem Timer im CTC Modus jeweils eine Zeitdauer
-
Thread
Einführung des Hexadezimalsystems
Joseph, der Seifenopernstar von uC.net! Jäger des verlorenen Zahlensystems. Joseph und die letzte 8-Bit CPU.
noch addieren, multiplizieren oder dividieren können. Man muss nur wissen, an welchen Positionen einzelne Bits gesetzt oder gelöscht sind und wie man diese Bits logisch verknüpft.
-
Thread
Welche Programmiersprache auf µC
, 100u>&, unsigned int, unsigned int) [/c] wobei das natürlich nicht die Version der libstdc++ ist. Also für 8-Bit: 220-Bytes und für 16-Bit 294 Bytes.
Hier ist ja mal wieder eine echte C vs C++ Duskussion im Gange. :) Dann will ich mal meine Ansicht zum Besten geben. Ich war sehr lange der Meinung, man müsse kleine 8-Biter mit C programmieren, da C++ der totale Overkill dafür ist
-
Thread
ENUM Name vergeben wie Struktur
man denn einen Enum in einen struct reinpacken? Ja, aber das löst kein Problem. Wenn man bei C bleibt, wird man sich eine eigene sinnvolle Notation für die einzelnen enum-Werte einfallen lassen müssen. Eine Variante ist die Verwendung des Enum-Namens als Präfix: [c] enum _states { _
bit-field in C: "The order of allocation of bit-fields within a unit (high-order to low-order or low-order to high-order) is implementation-defined." Das verhindert die Benutzung von bit-fields für
-
Thread
Wasserpegelanzeige
Hi Wolfgang schrieb im Beitrag #5024041: > Mit einem Absolutencoder kann man so selten abfragen, wie man möchte. Wo wir wieder beim 13bit GrayCode landen :) (okok - 13bit sind wohl nicht nötig) Selbst bei Starkregen wird sich der Pegel wohl nicht im cm-Bereich bei sekündlicher Abfrage
10186_10123_142,searchweb201603_2,ppcSwitch_5&btsid=4d91f6cd-b03b-4bb2-9af0-dbc2115a118f&algo_expid=6c4d57c8-82f8-4f08-8054-9e84097d2768-11&algo_pvid=6c4d57c8-82f8-4f08-8054-9e84097d2768
-
Thread
STM32F07VG Discovery - EXTI15_10_IRQHandler mit mehreren Interrupts
ich würde die [c]&& (EXTI_GetFlagStatus(EXTI_Line12) != RESET)[/c] weglassen. Vor [c]EXTI_ClearITPendingBit(EXTI_Line12);[/c] kannste die Pins abfragen
= GPIO_PuPd_UP; [/c] Default High, er will also anscheinend bei fallender Flanke in den Int... [c] if (GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_12) == Bit_SET){ if ((EXTI_GetITStatus(EXTI_Line12) != RESET)){
-
Thread
Wickenhäuser: Error: integer expression must be constant
c]
Konvertierung selber. Im einfachsten Fall (für positive Zahlen) sind das nur ganz wenige Codezeilen: [c] unsigned int read_val(int length) { unsigned int val = 0; while(length--) val = 10 * val + read_char() - '0'; return val; } [/c] Ggf. kommen noch zusätzliche Abfragen für die
-
Thread
Einzelnen Portpin lesen
Hallo, ich würde gerne lesen was an einem einzelenen Portpin für ein Signal anliegt. Ich würde es gerne über ein [c]#define[/c] machen. Zuerst dachte ich ich könnte [c]#define MEINPORTPIN PINK2[/c] sagen. Das geht aber nicht. Hat jemand eine elegante lösung für mich. Wie mache ich das? [c] //ATmega2560 #define MEINPORTPIN ((PINK & 0x04)>>2) void main(void) { DDRK&=0xFB;PORTK&=0xFB // Port K, Bit 2 -> INPUT, TRISTATE while(1) { if (MEINPORTPIN == 1) { //mache das } else if (MEINPORTPIN == 0) { //mache das } } [/c] Grüße
-
Thread
ATMega328-basierter Sprach-Synthesizer für den CPC 464 - Schnelles Byte-weises Lesen mit dem 328?
wie [c] loop_until_bit_is_set(PIND, 2); //pull ready READY immediately DDRB |= 1; clearBit(PORTB, 0); pinb = PINB; pinc = PINC; .... [/c] dazu führen, dass pinb, pinc
: [c] do { pinb = PINB; pinc = PINC; } while (bit_is_clear(PIND, 2)); do { pinb = PINB;
-
Thread
RFM12b von Polling zu Int (AVR)
Danke für deine schnelle Antwort. c-hater schrieb im Beitrag #5004864: > Maximal! > > Das Interruptflag wird aber gesetzt, sobald er das erste Byte im Sack > hat. Die restlichen Bits des FIFO sind nur der Puffer, der es dir > überhaupt
c-hater schrieb im Beitrag #5004993: >> und den FIFO neu gestartet > > Vollkommen falsch. Der muß einfach weiter laufen, um die nächsten 8 Bits > zu empfangen. Einige davon hat er mit einiger Wahrscheinlichkeit
-
Thread
Benchmark für Arduino-Boards?
272406088151?hash=item3f6cab09d7:g:IusAAOSwpLNX-SRr >Ich bestelle mir nun in China ein 2-Euro Board mit 32-Bit Controller: >Arduino IDE kompatibles Board STM32 STM32f103C8T6 ST ARM 32-bit Cortex >-M3 Das hat nur 72Mhz statt 168Mhz, deutlich weniger RAM ist ein M3 statt M4 und hat deshalb keine FPU.
Jürgen S. schrieb im Beitrag #4998648: > Ich bestelle mir nun in China ein 2-Euro Board mit 32-Bit Controller: > > Arduino IDE kompatibles Board STM32 STM32f103C8T6 ST ARM 32-bit Cortex > -M3 > > Und dann schaue ich mal, wie ich das in die Arduino-IDE eingebunden > bekomme, und was die Benchmarks
-
Artikel
16/32Bit Computer/Konsole
zwei Ports welche die jeweiligen Pins (SDA/SCK) der Komponenten bedienen können. Das eigentliche I2C-Protokoll ist in Software umgesetzt, d.h. mit den I2C_PORT_A/B Registern können nur Pins gesetzt bzw. ihr Zustand gelesen werden. Zum Daten lesen (SDA) wird Bit 3 (D) von Register I2C_PORT_A/B benutzt
schon erwähnt, ist das eigentliche I2C Protokoll in Software umgesetzt. Unter components/i2c.s sind die benötigten Funktionen implementiert. Timer im Detail. UCtrl besitzt zwei integrierte 32 Bit große Timer/Counter. Konfiguriert werden kann
-
Thread
Haussicherung mit Raspberry veranschaulichen und steuern
mich erst registriert habe und die Bestätigingsmail auf sich waren lässt. Was haltest du von 32 bit Port-Expandern/Schieberegistern? Dann könnte ich 2 32bit Schieberegister nehmen. Eines als Ausgang und eines als Eingang und hätte nur 10 Kabel zum Raspberry Pi. Wenn meine überlegung stimmt.
Stefan U. schrieb im Beitrag #4994730: >> Da ich 2 der 32 bit Schieberegister brauch, wäre das dann nicht so? > > Nein, Schieberegister kann man verketten. Auch die Ein- und Ausgänge vermischen? Dann mach ich es auch wie auf dem Bild. Mehrere 8bit Schieberegister
-
Thread
Zwei Interrupts/Auswertungen gleichzeitig
eigenständigen endlichen Automaten. Eine einzige globale Variable reicht. Eigentlich so gar nur ein Bit. Ich nenne das Bit z.B. "Blinkanforderung" Programmiere es so, dass dein Blinken "nebenläufig" arbeitet. Teste es einzeln.
im Beitrag #4989353: [c] TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5); [/c] Dieses Konstrukt muss man erst mal verstehen ..
-
Thread
Taste in ISR entprellen
p.s. Auserdem möchte man solche Abfrage- und Delay-Schleifen i.A. nicht systemblockierend in der ISR haben. Aber da kommt es natürlich drauf an, ob der µC sonst noch etwas zu tun hat und wie zeitkritisch das ist.
will den µC in dem Dutzend Millisekunden das die Entprellung braucht, ein bißchen weniger Strom verbrauchen lassen. Dann kann man mit einem Timer entprellen und schickt den µC zwischen den Timer-Interrupts zumindest
-
Thread
[V] Rauchmelder FireAngel ST-620-DET
vernetzen RMs herauszufinden. b) die Seriennummern gelistet werden ( -> Zuordnung zum Raum) c) die Batterie des Sensors oder des Sendemoduls Probleme macht d) es ggf. eine Doku zum Protokoll gibt, das da auf dem USB(?) Port gesprochen wird (ich würde die Abfrage gern automatisiert über Skripte
Aufkleber auf dem Gerät identisch. Zuordnen kann man die Geräte zu diesen Nummern indem man einen einzelnen Rauchmelder Alarm geben lässt oder leiser, indem man sich direkt unter den Rauchmelder stellt und dann den Melder mit dem stärksten Signal dem Raum zuordnet. Zu c) Ja. Getrennte Spannungsanzeigen
-
Thread
PIC12F1572: UART TRMT vs. TXIF - Bytes sporadisch doppelt übertragen?!
= 1; // */ } } void TMR2_ISR(void) { // clear the TMR2 interrupt flag PIR1bits.TMR2IF = 0; // Stop the Timer by writing to TMRxON bit T2CONbits.TMR2ON = 0; // Reset the timer TMR2=0; // Reset the byte counter byteCounter=0; } [/c]
light... TXREG = byteRead; [/c] hat reproduzierbar nicht funktioniert. Wie auch, das eine popelige NOP hat eine Execution time von 0,03µs gegen die Stop-Bit-Dauer von 52µs; das bringt also afaict nichts... Und, falls Du das
-
Thread
Einkaufsliste für die Einrichtung eines Elektronik-Labors
Zenerdioden sind allerdings immer wieder hilfreich, um Signalpegel herabzusetzen (kann man auch bei 5V µC verwenden).
man hier den Link nicht direkt posten. Es kommt die Meldung: Der Beitrag scheint Spam zu enthalten "c e r t e o . d e"
-
Thread
Viele Flags effizient speichern und schreiben/Byte in Bitfeld?
: 1; unsigned int bit12 : 1; unsigned int bit13 : 1; unsigned int bit14 : 1; unsigned int bit15 : 1; } bits; unsigned int data; } packet_t; [/c] Bitte lies mal in Deinem C Buch
Unions mit 1-4 Byte Zugriff macht man eigentlich nur für Register des µC, um die einzelnen Bits manipulieren zu können und dann in einem Rutsch zu lesen und zu schreiben. Telegramme, vor allem wenn sie mehr als 4 Byte enthalten, schreibt man eigentlich in einer (verschachtelten
-
Thread
Matlab: Protokoll zerlegen und verarbeiten
serial ('COM32'); set(mesaurement_device_data,'BaudRate',115200); set(mesaurement_device_data, 'DataBits', 8); set(mesaurement_device_data, 'Parity','none'); set(mesaurement_device_data, 'StopBit',1); set(mesaurement_device_data, 'ReadAsyncMode','continuous'); mesaurement_device_data.InputBufferSize
#4970206: > ich persönlich fand Matlab's fopen immer recht umständlich. > Manche Sachen sind in C einfacher zu realisieren und dann per DLL > einzubinden. Aber das nur so am Rande erstmal danke für Deine Antwort. Das mit einer externen DLL in C, die Idee ist mir auch schon gekommen, d.h. ich
-
Thread
2 mal USART interrupt, wie gestalten?
solltest Dir ansehen, wie eine UART funktioniert und wann sie ihren RX-Interrupt auslöst. Und wenn ein µC einen 8-Bit-Zugriff macht, erfolgt der nicht sequentiell mit einzelnen Bits, sondern das ist /ein/ Zugriff.
Attila C. schrieb im Beitrag #4969071: > Ist das immer noch zuviel "gerödel" für eine ISR? Natürlich nicht, aber die Abfrage mit Index ist langsamer als Abfrage auf einzelne Zeichen. Deswegen meine Bemerkung
-
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
STM32F0: Mit HAL-Lib überprüfen, ob Datenübertragung über SPI abgeschlossen ist?
SPI Optimierung" Genau so möchte ich das auch machen, wie in dem Beitrag beschrieben, also die einzelnen Flags auswerten. Ich möchte allerdings nicht wie du auf Registerebene programmieren und dort die einzelnen Bits abfragen. Denn bei meiner Aufgabe soll ich hauptsächlich auf die Funktionen der
Optimierung" > > Genau so möchte ich das auch machen, wie in dem Beitrag beschrieben, > also die einzelnen Flags auswerten. > > Ich möchte allerdings nicht wie du auf Registerebene programmieren und > dort die einzelnen Bits abfragen. Denn bei meiner Aufgabe soll ich > hauptsächlich auf die Funktionen
-
Thread
Die Illusion von Fortschritt im Bereich IT
Tja, Maßanzug vom Herrenausstatter, perfekt abgestimmt auf den eigenen Ranzen oder halt C&A Anzug von der Stange, one-size-fits-all.
beschwert, der hat noch nie einen Amiga 500 mit Workbench 1.3 von > Diskette gebootet. oder einen C64 mit Geos...
-
Thread
STm32Fxxx: I2C Hardware Experten gesucht
bleibt da hängen, wenn das EEPROM mit seinem internetn Zyklus befasst ist. Gruss, Christian [c] /* --------------------------------------------------------------- Schreibt ein Byte in eine einzelne Adresse Eingabe: Nr. des EEPROMs (0 und 1) 16 Bit Adresse 8
(I2C1, ENABLE); if (I2C_WaitForEvent(200, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS) return ERROR; // Adressiere das E2PROM I2C_Send7bitAddress(I2C1, EE, I2C_Direction_Transmitter
-
Thread
dht11 Mikrocontroller T89C51CC01 Familie 8051 Keil Uvision 4
der µC 'stirbt'. Dann noch: Das Programm ist ja irgendwo her, scheinbar aber nicht von Dir selber geschrieben? Die Funktionen timer1()/timer2() scheinen das Laufzeit-Kriterium der Bits bzw. Pausen zu
Selber habe ich Das so angegangen, daß ich einen Timer mitlaufen lasse und diese Laufzeit bei jedem Bit speicher - in Deinem Code wäre Das das c = (c<<1)|(0x01); bzw c = (c<<1); Wenn der Zähler überläuft, habe ich einen Fehler und dieses Auslesen ist beendet, sonst wird bei Low-High-Flanke der Timer