-
Thread
Controller mit mehr als 16MHz internem Takt?
Wenn ich es richtig verstehe, Regelst du, wenn c=0. c wird vom externen Interrupt auf 0 gesetzt. Wann und wieviel Mal pro Sekunde wird c=0 ? Kann es sein das du zu schnell regelst? Vielleicht mal eine Totzeit einbauen? Sehe ich es richtig, dass
keine Regelparameter. Es gibt nur den Ist- und den Sollwert. > Wann und wieviel Mal proSekunde wird c=0 ? Also c wird immer zwischen den Signalpegeln 0. Ein komplettes Signal dauert ca. 1,5ms. Zwischen den einzelnen Pulsen des Signals hat der Controller ca. 120µs Zeit die AD-Wandlung und die Regelung
-
Artikel
AVR-Tutorial: IO-Grundlagen
Widerstände mehr notwendig und die Beschaltung vereinfacht sich zu einem Taster, der einfach nur den µC-Pin mit GND verbindet. Zugriff auf einzelne Bits. Man muss nicht immer ein ganzes Register auf einmal einlesen oder mit einem neuen Wert laden. Es gibt auch Befehle, mit denen man einzelne Bits abfragen und ändern kann: Der Befehl sbic (skip if bit cleared) überspringt den darauffolgenden Befehl, wenn das angegebene Bit gleich 0 (low) ist. sbis (skip if bit set) bewirkt das gleiche, wenn das Bit gleich 1 (high) ist. Mit cbi (clear bit) wird das
-
Thread
struct vorbelegen
Hallo, ich möchte in einem Struct einzelne Bits abfragen, die mir für eine if-Bedingungen dienen sollen. Um nicht immer einen ganzen char zu verschwenden, sollte ich das mit einem struct machen: [c] struct { unsigned
unsigned SB_2:1; unsigned SB_3:1; . . . } StatusBit; [/c] Wie belege ich aber die einzelnen Bits mit 0 und 1 vor? StatusBit.SB_1 = 1; funktioniert nicht, da meckert der Compiler... Danke.
-
Thread
Lösung für Füllstandsmessung gesucht
https://cse.google.de/cse?cx=partner-pub-1202612203358489%3Ajaffbdxotov&ie=UTF-8&q=F%C3%BCllstandsmessung&sa=Suche
zuverlässig über Jahre hinweg. Den Spülkasten muss man ja nicht nehmen. Diese Regler gibts auch einzeln im Baumarkt.
-
Thread
Source Code Problem (Attiny2313 BASCOM)
Tastendruck und schaltet weiter in den Modus 2. Du musst dir darüber im klaren sein, dass dein µC viel zu schnell arbeitet, als dass du mit einem simplen If Pind.5 = 0 Then einen einzelnen Tastendruck erkennen kannst. Selbst wenn du ultraschnelle Finger hast, wird dein Programm diese Abfrage
übersehen, ich schau gleich noch mal rein :) Den Timer berechnest du ganz einfach: Taktfrequenz des uC / Prescaler / 65535 (Bei Timer1 mit 16bit) das was da raus kommt ist die Zeit in sec. die der Braucht um einmal hochzuzählen. Roland
-
Thread
LANC Implementierung
habe es gerade noch mal ohne Abfrage probiert: [c]while(1) { // Rec? PORTC = lanc[4]; }[/c] Da ich in genau diesem Byte entweder 0xEB oder 0xFB drinstehen habe, ergibt dies genau eine Änderung des 3. Bits
können auch c.a. 0,7V gewesen sein, auf dem Oszi ist das immer nicht so ganz genau ablesbar... Das mit den zwei Stopbits ist mir auch aufgefallen, sollte aber egal sein, da ich ja zwei einzeln getriggerte bytes sende
-
Thread
Wieso spricht man bei den 8 Bit-AVRs von RISC?
Renesas hat den M32C.. nicht ohne Grund so benannt. Zugegeben, es ist dort nicht alles 32 Bit. Daten-Register können zu 32 Bit komb. werden (was teils auch bei M16C mögl war), aber insbes. Rechnungen >16 Bit sind dort
andere) daran eingeschlafen sind. (Was wurde an 8051 an der Speicher-Architek. erweitert? nix) M16C20 - M16C60 - M16C80 - M32C - R32C, sind alles aufsteigende Serien. (keine dieser Serien ist zu blöd 'drausen' atomic ein Bit zu setzen oder 32 Bits auf ungerade Speicher-Adressen zu verteilen oder INT-Ebenen
-
Thread
Problem bei Temp-Messung Rasp. Pi Pico & Pt1000
. schrieb im Beitrag #7003217: > Vermutlich müsste ich OP-Amp benutzen Jein, da der rPi Pico 12bit an 3.3V Referenz auflöst, also 0.8mV, während sich die Spannung an einem Pt1000 um ca. 1.3mV/GradC ändert, könntest du auf 1 GradC auflösen. Da jedoch die letzten 4 bit der 12 bit ziemlich gestört sind
_t channel) { adc_select_input(channel); uint32_t raw = adc_read(); const uint32_t bits = 12; // Scale raw reading to 16 bit value using a Taylor expansion (for 8 <= bits <= 16) return raw << (16 - bits) | raw >> (2 * bits - 16); } [/c] Manfred M. schrieb im Beitrag #7008179
-
Thread
RS-232 als Bus mit dem UART der AVRs
AVR1 und AVR2 am Bus hängen. AVR1 sendet nun ein Paket, die Senderoutine sieht folgendermaßen aus: [c]void uart_send(uint8_t byte) { UCSRB &= ~(1 << RXEN); // Empfnger ausschalten UCSRB |= (1 << TXEN); // Sender einschalten _delay_us(100); // Warten, Bus auf High damit Start-Bit korrekt erkannt wird UDR = byte; loop_until_bit_is_set(UCSRA, TXC); UCSRA |= (1 << TXC); UCSRB &= ~(1 << TXEN); // Sender wieder ausschalten UCSRB |= (1 << RXEN); // Empfnger wieder einschalten }[/c] Ich denke die ist selbst erklärend
-
Thread
Frequenzzähler 1Hz - 40MHz
zu schaffen. In ASM würde ich schätzen das man es vielleicht bis 50 kHz schafft mit dem Mega88. In C könnte es einiges Langsamer werden, weil man wohl mehr als 32 Bit Auflösung braucht. ASM ist da bei Multiplikationen von 24 Bit x 24 Bit einfach im Vorteil. Hardwaremäßig ist der Aufwand nicht unbedingt
. Vergessen habe ich ... |- * die F_CPU Abfrage auf 24 Bit in der |main.c|, die nun raus könnte. Neu hinzugekommen sind die 64Bit Funktionen von Matthias Hopf und eine Anpassung der bin2bcd Funktion auf 5 (6) Byte Argumenten. In der |main.c
-
Thread
C-Programm auf XC866 'verzählt' sich
habe einen Microcontroller vom Typ XC866. Diesem möchte ich von einem Rechner mit W2k über eine 8-Bit-Verbindung insgesamt 5 Byte übermitteln. Der Rechner verfügt dazu über eine GPIB-Interfacekarte. Vor dem Controller hängt eine Karte, die aus dem GPIB-Signal insgesamt 64 Signale macht, die einzeln
reagiert auf eine steigende Flanke auf der 9. Leitung mit einem Interrupt (ISR siehe Anhang, Datei int.c, Funktion TriggerISR() ). In dem Programm steht P3_DATA für den 8-Bit-Eingang, an dem die 8 Leitungen für die Werte verbunden sind, P0.0 bis P0.2 sind mit Dioden (high-aktiv) verbunden, damit ich mir
-
Thread
Hardware PWM Timer1 funktioniert nicht
8 Bit und ohne Vorzeichen. ) [C] ISR(TIMER1_COMPA_vect) { Servo_Port = 0x00; Servo_ID++; if( Servo_ID == Servo_quantity ) Servo_ID = 0; Servo_Port = Servo_Bit[Servo_ID]; OCR1A += current_position[Servo_ID]; } [/C]
-
Thread
Zahl überprüfen
Die relevanten Bits sich raussuchen und überprüfen?
löst Dein Problem. Du musst die "134" erst als string vorliegen haben und kannst dann mit strchr einzelne Zeichen abfragen. Grüsse, R.
-
Thread
RFM69 OOK - ein Bit zuviel zwischen Transmissions
I/O für Debugging) Im speziellen kann man sehen: - scope07.png: Sieht so aus wie man sich [0x3C, 0xAA, 0x0C] vorstellt. - scope08.png: Hier sieht man das zusätzliche HIGH-Bit vor 0x3C (von Cursor markiert), Zusätzlich ist das letzte Bit von 0x0C zu lang, und zeigt, dass OOK so lange das letzte
nehm ich die gerne :D @fixxl: Ich hab meinen Testcase entsprechend geändert das unerwünschte Bit ist aber leider immer noch da. sieht jetzt in etwa so aus: [c] void sendFunc2(int debugPulses, byte byte1, byte byte2, byte byte3) { // send block of 3 bytes, pre-fill FIFO and change to TX
-
Thread
Suche Mentor für Entwicklung eines Audio-Messwert-Erfassers
wechselt der 3. Draht alle 4 Byte seinen Status, d.h. im SPI-Interrupt bräuchte ich nur den Pinstatus abfragen. Da nur 3 der 4 Byte wirklich Daten enthalten, könnte ich das 4. Byte grundsätzlich ignorieren und so z.B. auch RAM-Speicher sparen. > Du must somit nicht mehr jedes Byte einzeln von hand durch
, 24-bit Yes Yes Also auf Seite 22 sieht man beim I2S Timing Diagram, dass vor den 24Bit "Nutzdaten" ein Bit zum Vorspülen getrunken wird und nach den 24 Bit Nutzdaten wird auf der BCK-Leitung noch lustig
-
Thread
Arduino: page-write in I2C eeprom verliert sporadisch ein Byte
Speicher, weil keine Doppelpufferung benötigt wird. Und wenn noch viele andere Leitungen mit am I2C hängen, kann der EEPROM leicht gestört werden und falsche Daten schreiben. I2C kennt ja keine CRC. Ich speichere daher über einzelne Datenblöcke auch immer eine CRC mit im EEPROM.
einmal anschaut [code] 0101.0000 0x50 0101.1000 0x58 [/code] dann unterscheiden sie sich im 3. Bit. (7 Bit Adressierung) Laut Datenblatt des EEproms AT24C256 ist das "3. Bit" jedoch unveränderbar auf 0. [code] 1010. A2 A1 A0 R/W. bzw. 0101.0 A2 A1 A0 [/code] Die Frage lautet wo kommt die
-
Thread
ENC28J60 (Mikro-)Web-Server die Nächste
Dump des kaputten HTTP Headers mitschicken könntest. [pre] 0000 00 16 e6 d3 36 a2 00 03 6f 55 1c c2 08 00 45 00 ....6...oU....E. 0010 00 81 00 03 00 00 40 06 f8 c4 c0 a8 00 5d c0 a8 ......@......].. 0020 00 02 00 50 0f 85 00 00 00 e5 3f a4 1c 73 50 18 ...P......?..sP. 0030 05 b4 6c e5
Häng mal deine HttpD.c an.
-
Thread
PHILIPS VP5500 VoIP Telefon bei Pollin
16 RAM disks of 4096K size 1024 blocksize I2C driver Apr 7 2006 / 14:44:18 Initialize i2c-client-dbmx-codec module Philips Flash for MX21: probing 32-bit flash bus Amd/Fujitsu Extended Query Table v1.3 at 0x0040 number of CFI chips: 1 cfi_cmdset
S90dropbear # ./S90dropbear start Generating keys for the dropbear ssh server: Will output 1024 bit rsa secret key to '/etc/dropbear/dropbear_rsa_host_key' Generating key, this may take a while... Public key portion is: ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAAAgwCaTiBj/VToR9+ZaCJ1z1Nb+3c78kc CYa5Jxcm9l5lK3zE61t
-
Thread
Atmega8 Timer1 Interrupt Routine wird nicht angesprungen
möchte eine PWM erzeugen. Am Ausgang OCA1 ist eine LED angeschlossen. Der AD-Wandler ADC0 soll im 10-Bit Modus laufen. Die Interrupt Routine wird nicht angesprungen. Ich finde den Fehler nicht. Wenn mir jemand helfen könnte dem wäre ich dankbar. [c] #define F_CPU 160000000 #include <avr/io.h
den Kommentar umgesetzt, und siehe da es funktioniert. Dabei habe ich der Übersicht halber noch einzelne Änderungen durchgeführt. Der neue C-Code lautet folgendermassen: [c] #define F_CPU 160000000 #include <avr/io.h> #include <stdint.h> #include <avr/interrupt.h> volatile uint16_t buffer
-
Thread
Warum ist das AVR-GCC Tutorial so bescheiden?
Programmiersprache C. Ich beherrsche C grundlegend insofern, als dass ich Bits manipulieren, Funktionen schreiben, if-else und for-Schleifen implementieren kann. Ich habe Erfahrungen im Programmieren in C# und Matlab, das
immer nur auf einzelne Aspekte und nicht auf den µC oder die C-Programmierung als Ganzes beziehen, kann es keinen vom Anfang bis zum Ende durchgehenden roten Faden geben. Man sollte die einzelnen Kapitel eher als eine
-
Thread
10Bit in String für Display umwandeln
Hi, das Thema verfolgt mich und es hikft nichts. hier mein Problem: 10Bit vom ADC muss ich am Display anzeigen (T6963C) alles läuft, bis auf die korrekte Darstellung des Messwertes. Das heißt, ich müsste z.B. mit itoa() den ADC Wert in einen String aus Dezimalzahlen wandeln
Drei Schleifen und eine IF-Abfrage: RPM[]=" "; // führende Null ignorieren x=0; If (ADC>999) { RPM[0]='1'; RPM[1]='0'; ADC -= 1000; } while (ADC>99) { RPM[1]++; ADC -= 100; RPM[2]='0'; RPM[3]='0'; } while
-
Thread
PIC Interrupt Probleme
; PIR1bits.ADIF = 0; ADCON0bits.GO_DONE = 1; } return; }[/c] wenn ich nun das ADC-Interruptenablebit setze, und das einlesen in der Polling-Schleife auskommentier, funktioniert nichts mehr
im Interrupt auch gar nicht abfragen, wenn der IRQ ausgelöst wird ist auch dieses Bit auf 0.
-
Thread
Anfänger problem
> dass ich erst in nen register laden > muss welchen pin er abfragtund dann den ganzen port > abfragen und das dann nochmal für den anderen, Genau anders rum: Du liest den ganzen Port in ein Register ein und testest dann in diesem Register welche Bits gesetzt waren oder eben nicht gesetzt waren
LED ausschaltet. Ist das Bit gesetzt, dann unterbleibt dieser Sprung (da ja die Anweisung vom sbrs uebersprungen wird) und es folgt direkt der Code, der die LED einschaltet. sbrs r17, 0 ; Bit 0 gesetzt
-
Thread
Kuriose effekte beim beschreiben von EEprom 24C512
mehr woran es liegen könnte. Die Adresse zum beschreiben wird immer um 1 iteriert und als Word (16Bit) an das EEprom gesendet. Hier noch ein paar Ausschnitte aus meinem Code: [c] void eeprom_write(uint16_t addr, uint8_t val) { i2c_start_wait(Dev24C512+I2C_WRITE); //i2c_write( (addr/256
was ich möchte. Ich hoffe mal, dass wir nicht aneinander vorbeireden. Also zum schrieben: [c] i2c_start_wait(Dev24C512+I2C_WRITE); i2c_write((addr>>8)&0xFF); i2c_write(addr&0xFF); i2c_write(val); i2c_stop(); [/c] Wenn ich hier die Rückgabewerte abfrage nach jedem write, bekomme ich
-
Thread
Welchen Parameter muss ich nutzen, um mit Arduino und DS18S20 ein Relais zu steuern?
ein float. Der DS18B20 liefert keine Float und auch keine Nachkommastellen. Der Sensor liefert 9 Bit signed integer, die als 16 Bit signed integer ausgegeben werden (Fig. 4 im Datenblatt). Das LSB hat ein Gewicht von 0.5°C. Man muss die ausgegebenen Int-Zahlen also mit (Grenzwert * 2) vergleichen
die Abfrage auf >20° in die Hauptschleife legen. Testen kann ich mangels Hardware nicht, aber zumindest kompiliert das: [c] #include <Wire.h> #include <DallasTemperature.h> #include <OneWire.h> const
-
Thread
NeuesOS für AVR Mikrocontroller
auf einem array im RAM) sowie -Funktionen zur Task-Kontrolle (anhalten, löschen usw...) Die einzelnen Funktionewn sind im Quelltext dokumentiert. Das zip beinhaltet folgende Files: /software/nano_os.c - Das main-File /software/system/header/nano_os.h - die zentrale Konfigurationsdatei
Beitrag #1868836: > Wenn ich das alles abgeschrieben hätte würde es doch identisch aussehen. Einzelne Teile (insb. der Code in tasks.c) _sind_ identisch. Das kann man nicht mit "ähnlich" abtun. Die Interfaces sind identisch, die Variablen sind identisch, der Code ist identisch. Ich habe ja nicht
-
Thread
64 Bit float Emulator in C, IEEE754 compatibel
-63 ~ sin(22) -0x1f9bd030bb49300p-72 = f_sin(355), genau auf 31 Bits -0x1f9bd0307d1de2cp-72 ~ sin(355) +0x1921fb542000000p-56 = x1 +0x12168c41641e290p-87 = f_cos(x1), genau auf 23.2 Bits +0x12168c234c4c662p-87 ~ cos(x1) +0x1921fb546000000p-56 = x2 -0x1bd2e882cb70b90p
fp64lib 1.07 -0x1F9BD0307D491Dp-68 ~ -0.00003014435335952594358197194346349334637125 von 31bit genau auf 38bit [/pre] > +0x1921fb542000000p-56 = x1 > +0x12168c41641e290p-87 = f_cos(x1), genau auf 23.2 Bits > +0x12168c234c4c662p-87 ~ cos(x1) > > +0x1921fb546000000p-56 = x2 > -0x1bd2e882cb70b90p
-
Thread
[Ada] Record Representation Clauses - Wert eines "Records" in einem Zug füllen?
zu unerfahren bin. Ich will einen Datentyp (eine "Record" 32Bit breit) erzeugen und beispielsweise als 4x8Bit Datentyp benutzen. Das geht ja (zumindest die erste meiner Anforderungen) seit mind. Ada95 über die "Record Representation Clauses". - Analog dazu in C
BYTE_4 at 0 range 24 .. 31; end record; [/VHDL] Wenn ich die Größe des Records abfrage, bekomme ich als Antwort 32 (Bit) zurück geliefert. Das geht also schon einmal :-) Jetzt würde ich aber diesen Record einen 32Bit Wert zuweisen. [VHDL] Dat: Data := 2#1010_1010_0101_0101_1010
-
Thread
Nokia 6100 Grafiklibrary die Zweite
Tabelle. D.h. aus diesen Informationen baut der Controller intern einfach über Kombination der einzelnen Werte pro Tabelle die 256 Werte umfassende Tabelle zusammen. Diese Tabelle enthält also nach ihrer Fertigstellung 256 Werte a 12Bit. Der Vorteil dabei liegt daran das man nur sehr wenige Daten
Achtung: Auch in glcd02.S wird einmal gewartet. Hinzu kommt dann noch vor dem Ausgeben des D/C-Bits die SPI zu deaktivieren und ebenso in glcdDispRead(). Um diese Blöcke müsste man eigentlich noch ein cli/sei nehmen, da man sonst durch einen anderen Interrupt der ebenfalls am PortB "schraubt"
-
Thread
Problem beim auslesen den IIC
C [/C] Du musst SDA an PC1 hängen und SCL an PC0 und *NICHT* an Port D wie im Kommentar oben. Erste Anweisung in main() ein sei()??? [C] int main(void) { sei(); ... [/C
funktioniert einwandfrei!!! Danke für deine sehr schnelle und tolle und ausführliche Hilfe Stefan!!! [c] tempa[0]=(char)Temp/100+'0'; //Umwandlung der 16Bit in ASCII Zeichen tempa[1]=(char)(Temp-(tempa[0]-'0')*100)/10+'0'; tempa[2]=(char)Temp-(tempa
-
Thread
Funktionsparameter Gesperrt
wird von lcdSendData() benutzt // PE: data = zu sendende Daten void lcdSend(uint8_t data) { // Bit 3 an Port-A löschen (Schreiben auf LCD) cbi(PortLcdCtrl,3); // Daten auf Port-C PortLcdData = data; // Port-C als Ausgang konfigurieren PortLcdDataDDR = 0xFF; // Bit 0 an Port-A löschen
"nop \n nop \n nop \n"); // Daten an PIN-C holen data=PortLcdDataPIN; // Bit 4 an Port-A löschen cbi(PortLcdCtrl,4); // Bit 0 an Port-A setzten (ChipSelect = Aus) sbi(PortLcdCtrl,0); // Port-C als Ausgang konfigurieren
-
Thread
Dauerhaft FakeNews in allen AVR Series 0/1/2 Datenblättern
0). Es 'gibt' eben dieses IR-bit nicht in allen Betriebsweisen dieses Peripherals, in vielen Modi ist es durch das RXCIF-bit an gleicher Position 'ersetzt'. Nur verhält sich eben das RXCIF-bit anders als das IF-bit. Da verwundert
unterschiedlichen Interrupt-Flags die Rede ist? Das per Hardware automatisch gelöschte ist das Bit 7 (I-Bit) im SREG ...
-
Thread
Bewertung des Zufallsgenerators für einen Spielwürfel
und beim > Drücken den aktuellen Wert abzufragen? Nichts wenn man vom timer nur die letzten bits nimmt. Du kannst auch beim Programmstart (uC einschalten) irgendeinen Timer starten und immer rum zählen lassen und wenn du eine Zufallszahl brauchst, eben dessen Wert nehmen. So lange da eine
kein "brennen", runterfallen, ...) Lothar S. schrieb im Beitrag #3223838: > mit so 'nen kleinen uC Das Programm wird in ASM im einfachstem Fall keine 100bytes verbraten... was die "Größe" des uC jetzt auf den Zufall für einen Einfluss haben soll ist auch ein ungeklärtes Mysterium.
-
Thread
Sprachausgabe mit AVR
die Tastatur abgefragt wird ? Das Programm würde für mich mehr Sinn machen, wenn ich die Taster einzeln abfragen könnte, also pro PortPin ein Wave abspielen.
Morgen Ingo, eine Änderung ist nicht notwendig. Lege einfach je eine Datei für jeden Pin ab. Bit 0 = 001.wav Bit 1 = 002.wav Bit 2 = 004.wav : Bit 7 = 128.wav läuft super bei mir ! Die "Tasten" sind Taster und werden über den PinChange Interrupt 'abgefragt'. Siehe in "main.c" die Funktion
-
Thread
200kOhm Poti an Mega8 auslesen
nicht, welche Teile der vielen Beispiele im Internet für meine Anwendung gebraucht werden. Die Abfrage muss permanent laufen, darum darf der ADC glaube ich nicht abgeschaltet werden nach der Abfrage. Als Grudgerüst habe ich das hier stehen: [c] uint16_t ReadChannel(uint8_t mux) { uint8_t i
Wie wärs denn, wenn du dir einfach mal die Beschreibung des ADC vornimmst und nachsiehst, was die einzelnen Bits in den Controlregistern bedeuten? Das macht zwar ein bischen Arbeit, führt aber doch erstaunlich schnell zu netten Aha-Effekten.
-
Thread
Programm funktioniert.aber wieso?
werth = werth | 0b00000001; } wertl=wertl<<1; wertl = wertl & (0b11110111); //4tes bit invertieren auf 0 PORTA=werth; //Ausgabe an PortA = Highbyte PORTC=wertl; //Ausgabe an PortC = lowbyte // PORTA=counter; // PORTC=0; //**********************
Was ich auf die Schnelle sehe: [c] uint8_t status; //status des Programms [/c] muss "volatile" sein, da es in "main" und einer ISR benutzt wird.
-
Thread
Schieberegister 74LS165 an µC Mega8 auslesen
Hallo, ich habe hier einen ATMega8 µC, mit Hilfe dessen ich eine Reihe von Schieberegistern (74LS165) abfragen will. Ich habe also sehr viele Tasten, deren Zustände auf ein Signal hin in die verketteten Schieberegister gelesen werden sollen und dann nacheinander an einem Eingang des µC vorbeigeschoben werden. Zum Testen habe ich erstmal nur ein Schieberegister angeschlossen, und zwar: - PIN9 (QH) mit PIN13 (PD7) des µC - PIN2 (CLK) mit PIN11 (PD5) des µC - PIN15 (INH) mit Masse
-
Thread
LCD-Modul EPSON ECM-A0428 von Pollin
ich einen kontakt mache und den µC starte sehe ich nur schwarze blaken und flimmern.
schauen, was der Prozi bei >Tastendruck so ausspuckt, oder? Ich kann mir vorstellen, dass man die einzelnen Adressfelder der Matrix abfragen muss, bevor der ECM antwortet. Erstmal sollte man herausfinden, welcher Bus verwendet wird. Bei SPI muss ja bei einem angelegtem Takt an SCLK bei MISO etwas passieren
-
Thread
Hausautomatisierung mit Embedded Linux
Program Flash, 8MB DatFlash, 32MB SDRAM * SD-Card Socked * RS232, USART, I2S, AC97, TWI/I2C, SPI, PS/2, and several SSC * 16-bit stereo audio DAC * 2048x2048 pixel TFT/STN LCD controller (Touchpanel support) * high-speed USB 2.0 "B" client port with on-chip transceivers (PHY)
gefunden: http://www.toradex.com/d/colibri_pxa300.php CPU: PXA300 208MHz Memory: 64MB DDR RAM (16Bit) 128MB Flash (8Bit) Interfaces: 16Bit External BUS LCD (SVGA) CMOS image sensor I2C SPI 2xSDCard USB Host/Device 100MBit Ethernet 2x UART IrDA PWM 127 GPIOs Size: 67.6 x 36.7 x 5.2 mm
-
Thread
Module miteinander verbinden - welchen Bus nehmen?
Master, weswegen eine Vorab-Speicherung in dem Modulen flach fällt. Der Master soll also überall einzeln Bilder "hochladen" können. Ich denke ein paar MBit/s wären also ganz gut. Jetzt dachte man schon daran, weil ja 2 SPIs pro uC vorhanden sind, ob man nicht einfach einen SPI für IN und einen weiteren
schrieb im Beitrag #5786114: > SPI ist schon ok, das ist niederohmig. Du meinst wahrscheinlich I2C, das > ist etwas anfälliger bei langen Leitungen. Es ist genau umgekehrt. I2C filtert die Eingänge mit einem Tiefpaß gegen schnelle Störflanken und ist daher unempfindlich gegen Leitungsreflexionen
-
Thread
AES Verschlüsselung mit ARM Cortex M3
Das ich ein Programm schreiben muss das habe ich mir gedacht eine open source "ase.c" und "ase.h" habe ich ich habe nur noch nie uC programmiert :( Empfehlungen für Software bräuchte ich also auch noch. Zur Übertragung: das war wohl schlecht formuliert von mir. gemeint ist,
Firmware upgrade etc.). Wenn Du einen Chip mit HW Crypto Engine suchst, würd ich einen Xmega (128Bit AES) oder z.b. wenn es 32Bit sein sollen: AT32UC3A3256S Im Atmel Studio 5 gibt es fertige Library zur AES Anwendung wenn ich mich nicht täusche.
-
Thread
ARM und Assembler Programmierung?
das Gefühl gegeben wird, dass 8 Bit eigentlich eine aussterbende Art sei. Hoffe mal das sich das nicht bewahrheitet. Oder unsere Nachfahren schalten im Jahre 2250 vielleicht einzelne LEDs mit 512 Bit Mikrocontrollern und mit so viel
EinUserWasSonst schrieb im Beitrag #3860802: > Nun beschäftige ich mich mit ARM 32 Bit Mikrocontrollern und frage mich > ob irgendwer auf der Welt ernsthaft Assembler dabei nutzt. Der Hauptteil wird tatsächlich in C geschrieben. Es gibt aber Teile die in Assembler sinnvoll sind: Bit-Banging
-
Thread
USB Datenaustausch bei Nexys2 von Digilent
der PC Seite die > SW generieren? Vermutlich irgendwas C. Auf dem PC habe ich diese abgespeckte Version von Visual C++. Lange Zeit habe ich in Visual Basic programmiert, daher schließe ich das auch nicht ganz aus. Hätte halt den Vorteil, dass ich mich mit
gesendet hat. Wenn der PC etwas gesendet hat ist folgende Aussage wahr: !(EP1OUTCS&2) m.a.W. das Bit Nr. 2 in EP1OUTCS ist 0. Ist das Bit=1 sollte man keinesfalls aus in das fifo schreiben oder draus lesen, da die SIE das FIFO grade nutzt. Sind also Daten vom PC angekommen (Das überprüfte Bit
-
Thread
ADXL345 Device ID auslesen
den falschen SPI-Mode verwendest... Was heißt falscher SPI-Mode, ich sehe nur ein Byte um SPI / I2C zu verwenden. Lothar M. schrieb im Beitrag #6886188: > Also: SS#=low, 8 Bit Kommando senden, 8 Bit Dummy senden, SS#=high Okay, jetzt ist wechselt mein SCLK Signal schonmal 16 mal und 16 Bit werden
muss: mit jedem einzelnen gesendeten Bit schickt dir der Slave eines zurück. Er kann gar nicht anders, weil das in Master und im Slave ja einfach nur hintereinander geschaltete Schieberegister sind, die immmer mit jedem SCLK-Takt
-
Thread
Temperaturanzeige mit PIC16f872 und LCD display problem
viel aufwändiger, als es gleich richtig zu machen, ohne Hardware, ohne Interrupt, mit nur einer Abfrage pro main while Schleifendurchlauf. [c] uint8_t taste,gedrueckt; while(1) // deine Programm-Hauptschleife { taste=PINB&1; gedrueckt=taste&~gedrueckt; if(gedrueckt) { taster
Arrayinhalt ist veränderbar. Der Arrayinhalt wird mit "0000.0" iniitialisiert aber danach kannst du die einzelnen Zeichen ändern soviel du lustig bist. ---> C-Buch besorgen! >> Was ist mit dem hierunsigned char txt[3]; >> >> berücksichtigtshorttoStr(ad, txt); // Umwandeln >> dass ad nur
-
Thread
ATMega328p Onchip Temperatur Sensor
regelt. In C-Programmen sollten grundsätzlich diese 16-Bit-Register verwendet werden! Sollte trotzdem ein Zugriff auf ein Teilregister erforderlich sein, sind obige Angaben zu berücksichtigen. ... ADC und ADCW sind unterschiedliche Bezeichner für das selbe Registerpaar. Üblicherweise kann man in C-Programmen ADC verwenden, was analog zu den anderen 16-Bit-Registern benannt ist. =>ADCW<= (ADC Word) existiert nur deshalb, weil die Headerdateien auch für Assembler vorgesehen sind und es bereits einen
-
Thread
gleitender Maximalwert - wie umsetzen?
immer aus zwei Samples den Maximalwert ermitteln. Dazu brauch ich nur zwei Byte Speicher, plus ein Bit um "jedes zweite Mal" zu kodieren. Pseudo-Code: [pre] stage (uint8_t input) { old = new; new = input; if (bit == 0) { bit = 1; } else { bit = 0; next_stage(
Kondensator geben und den auf einen freien Analog-Pin legen (also ein Peak-Detector). Nach dem Abfragen den Pin auf Ausgang schalten und den C löschen. Hat den Vorteil, dass immer der Peak des realen Analog-Signals gemessen wird, auch wenn die Samples übersteuert waren. Du brauchst also keinen Buffer
-
Thread
CRC-16 Prüfsumme (serielle Übertragung)
: crc=0; //am Anfang initialisieren unsigned int calcCRC16r(unsigned int crc, unsigned int c) { // CCITT 16 bit (X^16 + X^12 + X^5 + 1). crc = (unsigned char)(crc >> 8) | (crc << 8); crc ^= c; crc ^= (unsigned char)(crc & 0xff) >> 4; crc ^= (crc << 8) << 4; crc ^= ((crc &
dargestellt: http://www.mikrocontroller.net/topic/65344 Hier ist etwas, was parametrisierbar C-Code aus vorgegebenem Polynom, Startwerten und Speicherbedarf (Schleife, 4-bit, 8-bit table) erzeugt. Must-have! http://www.tty1.net/pycrc
-
Thread
CFSensors XGZP6857D Drucksensor Informationen
jeden Baustein unterschiedlich. Bei dem besagten Drucksensor passiert es, daß bei ACK folgende Abfragen fehlerhaft sind. Was Arduino WIRE betrifft, ist das so eine Sache, weil die Multi-Byte Daten Abfrage kein NAK am letzte Byte ausgeben soll. Ich probierte eine Arduino Drucksensor Lib damit aus und
Nun, Abweichungen gibt es - Man denke nur an den ersten Intersema MS5344 Sensor. Bei dem war das I2C Protokol auch "verballhornend" umgesetzt und konnte nur als einzelner Busteilnehmer eingesetzt werden. Spätere Versionen wurden dann dem I2C Standard angeglichen. Wahrscheinlich haben sich damals viele
-
Thread
ATTiny 45 hängt bei Interrupt anscheinend (ADC)
aufgerufen. Du bleibst ewig in der ersten while-Schleife hängen. Schau dir nochmal an wie man einzelne Bits manipuliert. [c]foo |= (1<<3); // setzt Bit 3 in foo foo &= ~(1<<5); // löscht Bit 5 in foo foo ^= (1<<7); // toggelt Bit 7 in foo // äquivalent zu den oberen Zeilen aber mMn übersichtlicher
if( c & 1 ) STX_PORT &= ~(1<<STX_BIT); // data bit 0 else STX_PORT |= 1<<STX_BIT; // data bit 1 or stop bit c >>= 1; } } [/c] Peter