-
Thread
Leds mit gleichen Taster durchschalten
Logische Operationen mit einem Leerzeichen trennen. Erst einmal eine Variable deklarieren: [c] uint8t TasterCnt = 3; [/c] Der Else Teil deiner if Abfrage ist auch unnötig, also: [c] while(1) { if (!(PINB & (1<<PB0))) // Taster Abfrage high oder low?
um Erfahrungen auszutauschen > und jemanden Helfen, der nicht weiter weist. Also, nochmal: [c] volatile uint8t TasterCnt = PB3; // Falls du das mal in der ISR abfragen willst while(1) { if (!(PINB & (1<<PB0))) // Taster Abfrage high oder low? {
-
Thread
PIC16F877 Eingangsbit abfragen
RB1 benutzen. Hast Du an Pull-Up Widerstände gedacht? > Ich weiß nun aber nicht wie ich das einzelne Bit abfragen kann, einen > ganzen Port ist kein Problem. Du musst mit einer Bit-Operation das gewünschte Bit herausfiltern (genau: maskieren) und dann prüfen http://www.roboternetz.de/wissen/index.php/C-Tutorial#Bit-Operatoren [c] if (PORTB & 0b00000001) // falls Bit 0 in Port B gesetzt ist { ... } [/c]
-
Thread
Mehrere Attiny's mit 1 Atmega kommunizieren lassen
c-hater schrieb im Beitrag #5993272: > Ich bin sicher: jede einzelne davon hätte man auch mit einem Tiny10 > abhandeln können ... und mehr.
hochpräzise Messgeräte, und welcher Anfänger hat die schon. Dann aber bitte keinen Tiny10, der hat nur 8-bit ADC und keinen Referenzeingang. Und ja, man kann den Tiny10 auch in c programmieren.
-
Thread
Flashplatzbedarf 32Bit zu 8Bit Microcontroller
einen 32Bit Microcontroller, wieviel Flashbedarf hat das Programm dann? Wird beim 32Bit µC mehr Flash verbraucht da Befehle nun 32Bit lang sind?
> Wird beim 32Bit µC mehr Flash verbraucht da Befehle nun 32Bit lang sind? Im Prinzip ja. Allerdings versuchen die Hersteller das zu optimieren. In der Praxis ist es bedeutungslos weil 32Bit Controller deutlich mehr
-
Thread
DDS mit DE0-Nano Board nur niedrige Frequenzen?
! Bit 19 ist in der Tat für die Unterscheidung, von welcher Seite die Tabelle gelesen werden soll und Bit20 ist das eigentliche Vorzeichen-Bit! Ich kann aber mit meiner Tabelle nur Frequenzen generieren
Beschreibungen zwischen die Token [ vhdl] und [ /vhdl] (ohne Leerzeichen, so wie im Screenshot mit den C-Quelltexten). Dann funktioniert das auch mit dem Syntax-Highlighting... Atmega-Verleger schrieb im Beitrag #3110977: > oder ich takte den Prozess zum Abfragen von QUADRANT gar nicht > und packe
-
Thread
Automower G3 mit USB Diagnoseport fernsteuern?
Hi David, Zeit/Datum stellen: 02[04] 80 0c 28 00 -> 03[04] 00 0c 28 00 zeit auf 12:40 02[09] 81 df 07 08 08 04 00 00 00 -> 03[06] 00 df 07 08 08 04 datum aud 8.8.15 formatbyte: bit0 1-12h/0-24h, bit1+2 0-JMT/1-MTJ/2-TMJ, 2015
.....02-15-0c-00-00-00-e2-ff-0a-00-d9-03-00-aa-00-b4-03 [/code] Weiß z. B. jemand, wie man die im Robi eingestellte Uhrzeit abfragen kann?
-
Thread
Suche Software I2C Slave
das eigentlich ganz gut. Der MSP430 wird mit 8MHz getaktet und immerhin hat man dann (bei 100kHz I2C) zwischen den einzelnen Takten an SCL 80 Taktzyklen Zeit.
nur, um die ganze Prozedur zu starten. Und anschließend könnte man durch einen Timer o.ä. die einzelnen I2C-Bits abfragen und ggf auch BITS an den Master senden. Ein Fehler in der Kommunikation könnte somit korrigiert werden. >Ich weiß nicht, wie das bei den ATMEGA Controllern ist, aber bei die
-
Thread
mit eingänge rechnen
kompilierbar ist und gleichzeitig das Problem aufweist - also im Simulator geht aber nicht auf dem uC. Dann brauchen wir nicht jedes Detail einzeln von Dir zu erfragen.
geschrieben > wurde). Nun, ein String ist halt ein Array aus char. Sonst nutzt C nirgends char für Text. Für einzelne Zeichen wird in der Regel int benutzt. Schau dir mal die ganzen Standard-Funktionen an, die mit einzelnen Zeichen arbeiten, wie z.B. isalpha() oder toupper(). Dort
-
Thread
Wie fängt man ein Problem an zu lösen ?
etwas anderes angewöhnen. Bei MC-Programmierung muß man halt oft gezielt prüfen, ob ein bestimmtes Bit in einem Wert gesetzt ist oder man möchte so ein Bit setzen oder löschen. Ob man das jetzt direkt mit C-Operatoren macht ( if( wert & ( 1 << 5 ) )... oder if( wert & 0b00100000 ... ) oder sich dieses
dann alten Spezialfunktionen nicht mehr notwendig waren und man lieber wieder zurück auf Standard-C Mitteln ging. > Danach werde ich mir wohl angewöhnen müssen Ausgänge mit PORTB |= > (1<<PB2); (Als Beispiel) zu setzen und mit PORTB &= ~(1<<PB2); (Als > Beispiel) zurückzusetzen. Für die Abfrage
-
Thread
AVR-C Analog Read
Nicht irgendein Programm von irgendeiner Website, sondern dein konkretes Programm, welches auf deinem µC läuft.
Hausaufgaben gemacht hast, und in Theorie und Praxis (vor allen Dingen Praxis) gelernt hast, wie man einzelne Bits auf 1 bzw. auf 0 setzt, bzw. dass man 0 Bits nicht explizit setzen muss, wenn man sowieso dem Register als ganzes etwas zuweist.
-
Thread
Ein µC oder auf mehrere verteilen?
für die einzelnen µCs. Die Leiterbahnbreiten sollten passen. Habe grundsätzlich 0,5mm mehr breite genommen als "norm" also man sagt ja in der Regel 1mm pro A Leiterbahnbreite bei 35er Cu auflage. I2C Verbindung
auch Bosch hat zu 8 Bit Zeiten als die µC noch nicht soviele Timer-(funtkionen), ADCs... hatten mehrere µC auch auf mehreren Platinen verwendet. Auch von der Programmierung wirst du dich leichter tun wenn ein µC unabhängig
-
Thread
Differentiell-Taster für RS485?
Ja, wenn es ModbusRTU ist musst du den Sensor abfragen. Aber nicht über B, A & B gehören zusammen, das ist eine differentielle Übertragung, d.h. "A+ und B-" ist ein Bit, "A- und B+" das andere. Im Prinzip eine normale Halbduplex Serielle Schnittstelle
nicht den Buchstaben an, auf den ich drücke :/ Mir ist auch noch nicht klar, wie ich jetzt eine ganze Bit-Abfolge inkl. Addressfeld, Functionscode et.c. auf ein Mal sende. Ist dieser Link sinnvoll? https://unix.stackexchange.com/questions/117037/how-to-send-data-to-a-serial-port-and-see-any-answer
-
Thread
Was ist aus dem Thread der MeteoData geworden? Gesperrt
C immer unterschiedlich ausfallen, da K immer anders ist. Wenn sich die 40 Bit wirklich aus C und E zusammen setzen und E durch eine Paritäts-Matrix gewonnen wird müßten sich die 40 Bit mindestens um 3 Bit unterscheiden (ein geändertes Bit in C und folglich 2 geänderte Bits in E). Ich werde die Daten von Thomas mal daraufhin untersuchen. z.B. sind hier 2 Datensätze, die sich nur um 1 Bit in K1 unterscheiden
-
Thread
Programm bzw. Ablaeufe steuern
Karl-Heinz, Danke für Deine schnelle Antwort. Ich verwende ja zur Zeit ein Integer bei dem jedes Bit für einen Timer steht und mittels [c] if(TimerStatus & 0x08) { //... CODE } [/c] schaue ich ob der Timer abgelaufen ist (BIT = 1) Nun habe ich im AVR-GCC-Tutorial etwas über Bitfelder gelesen. Könnte ich nun ein Bitfeld wie folgt anlegen [c] struct { unsigned Timer1:1; // 1 Bit für Timer1 unsigned Timer2:1; // 1 Bit für Timer2 unsigned Timer3:1; // 1 Bit für Timer3 unsigned Timer4:1; // 1 Bit für Timer4 unsigned Timer5
-
Thread
AVR8ASM-Projekte
Handencoder von *Panasonic EVEQ > DBRL416B* > beim nach links drehen, also gegen den Uhrzeigersinn ( C.C.W ) in einer > oder einigen Raststellungen ziemlich heftig prellt. Dagegen hilft die passende Auswertung. https://www.mikrocontroller.net/articles/Drehgeber#Dekoder_f.C3.BCr_Drehgeber_mit_wackeligen_Rastpunkten
Tasten #define SW1 as PORTB.0 #define SW2 as PORTB.1 #define KEY_PORT as PORTB const SW1_BIT = 0 const SW1_MASK = BV(SW1_BIT) const SW2_BIT = 1 const SW2_MASK = BV(SW2_BIT) endpart '--------------------------------------- ' Init '---------------------------------------
-
Thread
Ultraschallsensor und ATmega 2560
Timer aufgerufen werden und einfach nur eine Variable hochzählen. Nennen wir sie uint32_t systick (8bit wäre zu klein). [c] uint32_t volatile systick=0; ISR(TIMER1_OVF_vect) { systick++; } [/c] Dann schreibst du dir noch eine Funktion, mit der du systick sicher lesen kannst ohne dass
Intervall machen soll. Du musst also abfragen können, ob inzwischen 10ms verstrichen sind. Das macht man so: [c] uint32_t anfang = getSystick(); ... irgendwas machen uint32_t jetzt=getSystick(); if (jetzt-anfang > 10000/58) {
-
Thread
Struct ins EEPROM schreiben
dem Verständnis der Funktion "eeprom_write_block" Folgendes - ich möchte eine Struktur welche 14bit groß ist (2 Byte) ins EEPROM schreiben in dieser Struktur stehen Zustandsmeldungen. Einzelne Bytes ins EEPROM schreiben hat bei mir funktioniert, aber ich glaube ich habe den Syntax noch nicht ganz
) ) // beide gleich 0? wenn dir das zu geschwätzig ist, dann mach dir eine Funktion dafür [C] uint8_t EqualBitValues( uint8_t Bit1, uint8_t Bit2 ) { return ( Bit1 && Bit2 ) || ( !Bit1 && !Bit2 ); } .... if( EqualBitValues( state.V_2, PORT_OUT & (1<<V2) ) ) .... [/C] Das
-
Thread
SPI Flash programmieren
bytes gesendet werden, wird der Interrupt ausgelöst und die Programmierung erfolgt anhand folgender abfrage: [c] SFlash_Init(); //---------------modified for ext. Flash------------------------------------------------- switch(bl_GetDeviceType(ulStart)) { case
Hier der Anhang mit dem *.py script für das Bit-File. Fazit: Der Done-Pin ist der Monitor das der FPGA Chip das Bit-Stream via ext. SPI-PROM akzepiert hat. (Bit-Stream-CRC). Du hast ja auch das Bit-File via Hilfe von Impact u.JTAG durch den
-
Thread
Codeschloss mit PIC [Assembler Code]
machst du in PIC-Assembler indem du beide zu vergleichenden Werte voneinander abziehst und dann das Z-Bit (Vergleich auf Übereinstimmung) oder das C-Flag (Vergleich ob größer oder kleiner) im STATUS-Register auswertest. Bsp. Test ob TasteA = TasteB ist: movfw TasteA subwf TasteB,w btfss
Ok, das hilft mir schon mal weiter also nach diesem Schema müsste ich ja dann Jede einzelne Zahl mit einer Vorgabe vergleichen also bsp.: Vorgabe = 12345 Tastatur abfrage Taste = A dann Tatste mit einem Register vergleichen indem 1 Steht Tastatur abfrage Taste = B dann Tatste
-
Thread
µC - UART - Linux
CREAD | CLOCAL | bits | parity | stopbits | baud; comm_params.c_lflag = 0; comm_params.c_line = 0; comm_params.c_cc[VMIN] = 1; comm_params.c_cc[VTIME] = 0;[/c] wie man sieht, ignoriere ich auch den alten Zustand
so nun folgendes szenario: µC: das erste bit jedes bytes ist jetz für framestart reserviert. also beim h-byte = 1 beim l-byte = 0 die linux app ist nun die angehängte. soweit leider keine änderungen. habe einen zähler eingebaut
-
Thread
Anfängerfrage: Temperaturgesteuerter Heizer
// bzw. umgekehrt gleichzeitig 8 Bit vom IC zu holen uint8_t w1_byte_rd( void ); // liest ein Byte vom DS1820 void w1_command( uint8_t command ); // übertragät ein Kommando zu IC Die Abfrage if( W1_IN & ( 1 << W1_PIN
durch 16 Lass doch den Mist, wenn du ihn nicht brauchst! Wozu soll denn das überhaupt gut sein? tC ist bei dir ein int8_t damit ist alles was du da an den oberen 8 Bit rumfmmelst sowieso für die Katz! Schreib Code so einfach wie du nur kannst (gilt auch für den Rest) [C] t =
-
Thread
Bosch Athlet 25,2 V Akku 7 Stück Tauschen
Programm für einen AVR mit LC Display gemacht. Die Schnittstelle zum Batteriecontroller ist langsames I²C (auch SMBus genannt) und man kann so die einzelnen Register abfragen. Ändern der Register ist eine andere Sache, aber auch eigentlich nicht nötig. Denn kein Batteriecontroller, der mir bisher untergekommen
BAT, 2); Serial.println("V"); // 5. Measure Individual Cells (Balancing OFF for accuracy) I2C_8Bit_writeToModule(0x10, 3, 0b00000001); I2C_8Bit_writeToModule(0x10, 4, 0b00000000); UCELLMIN = 5.0; UCELLMAX = 0.0; for (int x = 0; x < NUM_OF_CELLS; x++) { I2C_8Bit_writeToModule
-
Thread
Anfängerfrage: etwas machen wenn 2 ereignisse eingetreten sind
Pinnummer ) [/code] die musst du so wie sie ist erhalten. Denn die isoliert dir dieses eine bestimmte Bit aus dem irgendetwas. Und erst dann, wenn du dieses Bit hast, kannst du entscheiden und abfragen ob dieses Bit jetzt 0 oder nicht 0 sein soll.
einzelne Strichpunkt am Zeilenende vom if verändert die logische Struktur :-) wenn es dir mehr hilft, dann schreibs halt so [C] while( !(PINB & (1 << PINB0)) ) { // solange Endposition nicht erreicht
-
Thread
Wieviel SRAM braucht man für ein Fernsehbild
16bit sind auch RGB, glaub 5 bit rot, 6 bit grün und 5 blau. Wenn du das Bild mit'm uC auf den Fernseher bekommen willst, brauchst du garnet weitermachen, dafür ist der uC zu langsam. Du hast da auch gleich
auch mit dem Teil sehr sehr knapp. Rechne mal mit 20MSamples/sek, dann hast du 4 Takte in denen du 16bit raushauen musst. Wenn's ein 8bitter ist, hast du für 8bit grad mal 2 Takte. Wenn man es klug anstellt, kann man zwischen den einzelnen Bänken umschalten während der Strahl links/rechts außerhalb vom
-
Thread
Heizungssteuerung mittels I²C?
nur abfragen muss. (LM75 Fühler an einen PCF) 2. Einen weiteren µC der die Pumpen ansteuert (ca. 8stk. über Relais) 3. Eine seperate Einheit für die Uhr/Kalenderfktion 4. Einen EEPROM für das Speichern der
+ tastatur + eeprom und das noch die kalenderfktion. Ich müsste ja jeden Port der reihe nach abfragen ob da etwas passiert ist, oder nicht? Und bei einem µC wird das doch bischen viel. Oder denke ich da falsch?
-
Thread
AVR-GCC nutzt 16 Bit für uint8_t Variable
, dass ohne die if-Abfrage nur EIN Byte verwendet wird. Typecasts innerhalb der if-Abfrage haben bisher nicht zum erwünschten Ergebnis geführt. Hier mal der C-Code: [c]void onew_skip_rom ( void ) { uint8_t i;
i ist hier aber kein int sondern ein unsigned char. Das ist doch gerade das Problem! /int/ ist im C-Standard vorgesehen als Datentyp mit der "natürlichen Breite" des Systems. C ist aber für Systeme mit 16 Bit und mehr geschrieben, weshalb /int/ auch gleichzeitig mit "mindestens 16 Bit" definiert ist
-
Thread
Variablengröße 10-Bit-Integer gesucht
anstatt 2048 wenn man einfach ein uint16_t Array verwendet. Hier beispiel: [c]#include <stdio.h> #include <inttypes.h> int main() { uint32_t temp, var32; /*es werden hoestens 10bit verwendet*/ uint16_t a=342 , b=1023, c=987; /*3 10Bit a,b,c Variablen
|= temp; printf("a:%u b:%u c:%u\n", a, b, c); /*3 10Bit Variablen aus einer 32Bit Variable decodiern*/ temp = var32; temp = temp>>20; a = temp & 0x3ff; temp = var32; temp = temp>>10; b = temp
-
Thread
Kann man das besser schreiben?
Das hatte cih ja vor, aber muss ich dazu nicht das Arary bit für bit (bitweise) auslesen undann ausgeben? Das Schieberegister hat doch nur einen serielen Eingang. Oder meintest du das so: [c] uint8_t Led [32] = { Led[1] 1, Led[2] 0, . . . } [/c] ?
Wiechert schrieb im Beitrag #1813076: > Das hatte cih ja vor, aber muss ich dazu nicht das Arary bit für bit > (bitweise) auslesen undann ausgeben? Wozu? [C] for( i = 0; i < 32; ++i ) { if( Led[i] == 0 ) // LEd i soll nicht brennen ( 0 ausgeben ) else // Led
-
Thread
Baustein mit 8-Bit Register gesucht
ups keine Abfrage des Reset-Pins!?
8 Bit getaktetes Register : 74364 2 * 4 Bit Volladierer: 74283 Das hier mit einm µC zu lösen ist vergleichbar emit die 200m bis zum Bäcker mit dem Auto zu fahren. Es geht aber ........
-
Thread
AVRTiny13: Code verhält sich sonderbar
PB3)) || (PINB && (1 << PB4))) > { > if(PINB && (1 << PB3)) Ich denk diese beiden Abfragen machen auch nicht das, was du willst. Die If Bedingung ist immer dann war, wenn ein Bit (egal welches) in PINB 1 ist. Wenn du einen einzelnen Pin (ein Bit) in einem Byte testen willst, brauchst
mit Q2). > Wäre es besser die Abfrage dieser Taster mit Interrupts zu lösen? Nein. Taster an einem Interrupt sind mit einer Ausnahme meistens eine schlechte Idee. Die Ausnahme: Wenn der Taster den µC aus dem Tiefschlaf aufwecken
-
Thread
bitte um hilfe bei switch case aufbau
Für die Abfrage einzelner Bits ist switch/case nicht geeignet, da die Nachbarbits mit eingehen. Außerdem ist kein Mensch in der Lage, aus CPU-Sicht 2 Tasten gleichzeitig zu drücken (innerhalb 50ns) oder loszulassen
Du hast aber folgende situation: [c] if( x & (1<<0) ){ // ist bit 1 gesetzt? } if( x & ( (1<<1) | (1<<2) ) ){ // ist bit 2 oder bit 3 gesetzt? } [/c] Das kann man nicht mit switch case abbilden, denn es ist kein Vergleich ob ein
-
Thread
ADC Conversion
Wie machst Du einen 16-Bit Lese-Zugriff auf den I/O-Bereich? xyz=adc (oder adcw, musst mal in der Doku zu AVR-C nachschaun, ich mach' in ASM) ...
volatile' sein (weiß jetzt nicht, oder Compiler da meckert). Ansonsten wie gesagt: gib mal nur die einzelnen Bytes aus, kein 16-bit-Wort. Also ADCH und ADCL getrennt.
-
Thread
AVR-Bootloader mit Verschlüsselung
zb. für Ellipsen und Linien die in C intern mit 32Bit Variablen rechnen mussten. In Assembler konnte das aber so optimiert werden das zb. nur 24Bit Berechnungen nötig waren. Desweiteren gibt es verschiedene Funktionen die im Grunde sich
Password, first 32 bit used as Signature BootKey: .db $A7,$39,$C9,$AD,$A2,$D1,$1E,$F6,$45,$7F,$75,$7A,$6D,$4C,$21,$41 As I know, the GUI software generate password from that Boot key. am I right? If I'm wrong, what
-
Thread
Doppelklick abfragen - Welches ist die beste Strategie ?
verwendet werden). Um einen Taster ca. 20x am Tag abzufragen muss man ihn nicht knapp 52 mio. mal abfragen. da legt man den µC besser Schlafen. Immer die verhältnismäßigkeit der Mittel im Auge behalten! ;-)
Tastenentprellung verwendet werden kann? >am Tag abzufragen muss man ihn nicht knapp 52 mio. mal abfragen. da legt >man den µC besser Schlafen. Ok, in DIESEM Fall hast du wohl Recht. Aber wenn es um ein Gerät geht, welches ONLINE bedient wird mit LCD etc., ist die Timer Poll Methode IMHO die bessere
-
Thread
Arduino Blue Pill & CAN mit SN65HVD230
#7399501: > soweit hab ich es jetzt. Es funktioniert. Ich habe aber die Zuweisung > über den Befehl bitWrite bzw bitRead gemacht. Ich weiß nicht ob das ein > Arduino spezifischer Befehl ist. Ja, die (Makro-)Definition von bitWrite und bitRead finden sich in C:\Program Files (x86)\Arduino\hardware
Daten werden eingefüllt // mit bitwrite lassen sich einzelne bits innerhalb eines Bytes beschreiben. Hier Zustand TasterState in Erstes (ganz rechtes) Bit von Data0 schreiben bitWrite (CAN_TX_msg.data[0], 0, WeicheEinfahrtSBHSudGeradeausState);
-
Thread
3 Atmega8 mit Atmega32 verbinden
Kann man über die UART Schnittstelle mehr als 2 Controller verbinden? Wie lange dauert eine einzelne Datenübertragung bei UART bzw. I2C (was ist schneller)? Grüße
direkt, dazu müsstest du einen BUS ala RS485 realisieren. Die Frage ist auch, wie weit sind die 4 uC räumlich getrennt. >Wie lange dauert eine einzelne Datenübertragung bei UART bzw. I2C (was >ist schneller)? Schon mal die Datenblätter angeschaut? Ein UART läuft mit Standardfrequenzen mit
-
Thread
Würde gerne Assembler in C umschreiben, aber ich blick's net
für das Benutzerinterface verwenden. Kann man nicht in der Assemblerschleife eine Bedingung abfragen, die ich aus meinem C-Code heraus setzten könnte? Wenn eine globale Variable zu viel Registerwechsel bedeuten würde, könnte man dann nicht auch ein (unbenutztes) Pin abfragen?!?
Michael U. wrote: > mein Ansatz wäre: die main-Schleife unverändert irgendwie in C > reinbekommen (programmiere nicht in C, nur ASM. Ja. Das mit dem T-Bit ist völlig unnötig. Die Variablen für die Addition als Registervariablen definieren, dann kann sie ein Interrupt verändern
-
Thread
STM32F0 Discovery welche Library wird genutzt (HAL oder SPL)?
Datenblatt zu lesen und (wenn nötig) den Artikel [[Bitmanipulation]] und dann direkt mit den Registern des µC und den Bits darin zu arbeiten. Eine HAL im eigentlichen Sinn sind ja weder SPL noch das was ST neuerdings /HAL/ nennt. Denn abstrahiert wird da gar nichts [1]. Es ist auch nicht wirklich einfacher
Natürlich bekomme ich als ehem. ASM-Coder Krätze, wenn ich mir überlege, dass ich z.B. zum Setzen oder Abfragen eines Bits ein Unterprogramm aufrufe, welches teilweise auch noch relativ sinnfreie IF-Abfragen enthält. Neutral: - Keine echte HW-Abstraktion, man muss die Beschreibung der Funktionen und
-
Thread
12 bit Wert in Array aus uint8_t speichern
Aber soweit ich das sehe werden dort doch nur 8 bit genutzt, oder? Ich würde aber gerne schon die vollen 12 bit nutzen ;) http://www.mikrocontroller.net/topic/169509#1631439 Aber ich glaube ich habe mein if-Problem lösen können mit: [c] if(led
[c] // Blöcke 1, 3, 5, 7, ... [/c] Du hast für jedes Bit eine If-Abfrage? Schon mal was von Schleifen gehört?
-
Thread
Schlanker UART Bootloader für STM32F031c6
Hochsitz C. schrieb im Beitrag #7535442: [c]SYSCFG->CFGR1 &= ~SYSCFG_CFGR1_MEM_MODE_1; //Bit löschen SYSCFG->CFGR1 |= SYSCFG_CFGR1_MEM_MODE_0; //System Memory auf Adresse 0 remappen[/c] Das ist die Einstellung
Bauform B. schrieb im Beitrag #7536291: > Also wenn du diese Abfrage noch vor main() > einbaust: habe ich ja auch probiert, vor jeder Hardwareinitialisierung zu springen: https://github.com/stancecoke/Lishui9FET/blob/92edff1ca3bb2cc05348b4964c219251c542f4e0/Core
-
Thread
simpler µC ADC2UART
Hallo zusammen, ich suche einen µC mit folgenden Spezifikationen und wollte fragen, was ihr mir empfehlen würdet: -mindestens 10 ADC channels @>=12bit -mindestens 1 UART port -halbwegs anständige ADC quali (muss jetzt nich auf AD
wichtig ist die GARANTIERTE Reaktion im vorgegebenen Zeitraster. Ansonsten kenne ich keinen µC mit 10 parallel arbeitenden ADCs. Mir fallen da z.B. 10 MCP3201 (12 Bit) an einem Mega8 ein. Am µC erfordert das 2 Pins zum Ansteuern und 10 zum Auslesen. Und eine halbwegs autonom arbeitende USART
-
Thread
riesige Datenbank verwalten
2021-04-06T14:53:32.106Z", "garage": {"ms": 433935998, "sw": "lueftung06.ino, Aug 27 2020 16:01:22", "c0c": 28929, "c0f": 87.1, "c0n": "Zu", "c0t": 0.8, "c1c": 28929, "c1f": 61.5, "c1n": "Wa", "c1t": 15.1, "c2c": 28929, "c2f": 64.8, "c2n": "Ab", "c2t": 6.4, "c3c": 28929, "c3n": "Mi", "c3t": 14.8, "c4c"
lange wie möglich auch im RAM durchsuchen können. Und zusätzlich Statistiken führen, bei welcher Abfrage welche Organisations- und Suchmethode am effizientesten ist und entsprechend dynamisch den passenden Algo nehmen. Es macht nämlich einen großen Unterschied ob du einzelne Datensätze haben willst
-
Thread
Projekt : viele kleine zu einem groß Projekt, brauche Infos
um das so umzusetzen dann wohl eher die variante in > einer schleife immer wieder die slaves abfragen. Warum nennst du die dann cs Leitung? Sowas wie Interrupt Request wäre angebracht. Das ist nichts was etwas mit I2C zu tun hat sondern nur eine extra Leitung über die der Slave halt einen Interrupt
abfrageleitung" einplanen um pins zu sparen. naja halt per ISR > sobald daten zum abholen da sind sofort abfragen und dann weiter im > code. Hast du dir schon Gedanken über die Datenmenge gemacht die du hin und her schieben möchtest/musst? I2C ist nicht sooo schnell.
-
Thread
anfänger bei assembler
Hallo, der Befehl "in" lädt ein ganzes Byte auf einmal, es ist also nicht möglich nur ein einzelnes Bit zu laden. Die Idee mit der Bitmaske ist hier schon richtig. Zusätzliche Informationen zu den einzelnen ASM Befehlen von Atmel findest du im Instruction Set http://www.atmel.com/images/doc0856
weiter: >andi temp1 , 0b00000010 ;testen ob PB1 gedrückt wurde Mit dem ersten 'andi' löschst du Bit 1. Also kann es bei der zweiten Abfrage nie 1 sein. MfG Spess
-
Thread
mehrere MC seriell über Datenbus verbinden (1Draht)
Block zu betrachten. Wenn etwas nicht funktioniert, mußt Du debuggen. Dazu muß man das Programm in einzelne Teile zerlegen und diese testen. Z.B. beide Datenrichtungen getrennt testen. Auch kann man erstmal kritische Timings runter setzen. Die Routine (slave1a.c) mit nur einem Compareregister ist durch
// enable tx interrupt volatil(tx_idx) = 0; // point to first bit volatil(tx_buff[0]) = addr; volatil(tx_buff[1]) = data; while( DATA_INT ); // until tx done } [/c] führt zum "Erfolg" im Anhang. Ausgesendet soll zweimal
-
Thread
Befehlsschnittstelle erstellen
Lösung nicht vorenthalten. Da ich ohnehin einen Parser implementieren musste, ist der Schritt zum Abfragen der nötigen Parameterlänge für einen Befehl nicht mehr soo gross. PSEUDOCODE [c] /* Struktur für einen Tabelleneintag in der Lookup-Tabelle ==> Befehl */ struct CommandEntry { char CB1
. union betrifft.. [c] #define SL_UINT8 unsigned char /* unsigned 8 Bit */ typedef union /* 8/16 bit IO conversion union */ { SL_UINT16 uint16; /* unsigned 16-bit int */ SL_SINT16 sint16; /* signed
-
Thread
Game of Life in C für µC
mit Index (hab leider damit noch nie was damit gemacht) oder Ähnlichem löse, denn ich will ja die Abfrage nicht für jedes Matrix das von Hand programmieren sondern es sollja mit Variabeln oder Indexen gehen. Ich weiss nur noch nicht wie ich das in C (für PIC) realisieren soll. Am liebsten wäre mir
eine Frage der geschickten Umsetzung.. :-) > eine zelle kann entweder leben, oder tot sein, also 1bit pro zelle. Jaschon, aber ein einzelnes Bit kann man auch hervorragend in einen int verpacken, so wie einer der Vorposter das gemacht hat ..oder war das der Code, den Tante Gugl ausgespuckt hat? Egal
-
Thread
Programmoptimierung
hat jedes Bit einen Namen. Mit der 1 << Bitname Syntax arbeiten! [C] hilf_low_flow = ADCL; adcwert_flow = (ADCH << 8); adcwert_flow |= hilf_low_flow; [/C] Dein Compiler weiß schon wie man 16 Bit Register
denn das ist es doch was dich interessiert: ist der Wert im erlaubten *Bereich* oder nicht. [C] flowwert_in_range = ( flowwert > FLOW_MINIMUM && flowwert < FLOW_MAXIMUM ); [/C] und dann lesen sich deine Abfragen zb so [C] if( flowwert_in_range ) mach was if( !flowwert_in_range
-
Thread
ADC mit Bascom 8bit ?
ADCL und ADCH, ferner auch noch DIDR0. Das sind nämlich die Schnittstellen zum ADC, in denen einzelne Bits bestimmte Schalterwirkung haben, andere Bitgruppen Zahlen repräsentieren. Um das zu verstehen, brauchst Du kein ASM zu lernen (obwohl das keinesfalls schaden würde), sondern nur im Datenblatt
Ich nutze zu solchen Zwecken meist die Variable "merker" vom Typ Byte und benenne (mit Alias) die Bits einzeln zu Merkern. Der ADC wird also nach jeder Messung in den Interrupt verzweigen, den Messwert sichern, den Index erhöhen und begrenzen, auf die neue Messquelle umschalten und den ADC wieder
-
Thread
[AVR-ATmega8] LCD-Menü mit 2 Tastern
lcd_gotoxy(0,1); lcd_puts_p(test); while(1); } } return 0; } [/c]
dir jetzt erst mal von hier http://www.mikrocontroller.net/articles/Entprellung#Komfortroutine_.28C_f.C3.BCr_AVR.29 die Routinen für die Tastenbehandlung und bringst die zum laufen. Dein Programm könnte zb so aussehen [C] lcd_put_choice_p( uint8_t row, const char* text ) { lcd_gotoxy(