-
Thread
DIY Frequency Counter mit 10 bis 12 Digits?
Das mag bei Addition und Subtraktion so sein aber bestimmt nicht bei einer Multiplikation / Division. 8 x 8 Multiplikation ist ein Befehl 16 x 16 Multiplikation sind 4 x 8Bit Multiplikation Lo1 x Lo2, Lo1 x Hi2,Lo2 x Hi1 , Hi1 x Hi2 32 x 32 Multiplikation sind dann schon 16 x 8 Bit Multiplikationen
Das mag bei Addition und Subtraktion so sein aber bestimmt nicht bei > einer Multiplikation / Division. Gut. Bei DADD und DSUB sind wir uns schon mal einig. Bei DMUL und DDIV gehe ich davon aus, daß diese ohne Hardwaremultiplizierer des µC per Schiebeoperationen berechnet werden. Wenn ein µC MUL
-
Thread
STM32F4: Datenübertragung extrem langsam
/int/ - Ausdruck, der ist konstant 0. Wolltest Du 0.001 erzeugen, müsstest Du eine /float/ -Division durchführen, also "wait_nms(10.0 / 1000.0)" verwenden. Auch wenn das 'ne Konstante ist: Keine gute Idee. Benenne die Funktion um in wait_microsec() und übergebe ihr einen int, also hier 10.
Dies ist meine Wartefunktion in ms (10/1000) = 0,001 ms. Wenn (und falls) ich annehme, dass die Division, egal aus welchem Zahlenbereich Dividend und Divisor kommen, eine reale Zahl oder auch rationale Zahl ergeben, dann stimmt das im Bereich der Mathematik. Allerdings stimmt das auch in C nicht grundsätzlich
-
Thread
Wie Hilbert-Transformator berechnen
in reversed order! for( n = 0; n < num_taps; n++ ) { if( n == k2 ) { // avoid division by zero b[cix] = 0.0; } else { arg = (n - k2) * M_PI; b[cix] = (1.0 - cos( arg )) / arg; } cix--; } fdata->a_coeff = 0;
zusammenbleibt. > > bi = (1-cos(i-(k/2)π))/(i-(k/2))π Ja was denn nun? Normalerweise sind Division und Multiplikation gleichberechtigt. Da fragt man sich, wie du das mit dem schlußendlichen PI meinst. Soll das so gerechnet werden, wie du es darstellst oder soll es mit in den Nenner? W.S.
-
Thread
Variable nur jeden x-ten Schritt weiterzählen
Mit der Modulo-Operation (%, Division mit Rest) geht das: https://de.wikipedia.org/wiki/Division_mit_Rest Für jeden zweiten Schritt prüfst du ob dein Schleifenzähler i%2=0 ergibt.... denn wenn i durch zwei teilbar ist (und das ist
-
Thread
Datenbank Korrekt?
verkehrt einzufuellen. Adresszusaetze : Supercampus of Hainan University, Hainan, China, Division Supertech, Superlab 2134, Floor 123, .. Hainan University, Hainan, China Hainan, China Da war dann nichts mit 80 Zeichen fuer irgendwas. Wenn man nichts senden muss, am besten ein Textfeld fuer
-
Thread
Cortex-M4 double Berechnungen
Die Division dauert am längsten. Insgesamt bleiben die Grunrechenarten unter 1 µs: https://www.mikrocontroller.net/topic/342688#3779925
-
Thread
ATMega168 @ 20Mhz ADC dauert zu lange DCC NMRA
= U/R) Was willst Du mit dieser elendig langen Rechenorgie, noch dazu mit 2 schnarchlahmen Divisionen. Du willst doch bestimmt nur auf einen Schwellwert vergleichen. Da kann man ganz einfach die Schwelle einmalig in ADC-Schritte umrechnen und erreicht genau das gleiche, bloß 1000-mal schneller
>Was willst Du mit dieser elendig langen Rechenorgie, noch dazu mit 2 >schnarchlahmen Divisionen. geteilt durch 2^10 wird doch bestimmt durch ein shift ersetzt... GRuß J
-
Thread
STM32f4 Timer Overflow Problem
hICtim.Init.CounterMode = TIM_COUNTERMODE_UP; pThis->hICtim.Init.Period = 0xFFFF; pThis->hICtim.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; pThis->hICtim.Init.RepetitionCounter = 0; HAL_TIM_Base_Init(&pThis->hICtim); sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL; HAL_TIM_ConfigClockSource
-
Thread
Laser mit 1MHz modulierbar Poptisch >=1mW (möglichst preisgünstig) gesucht für Entfernungsmessung
können wir aber schon auseinanderhalten?! Mischung ist Subtraktion der Frequenzen, keine Division. Die Phasenbeziehungen bleiben m.W. tatsächlich erhalten.
-
Thread
Software von ST
dennoch strotzt der erzeugte Code nur so von printf-Geraffel und zwei Dutzend verschiedenen Integer-Divisions und Multiplikationsroutinen in allen Varianten, signed und unsigned, lang und kurz und wahrscheinlich ist auch noch ne halbe Tonne float mit drin, ich musste relativ schnell meinen Blick abwenden
strotzt der erzeugte Code nur so von printf-Geraffel und zwei > Dutzend verschiedenen Integer-Divisions und Multiplikationsroutinen in > allen Varianten, signed und unsigned, lang und kurz und wahrscheinlich > ist auch noch ne halbe Tonne float mit drin OMG.. ja, da hat man in der Tat keine Fragen
-
Thread
Manual für HP1615a Logic Analyzer
Birth_of_la.pdf (Seite 27 ein Foto des 1610a) "George Haag, from the California Data Terminals division, led the flagship HP 1610A (Figure 3a) development, a high, wide, and handsome $10,000 state machine." http://www.hpl.hp.com/hpjournal/pdfs/IssuePDFs/1979-10.pdf Seite 18 ebenfalls ein Foto von
-
Thread
Spannungsreferenz justieren
exakt 1mV. Bei 11Bit, 15bit, 16bit bleibt es immer noch beim simplen shiften. Ohne Multiplikation, Division oder sontigen aufwändigen (mit Fehlern behafteten) Rechenschritten. Drum ist 4096mV auch eine sehr schöne Referenzspannung, insbesondere wenn man die früher üblichen 5V Versorgung bedenkt. Und
-
Thread
Pascal und Ada für AVR
nichts gequetscht. Krass Berny Wikkipedia (Cobol) [code] Identification Division. Program-ID. HALLOPGM. Procedure Division. Display "Hallo Welt!" STOP RUN. [/code] Der Zielcode des Cobol-Compilersist nicht länger, als der entsprechende
-
Thread
Atmega88 mit 100kHz
langsam > schalten. Ach, das wusste ich gar nicht. Danke für den Hinweis! Dann ist ein Clock Division Factor von 1, 2, 4, 8, 16, 32, 64, 128 und 256 möglich... gut zu wissen. Damit käme man z.B. auf 125kHz.
-
Thread
STM32F4 Timer OVF Fehler
0xFFFF; TIM_TimeBaseStructure.TIM_Prescaler = 0; TIM_TimeBaseStructure.TIM_ClockDivision = 0; TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseStructure.TIM_RepetitionCounter = 0; TIM_TimeBaseInit(TIM1, &TIM_TimeBaseStructure); NVIC_InitStructure.NVIC_IRQChannel
-
Thread
Division mit "krummen" 10
und a=b<<1 erzeugt der Compiler exakt den selben Bytecode. Bestimmt _nicht_. Ersteres ist eine Division, letzteres eine Plutimikation ;-)
noch schlechter ist, als die Division.
-
Thread
Timer Interrupt STM32F103
TIM_CounterMode_Up; timerInitStructure.TIM_Period = 500; timerInitStructure.TIM_ClockDivision = TIM_CKD_DIV1; timerInitStructure.TIM_RepetitionCounter = 0; TIM_TimeBaseInit(TIM2, &timerInitStructure); TIM_Cmd(TIM2, ENABLE); TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE); }
TIM_CounterMode_Up; timerInitStructure.TIM_Period = 500; timerInitStructure.TIM_ClockDivision = TIM_CKD_DIV1; timerInitStructure.TIM_RepetitionCounter = 0; TIM_TimeBaseInit(TIM2, &timerInitStructure); TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE); TIM_ClearITPendingBit(TIM2, TIM_IT_Update
-
Thread
DCF und Mondphase
Gauss ist etwas mehr, als das kleine 1 x 1... Mal sehen, ob ich noch Platz für passende Divisions-Routinen habe. > Wetter-Bits Habe ich nicht zur Verfügung.
die (e)patta auf Deutsch nennt. Wenn man sich z.b merkt, 2014 ist epatta 29 braucht man weder Division geschweige denn Fliesskomma.
-
Thread
STM32F437: TIM3 CH3 PWM
ARR-Register kommt. Der Timer zählt dann von 0 bis ARR (inklusive), d.h. ein Wert von 10 entspricht einer Division durch (ARR+1) = 11; 84MHz/11 = 7.64MHz
> Der > Timer zählt dann von 0 bis ARR (inklusive), d.h. ein Wert von 10 > entspricht einer Division durch (ARR+1) = 11; 84MHz/11 = 7.64MHz Das war auch die Intension meines Beitrages: steht exakt so im RefMan :-) Der junge Mann wird aber nie selbst Debuggen lernen, wenn ihm die Lösung so auf
-
Thread
for(;;) bedeutung?
einlesen und diese weiter verarbeiten. Dabei wird mit diesen Werten gerechnet und u.a. auch eine Division durch geführt. Dumm bloß wenn dabei ein Wert zufällig 0 ist oder noch blööder bei der Berechnung ergibt sich ein Wert der 0 ist und mit dem muß weiter gerechnet werden. Man könnte das z.B. mit if
einlesen und diese weiter > verarbeiten. Dabei wird mit diesen Werten gerechnet und u.a. auch eine > Division durch geführt. Also komm, wenn ein Algorithmus Divisionen mit Meßwerten macht, dann ist es vollkommen offensichtlich, daß man sich Gedanken machen muß, was bei null herauskommt - und sei es, daß
-
Thread
STM32 Phasenverschobene Sinuswellen
}; [/C] Berechnung der 3 Stellen fuer den 120 Grad Versatz. "zaehl" wird laufend erhöht. Die Division durch 16 macht eine feinere Frequenzeinstellung möglich. [c] arg0 = (zaehl / 16 + 0) % 156; arg1 = (zaehl / 16 + 52) % 156; arg2 = (zaehl / 16 + 104) % 156; [/C] Der Tabellenzugriff
-
Thread
ADC-Wert auf 4 7-Segmentanzeigen darstellen ohne viel Rechenleistung
OK, dann war der Gedanke halt falsch und ich mach es halt doch mit Division. Wollte ja nur wissen, ob es eine bessere Lösung gibt.
operator is actually three operators in one (- * /). Thus effectively I have eliminated three divisions and so I expected a significant improvement in speed. [/pre] Modulo liefert den Rest, der bei einer Division ohnehin anfällt. Der Aufwand für Division (/) und Modulo (%) ist also normalerweise
-
Thread
negativen Wert v. Poti zu positiven Wert umkehren
funktioniert oder nicht. Nur um einen Betragswert zu bilden dürfte eine Multiplikation und eine Division auf einem kleinen µC der das nicht in Hardware kann so ziemlich das langsamste sein, was man machen kann. Ausserdem muss deine Variable durch die Multiplikation mindestens die doppelte Länge haben
-
Thread
Analoger Dividierer (Single Supply bis 7V)
eines OP. Das hat aber um Null herum das Problem, dass die Verstärkung gegen unendlich wandert (Division durch Null). Es gibt einen kompatiblen Ersatz für den MLT-04 von Analog Devices, der nicht mehr produziert wird: https://www.ichaus.de/product/iC-BM der läuft mit +/-5V, ebenso der AD835.
-
Thread
STM32F103 ADC per Timer triggern (SPL)
TIM_TimeBase_InitStructure.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBase_InitStructure.TIM_ClockDivision = TIM_CKD_DIV1; TIM_TimeBase_InitStructure.TIM_Prescaler = 32; TIM_TimeBase_InitStructure.TIM_Period = 1023; TIM_TimeBaseInit(TIM1, &TIM_TimeBase_InitStructure);
-
Thread
Programmiersprachenempfehlung
praktischen Gründe dafür, den Divisionsoperator (/) nur für die gewöhnliche Division (also mit gebrochenem Ergebnis) zu verwenden und für die ganzzahlige Division einen neuen Operator (//) zu definieren. Wenn es dich stört, dass bei der
wiederholte Multiplikationen (deswegen ein doppeltes * als Symbol), aber Wurzeln keine wiederholten Divisionen. >> Für die gewöhnliche Division gilt die Beziehung >> >> (a / b) · b = a >> >> für die ganzzahlige Division i.Allg. nicht. > > Für float aber auch nicht immer. Es muss gerundet werden
-
Thread
Nötige Takte für Codeabschnitt herausfinden
möglichst effizient zu schreiben. Mein Ringpuffer hat den Wraparound 255++ = 0 ausgenutzt, alle Divisionen waren Shifts (FIR in Matlab entsprechend konstruiert) usw. Und dann hab ich tatsächlich im Datenblatt geguckt welche Operationen wie lange dauern. Das steht da ja drin, man muss nur die Wertebereiche
-
Thread
STM32F303 USART in Kombination mit Timer+ADC+DMA der 2te
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_CenterAligned1; TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; TIM_TimeBaseStructure.TIM_RepetitionCounter = 0; TIM_TimeBaseInit(TIM1, &TIM_TimeBaseStructure); TIM_ITConfig(TIM1, TIM_IT_Update, ENABLE); TIM_OCStructInit(&TIM_OCInitStructure
-
Thread
Digitaler PID Regler frage zur Formel
Ta++; delay_m(1); } else { Ta = 1; // Damit keine Division durch 0 entsteht. } esum = esum + e; //Integration I-Anteil y = Kp*e + Ki*Ta*esum + Kd/Ta*(e – ealt); //Reglergleichung ealt = e; } Bitte den code nicht auf Syntax prüfen
-
Thread
Elektronische Last - Mosfet Treiber brennt durch
neue Elektronische Last mit einer rein anlogen Leistungsbegrenzung versehen. Mit AD633 in Divisionsschaltung. Funktioniert perfekt! Habe ich auf meiner HP (www.hcp-hofbauer.de) beschrieben. Nicht über die teilweise etwas seltsame Schaltung wundern, ich wollte nur solche Halbleiter verwenden, die
-
Thread
STM32F7 HAL DMA Interrupt Problem
htim.Init.Period = Period; htim.Init.Prescaler = Prescaler; htim.Init.ClockDivision = TIM_CLOCKDIVISION_DIV4; htim.Init.CounterMode = TIM_COUNTERMODE_UP; htim.Init.RepetitionCounter = 0x0; if (HAL_TIM_Base_Init(&htim) != HAL_OK) { /* Timer initialization