-
Thread
Ähnlichkeit von drei Messreihen
Hallo, ich habe folgendes Problem: Reihe1 Reihe2 Reihe3 88,064 160,256 245,76 32,256 43,008 61,952 5,12 25,088 44,032 23,04 44,032 61,952 43,008 93,184 154,112 27,136 71,168 126,976 65,024 129,024 209,92 29,184 79,872 138,24 16,896 34,816 53,248
Sieht aus wie die Monatssummen der solaren Einstrahlung - Min, Mittel, Max Werte. Die blaue Kurve ist anscheinend ein Mittelwert. Es besteht ein Zusammenhang zwischen Abweichung zu Min/Max und dem Mittelwert. Diese Abweichung kann eine Funktion sein. zB: Abweichung
-
Thread
Impulsverfahren auslesen / Morsecodes im uC interpretieren
falsch. Wilde Vermutungen enden immer in unnützer, weil fehlerhafter Arbeit. Du mußt wissen: - min/max Pulsdauer - min/max Pulspause - min/max Zahlenpause - min/max Stringpause Erst dann kann man anfangen zu überlegen. Peter
Peter Dannegger schrieb im Beitrag #2988491: > Du mußt wissen: > - min/max Pulsdauer > - min/max Pulspause > - min/max Zahlenpause > - min/max Stringpause Falls es sich um Impulswahl handelt: Die FTZ-Richtline 1TR2 (Technische Forderungen an Endeinrichtungen zur Anschaltung
-
Thread
Bild übertragung
Zusätzlich ist ein SRAM integriert, das meist so groß ist wie eine Speicherzeile. (Bei 128k meist 256Byte, bei 256k 512Byte). Dieses lässt sich mit einem Takt sequentiell lesen oder beschreiben. Da sich der SRAM (meist als SAM, serial access memory, bezeichnet) sich in zwei Hälften aufteilen lässt,
VRAM neu bei Adresse 0. Nun hat man 2 Möglichkeiten: 256 Graustufen über einen einfachen DAC, oder 256 Farben über einen RAMDAC aus einer ISA Grafikkarte. (Die RGB Signale gehen dann über SCART in den TV, oder werden per Zusatzschaltung in ein FBAS Signal
-
Thread
VFD "Kundendisplay"-Ansteuerung
Hallo Christoph, laut Beschreibung ist es RS232, dafür spräche auch das auf dem Board ein MAX232 verbaut ist. Belegt sind am MAX232 ein RXD und ein TXD. Auf dem Board steht übrigens "Telesincro", "209000211/B", "515000777/52", "TS 23 0804 V*S*R*D*G*I" (das "V" und das "G" sind mit blauem Kugelschreiber
>Der 80c31 hat ein 27c256 Eprom dran. Jemand mit einigen Kenntnissen zu >der 8051er Reihe müßte doch da das Kommunikationsprotokoll "rauslesen" >können. Eher nicht, 32kB undokumentierter Code aus dem Disassambler macht
-
Thread
29F040B in Schaltung programmieren
dannach wieder beschreiben ?, also nicht Byteweise? Wenn das so ist, welcher Baustein mit mind. 256k*8Bit im DIL kann das? Danke für die schnelle Antwort !
Winbond W29C040 auch 256 Byte Sektoren.
-
Thread
Induktiver Positionssensor - Fragen dazu
deutlich andere Werte: ACS712: max. 13mA Quelle: file:///Users/A287500/Downloads/ACS712-Datasheet.pdf ... dort auf S. 5 PeDa-Oszillator: unter 1mA (ja, mehr ist es nicht!) Arduino Uno: max. 686 mA (natürlich
0; TCCR1B = (1<<ICNC1) | (1<<ICES1) | (1<<CS10); TIMSK1 |= (1<<ICIE1); min = 800; max = 200; } void loop() { uint16_t pulseLength; pulseLength = measurePulseLength(); if(pulseLength > max) { max = max + (pulseLength - max) / 2 + 1; } if(
-
Thread
Z180SoftSystem
Einstellungsmöglichkeiten vorgesehen: Köpfe 0 - 15 , Spuren 0 - 2047 , Sektoren 1 - 63 , Bytes pro Sektor 128 , 256 oder 512.
Schau mal nach ob Du den Arbeitsspeicher auf 256KB eingestellt hast. Habs gerade nochmals bei mir (Linux) mit der Version 2.2.0 und den CP/M Testdaten (beide extra von GitHub heruntergeladen) probiert. Wenn der Speicher auf weniger als 256KB eingestellt
-
Thread
ATmega8/STK500 Servo pfeift
Gefahr hin mich als echter Anfänger zu outen: Das ist ja ein 8 bit timer. Somit hat man 255 Werte max. Wenn aber doch 1ms etwa 50 "Einheiten" entspricht (72-22 zwische Servo links und Servo rechts) dann müsste doch 255 etwa 5ms lang sein? Daher bekommt mein Servo alle 5 ms einen Puls. Ist das richtig
rechnest du denn rückwärts? Du hast einen Takt von 8 Mhz und einen Prescaler von 256. Der Timer läuft nach 256 Timer-Takten über, also 8 Mhz / (256 * 256) = 122 mal pro Sekunde, bzw ca. alle 8 ms. Deine gefundenen Grenzen von 22 und 72 entsprechend dann einer Pulsdauer von 0,7 bis 2,3
-
Thread
Webradio - atmega644, vs1053b, enc28j60,sd - mit multitasking und timer management
haben geruckelt beim Abspielen (außer im lokalen Netzwerk, aber ist ja auch logisch). 32kB Buffer bei 256kbit/s Streams ist definitiv Minimum, würde ich sagen.
wird, kann man auf meinem WebRadio auch noch einen F-RAM nachrüsten. Den gibt es mittlerweile bis 256kByte.
-
Thread
Ausgabe bei FTDI
was ich in das Eingabefeld reinschreibe (der STring wird mit FT_Write gesendet) kommt immer nach den 256 Ì. das ist der Code Abschnitt (in VC++ erstellt): //DATEN SENDEN mit FT_WRITE und EINLESEN mit FT_READ DWORD written; int i; int max; //FT_SetLatencyTimer(ftHandle
1ms Latency Timer FT_SetBaudRate(ftHandle,19200); //ByteTime 38400 * 16 = 1.6us char txbuf[256],rxbuf[256]; CString output; DWORD BytesReceived; strcpy(txbuf,m_ein); max = strlen(txbuf); //buf[0]='A'; //buf[1]='B'; for(i=0; i<max; i++)
-
Thread
ca. 230V, 10A, gleichrichten und glätten (für elektrolyse) Gesperrt
laden: $ 1 5.0E-6 11.708435524800691 50 5.0 48 w 64 80 192 80 0 w 192 80 192 144 0 d 192 144 256 208 0 d 192 272 256 208 0 d 128 208 192 144 0 d 128 208 192 272 0 w 256 208 304 208 0 w 304 208 384 208 0 r 384 208 384 256 0 100.0 w 384 208 480 208 0 w 480 208 480 240 0 w 480 272 480 304
208 128 368 0 w 128 368 304 368 0 w 304 368 384 368 0 w 384 368 480 368 0 t 384 256 480 256 0 1 -7.6924398237270175 0.7243856693735111 4.35 x 514 342 548 346 0 18 load o 15 64 0 33 10.0 12.8 0 -1 o 12 64 0 33 5.0 0.4 1 -1 o 12 64 0 34 10.0 0.2 2 -1
-
Thread
Mehrere ATmegas + VGA Signal + Speicher
Ziel ist, halbwegs schnelle Grafiken zu erzeugen, d. h. Echtzeit. Die Auflösung ist aktuell so ca. 256x256. Alles soll weiterhin auf einem Steckbrett laufen. Aufgrund mangelnder Lötfähigkeiten, bin ich leider auf DIPs beschränkt... Es handelt sich um ein reines Vergnügungsprojekt - ich will damit
Gute Idee, die ich mir vorstellen kann. Eine Sache macht mir jedoch gerade Sorgen: bei 256x256x8 bit = 65.536 px @ 20 MHz benötige ich bei utopischen 1-cycle Schreibzugriffe 3,2768 ms um ein volles frame zu zeichnen. Da wird aber noch mehr kommen, denn die Zeichenroutinen (auch wenn es
-
Thread
Reziproker Frequenzzähler+ Optimierte 64bit uint Routinen
256, 272 Die Spannungsbereich wären dann U_bereich = 5V / (N+1) 'breit'. Mit N=13 dann U_bereich = 0,3571V, das entspricht +73dec bei 10 Bit ADC Auflösung. Faktor 1: 0 - 73 ADC-Wert Faktor
* Find precision (auto-range) */ uint8_t s = MIN_RES; while (s && frq >= (uint64_t)pow(10, MAX_RES)) { frq += 5; // Runden frq = uint64_div32(frq, 10); s--; } [/c]
-
Thread
Brauche eure Hilfe zum Programmieren
c2 ; wenn nicht 0, zurück zu c2 mov AV_L,BH ; Durchschnittswert aus 256 Durchläufen mov AV_H,CL ; BL fällt weg = Division durch 256 rcall print_current ; LCD-Ausgabe Strom rcall stop_pwm ; PWM aus rcall get_voltage
vct1 ; wenn nicht 0, zurück zu vct1 mov AV_L,BH ; Durchschnittswert aus 256 Durchläufen mov AV_H,CL ; BL fällt weg = Division durch 256 rcall print_voltage ; Spannung ausgeben clr BL ; Additionsregister wieder auf 0 clr
-
Thread
Capsense Algorithmus mit fraction Byte
); SensorBaselineLow[sensor] = ((uint8) calc); } //global deklariert: uint16 SensorBaseline[max_SENSOR]; //used to store fraction byte of baseline value uint8 SensorBaselineLow[max_SENSOR]; Warum bildet man nicht einfach die Differenz des Sensorwertes und der Referenz: RawData - SensorBaseline
Das ist ein IIR-Filter mit y_n+1 = (y_n * 255 + x ) / 256 Wegen der einfacheren Berechnung ist 255 als y_n * 256 - y_n realisiert MfG
-
Thread
Selbstbau-Testboard für STM32F4Discovery
3 used to address NAND Flash devices (1 device per bank)", dass ich einen Flash Chip pro Bank mit 256 MB einsetzten kann? Wie oebn schon geschrieben, finde ich keine Chips, die noch active sind, für meine Anforderungen: Data Width: 16bit Spannung: max. 3.6V Schnitstelle: parallel Typ: SCL Speichergröße
... ich habe da den NAND256-A , gewonnen durch Heißluft von der VIP 1710, im Auge; Aber, - ich bin auch mehr der "Praktiker";
-
Thread
SST26VF016B Flash Speicher Adressierung
Steht alles im DB..... Adressierung ist Byte weiße. Du kannst 1 bis max 256 Bytes in einem rutsch schreiben aber nur bis zum 256 Byte Page boundary sonst gibt es einen wrap arround zum Page Anfang. Einfach etwas überschreiben geht nicht, halt flash typisch, also
meinem Fall müsste ich alle 10us 3-4 Bytes wegschreiben können und das in Summe von etwa 100kB. Die 256Byte Puffer reichen also nicht aus. Der oben genannte Chip benötigt für das speichern eines Bytes etwas über 50us. Volle 256 Byte sind nach rund 1100us gespeichert... das sind nicht mal 0,25MB/s für
-
Thread
SDR als Spektrumanalysator?
Eigenbau-Tuner betrieben, ähnlich dem obigen Prototyp, der ist dann im Vergleich doch etwas besser als der MAX 3543 Aufbau.
soweit gediehen. Der Scan selbst geht sehr flott, vor allem beim Eigenbau-Tuner mit einem ADF4350 bzw MAX2870 als VCO. Vor dem aktuellen VUHF-Tuner ist ein PE43205 als schaltbarer ATT vorhanden. Für mich ist das alles ausreichend, hab ja keine größeren Pläne damit vor.
-
Thread
Selbstbau Logic analyzer
Meiner war billiger: Ein 8051 uC, eMAX232, 256kByte VRAM, 32MHz Quarz + 74HC404 Teiler, 3x 74HC151 (für die Triggerauswahl und Samplerateauswahl, 74HC245 und ein paar Pullups, Spannungsregler usw. Kann immerhin 32MHz, 8 Kanal...
PCI Grafikkarten sind 2-16x 256k x 16 DRAMs drauf.
-
Thread
HMC5983 Thermometerdaten umrechnen klappt nicht
Die zwei Werte MSB und LSB sollen zu einer Zahl zusammengesetzt werden. Also MSB * 256 + LSB. Das ergibt eine 16-Bit-Zahl - und das ist pillepalle: OK. > (MSB*256)+LSB/(2⁴ * 8) +25 = Temperatur in °C Na gut, Peter Thermometer hätte besser ((MSB*256)+LSB)/(2⁴ * 8) +25 = Temperatur
Peter Thermometer schrieb im Beitrag #4872854: > MSB*256 ergibt immer 0, das kann man gleich weglassen Das rechne mal vor. MSB liegt im Bereich 0xF8..0x07, d.h. MSB*256 ergibt als 16-Bit Wert eine Zahl im Bereich 0xF800..0x0700
-
Thread
Mehre ints speichern in char array und lesen
Entity_Init(); Entity_SetData(0, 0, 1); Entity_SetData(0, 1, 0); Entity_SetData(0, 2, 256); Entity_SetData(0, 3, 256); Entity_SetData(1, 0, 2); Entity_SetData(1, 1, 0); Entity_SetData(1, 2, 512); Entity_SetData(1, 3, 256); printf("Entity:\n%s\n%d\n", Entity, Entity_GetData(1, 2)); [/c] Entity.c: [c] /** Entry Steuerung */ #define Max_Entity 128 char Entity[8*Max_Entity]; void Entity_Init() { int n; /* Entity füllen mit Nullen */ for(n = 0; n < Max_Entity-1; n++) Entity[n] = '0'; /* Ende setzen
-
Thread
Frequenzen mit ATmega messen
Laufzeit eingegangen sind - Die Laufzeit von der ersten Periode bis nach der letzten Periode (sind max. 45sec) Ich bin mir jetzt nicht ganz sicher, ob ich hierfür einen ATmega16 bzw. 32 nehmen kann. Dort habe ich ja nur 2x 8bit Timer und 1x 16bit Timer zur Verfügung. Brauche ich für die Frequenzmessung
>Deine Überlaufvariable hat aber den Wert 256... Richtig, mein Fehler, sorry und danke für den Hinweis. >Du willst 50-70Hz messen. Das bedeutet Periodendauern zwischen 14 und >20ms zu messen. Ein 16Bit-Timer bei einem (CPU-)Takt von 1MHz hat
-
Thread
Elektor - nächste Ausgabe mit R8C/13 Platine
und 256 K Ram(auch noch Muster) Außerdem frage ich mich, warum die ARMs von Atmel wesentlich höher getaktet werden können als die AVRs.
ARMs von Atmel wesentlich höher getaktet werden können als die AVRs." Flash-Speed: AVR: 20MHz max. ARM 25MHz max. Nicht so arg verschieden. Um den AVR schneller zu kriegen, müsste die Instruction-Fetch vom AVR neu konzipiert werden, woran Atmel verständlicherweise wenig Lust hat. Ich habe mal was
-
Thread
Tabled-PC welchen könnt Ihr empfehlen
Bildschirm mit 1024x 600 Pixeln und resistivem Touchscreen. Gerät basiert auf einer 1.0 GHz CPU, 256MB Speicher, 2G NAND flash. 10'' Touchscreen Display. 1GHz CPU, 256MB Speicher. 2GB Internen Speicher. Gerät wiegt circa 600 Gramm. Wi-Fi (Wlan fähig). OS/Betriebssystem: Android 2.1. 2 Eingebaute
USB Tablet PC MID - Processor Type ARM 11 Processor Clock Speed 1Ghz RAM Installed Size 256MB DDR2 Display Diagonal Size 10 inch Max Resolution TFT 1024X600 Graphics Type Integrated Graphics Graphics Model Support 1080P/720P Storage and Expansion Hard Drive Type NAND Fast
-
Thread
Fehlermeldung Arduino C++
Falk Brunner schrieb im Beitrag #4078527: > Ein einzelnes Bild im Flash darf max. 32767 Bytes groß sein, denn hier > greift leider die maximale Größe eines einzelnen char[] Arrays. Wieso sollte es da eine Begrenzung geben? Könnte es sein, daß Du einen ungünstigen Datentyp als
andere ARMs, die können ihren Speicher ohne Handstände voll ausnutzen. Der einzige Vorteil des MEGA256 sind mehr Pins und IO Module (UARTs, SPI, Timer, PWM, etc).
-
Thread
FIR Filter auf PIC
Moin, Max M. schrieb im Beitrag #5096330: > der EFM8LB1 läuft mit max. 72MHz, 14-bit ADC und > 12-bit DAC, zur IDE bekommt man kostenlos eine Lizenz des Keil 8051 > C-Compilers dazu. Weiaweia, da wuerd'
Max M. schrieb im Beitrag #5101124: > Edit_2: Okay, so gehts nun :Dtime=0:1/31400:4; Sorry, ich hatten den gleichen Fehler gemacht und dann die falsche Zeile kopiert. Max M. schrieb im Beitrag #5101124
-
Thread
3x LED-PWM-Faden
schreibt ist aber die Auflösung der Timer unterschiedlich Timer1 zählt bis 1024 aber Timer 2 nur bis 256. zu 2 grensen sind ie max werte also 1024 und 256 z.B. die 1,3,8 ist er wert vom PWM vereinfacht wie lange die Spannung anliegt zB. 1/256,3/268,8/268 der Grundfrequenz Gruß Andreas
Timingprobleme im Bereich ab 60000 (da gibt es ein paar Werte, wo er komplett aus geht) und kleine Werte (0...256) bekommt er auch nicht richtig hin (zu grob abgestuft und "zu hell").
-
Thread
Zeigt her eure Kunstwerke (2017-2019) Gesperrt Bilder
ein "Hoch"spannungsnetzteil von DC 12V auf DC 40...~260V mit einigen Watt - aktuell angezeigt werden 256V). Gruß, Klaus.
Klaus R. schrieb im Beitrag #6005603: > aktuell angezeigt werden 256V). Die Anzeige meint 25.5 Wenn das 255 (nicht: 256) Volt darstellen soll, dann ist dies zumindest verwirrend (wegen dem Punkt) Ich hätte vielleicht auch noch die Ausgangswerte (Spannung, Strom
-
Thread
Feldmühle A/D Wandler
ICL/MAX 7135 0.1mV resolution , ICL/MAX 7107 1mV resolution.
>Mit einem 8Bit Wandler habe ich eine Auflösung von 1024 Der hat eine Auflösung von 2^8 = 256 Schritten. Da die Feldmühle eine Wechselspannung abgibt, benötigst Du zuerst einen Messgleichrichter. Dann kannst Du die gleichgerichtete Spannung über Spannungsteiler in z.B. drei Bereiche aufteilen
-
Thread
C versus Assembler->Performance Gesperrt
//-- UserFunktion aufrufen -------------------------------- uint8_t u8Idx = 0; uint8_t u8Max = (uint8_t) ( sizeof(scEsc_SysTick.apfct ) / sizeof(scEsc_SysTick.apfct[0]) ); while ( u8Idx != u8Max ) { void ( *pfct ) (void) = scEsc_SysTick.apfct[u8Idx
6 Bytes hinzuaddieren, und es steht jetzt final [pre] 256 : 256 [/pre] also unentschieden. Ich kann mit diesem Ergebnis sehr gut leben, du auch? Und Moby, jetzt mal ganz unter uns: Selbst wenn das C-Programm 300 oder gar 400 Bytes belegen würde,
-
Thread
LED Neomatrix Stromversorgung
"255" wenn als 8-Bit Wert) angesteuert werden dann ganz grob über den Daumen 3x20mA = 60mA 16x16=256 256x60mA=15360mA (ja 15,36A !) und das macht bei drei Stück 15,36A über 46A - das ist (wäre) schon eine ordentliche Hausnummer, mit entsprechenden notwendigen dicken Leitungen und mehrfacher Einspeisung
Das Datenblatt zur WS2812B sagt: Versorgungsspannung: 3.5V - 5.3V Eingangsspannung "Low" Level: Max. 0.3 x Vdd, Min. -0.5V Eingangsspannung "High" Level: Min. 0.7 x Vdd, Max. Vdd + 0.5V Wenn Du die Pegel für die Eingangsspannung nach oben oder unten überschreitest, killst Du die erste LED.
-
Thread
Industrielle [3D-Drucker] Bastelgrundlagen
Beitrag #7060514: > Mich kotzt das immer an, wenn's nicht dicht ist. hast du die Düse auch bei max. Temperatur festgezogen?
Welle Nema 17 Schrittmotor zzgl. 256 mikroSteps? (TMC2009) lautet auch: Bastelbastel, Grundlagen, industriell,
-
Thread
Toochain bauen avr-gcc-x.x mit binutils-2.34 funktioniert nicht
atxmega128c3 atxmega128d3 atxmega128d4 atxmega192a3 atxmega192a3u atxmega192c3 atxmega192d3 atxmega256a3 atxmega256a3u atxmega256a3b atxmega256a3bu atxmega256c3 atxmega256d3 atxmega384c3 atxmega384d3 atxmega128a1 atxmega128a1u atxmega128a4u attiny4 attiny5 attiny9 attiny10 attiny20 attiny40
atxmega192a3u avr/lib/avrxmega6/atxmega192c3 avr/lib/avrxmega6/atxmega192d3 avr/lib/avrxmega6/atxmega256a3 avr/lib/avrxmega6/atxmega256a3u avr/lib/avrxmega6/atxmega256a3b avr/lib/avrxmega6/atxmega256a3bu avr/lib/avrxmega6/atxmega256c3 avr/lib/avrxmega6/atxmega256d3 avr/lib/avrxmega6/atxmega384c3
-
Thread
USBasp+AVRdude+libusb=MEGA-STRESS
0xff 0xff flash 33 6 64 0 yes 32768 128 256 4500 4500 0xff 0xff lfuse 0 0 0 0 no 1 0 0 2000 2000 0x00 0x00 hfuse 0 0 0 0 no 1 0 0 2000
0xff 0xff flash 33 6 64 0 yes 32768 128 256 4500 4500 0xff 0xff lfuse 0 0 0 0 no 1 0 0 2000 2000 0x00 0x00 hfuse 0 0 0 0 no 1 0 0 2000
-
Thread
Self-Powered / USB-Powered umschalten
Hier: http://www.mouser.com/ds/2/256/MAX1551-MAX1555-42751.pdf Habe ich eigentlich gefunde, was ich suchte. ABER: Kann in den ganzen Kram mit dem Erkennen von DCP, CDP und SDP auch softwareseitig später erledigen um dann ggf. 500mA
You About USB". D a v i d K. schrieb im Beitrag #3163133: > Hier: > http://www.mouser.com/ds/2/256/MAX1551-MAX1555-42751.pdf > Habe ich eigentlich gefunde, was ich suchte. > > ABER: Kann in den ganzen Kram mit dem Erkennen von DCP, CDP und SDP auch > softwareseitig später erledigen um dann
-
Thread
cooles Arduino Projekt gesucht
und Timer1 in einem speziellen Modus > nutzen. > > Da kannst Du den hier nehmen. Hat allerdings 256 Stützstellen. > > https://github.com/ChrisMicro/AttinySound/tree/master/_001_sineWaveGenerator
Mit IR-Fernbedienung könnte man zwischen Kelvin, Fahrenheit, Celsius, Reaumurs umschalten, Min/Max abfragen, von Blinken auf Morsen umschalten. Zu den Temperatur-Skalen: http://www.mathe-schule.de/download/pdf/Physik/Temperaturskalen.pdf MfG
-
Thread
AVR als EPROM benutzen (C-Optimierung)
sind (AVR-Eingänge werden einen Zyklus vorher gelatcht, daher 14). Die langsamsten 2716 erlaubten max 450ns Delay. Um die zu simulieren müßte der AVR mit 14/450e-9 = 32MHz takten. Den /OE muß man aber mit extra Treibern machen, der geht nicht in SW (max 100ns Delay).
> (AVR-Eingänge werden einen Zyklus vorher gelatcht, daher 14). > Die langsamsten 2716 erlaubten max 450ns Delay. Um die zu simulieren > müßte der AVR mit 14/450e-9 = 32MHz takten. > > Den /OE muß man aber mit extra Treibern machen, der geht nicht in SW > (max 100ns Delay). Vieles davon hatte
-
Thread
struct als volatile => syntax fehler ...
Mein Code sieht so aus: [c] struct time_t { uint8_t hour; // max 23 uint8_t minute; // max 59 uint8_t second; // max 59 }; volatile time_t actualtime; [/c] Fehler vom WinAVR ist: > "make.exe" all avr-gcc -g -Wall -O2 -mmcu=atmega8 -c -o demo.o
an dem volatile, sonst hätte ich's einfach so gemacht: [c] struct time_t { uint8_t hour; // max 23 uint8_t minute; // max 59 uint8_t second; // max 59 } actualtime; [/c] Hmmm, geht denn auch: [c] volatile struct time_t { uint8_t hour; // max 23 uint8_t minute; // max 59
-
Thread
Was benötige ich um einen 8086 in Assembbler zu programmieren ?
viel wie RAM da ist, - Daten, - Programm. Ein Z8002 hat immerhin schon ein *eigenes* Stacksegment (max. 64k).
etwas zuviel gespart, der AVR z.B. kann nicht mal ein "ADDI r16,88" - da muß man sich mit SUBI r16,(256-88) behelfen, was das carry-Flag ebenfalls invertiert. Sowas finde ich nerviger als die Segmentierung beim x86.
-
Thread
Pwm periode Timer1 einstellen.
|----| |. | |. |______ 0 Ocr1a. Max Wenn das meine Periode ist, gibt ja ocr1a den Wert an wo der Pegel Wechsel statt findet. Von Max soll er ja auf 0 springen und am Ausgang wieder auf High schalten. Mit den ocr1a wert kann ich doch jetzt die Einzeit Variable verstellen von 0 bis Max. Nur wo lege ich den Wert Max fest?
-
Thread
Tut gelesen und trotzdem Problem mit Strings im Flash
Startpunkt für meine HTTP Daten dar. Hier würde dann die eigentliche Webseite landen. Das funktioniert für 256 Bytes und dann ist schluss. Ich vermute die CRC routine ist ok, da sie auf dem ED2 ja auch funktioniert hat. Ausserdem rechnet sie ja auch weiter, aber die Daten im Paket hören einfach ab dem 256 Byte
// } [/C] Das Versagen bei Paketen mit mehr als 256 Bytes Nutzdaten käme mir plausibel vor, wenn z.B. ein Paket 256 Bytes Nutzdaten hat und durch die falsche Erhöhung alle Folgepakete ausser dem ersten wg. falscher Checksumme verworfen werden. Ich kann
-
Thread
U(S)ART auf XMega D4?
[256]; volatile byte rxbuffer_write_ix; volatile byte rxbuffer_read_ix; byte txbuffer[256]; volatile byte txbuffer_write_ix; volatile byte txbuffer_read_ix; volatile byte rxed_cmd_cnt; rs232_send_char
// at 16MHz is used. // NOTE: For now disabled, will enable if flash space permits. // #define MAX_STEP_RATE_HZ 30000 // Hz [/c] Die tatsächliche Tickrate wird in Zeile 772ff (stepper.c) berechnet und gesetzt.
-
Thread
USB Speicher-Oszilloskop (Anfängerhilfe)
einen nenner zu kommen....alfsch(at)freenet.de bzgl 50eu: adc 50Ms/s ca.10eu ram 32k 15ns oder 256k 10ns , von altem mainboard 0eu ("schrott") steuerung cpld ca 6eu controller evtl mega16 ca 4eu einige hc + ac treiber usw ca 5eu analog input schaltung: einige rf-mosfet (max. ca 200mhz wären
dem grossen ram, zb em531323-6 (6ns), 32k x 32bit, sind 2 adc 8bit und 16x digital logik input bei max 66mhz möglich... hier könnte das design variabel sein, also zb 1x8bit adc als billigst-variante, bis 4x8bit als max ausbau. bzgl undersampling: ja, phasen-versetzt/periodisch, mit etwas trickreicher
-
Thread
PIC16F690 Array als LONG deklarieren
aus dem ARRAY zuweise, z.B. 311, dann bekomme ich als Wert der Variablen 55 angezeigt, also 311 - 256: Wo liegt der Fehler? kann man als CONST keine LONG im ARRAY ablegen oder was mache ich falsch? Gruß Uwe
aus dem ARRAY zuweise, z.B. 311, dann bekomme ich als Wert der Variablen > 55 angezeigt, also 311 - 256: Mich wundert schon, dass sich eine const Variable überhaupt zuweisen lässt.
-
Thread
Poti am PWM Controller gegen Hallsensor tauschen
https://www.falstad.com/circuit/circuitjs.html?cct=$+1+0.000005+10.20027730826997+57+5+50%0Av+96+256+96+112+0+3+40+2+2.84+0+0.5%0Ag+96+256+96+336+0%0Aw+192+208+192+256+0%0Aa+192+192+336+192+9+5+0+1000000+2.6127788695231304+2.6127999076732884+100000%0Aw+336+192+336+256+0%0Aw+192+112+192+176+0%0AO+336+192+400+192+0%0A174+144+272+224+272+0+100000+0.7376+Gain%0Aw+240+272+336+272+0%0Aw+336+272+336+256+0%0A174+128+320+144+224+0+100000+0.8564+Offset%0Ag+128+320+128+336+0%0AR+128+224+160+224+0+0+40+5+0+0+0.5%0Aw+96+112+192+112+0%0Ao+0+64+0+4354+4.839999934542879+0.0001+0+2+0+3%0Ao+6+64+0+12546+5.001723510117205
-
Thread
Uhr mit ATMega8515
1807 Overflows/Sek > >Stimmt das überhaupt ? Nein. 3686400 Hz/8 => 460800 Hz => 2,17µs/Takt * 256 => ???? Overflows/Sek
holger schrieb im Beitrag #2145646: > Nein. > > 3686400 Hz/8 => 460800 Hz => 2,17µs/Takt * 256 => ???? Overflows/Sek Wenn ich mit "256" rechne komm ich genau auf 1800 ! Damit läuft die Uhr aber immer noch zu langsam ... nach 2 Min läuft das Teile ca. 1 Sekunde nach ! Oder stimmt der Berechnungsweg
-
Thread
Probleme beim ADC-Wert auf LCD ausgeben
messungen ; Schleifenzähler MINUS 1 brne sample_adc ; wenn noch keine 256 ADC Werte -> nächsten Wert einlesen ; Aus den 256 Werten den Mittelwert berechnen ; Mathematisch eine Division durch 256 ; Da aber 2^8 = 256 ist ist da einfach durch das weglassen des niederwertigsten
messungen ; Schleifenzähler MINUS 1 brne sample_adc ; wenn noch keine 256 ADC Werte -> nächsten Wert einlesen ; Aus den 256 Werten den Mittelwert berechnen ; Mathematisch eine Division durch 256 ; Da aber 2^8 = 256 ist ist da einfach durch das weglassen des niederwertigsten
-
Thread
M24M02 EEPROM
nun soweit. Noch eine kurze Frage. Ich muss ein Array mit 1026 Werten abspeichern.Ich kann ja max 256 Bytes nacheinander schreiben. Muss ich nach 256 Bytes das WC kurz auf High ziehen oder wie läuft der weiter Schreibvorgang ab? Habe den WC PIN dauernd auf LOW
@ Christoph B. (christoph_b) >Ich muss ein Array mit 1026 Werten abspeichern.Ich kann ja max 256 Bytes >nacheinander schreiben. Eben, also musst du blockweise schreiben, aka Page mode. > Muss ich nach 256 Bytes das WC kurz auf High Nein. >ziehen oder wie läuft der weiter Schreibvorgang
-
Thread
Genaue Frequenzbestimmung nach FFT
Frequenz sollte auch dann klappen. Der besagte Spezialfall: 2-Punkt-FFT. Etwa so: [math] f_{max}=\frac{1}{N_{shift} \cdot T_a}=\frac{f_a}{N_{shift}} [/math]
sin(1.2*2*pi*(0:511)/512); c=hilbert(a); cd=c(2:end)./c(1:end-1); d=0; length(a)*mean(angle(cd(256-d:256+d)))/2/pi return