-
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
-
Thread
Assembler lernen für Mikrocontroller-Programmierung
Hallo zusammen, bei der Assemblerprogrammierung lernt man ja jedes Bit des µC einzeln kennen. Habe das im Screnshot zu sehende Programm zum Festellen des Systemtaktes benutzt. Das Oszi zeigt eine Frequenz von 14,660kHz an PB4 ( Pin3 ), an. Dies mal 8 ergibt -> 117,280kHz
-128 bis 127 -> V gesetzt $C2-$FF = -62 - -1 = -61 liegt im Bereich -128 bis 127 -> V nicht gesetzt Das gilt dann auch für 16-bit, 32-bit etc. arithmetik.
-
Thread
ATmega2561 - USART
patronic wrote: > ja im ich möchte jedoch einen string senden können. In C? Ist doch kein Problem. Wenn du erst mal eine Funktion hast, die ein einzelnes Zeichen korrekt versendet, dann ist es doch trivial darauf aufbauend eine Funktion zu schreiben, die einen String
receiver and transmitter*/ UCSR0B = (1<<RXEN0)|(1<<TXEN0); /*Set frame format: 8data, 2 stop bit */ UCSR0C = (1<<USBS0)|(3<<UCSZ02); } /*USART Transmit*/ void USART_Transmit(unsigned char data) { /*Wait for empty transmit buffer*/ while(!(UCSR0A & (1<<UDRE0))) /*Put data into
-
Thread
Temperatursensor an LPT
, aber ich frage lieber nach, weil der LPT ja nicht so sicher wie der COM Anschluss ist. Die einzelnen Ports werde ich dann mit VB oder C abfragen... Schönes Wochenende x86
Du mußt erstmal den Port auslesen, und dir dann das jeweilige Bit ausmaskieren: [c] a = inp(BASE); if(a & (1 << BIT#)) {...} else {...} [/c] BIT# = 3, falls deine Daten an D3 gehen, halt als Beispiel.
-
Thread
STM32Cube HAL UART Einstieg
einen Eindruck zu kriegen, wie sowas geht: https://www.mikrocontroller.net/attachment/316790/STM32F103C8T6.ZIP Im Prinzip hast du ja in main immer eine Grundschleife, in der sich der µC dreht, wenn es sonst nix zu tun gibt. Also etwa so: immerzu: mach dies mach das wenn X dann mach Y
nennst du "nichts Einfacheres"? Und du meinst, sowas sei eine Hardware-Abstraktion? Lies mal das: [c] char c; if (RxAvail(UART1)) { c = GetChar(UART1); Char_Out(c, UART1); } [/c] Bei sowas ist ne echte HW-Abstraktion dahinter. Das ist Code, der bei Vorhandensein ordentlicher LL-Treiber
-
Thread
1-Draht-Bus in BASIC
Tasteneingabe eines angesprochenen Slaves zum Master übertragen und dort verarbeitet werden. Die C-Control (Master) ist bereits vorhanden. Ebenso die einzelnen Softwarebausteine zur Tastenauswertung im Slave und zur Verarbeitung dieser Daten im Master. Was jedoch noch fehlt ist die komplette Bus-Verbindung
. Tatsächlich ist es aber so wie Du vermutet hattest. Also sternförmig verdrahtet. Paralleles Abfragen dürfte aber so wie so schwieriger sein, da ich ja nicht nur ein Bit, sondern mindestens ein Byte vom Slave zum Master senden muss. Jeder Slave überwacht 2 Tasten auf "Klick", "Doppelklick", "langes
-
Thread
3 Interrupts am Arduino Nano
if (PIND & bit(4)) // if it was high ISR_C; Serial.println("ISR"); //Kommt NICHT :( } [/c] ISR_A,B,C sind die separaten Methoden für die einzelnen Pins
OLED Display dar Serial.println("A: " + String(total_A) + " B: " + String(total_B) + " C: " + String(total_C)); } [/c] Erstaunlicherweise, haben die Zähler "total_A,B,C" auch plausibel gezählt obwohl ich mit den Bits um eins verschoben war, es scheint mir als ob die Maskierei gar nicht
-
Thread
Alles Rund um den MEDION LIFE P89626 NAS
PPPoL2TP kernel driver, V1.0 NAND device: Manufacturer ID: 0xad, Chip ID: 0xf1 (Hynix NAND 128MiB 3,3V 8-bit) Scanning device for bad blocks Creating 7 MTD partitions on "NAND 128MiB 3,3V 8-bit": 0x000000000000-0x000000040000 : "stage1" 0x000000040000-0x0000003c0000 : "uboot" 0x0000003c0000-0x000000440000
dann ist zumindest das zuletzt genannte Kommando in der Lage irgendwo auf der Platte zu lesen: [c] #define CFG_64BIT_STRTOUL [/c]
-
Thread
mega8 - fragen bei assembler
da ich die pullups nicht benutzen will sollte das alles gewesen sein richtig?? die frage bei port c: das ist nur ein 7 Bit Port..wird der trotzdem so als wären es acht initialsiert?? der pin 6 soll als normaler ausgang aktiviert werden, nicht als reset..richtig so?? oder fehlt da noch was?? was fehlt
ihn als Ausgang zu verwenden. Solange sie gelöscht ist, kannst Du in die Steuerregister für Port C, Bit 6 programmieren, was Du willst. Ansonsten klar, Du mußt den Port natürlich im Ganzen ansprechen, Bit 7 ist offiziell reserviert, d. h. es wird als 0 gelesen und sollte als 0 geschrieben werden
-
Thread
Möchte Arduino mit RFM70-S verbinden!?
Befehle' aufnehmen kann? Nein. Das heißt, daß gerade etwas passiert ist und das Modul dies dem µC mitteilen will, dieser also schleunigst per SPI mal den Status abfragen soll, um herauszufinden, was jetzt passiert ist.
Weißt du was ein Register ist? Weißt du dass einzelne Bits in so einem Register spezielle Funktionen und Namen haben? (PRIM_RX z.B.). Im Datenblatt steht was diese Bits bewirken. Im Datenblatt steht wie man die Register schreibt und liest Im Datenblatt
-
Thread
Giess-o-mat mit AVR Version 2
wirklich Lust hätte. Hat mittlerweile schon jemand ein Board-Layout erstellt? Ich bin noch blutiger µC- und teils E-Anfänger und möchte den Code und die Schaltung gerne verstehen. Ich würde u.a. gerne das Layout um eine USB-Schnittstelle erweitern und irgendwie eine Web-Abfrage o.ä. implementieren, um
hi eine frage habe ich noch zu diesem projekt kann man da noch ein lcd display mit i2c anschliessen oder geht das hier nicht mehr so könnte man direkt an lcd die einzelnen werte der sensoren ausgeben
-
Thread
LPC935 EEPROM-Programmierung
kannst du keine Int Werte (16Bit) direkt speichern. Du musst diese erst in zwei einzelne Bytes aufteilen und getrennt speichern/abfragen. In deinem Beispiel schreibst du "DEEDAT = 511" was unsinnig ist, da du nur Werte zwischen 0-
Speziell zu der LPC900 Familie von 8051er Controllern kann ich dir das Buch auf www.c51.de empfehlen. Ich habe es mir damals selber gekauft und es erklärt sehr gut die Software sowie Hardware Aspekte dieser Controller. Es sind auch sehr viele Codebeispiele mit dabei um die einzelnen Funktionen
-
Thread
Differenzverstärker INA105
ich meine fast, die Aufgabe bekommt man sogar nur mit Spannungsteilern hin, wenn man statt des 10-Bit-MCP einen 12-Bit-Wandler nimmt...
fertige Chips, da verbindest du deine 15 Zellen einfach dran, und kannst dann bequem über SPI oder I²C alle Einzelspannungen abfragen. Ja, kosten ein paar €, und nein, fertige Arduino-Breakout-Boards bei Aliexpress findest du eher nicht. Beispielhaft mal das Datenblatt für den LTC6812-1 angehängt
-
Thread
CARRY schnell invertieren Assembler ATmega8 ?
>Und warum musst du es bitweise umdrehen? Nach 8 Bits ist einfacher. So einfach ist das nicht: Weil der MASTER vom 1WIRE Datenbus mur einzelne Bits sendet bzw. empfängt, speziell im Search-Modus, 2 Bits empfangen, danach ein Bit senden
#4409298: > So einfach ist das alles nicht, zumal der MASTER sehr schnell > hintereinander die Bits abrufen kann. Was ich beschrieb sorgt vor allem dafür, den zeitkritischen Teil der ISR zu entlasten. Im verlinkten Code hat an genau dieser Stelle die zeitraubende Abfrage einer Statemachine drin
-
Thread
Mit der Butterfly an den CAN Bus?
>In Bascom müsste ich mich kurz einarbeiten, C wäre evtl. für mich >leichter, da ich C++ behersche (mehr oder weniger). Und wenn du mit Bascom "arbeitest" gehst du uns damit auf den Keks... Da du C++-Kenntnisse hast, solltest du sie nutzen
sondern als Software-SPI. @Stephan: Software-SPI = SPI via expliziter Programmierung der einzelnen Portpins ohne Benutzung des SPI-Moduls des Controller, Bit für Bit, Zustand für Zustand. Ist eigentlich kinderleicht - vorausgesetzt man versteht die entsprechenden Signaldiagramme vom Datasheet.
-
Thread
Gitarreneffekte selber bauen
M4 ARM haben durchaus Befehle deren Resultat in 2 Register geschrieben wird. Das sind mithin 64 bit. [code] ldrd r2,r3,[r0,#0] smull r1,r2,r2,r3 ldr r1,[r0,#8] str r3,[r0,#8] [/code] Daran sollte es also nicht scheitern. Ich zweifle nur daran, dass ein C-Compiler da immer
passenden Zugriffssequenzn parat hat, obwohl ich aus reiner Bequemlichkeit auch so etwas schon in C geschrieben habe. Da war mit aber die Perfomance schlicht egal. [code] tmp = (((long long)co * (long long)s1) >> 30) - s2; [/code] Beim 56002 ist es halt bequemer, weil der 56 bit Akku
-
Thread
unauffällige Ferienausüberwachung
Wenn es nur um unbefugte Vermietung geht, Licht abfragen. Ist noch Platz im Sicherungskasten? Laufen da vielleicht gleich geschaltete Leitungen vom Licht durch? Oder Stromverbrauch: Versorgung für Licht mit der Spule eines ausgedienten FI-Schalters abfragen
mit Passwort herum und die werden sich garantiert einloggen. Einfach den Router aus der Ferne abfragen - man sieht sofort, ob jemand im Haus ist - weil eingeloggt.
-
Thread
einfache Grafikkarte mit 256x252 und 256 Farben für AVR
Dann bleibt nur noch der K6T4008C1B-DB55. Das Video kann ich leider nicht sehen, aber aus dem Teil könnte man doch ideal ein Oszi bauen. Noch einen parallelen A/D Wandler mit 8 bit. an PortD. und fertig
ich dachte jetzt ich nehme mir ein Bild, ändere die Größe auf 256X252 Pixel und speichere es als 8Bit-BMP wieder ab. Ohne jetzt den Rechner zu starten sehe ich schon so, das es (für einen µC) viele Bytes sind. Aber ich denke, einfacher geht es wohl nicht? Ich stelle mir das so vor, das man ein paar
-
Thread
AVR-Controller Eignung
gelegenheit.(THX für den Tip) Was mich derzeit aber brennend Interessieren würde ist die I2C Geschwindigkeit unter Basic. (Das Bascomdemo sauge ich heut Abend damit ich mal nen Eindruck bekomme welche Befehle mir da zur verfügung stehen.) Bei der CC1 hab ich mit nem PCF8574 (8-Bit Port einfach
) mit werten zu versorgen braucher ich schon satt über ne Sekunde. 8 Fühler will ich auch noch abfragen und das LCD am I2C soll ebenfalls versorgt werden was dann am Ende mit berechnungen so auf 10 Sekunden für einen kompletten Programmzyklus kommt. Da kann ich gleich per Hand regeln und die Werte
-
Thread
Hardware Programmierung mit Python
interaktiven Shell Python-Anweisungen ausführen lassen. Das ist für den Einstieg in einen neuen µC-Typ ganz praktisch, weil man damit erst einmal aller Features einzeln und interaktiv ausprobieren kann, bevor man beginnt, daraus ein ganzes Programm zu erstellen. Auch zum Debuggen ist das ganz
angefangen bei alternativen Interpretern wie Pypy bis hin zu der Möglichkeit, Python ganz oder nur einzelne Teile des Codes in andere Programmiersprachen zu übersetzen und dann in nativen Code zu übersetzen. Und dann gibt es natürlich immer noch die Möglichkeit, performancekritische Teile in C oder C++