-
Thread
Fragezeichen in C-Code - was ist das?
[c]xx += sx; xx *= sx = x0 < x2 ? 1 : -1;[/c] oder besser... [c] xx += sx; if (x0 < x2) { sx = 1; } else { sx = -1; } xx *= sx; [/c]
Wenn du aber denselben Test mit -Os machst [code] avr-gcc test.c -S -Os [/code] so kommt beim Winavr2010 beides mal derselbe Assembler Code raus: [code] foo: /* prologue: function */ /* frame size = 0 */ rcall . ldi r24,lo8(.LC0) ldi r25,hi8(.LC0)
-
Thread
Eine Zeile Code, 2K flash
ist ein Cortex-M0 (nrf51488). Folgende Zeile Code ist für 2 KByte des Binaries verantwortlich: [c] delta_time delta_time::ppm( unsigned part ) const { return delta_time( std::uint64_t( usec_ ) * part / 1000000 ); } [/c] Wobei usec_ vom Typ std::uint32_t ist. Diese Zeile
Hm, habe ich mich wohl wieder unklar ausgedrückt. Entschuldigt! Hier noch mal in einfacher: [c] std::uint32_t usec_ = ...; const std::uint32_t r = std::uint64_t( usec_ ) * part / 1000000; [/c] Der Code sieht völlig normal aus, es werden die Funktionen __aeabi_lmul und __aeabi_uldivmod
-
Thread
Windows 7 3 Mal auf dem selben Rechner?
GROUP=E66;GROUPID=733;ARTICLE=62181;START=0;SORT=artnr;OFFSET=16;SID=11TiLNtn8AAAIAAC25JCUd0dd0bc9949cb24ab858c63c4a1aac46
Icke ®. schrieb im Beitrag #2651345: > Mit 64-Bit hat das nichts tun. technisch nicht, aber ich hatte irgendwo mal gelesen das es eine Anforderung für das Win7 (64bit) logo ist.
-
Thread
Dezimal nach Hex-Umwandlung PIC18
Jan geschrieben hat oder oben schon der Gustl hier in Primitiv-Form: //0x26100->0x65F4 rc24 = 2*10000; rc24+= 6*1000; rc24+= 100; Die Lösung von fchk geht nicht, da der olle uC ja in hex rechnet, da kommt nur Mist raus - sorry, nicht böse gemeint, mit dem der nem ähnlichen Lösungsansatz
Gerhard schrieb im Beitrag #7974584: > atoi() wäre auch mein Favorit gewessen, > gibts aber in C99 nicht mehr. Doch gibt es. Von C89 bis C23. Steckt in stdlib: https://en.cppreference.com/w/c/string/byte/atoi
-
Thread
80c515C - Parameterübergabe
Hi Leute, Ich verstehe die Parameterübergabe beim Infineon C515C-L nicht, kann mich da bitte einer aufklären. Ich habe: [c]code char text1[] = "Text-1"; code char *text2 = "Text-2";[/c] Wenn ich nun diese zwei einzeln puts übergebe, so entstehen folgende
leer bleiben. Keil unterstützt auch noch Banking von Code und Xdata, so daß man den 8051 (auch 80C515 und 80C517 und viele andere Derivate) mit einem Vielfachen des normalen maximalen Speicherausbaues von 64k gestalten kann. Ursprünglich war das vom Chiphersteller mal gar nicht vorgesehen, weil man
-
Thread
Kompletter Einsteiger: welcher µC, um Knopfdruck an PC weiterzuleiten?
in den Comp zu geben und das terminal. Oder so. Heutzutage muss es ein ganzer Heimcomputer ala C64 sein für so einen Aufgabe.
man die Taste einfach an seinen C64 angeschlossen, und der hat das dann nebenbei einlesen können. Heute muss man an den PC erst das Pendant eines C64 (allerdings mit mehr Rechenleistung) anschließen, der dann dediziert zum Einlesen der
-
Thread
Ubuntu-Grafikkartentreiber Installation. Keine Chance X Server auszuschalten
5.0 seconds = 886.945 FPS zu den Befehlen: Karl Käfer schrieb im Beitrag #2693776: > $ ping -c4 www.google.de" [c] PING www-cctld.l.google.com (173.194.39.88) 56(84) bytes of data. 64 bytes from bud01s10-in-f24.1e100.net (173.194.39.88): icmp_req=1 ttl=56 time=16.3 ms 64 bytes from bud01s10
BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP qlen 1000 link/ether 00:22:43:20:29:0c brd ff:ff:ff:ff:ff:ff inet 10.0.0.4/24 brd 10.0.0.255 scope global wlan0 inet6 fe80::222:43ff:fe20:290c/64 scope link valid_lft forever preferred_lft forever [/c] Karl Käfer
-
Thread
[C] Funktionen in Abhängigkeit von defines kompilieren
#endif /* FOO_E_INCLUDED */ #undef FOO_E[/c] Dies ist dann das dazugehörige Source-File foo.c: [c]#ifdef FOO_D_INCLUDED void foo_d(uint24_t data){ . . . } #endif /* FOO_D_INCLUDED */ #ifdef FOO_E_INCLUDED void foo_e(uint64_t data
allen Compilern gleich sein. Sorry, hab mich wohl zu wenig genau ausgedrückt. Ich prüfe nur mit [c]#ifdef UINT24_MAX void foo_d(uint24_t data); #endif /* UINT24_MAX */[/c] auf das Vorhandensein der Definition. Bei Compilern, die keine 24 oder 64 Bit Integer verwenden, wird wohl UINT24_MAX und
-
Thread
Fuseeditor, grafische Benutzeroberfläche für AVRdude
Filemanager ist Caja 1.24.0 Ergebnis von >file< thomas@thomas-ESPRIMO-Mobile-V6535:~/Fluid_work$ file fuseedit fuseedit: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=5903c02d0488763cad1d0f1214f8e5e6c7739e29, for GNU/Linux 3.2.0, stripped thomas@thomas-ESPRIMO-Mobile-V6535:~/Fluid_work$ Mittlerweile bin ich aber schon einen kleinen Schritt
-
Thread
Tipps zu: 600+ Schrittmotoren ansteuern
Theoretisch könnte man für 16 Motoren einen µC verwenden, der die 64 Endstufen jeweis einzeln per Pin Toggeln im Timer macht. Diese viele µC sind mit FD-CAN miteinander verbunden. Damit wären 38 Stück davon nötig. Wenn man jedem Motor 256
Markus M. schrieb im Beitrag #7889095: > Theoretisch könnte man für 16 Motoren einen µC verwenden, der die 64 > Endstufen jeweis einzeln per Pin Toggeln im Timer macht. > DANKE für diesen vernünftigen sachlichen Beitrag.
-
Thread
PIC oder AVR, was ist besser
und Windows. Man kann damit auch gut arbeiten, aber nicht unter Linux. Ab PIC24 basieren die C-Compiler von Microchip auch auf dem GCC. Microchip bietet die nur für Windows an. Technisch könntest Du den auf Linux portieren (und dabei den Lizenzmanager rauswerfen), aber die Lizenz
Auf http://ww1.microchip.com/downloads/MPLAB/X_Beta/installer.html Linux x86 auswählen... > Ab PIC24 basieren die C-Compiler von Microchip auch auf dem GCC. > Microchip bietet die nur für Windows an. Technisch könntest Du den auf > Linux portieren (und dabei den Lizenzmanager rauswerfen), aber die
-
Thread
[S] EPROMs suche
als DIP 24/28 20 x 27C16 20 x 27C32 20 x 27C64 20 x 27C128 Am besten NOS, evt. auch gebrauchte. Angebote per email oder hier im Forum.
Thomas Lamparter schrieb: > was bezahlste ? > > ich habe bedrahtete Kunst (DIL) > 27C64, 27C128 und 27C256 c64 und c128 dil nehme ich gerne > > dazu kann ich noch ein Programmiergerät zugeben und ein UV-Löschgerät > (quasi Neuwertig) > nehme ich auch mit, als richtwert -
-
Thread
Analog Devices: DDS IC (AD9959) mit ATMega64L ansteuern SPI
beschäftigt und probieren von Analog Devices ein DDS IC (genauer gesagt den AD9959) mit einem AVR ATMega 64 Atmel uC anzusteuern. Die Verbindungen habe ich wie folgt vorgenommen: // uC ATMega DDS IC // PB1 (Pin 11) SCK <---> Pin 48 SCLK // PB2 (Pin 12) MOSI <---> Pin 50 SDIO_0 // PB3
Schaltplan zum uC ATMega64L
-
Thread
Conrad Adventskalender
----- 6.60 EUR Da bleiben noch 3.40 EUR für den Druck des Kalenders, den Autor und C.
. ... und dieses Jahr gibt es zu Heilig Abend wieder einen 100nF C,
-
Thread
ASM-Nachoptimierer
size=1) */ 59 /* function test size 6 (5) */ 61 .Lscope0: 64 .global main 66 main: 5:x.c **** 6:x.c **** int 7:x.c **** main(void) 8:x.c **** { 68 .
82 0016 0196 adiw r24,1 83 0018 8731 cpi r24,23 84 001a 9105 cpc r25,__zero_reg__ 85 001c E4F3 brlt .L8 16:x.c **** c=c+b+i; 17:x.c **** 18:x.c
-
Thread
Library für alle AVRs erstellen
; 702 jump [length = 1] [/avrasm] Der case für JOB_idle: [avrasm] .L118: ;; Z = i2c_soft->fifo ld r30,Y ; 213 *movhi/3 [length = 2] ldd r31,Y+1 ;; Z = fifo->count ;; if (0 == fifo->count) ;; return -1; --> führt zu "break" in JOB_idle. ld r24,Z ; 214 movqi_insn
natürlich abseits der Multilib-Optionen noch eine Unterteilung vornehmen in die AVRs, die SPI auf 0x2C … 0x2E haben (alle neueren) und die, die es auf 0x0D … 0x0F haben: ATmega128A ATmega128 ATmega162 ATmega16A ATmega16 ATmega32A ATmega32 ATmega64A ATmega64 ATmega8515 ATmega8535 ATmega8A
-
Thread
Grundlegende Fragen zum Bootloader
hier vielleicht rein. Also ich habe ein HEX File in dem zB dies hier drinsteht: :10 0000 00 12C02BC05BC04AC039C027C026C025C0 63 :10 0010 00 24C023C022C022C020C01FC01EC01DC0 DB :10 0020 00 1CC01BC01AC011241FBECFE5D4E0DEBF 28 :10 0030 00 CDBF10E0A0E6B0E0E6E1F0E102C00590 3F :10 0040 00 0D92A036B107D9F710E0A0E6B0E001C0
Achso, die Bootloader die ich bisher gesehen habe, die hatten ein 64 Byte großes Array (dann wohl im RAM), darin wurden die Daten erstmal geschrieben, zB vom I2C kommend. Wenn 64 Byte voll waren, dann wurde diese boot_program_page() aufgerufen. Aber, wenn es so ist wie
-
Thread
Arm Cortex im DIP Gehäuse Gesperrt
Bülent C. schrieb im Beitrag #5211146: > Google mal nach s64dil reusch Erledigt, danke für den Tipp! http://reusch-elektronik.reworld.eu/de/produkte/s64dil-476/right.htm Das ist ja ein überaus nettes
Ist aber ein weiterer Punkt, der mit bei den M16C missfiel: Die Adressraumtrennung. Die haben einen 1MB Adressraum, mit 64KB RAM/IO unten eingebettet. Nur bei kleinen R8C liegt das Flash auch in diesen 64KB, erlaubt also prinzipiell eine Datenadressierung
-
Thread
Erzeugung von reduntantem Code in AVR-GCC
teilweise beeindruckend optimal. Ich bin über eine Merkwürdigkeit gestolpert: Aus dieser Zeile: [c] uchar isLast = ((currentAddress % SPM_PAGESIZE) == 0); if (isLast)... [/c] currentAddress ist short, SPM_PAGESIZE=64 per define wird dieser Code erzeugt: [code] 1e02: 80 91 69 00 lds r24,
So klappt es: [c] if (*((unsigned char*)&idlePolls)&0x90) DDRB |= _BV(NANITE_CTRLPIN); [/c] [code] 1eb6: 80 91 66 00 lds r24, 0x0066 1eba: 80 79 andi r24, 0x90 ; 144 1ebc: 09 f0
-
Thread
Bug im avr-gcc bei Behandlung von SFRs als Bitfields?
BFM_COM0A |= 0b11; wird übersetzt mit: BFM_COM0A |= 0b11; 5a: 84 b5 in r24, 0x24 ; 36 5c: 84 b5 in r24, 0x24 ; 36 5e: 80 6c ori r24, 0xC0 ; 192 60: 84 bd out 0x24, r24 ; 36 Hier wird der in-Befehl vom TCCR0A-Register überflüssigerweise
b5 in r24, 0x24 ; 36 48: 84 b5 in r24, 0x24 ; 36 4a: 80 6c ori r24, 0xC0 ; 192 4c: 84 bd out 0x24, r24 ; 36 macht 2x IN. Und da ist nur eine Dereferenzierung drin.
-
Thread
Deklaration von external memory
r18 20c: 23 70 andi r18, 0x03 ; 3 20e: 80 93 04 02 sts 0x0204, r24 212: 20 93 05 02 sts 0x0205, r18 Ändert man die Definition in: [c] { unsigned int rm_nr : 10; unsigned int
P. schrieb im Beitrag #3988429: > Unter asm wäre das unter Zeitaspekten > auch noch mit dem DS80C320 lösbar gewesen, allerdings war der RAM alle Das verstehe ich nicht. Der DS80C320 kann 64kB XDATA adressieren + 256B IDATA. Beim ATmega2560 ist es sogar weniger (64kB - 512B für IO).
-
Thread
Daten>32Bit auf AVR
(Gast)" berücksichtigen, und nicht immer 2 Ziffern in einem Byte, sondern 19 Ziffern in einem uint64_t in 8 Bytes verarbeiten. Ich hänge mal die nach .c umbenannte Arduino-Datei an, damit man sich den Code hier im Forum ansehen kann. Der Code ist aber ein Arduino-Sketch (.ino Datei).
Zeit. Das ist hier heute morgen über meinen seriellen Monitor in der Arduino-IDE gelaufen: [c] Start calculating 128 hex digits of PI first digit is digit #:8000 last digit is digit #:8127 calculating... 5 6E16369788D273CCDE96629281B949D04C50901B71C65614E6C6C7BD327A140A 45E1D006C3F27B9AC9AA53FD62A80F00BB25BFE235BDD2F671126905B204022
-
Thread
Problem mir C-Pointer oder Brett vorm Kopf
angenommen "input" enthält tatsächlich einen base64 String, dann sollte das auch so gehen: [c]unsigned char * decoded = base64_decode(input, test, &outputLength);[/c]
Der zweite Parameter von base64_decode ist die Länge des Eingabebuffers. [c] > char * toDecode = &input[0]; > uint16_t test = 40; > ... > ... base64_decode((const unsigned char *)toDecode, test, &outputLength); [/c]
-
Thread
LED Leiste ansteuern
ist dann > schlecht. Ja, sieht man im Listing ganz deutlich: [pre] int main( void ) { 4c: 81 e0 ldi r24, 0x01 ; 1 4e: 88 bb out 0x18, r24 ; 24 PORTB = 1; return 0; } 50: 80 e0 ldi r24, 0x00 ; 0 52: 90 e0
oder man ignoriert die Warnung wegen dem fehlenden Return-Wert). Wenns also spart, ein Grund mehr, C-konform zu sein. Man sollte auch nicht absichtlich versionsabhängigen Code schreiben. Peter P.S.: Ist auch nicht so der Brüller mit dem neuen Compiler beim ATtiny13 von den 64 Bytes SRAM
-
Thread
Atmega64 Beschaltung
oder eben Low-Power LED nehmen müssen, die anstelle von 15mA sich mit 1 bis 2mA zufrieden geben. 24 LED, a 15mA machen in Summe 0.36A. Ich kenn zwar die Grenze für den Mega64 nicht auswendig, aber das 360mA da weit drüber liegen weiß ich auch so.
Karl Heinz schrieb im Beitrag #3702693: > 24 LED, a 15mA machen in Summe 0.36A. Ich kenn zwar die Grenze für den > Mega64 nicht auswendig, aber das 360mA da weit drüber liegen weiß ich > auch so. OK. Ich hätte vorher nachsehen sollen.
-
Thread
µC mit viel RAM für Touch TFT mit "Wischen"
PIC24FJ256DA210 hat einen TFT Controller mit Speicher und mit der Charge Time Measurement Unit kannst du kapazitiven Touch auswerten. 64 Pin im 0,5 oder 100 Pin im 0,4 Raster. Gibts bei Microchip als
Torsten C. schrieb im Beitrag #3599303: > Ich denke mal laut: > > Bei 480 x 272 Dots und mehr wären schon 1..2MiB und mehr angebracht. Da > der PIC24… kein SDRAM kann, machen größere Speicher keinen Sinn
-
Thread
CRC oder einfach die Daten doppelt schicken?
nur Fehler erkennen, sondern auchkorrigieren: https://de.wikipedia.org/wiki/Zyklische_Redundanzpr%C3%BCfung#Erkannte_Fehler Siehe auch CRC-24.
, 0xcb61b38c, 0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c, }; const uint8_t *data = (const uint8_t *) buffer; for (size_t i = 0; i < size; i++) { crc = (crc >> 4) ^ rtable[(crc
-
Thread
itoa in Verbindung mit Einerstellen im "xx" Format.
foobar schrieb im Beitrag #6204566: >> for (c1 = '0'; c1 <= '9'; c1++) > > AI warning: condition c1 <= '9' is always true ;-) Vielleicht so? [C] c1 = '0'; while (value >= 10) { c1++; value -= 10; } [/C] Stefan ⛄ F. schrieb
Oder schafft es der > Compiler tatsächlich, den Rest aus der ersten Division zu nutzen? Aus [c] buf[0] = '0' + value / 10; buf[1] = '0' + value % 10; [/c] wird [avrasm] ldi r22,lo8(10) call __udivmodqi4 subi r24,lo8(-(48)) st Z,r24 subi r25,lo8(-(48))
-
Thread
AVR: I2C Write in EEPROM nicht möglich
LCD_CLEAR_DISPLAY; lcd_setcursor( 0, 1 ); lcd_string("Kontrollanzeige:"); i2c_init(); // initialize I2C library if(!(i2c_start(Dev24C64+I2C_WRITE))) //--> OK { i2c_write(0x05); // write address = 5 i2c_write(0x75); //
... */ LED(RED, LED_ON); } _delay_ms(50); i2c_start_wait(Dev24C64+I2C_WRITE); //device address/write mode; i2c_write(0x05); i2c_rep_start(Dev24C64+I2C_READ); // set device address /read mode ret=i2c_readNak();
-
Thread
Attiny-Entwicklungsumgebung rott?
rjmp .+30 ; 0x2e <__bad_interrupt> 10: 0e c0 rjmp .+28 ; 0x2e <__bad_interrupt> 12: 0d c0 rjmp .+26 ; 0x2e <__bad_interrupt> 14: 0c c0 rjmp .+24 ; 0x2e <__bad_interrupt> 16: 0b c0
12 32: 87 bb out 0x17, r24 ; 23 34: 87 bb out 0x17, r24 ; 23 36: 08 95 ret 00000038 <main>: 38: cc e0 ldi r28, 0x0C ; 12 3a: fa df rcall .-12 ; 0x30 <PowerUp> 3c
-
Thread
TCP Port x-IP Server Client Modell
group default qlen 1000 link/ether 0e:dc:7e:8e:62:72 brd ff:ff:ff:ff:ff:ff inet6 fe80::2c0d:63ff:fe3f:ccb7/64 scope link valid_lft forever preferred_lft forever 8: vm-server@if7: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc noqueue master br-fake-switch state LOWERLAYERDOWN
MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default qlen 1000 link/ether 12:71:82:95:c7:62 brd ff:ff:ff:ff:ff:ff link-netnsid 0 inet 10.83.5.2/24 scope global vs-server valid_lft forever preferred_lft forever inet6 fe80::1071:82ff:fe95:c762/64 scope link valid_lft
-
Thread
Viele Fragen und ein kleiner Blog
; Delay ; 500ms: ; ----------------------------- Delay500ms: ldi Dummy1, $24 S1: ldi Dummy2, $BC S2: ldi Dummy3, $C4 S3: dec Dummy3 brne S3 dec Dummy2 brne S2 dec Dummy1 brne S1 ret [/avrasm]
folgendes erst mal umgesetzt. [avrasm] ; ============================= ; Delay ; $24,$BC,$C4 = 500ms: ; ----------------------------- .macro Delay ldi Dummy1, @0 S1: ldi Dummy2, @1 S2: ldi Dummy3, @2 S3: dec Dummy3 brne S3 dec
-
Thread
Viele Kippwaagen, wie zählen?
Markt angekommen. > EEPROM das braucht zu viel strom Im automatischen Standby-Modus nimmt ein 24C04 dann auch nur nur 1µA auf. > und ist nur Begrenzt reprogrammierbar, also nicht als Zähler geeignet > der Permanent Zählt Wenn ich ein 24C04 Derivat für 16 Cent in Einzelstückzahlen mit 512 Bytes
speichern. Das dürfte für die Versuchsdauer gut reichen. https://www.reichelt.de/eeprom-4-kb-512-x-8-i2c-400-khz-2-5--5-5-v-so-8-st-24c04-mn-p45591.html
-
Thread
Gehalt/Gehaltsentwicklung Informatiker/Ingenieure 2019
Ich bin immer wieder erstaunt, wie im Internet ein völlig anderes Bild gezeichnet wird. Ich bin in C++, C# und Matlab fit und habe dies in einem Assessmentcenter nachgewiesen. Naja, im Mai habe ich erstmal ein Vorstellungsgespräch bei Brunel. Mal schauen was da geht.
Cyblord -. schrieb im Beitrag #5809811: >> Ich bin in C++, C# und Matlab fit und habe dies in >> einem Assessmentcenter nachgewiesen. > Ist das für einen E-Techniker das wichtigste? Als E-Techniker musst du deine Entwicklungen selbstverständlich
-
Thread
Wlan2Serial Modul für 5 euro
uint16 ICACHE_FLASH_ATTR adc_read(void) { uint8 i; uint16 sar_dout, tout, sardata[8]; rom_i2c_writeReg_Mask(0x6C,2,0,5,5,1); // disable interrupts.. SET_PERI_REG_MASK(0x60000D5C, 0x200000); while (GET_PERI_REG_BITS(0x60000D50, 26, 24) > 0); //wait r_state == 0 sar_dout = 0; CLEAR_PERI_REG_MASK
tout = (sar_dout + 8) >> 4; //tout is 10 bits fraction // // re-enables interrupts rom_i2c_writeReg_Mask(0x6C,2,0,5,5,1); while (GET_PERI_REG_BITS(0x60000D50, 26, 24) > 0); //wait r_state == 0 CLEAR_PERI_REG_MASK(0x60000D5C, 0x200000); SET_PERI_REG_MASK(0x60000D60, 0x1); //force_en=1
-
Thread
Hilfe um 8 Bitfelder in uint8_t umzuwandeln (ESP32)
7 setzen und ausgeben Test.Input.bit6 =1; printf("%d\n", Test.Byte); //Ausgabe: 65 (64+1) return 0; } [/c]
bool bit26 : 1; // OFFSET 26, LENGTH 1 bool bit25 : 1; // OFFSET 25, LENGTH 1 bool bit24 : 1; // OFFSET 24, LENGTH 1 // byte 4 (rest) + byte 5 uint16_t var5 :11; // OFFSET 29, LENGTH 11 } Input4; memcpy(&Input4, Data, len); [/c] funktioniert nicht. für bit24 ... bit28 oder
-
Thread
Temperaturmessung mit PT100
@San: Danke für den Tipp... Ich mach das über die Formel mit dem Logarithmus! Ich denke, bei einem 64MHz µC ist das kein Problem, vor allem, wenn ich nur alle Sekunden einen Wert berechne!
Gert schrieb im Beitrag #3570376: > Ich denke, bei einem 64MHz µC ist das kein Problem, vor > allem, wenn ich nur alle Sekunden einen Wert berechne! Ist es absolut nicht, kann ich dir bestätigen. Ich arbeite mit dem ADuC7020 mit 41 MHz. Brauche für 4 AD Messungen
-
Thread
AVR AtMega8 Preemtive Scheduler
fpt.html#defi void (*pt_function1)() = 0;//http://www.alenck.de/AVR_Tutorial_4_CVAVR/05_Syntax%20der%20C-Programmierung/CVAVR_05.pdf S.64 uint16_t *Stack_Ptr = 0; SIGNAL (TIMER2_COMP_vect)//TIMER1_COMPA_vect) { PORTC = 0b00100000; Stack_Ptr = SP;//assign current SP position to my own Stackpointer
60: fe b7 in r31, 0x3e ; 62 Stack_Ptr++; 62: 32 96 adiw r30, 0x02 ; 2 64: f0 93 64 00 sts 0x0064, r31 68: e0 93 63 00 sts 0x0063, r30 6c: 32 97 sbiw r30, 0x02 ; 2 *Stack_Ptr = pt_function1;// store function adress to adress pointed to by my own Stackpointer
-
Thread
Problem mit CodeVisionAVR
Ich habe mich da mal informiert. Der I2C-EEPROM Typ 24C64 wäre womöglich dafür geeignet. Dieser Chip hat 64KByte Speicher.
Für 30kB muß es mindestens ein 24C256 (32kB) sein. Der 24C64 hat nur 8kB. Peter
-
Thread
Problem mit gosub in Bascom
, 0 ' A Data 62 , 65 , 65 , 65 , 34 , 0 ' C Data 127 , 8 , 8 , 8 , 127 , 0 ' H Data 64 , 64 , 127 , 64 , 64 , 0 ' T Data 127 , 73 , 73 , 73 , 65 , 0 ' E Data
Text-Fehler. EDIT: Komisch, irgendwie zeigt der in der datei ab "RU" nicht mehr weiter an: [c] Data 64 , 64 , 127 , 64 , 64 , 0 ' T Data 50 , 73 , 73 , 73 , 38 , 0 ' S Data 62 , 65 , 65 , 65 , 34 , 0 ' C Data
-
Thread
Attiny24 Timer1, Frequenzmessen
Hallo in die Runde, ich hab da ein kleines Problem mit dem Timer am tiny24. Erstmal möchte ich den Timer einfach laufen lassen, den Wert auslesen und vergleichen. Der Tiny läuft auf 8Mhz. [c] TIMSK1 = (1<<ICIE1 )|(1<<TOIE1); TCCR1B = (1<<CS11)|(1<<CS10)|(1<<ICES1); //vorteiler 64, Positive Flanke [/c] [c] while(1) { if (TCNT1 <= 360) { PORTA &= ~(1<<PA3); } else { PORTA |= (1<<PA3); } } [/c] OK jetzt rechne mal
-
Thread
Lange Bitcodes speichern und ausgeben
2000/8=25 [c] uint8_t array[25]; array_fill(&array); //Ausgabe an PB0 DDRB |= (1<<PB0); for(uint8_t c=0; c<25; c++) { for(uint8_t c2=0; c2<8; c2++) { if( array[c]&(1<<c2) ) PORTB
aber 1MBit/s wird da auch nicht rauskommen und dein Controller ist während der Ausgabe blockiert. [c] unsigned char array[25]; register unsigned char buffer asm("r6"); register unsigned char counter asm("r7"); /*...*/ buffer = array[24]; /*...*/ ISR(TIMER1_COMPA_vect) { unsigned char
-
Thread
USB HOST und Device an USB-A
du deinen MCU als USB Stikc an > deinen Computer anschliessen ??? Viele Controller wie z.B. PIC24F64GB002 können sowohl Host als auch Device sein. https://www.microchip.com/en-us/product/PIC24FJ64GB002 fchk
deinen MCU als USB Stikc an >> deinen Computer anschliessen ??? > > Viele Controller wie z.B. PIC24F64GB002 können sowohl Host als auch > Device sein. > https://www.microchip.com/en-us/product/PIC24FJ64GB002 > > fchk Habe den PIC32MZ vorgesehen, wenn ich noch einen bekomme :-)
-
Thread
Fragen zu MISRA
c2000 schrieb im Beitrag #3321386: > Mit nichten! Ein char kann auch z.B. 16 bit lang sein. Z.B. beim C2000 > ist ein char immer 16 bit! Char kann bei einigen DSP auch 24bit sein.
Stefan Rand schrieb im Beitrag #3326654: >> Char kann bei einigen DSP auch 24bit sein. > > Nein. Mir ist zwar kein Beispiel bekannt, aber so ein definitives "Nein" würde ich da nicht hinschreiben. Selbstverständlich /kann/ es das sein, vom C-Standard her wäre das völlig
-
Thread
MC fuer Einsatz in Armbanduhr gesucht
Quellen bekommst Du die Teile für ~ 5 - 20€ hinterhergeschmissen: http://www.ebay.de/itm/0-96-I2C-IIC-SPI-Serial-128X64-OLED-LCD-LED-Display-Module-for-Arduino-blue-/201090248000?_trksid=p2054897.l5660 Wenn Du die Trägerplatine entfernst (oder gleich ein Display ohne Trägerplatine findest), dann
C8051F912
-
Thread
1 bit/s reicht
im Beitrag #6306218: > am atariST mit dem sensiblen Portchip Verwechselst Du das gerade mit dem C64? Der 6526 (mit kastriertem 5V-UART) war sehr empfindlich. Der ST wiederum hatte eine RS232 - wenn ich mich recht erinnere, mit MC1488/1489.
Hmmm schrieb im Beitrag #6306234: > Verwechselst Du das gerade mit dem C64? nö, ich wollte bei dem die Tastatur absetzen https://p5.focus.de/img/fotos/crop1012648/5812717800-w1200-h627-o-q75-p5/dig-Technik-Meilensteine-Atari-520-ST-2100.jpg Das Mainboard hatte ich
-
Thread
Datenlogger, 2000 sps
Den AT24C512 kannst Du seitenweise beschreiben: 1 Seite a 128 Byte mit typisch 5ms Schreibzyklus = 25kByte/s Peter
Ich glaube für meinen Fall (2000 Werte/Sekunde) reicht einen I2C-EEPROM (AT24C512) aus, um den AD-Wert ohne FIFO zwischendurch abzuspeichern. ich verstehe nur nicht, warum ein I2C-Schreibzugriff bei mir so lange dauert (2,5ms). Ich schreibe ja ein einziges Datenbyte
-
Thread
IPv6 für mikrocontroller.net
auch nicht: martin@newton:~$ ping6 heise.de PING heise.de(redirector.heise.de) 56 data bytes 64 bytes from redirector.heise.de: icmp_seq=1 ttl=58 time=24.1 ms 64 bytes from redirector.heise.de: icmp_seq=2 ttl=58 time=23.4 ms martin@newton:~$ ping heise.de PING heise.de (193.99.144.80) 56(84) bytes of data. 64 bytes from redirector.heise.de (193.99.144.80): icmp_req=1 ttl=243 time=6.53 ms 64 bytes from redirector.heise.de (193.99.144.80): icmp_req=2 ttl=243 time=7.17 ms
-
Thread
Chip als Mehrfach Umschalter
Der sollte folgende Pins haben. 1.) 1 Eingang. Belastbar mit 5 Volt da Schaltspannung. 2.) i2c Bus für die Befehle. 3.) Jede Menge Ausgänge (je mehr desto besser) Folgende Aufgabenstellung. Der Eingangspin bekommt ein Signal / Strom bis zu 5 Volt/ GND oder was auch immer. Per i2c bekommt
Mit I2C wüsste ich nichts aber mit SPI gibt es den 64-Fach Schalter STHV64SW. Einfach alle Eingänge miteinander verbinden und du hast einen 64-Fach Multiplexer.
-
Thread
Was ein C++-"Guru" so ueber Geschwindigkeit erzaehlt.
verschiedene Schreibweisen den gleichen Assembler. Hier mal für die beiden obigen Routinen (AVR-GCC): [c] void copy_i(int* src, int* dst, int elements) { c0: dc 01 movw r26, r24 c2: fb 01 movw r30, r22 c4: 20 e0 ldi r18, 0x00 ; 0 c6: 30 e0 ldi r19, 0x00 ; 0 c8: 06 c0 rjmp .+12 ; 0xd6 <copy_i+0x16> for(int i = 0; i < elements; i++) dst[i] = src[i]; ca: 8d 91 ld r24, X+ cc: 9d 91 ld r25, X+ ce: 81 93