-
Thread
CRC Berechnung Codewort
Thema CRC angesehen: http://www.mikrocontroller.net/articles/CRC Dort wird der Rest aus der Division von 111010011100100000:100110 berechnet. Dieser ist laut dem Artikel 100 (alles in Binärdarstellung). In C lässt sich der Rest einer Division ja wunderbar mit dem Modulo-Operator berechnen. Wenn ich
Dezimalzahlen entspricht 111010011100100000 = 239.392 und 100110 = 38 und tatsächlich ist das Ergebnis der Division von 239.392:38 = 6299 Rest 30. Und 30 entspricht der Binärzahl 11110 und nicht 100. Kann mir mal bitte Jemand sagen, warum der Modulo-Operator hier nicht funktioniert oder wo mein Fehler liegt?
-
Thread
AVR -> STM8/32. Was ist anders? Was zu beachten? Was benötigt? Gesperrt
Pointer-Operationen, Shifts um variable Bit-Zahlen, Stack-Zugriffe, je nach Modell auch Arithmetik (Division, Floating-Point)).
lassen, alle nase lang vor. Klar, man kann skalieren und dann mit int64 rechnen (viel Spaß bei Divisionen..), aber weitaus angenehmer als derartige Workarounds ist es eben, gleich in double zu rechnen. Aber da wir hier in einem Bastelforum sind: Denk mal an DDS-Berechnung für die diversen DDS von
-
Thread
Einheitenumrechnung
> Gilt für Potenzen auch. > > Ergo: m^-3 = 1/(m^3) Wie man von der Rechenregel für die Division durch einen Bruch auf die Rechenregel für Potenzen mit negativem Exponenten kommt, solltest du vielleicht etwas näher erläutern. Ich kann es jedenfalls nicht ganz nachvollziehen. > Arbeit =
-
Thread
Es gibt noch immer Entwickler-Jobs in Hochlohnländern. Wieso?
etliche Showstopper eingeschlichen, und damit meine ich nicht die vergleichsweise triviale Pentium-Division. Sondern echte Designfehler, wie beim K6 der ersten Generation. Und kaum hatte Intel eine schöne und wichtige neue Befehlssatzerweiterung rausgebracht (Haswell TSX), musste die auch sogleich wieder
-
Thread
STM32F4xxx - FPU - GCC Codegenerierung
@ 168 MHz bei > doppelter Genauigkeit. Das kann ich kaum glauben, zumindest nicht für die Division. Beweise?
168 MHz bei >> doppelter Genauigkeit. > > Das kann ich kaum glauben, zumindest nicht für die Division. Beweise? Hab grad keinen F4-Aufbau auf dem Tisch liegen, deswegen kann ich's Dir nicht rausmessen, aber wenn jemand grad Zeit hat: https://www.mikrocontroller.net/topic/261021
-
Thread
Einstieg in STM32 : STM32F103C8T6 --> Kompilieren und Flashen?
die diversen Bibliotheksfunktionen aus den zuständigen Bibliotheken mit dazulinkt (z.B. Integer-Division, double-Addition, und sonstigen Kram, den nur der Compiler kennt und benutzt). Dazu muß der Linker auch wissen, für welche Zielplattform das Ganze gut sein soll, damit er die richtige Laufzeit-Bibliothek
-
Thread
Register reservieren in avr-gcc
übersetzter Code in meinem Programm landen könnte? Ja, die Libraries des Compilers. Wenn du z.B. den Divisions- oder Modulo-Operator verwendest, landen dafür Funktionen aus diesen Libraries in deinem Code (außer natürlich es lässt sich zu was anderem optimieren, wie Shiften). Oder auch (noch weniger offensichtlich
-
Thread
PWM Signal mit STM32
TIM_CounterMode_Up; timerInitStructure.TIM_Period = period; timerInitStructure.TIM_ClockDivision = TIM_CKD_DIV1; //timerInitStructure.TIM_RepetitionCounter = 0; TIM_TimeBaseInit(TIM2, &timerInitStructure); TIM_Cmd(TIM2, ENABLE); } void InitializePWMChannel() { TIM_OCInitTypeDef
-
Thread
STM32: interne Pull-Ups für SPI
0; htim4.Init.CounterMode = TIM_COUNTERMODE_UP; htim4.Init.Period = 0; htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; sConfig.EncoderMode = TIM_ENCODERMODE_TI1; sConfig.IC1Polarity = TIM_ICPOLARITY_RISING; sConfig.IC1Selection = TIM_ICSELECTION_DIRECTTI; sConfig.IC1Prescaler
htim12.Init.CounterMode = TIM_COUNTERMODE_UP; htim12.Init.Period = 0; htim12.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; if (HAL_TIM_PWM_Init(&htim12) != HAL_OK) { Error_Handler(); } if (HAL_TIM_OnePulse_Init(&htim12, TIM_OPMODE_SINGLE) != HAL_OK) { Error_Handler(
-
Thread
Aktuelle FPGAs in QFP
dann aber keinen Support, wenn man nicht genau das gleiche Host OS fährt. Nunja. Die Software-Division sollte vielleicht auch mal zum Docker-Konzept wechseln, was Auslieferung von Tools angeht. > War vor allem lange Zeit ein Problem als JTAG-Downloadkabel nur über > einen Windriver basierten Treiber
-
Thread
Problem Timer1 überlauf
eines Vorteilers: Zeit = Quarz / Vorteiler / Timer Code ausführen benötigt Zeit, insbesondere Division und Float. Da Du keinerlei Angaben machst, kann man nur vermuten. Wenn der Timer alle 10µs überlaufen soll, wirst Du dazwischen kaum Berechnungen machen können. Du mußt die Zeit so lang wählen,
-
Thread
QTouch SAMD20E17
system_gclk_gen_get_config_defaults(&gclk_conf); gclk_conf.source_clock = SYSTEM_CLOCK_SOURCE_OSC48M; gclk_conf.division_factor = 1; //Pre-scaler gclk_conf.run_in_standby = false; gclk_conf.output_enable = false; system_gclk_gen_set_config(GCLK_GENERATOR_0, &gclk_conf); system_gclk_gen_enable(GCLK_GENERATOR
system_gclk_gen_get_config_defaults(&gclk_conf); gclk_conf.source_clock = SYSTEM_CLOCK_SOURCE_OSC48M; gclk_conf.division_factor = 12; //Pre-scaler gclk_conf.run_in_standby = true; gclk_conf.output_enable = false; system_gclk_gen_set_config(GCLK_GENERATOR_1, &gclk_conf); system_gclk_gen_enable(GCLK_GENERATOR
-
Thread
C: Werte aus Array mit 3.3 multiplizieren?
Fließkommazahl umwandeln müssen. Eventuell reicht aber auch Multiplikation mit 33 und anschließende Division durch 10. Beachte aber mögliche Überläufe und Rundungsfehler. > Dafür habe ich den Wert aus dem Array zunächst in einer extra Variable > "sp" gespeichert. [c] uint8_t buffer[2]; uint16
-
Thread
eigene pow - Funktion
Variable? Das wäre doch exp((a/20) * ln(10)) ln(10) ist eine Konstante, bleibt also nur die Division von a durch 20 und die Anwendung von exp(). Also brauchst Du nur eine Taylor-Approximation von exp().
-
Thread
Variabler Clockdivider in Verilog
Simulation funktioniert. Wenn ich es aber auf den FPGA spiele bekommt der Divider immer 0 als Divisionswert. Hat jemand eine Idee was ich da falsch mache?
-
Thread
Probleme mit Timer Prescaler und OC beim STM32F103
TIM_CounterMode_Up; TIM_TimeBase_InitStructure.TIM_Period = 1023; TIM_TimeBase_InitStructure.TIM_ClockDivision = TIM_CKD_DIV1; TIM_TimeBaseInit(TIM2, &TIM_TimeBase_InitStructure); //TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE); TIM_OC_InitStructure.TIM_OCMode = TIM_OCMode_Toggle; TIM_OC_InitStructure.TIM_OCIdleState
-
Thread
STM32F103C Systemtakt Einstellung Hilfe
{/* PREDIV1 selected as PLL clock entry */ /* Get PREDIV1 clock source and division factor */ prediv1source = RCC->CFGR2 & RCC_CFGR2_PREDIV1SRC; prediv1factor = (RCC->CFGR2 & RCC_CFGR2_PREDIV1) + 1; if (prediv1source == 0) {
{/* PLL2 clock selected as PREDIV1 clock entry */ /* Get PREDIV2 division factor and PLL2 multiplication factor */ prediv2factor = ((RCC->CFGR2 & RCC_CFGR2_PREDIV2) >> 4) + 1; pll2mull = ((RCC->CFGR2 & RCC_CFGR2_PLL2MUL) >> 8 ) + 2; SystemCoreClock
-
Thread
STM32F4 PWM Problem
TIM_CounterMode_Up; TIM_TimeBaseStructure.TIM_Period = 4200 - 1; TIM_TimeBaseStructure.TIM_ClockDivision = 0; TIM_TimeBaseStructure.TIM_RepetitionCounter = 0; TIM_TimeBaseInit(TIM1, &TIM_TimeBaseStructure); /* Channel 1, 2 and 3 Configuration in PWM mode */ TIM_OCInitStructure.TIM_OCMode
-
Thread
Digitalen Filter aus Matlab in µC umsetzen
Koeffizienten verdoppeln - Koeffizienten auf die am nächsten liegende Zweierpotenz runden, ebenso den Divisionsfaktor zur Dezimierung am Ende - Das ganze nochmal zur Überprüfung durch Matlab schicken - In C Implementieren, Compiler setzt Multiplikationen und Divisionen in Shift-Operationen um. Auf die Weise
>- In C Implementieren, Compiler setzt Multiplikationen und Divisionen in >Shift-Operationen um. Wenn 2er Potenzen. Man kann auch skalieren und nur mit integer werten rechnen, find das paper allerdings nciht mehr. Gruß J
-
Thread
Befehl in C (Bitmanipulation)
"adr" wird um 8 Bits nach rechts geshifted, was gleichbedeutend ist mit einer Division durch 256. Das Resultat wird mit der Konstanten 1 verANDet. Und das Resultat davon wiederum wird nach "unsigned char" gecastet und dann etwas namens "DEECON" zugewiesen. Aufgrund der verANDung
-
Thread
Division eines Floatwertes mit sich selbst ergibt nicht 1
implizit in "int" gecasted, so dass dort der Wert 33381 steht. Das Gleiche nach der anschließenden Division, zunächst ergibt sich hier (33381 / 130.9 = 254.9). Dieses Ergebnis wird aber wiederum implizit in Integer gecasted, daher ergibt sich 254.
ne das steht in dem Betreff: Division eines Floatwertes mit sich selbst ergibt nicht 1
-
Thread
Programmgeschwindigkeit Arduino
paar hundert ms aktualisieren, siehe [[Interrupt]]. 4.) Aufwändige mathematische Operationen wie Division und Wurzel möglichst vermeiden. Eine Division kann man durch rechtschieben ersetzen, wenn man den Divisor als 2er Potenz auslegt, also 2, 4, 8, 16 etc. Die Wurzel kann man über eine Tabelle "ausrechnen
void ADC_Init(void) { ADMUX =((1<<REFS0) | (1<<REFS1)); // ref 2,5V //Free Running Mode, Division Factor 128, Interrupt on ADCSRA=(1<<ADEN)|(1<<ADSC)|(1<<ADATE)|(1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0)|(1<<ADIE); } ISR (ADC_vect) { ANALOG_OFF; //ADC OFF static unsigned char start=0; if
-
Thread
Horizon EDA [War: Neues, halbfertiges Elektronik-CAD-Programm]
sich jemand beim Umrechenen mm vs. inch und retour vertan hat. Sei es das er Multiplikation mit Division verwechselt hat, oder aber einen falschen Faktor verwendet hat, oder als Längeneinheit preußische Lachter verwendet hat. Mit freundlichem Gruß: Bernd wiebus alias dl1eic http://www.l02.de
-
Thread
Eingabe und Berechnung mit Modulo
noch ein wichtiger Zusammenhang. "+" Addition, "-" Subtraktion, "*" Multiplikation und "/" Division sind bekannt. "%" Modulo auch, aber wie ist der Modulo über die anderen Rechenoperatoren definierbar ?
ziffernweise von Hinten nach Vorne: nextchar2: Zeichen=Zahl%10 (Modulo) Zahl=Zahl/10 (Integer-Division) Ausgabe Zeichen (als ASCII +$30 ... oder auch "0") Ist Zahl>0 ? goto nextchar2 MfG
-
Thread
Stm32F4 Timer
Hab ich: TIM_TimeBaseInitStructure.TIM_ClockDivision = TIM_CKD_DIV4; //42MHz 100000 passen ja nicht in den vorteiler. mein Problem ist wie ich das berechne das ich auf 10Sekunden komme komme, das hatte ich gefragt.
ich dann den Timerclock auf 42Mhz habe das war falsch. TIM_TimeBaseInitStructure.TIM_ClockDivision = TIM_CKD_DIV4 Aber wozu ist diese Einstellung daran hapere ich noch . könnte mir das jemand kurz erklãren. danke
-
Thread
STM32F1 Brushless Motor Steuerung
TIM_TimeBaseStructure.TIM_Period = TimerPeriod; //2800 - 1; TIM_TimeBaseStructure.TIM_ClockDivision = 0; TIM_TimeBaseStructure.TIM_RepetitionCounter = 0; TIM_TimeBaseInit(TIM1, &TIM_TimeBaseStructure); TIM_UpdateRequestConfig(TIM1, TIM_UpdateSource_Global); TIM_UpdateDisableConfig
TIM_TimeBaseStructure.TIM_Period = TimerPeriod; //2800 - 1; TIM_TimeBaseStructure.TIM_ClockDivision = 0; TIM_TimeBaseStructure.TIM_RepetitionCounter = 0; TIM_TimeBaseInit(TIM1, &TIM_TimeBaseStructure); /* Channel 1, 2 and 3 Configuration in PWM mode */ TIM_OCInitStructure.TIM_OCMode
-
Thread
Arduino - Speicheroptimierung?
8bit-Ints gebraucht werden. Außerdem ist die Basis auch noch variabel. Also wohl mit Modulo und Division und dann auch noch in 16bit. Daher könnte man ein LEDtoa() selber implementieren, das sollte auch die Flash-Ersparnis wieder raufschrauben. also itoa(LED_num, str_req+STR_REQ_LED_NUM_POS, 10
daran ist, daß auf dem AVR zwar die nette Funktion div existiert, die einem Quotient und Rest einer Division auf einen Schlag liefert, blöderweise aber für 16bit-ints. Also richtig zu Fuß und dann auch ohne Division und Modulo, das müßte auch auf einem 8-bitter zügig gehen. 8-bit-Hacking, yeah. :-)
-
Thread
STM32F3 Timer Interrupt hängt
TIM2Init; TIM2Init.TIM_Prescaler = 10; TIM2Init.TIM_Period = 2000; TIM2Init.TIM_ClockDivision = TIM_CKD_DIV1; TIM2Init.TIM_CounterMode = TIM_CounterMode_Up; TIM2Init.TIM_RepetitionCounter = 1; TIM_TimeBaseInit(TIM2, &TIM2Init); TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE
-
Thread
Arduino Nano vs UNO , Spannungsteiler, Werte ungenau
für einen Analogrechner. Keinesfalls ist ist ein solcher Analogrechner ungenau. Jede digitale Division trägt das Potential in sich viel ungenauer zu sein.
-
Thread
Modulo von großer Zahl
der Zahl zu operieren Das lernt halt heute keiner mehr, aber man kann ja nach schriftlicher Division googeln, so schwer zu begreifen ist das nicht. Georg
-
Thread
Lineare Beschleunigung schrittmotor in bestimmter Zeit
in 1 fast multiply loop: https://en.wikipedia.org/wiki/Division_algorithm#Newton.E2.80.93Raphson_division
Wolfgang schrieb im Beitrag #4873022: > Geert H. schrieb im Beitrag #4873004: >> Division consumes a lot of time. > > It dependst on your understanding of "a lot". I think on AVR it takes about 3000 cycles for a 'standard' floating point division. At 16 Mhz some 5000 divisions/sec
-
Thread
ACS712 effiziente Berechnung der Stromstärke
Dann ist es besser, statt ADCW * 50 lieber die Summe von 50 Wandlungen zu verwenden. Statt einer Division kann man eine Multiplikation (kann der atMega in Hardware) mit nachfolgender Division durch ein Vielfaches von 2 verwenden, was auf ein SHR shift right rausläuft. Also überlegt: wie hoch ist die
bei 16-Bit bleiben. Obwohl ich selten Float verwende, ist die "Trägheit" meist kein Grund. Eine Division läuft im Millisekundenbereich, d.h. 1000 Divisionen pro Sekunde - warum sollte das zu langsam sein? Außerdem, was soll das abs(512-ADCW)?
-
Thread
UART Baudrate richtig runden ( Regelung )
Operator-Reihenfolge. > Systemtakt / 16* Baud -1 = 218,5 Systemtakt wird wohl int sein dann erfolgt die Division durch 16 was als Int augeführt wird. dann wird Baud multipliziert was auch als int gemacht wird und dann wird die 1 abzogen. Dabei kommt also überhaupt keine Nachkommestellen raus, weil alles
Integerrechung wird immer abgeschnitten. ... was einen aber nicht daran hindern kann, vor der Division zum Dividend die Hälfe des Divisors hinzu zu addieren. De facto läuft das dann etwa auf das Gleiche wie eine Rundung bei der Division reeller Zahlen hinaus.
-
Thread
STM32F4: µs-Delay
dessen Version bei 1µs nicht so präzise ist, wundert mich nicht. Kommt sicherlich daher, daß er die Division in der Warteroutine macht, anstatt den Ausdruck "SystemCoreClock/1000000L" außerhalb nach dem Einstellen der Taktfrequenz einmal zu berechnen und in einer globalen Variablen (naja, file-static) zu
-
Thread
ATMEGA328P-PU: USART sendet ungültige Zeichen bei 8MHz, funktioniert aber bei 1 MHz
Fragezeichen, egal welche Baudrate ich beiderseits eingestellt habe. Wenn ich jedoch das Clock Division Fusebit setze, sodass der µC auf 1Mhz läuft funktioniert alles wunderbar und ich habe keine Ahnung warum. Wenn möglich würde ich gerne auf einen externen Quarz verzichten, vor allem kann's doch
Klaus V. schrieb im Beitrag #4863978: > Wenn ich jedoch das Clock Division Fusebit setze, sodass der µC auf 1Mhz > läuft funktioniert alles wunderbar und ich habe keine Ahnung warum. Wenn du nur das Fuse-Bit änderst und es dann geht dann stimmt schlicht dein UBBR-Wert
-
Thread
Polynomdivision mit Schieberegister
links: 0b101 << 2 = 0b10100 ~ x^2 * (x^2 + 1) = x^4 + x^2 Schieben nach rechts entspricht Division mit Rest durch x, wobei das herausfallende Bit 0 (Carry) den Rest darstellt: 0b101 >> 1 = 0b10, Carry=1 ~ x Rest 1 = (x^2 + 1) Div x etc. Ansonsten ist der Algorithmus für die Polynomdivision
-
Thread
kein ADC Wert trotz anliegender Spannung
aber weiterhin kein Bit gesetzt. Mit den Wandlungsraten kenne ich mich nicht aus. Ich habe den Division factor auf 128 gesetzt. Was muss ich hier beachten?
-
Thread
STM32 USART mit falscher Baudrate
{/* PREDIV1 selected as PLL clock entry */ /* Get PREDIV1 clock source and division factor */ prediv1source = RCC->CFGR2 & RCC_CFGR2_PREDIV1SRC; prediv1factor = (RCC->CFGR2 & RCC_CFGR2_PREDIV1) + 1; if (prediv1source == 0) {
{/* PLL2 clock selected as PREDIV1 clock entry */ /* Get PREDIV2 division factor and PLL2 multiplication factor */ prediv2factor = ((RCC->CFGR2 & RCC_CFGR2_PREDIV2) >> 4) + 1; pll2mull = ((RCC->CFGR2 & RCC_CFGR2_PLL2MUL) >> 8 ) + 2; SystemCoreClock