-
Thread
Was kann man mit 16Byte an RAM machen?
Interrupts können zu jedem beliebigen Zeitpunkt feuern, welche Register > will man da sichern - AVR hat 32 davon - alle ? > > Wenn man ein nur einigermassen kompliziertes Programm in ASM schreibt, > müssen die benutzten Register und die geänderten Variablen irgendwo > verfolgt und festgehalten
Interrupts können zu jedem beliebigen Zeitpunkt feuern, welche Register > will man da sichern - AVR hat 32 davon - alle ? Was für ein Unsinn - wozu Register sichern, die in der ISR garnicht verändert werden? Das sind aber nun wirklich allerprimitivste Grundlagen, die jeder Assembler-Programierer
-
Thread
Erkennung von Modellfahrzeugen per Infrarot ID
Hallo, ich habe eigentlich eine einfache Aufgabe: Ich will Modellfahrzeuge (1:14) erkennen und unterscheiden können. Hintergrund ist die Erfassung von Fahrten auf einer Waage. Habe mich schon viel Beraten und Recherchiert und war erst bei NFC. Allerdings habe ich weder den
Empfänger egal, der den Seriellen Datenstrom ausgibt. Von da aus dachte ich, der Sender gibt eine 32Bit Zahl aus. Der Empfänger in dem Boden der Waage empfängt diese und gibt dies an den Hauptprozessor weiter. Meine Erfahrungen beschränken sich bisher allerdings auf ATmega und avr-gcc. Bevor ich
-
Thread
PROM lesen /schreiben / Programmiergerät
Leser, dann lese ich die PROMs mal aus. Aus dem PLL Manual hab ich noch gesehen, dass eine Frequenz 32 Bit hat. Macht auch sind 32 Frequenzen mal 32 Bit = 1024 Bit des PROM
Update: Ja lese gerade: 1792 Bytes Programm-Speicher-PROM, organisiert in 1024 Worten zu je 14 Bits, nur einmal programmierbar.:( Gut könnte ihn wohl auslöten und durch einen beschreibbaren ersetzen
-
Thread
DTMF decoder
Telefonatmitschnitten, aber der Spezialbaustein MT8870 ist perfekt und kostet keinen Euro. [c] #include <avr/io.h> #include <math.h> int32_t MulAndDiv65536(int32_t v32, uint16_t v16) { uint32_t t0 = ((((uint32_t)v32&0xffff)*v16)+0x8000)>>16; int32_t t1 = (v32>>16)*v16; return t1+t0; } int16
MOVW R12,R14 Copy register pair 0000026B CLR R14 Clear Register 0000026C CLR R15 Clear Register int32_t t1 = (v32>>16)*v16; 0000026D MOVW R18,R6 Copy register pair 0000026E CLR R21 Clear
-
Thread
Ich versuch es ja, aber ich werde mit C++ einfach nicht warm :(
tigcc.ticalc.org/doc/stdint.html#UINT8_C Das es anders sein sollte sehe ich ja ein, ist es aber nicht. UINT32_C() sieht so aus: [c] # define UINT32_C(c) c ## U [/c] Okay, das leuchtet mir halbwegs ein. Ob das mit dem UINT8_C() jetzt wirklich ein "Bug" ist kann ich nicht beurteilen.
sinnvoll einsetzen und nicht so willkürlich, wie in besagtem Buch. Meine Bibliothek habe ich für AVR und stm32 geschrieben. Da wird es dann schnell haarig, weil man jede Funktion, die man beim stm32 aus der STL verwenden könnte, beim AVR nach implementieren muss. Selbst der C-Standard ist nicht einheitlich
-
Thread
Getting started Stm32F4 + WS2812
Zeit in die digitale Welt einsteigen. Hierfür habe ich mir den Arm Mikrocontroller-EVM von STM (Stm32F401 und Stm32F11) geholt. Ich habe desöfteren schon an Mikrocontrollern gearbeitet - PICS , AVRs etc sind mir nicht ganz so fremd nur das Problem war, dass ich die Entwicklungsumgebung + Hardware schon
1,14 µs, 0,76 µs / 0,76 µs). Importiere dir mal das hier: https://developer.mbed.org/users/JojoS/code/cylon/ Getestet mit einem STM32F429 Disco Board. Wenn deine LED Kette kürzer ist müssen das define
-
Thread
Wird gdb eigentlich produktiv eingesetzt?
zieht sich aber durch die ganze gnu Welt: Man braucht Zeit > zum Einarbeiten. > Früher auf dem AVR war ich noch mit notepad und avrgcc, PonyProg und > printf unterwegs, heute auf ARM Cortex möchte ich MDK-ARM/ULINKpro mit > den ganzen Debug- und Trace- Möglichkeiten sowie grafischer Darstellung
mehr missen. Dafür kann GCC auch nicht-antike Sprachstandards. Bei sinnvoller Verwendung von C++14 findet der Compiler bereits eine Menge Fehler von alleine, sodass man gar nicht mehr so viel Zeit mit den tollen Debuggern verbringen muss...
-
Thread
Viel Information mit wenig Bytes übertragen
auch wieder Verschwendung irgendwie). Ich könnte auch die zwei Bytes zusammenlegen und könnte dann −32.768 bis 32.767 codieren. Das auf einen sinnvollen Temp Bereich gemappt (z.B. -40 bis +88 --> 128°) ergibt zB. folgendes: Wertebereich = 65.535 (dh. ich habe eine Auflösung von 128 / 2^16 = 1/512
Paketes (00 = Temperatur, 01 = Luftfeuchte, 10 = Windgeschwindigkeit, 11 = ?). Dann hast du immer noch 14 Bit (= 8192 Werte) für die Information übrig.
-
Thread
SSD1306 Display Probleme bei Zahlendarstellung
) : - 0x003A Colon {0x00,0x56,0x36,0x00,0x00}, // ( 27) ; - 0x003B Semicolon {0x08,0x14,0x22,0x41,0x00}, // ( 28) < - 0x003C Less-Than Sign {0x14,0x14,0x14,0x14,0x14}, // ( 29) = - 0x003D Equals Sign {0x00,0x41,0x22,0x14,0x08}, // ( 30) > - 0x003E Greater-Than
Letter N {0x38,0x44,0x44,0x44,0x38}, // ( 79) o - 0x006F Latin Small Letter O {0x7C,0x14,0x14,0x14,0x08}, // ( 80) p - 0x0070 Latin Small Letter P {0x08,0x14,0x14,0x18,0x7C}, // ( 81) q - 0x0071 Latin Small Letter Q {0x7C,0x08,0x04,0x04,0x08}, // ( 82) r - 0x0072
-
Thread
Problem UC1608 Grafik LCD
PiTris oder in Assembler: (ganz unten) http://www.midasdisplays.com/products/controllers-on-board-32.page mit freundlichem Gruß
PIC, nicht SPI. Ich habe oben das Datenblatt vom PIC verlinkt, schau mal da auf Seite 132, FIGURE 14-3: SPI MODE WAVEFORM (MASTER MODE).
-
Thread
128 Bit Risc
mod64) { //[ uint ctz = mod64 ? 0 : 64; if (ctz) { return ctz; } else { ui32* pui32 = (ui32*) &mod64; if (pui32[0]) { _BitScanForward((DWORD*) &ctz, pui32[0]); } else if (pui32[1]) { _BitScanForward((DWORD*) &ctz, pui32[1]); ctz
cnt = 0; c = 0; do { // 32bit implementation cnt++; flg = (*((ui32*) (&x.l))) & 1; // w = x/2; t32 = ((*((ui32*) (&x.h))) & 1) << 31; w.h = x.h >> 1; w.l = x.l >> 1; (*(((ui32*)
-
Thread
WS2812 LED-Streifen mit Raspberry Pi 3 ansteuern?
ware das Prinzip (egal ob SPI oder UART) leider deutlich komplizierter umzusetzen als beim AVR. Jedenfalls wenn Linux als OS die Basis sein soll... Dazu würde nämlich der Kern meiner AVR-Lösung als Treiber umgesetzt werden müssen, sonst grätscht das nicht echzeitfähige System für den userspace
branch, ld, shift, out...) 8 Register POP = 8Cy //* Selbst mit nur 4 Registern sind es 14us ISR reti = 4Cy ============================== Gesamt = 32Cy [/c] 32Cy * 4 Aufrufe = 128Cy = 16us bei 8MHz. Anstatt 9-10us bei Bitbanging. Dann gibt
-
Thread
Servo an Atmega328p funktioniert nicht
auch Beispielprogramme, auch für Servos, aber leider auch ohne stack-Werte. Verwende mal $hwstack=32 $swstack=8 $framesize=24 edit Hab' das $framesize erhöht Schau in der bascom Hilfe unter BASCOM Language Reference ->Compiler Directives -->$HWSTACK
'wert von Poti 1 Adcin1 = Adcin1 - Potimid '-512...512 Adcin1 = Adcin1 / 16 '-32...32 Servovalue1 = Adcin1 + Servomid Adcin2 = Getadc(4) 'wert von poti 2 Adcin2 = Adcin2 - Potimid '-512...512 Adcin2 = Adcin2 / 16 '-32...32 Servovalue2 = Adcin2
-
Thread
Pin auf high setzen MKL26
Peripheral Access Layer * @{ */ /** GPIO - Register Layout Typedef */ typedef struct { __IO uint32_t PDOR; /**< Port Data Output Register, offset: 0x0 */ __O uint32_t PSOR; /**< Port Set Output Register, offset: 0x4 */ __O uint32_t PCOR; /**< Port Clear Output Register, offset: 0x8 */ __O uint32_t PTOR; /**< Port Toggle Output Register, offset: 0xC */ __I uint32_t PDIR; /**< Port Data Input Register, offset: 0x10 */ __IO uint32
-
Thread
ATMega16u2 auslöten geht nicht, warum?
Ja, ein großes Massepad hat der QFN32: http://i.ebayimg.com/images/g/dpwAAOSwZG9WkmQi/s-l300.jpg (nächstbestes Bild) Also nächster Versuch mit mehr Power. Hab mich da heute nicht mehr getraut...
ig sagen kann, ob alle Pads des IC wirklich Kontakt haben, denn die sind ja unter dem Chip beim QFN32. Optisch von der Seite sieht es ok aus. > Bei Youtube gibts herrliche Videos zu sehen, wie man ICs in SMD-Technik > lötet. Da kriecht dank des Flussmittels das Lot von selbst an seinen > Platz
-
Thread
langsamstes Quart für welche Baudrate? Gesperrt
Ach ja, Atmega32
Frage steht dann im Raum, welcher Takt wird mindestens für SPI benötigt? Natürlich weiterhin Atmega32! also kein Multiplikator etc Ich gehe davon aus mit 32.xxxkhz ist beim Mega32 kein Uart mehr möglich?
-
Thread
Verbindungsprobleme Atmega328
Copyright (c) 2007-2009 Joerg Wunsch System wide configuration file is "C:\WinAVR-20100110\bin\avrdude.conf" Using Port : com6 Using Programmer : stk500 AVR Part : ATMEGA328P Chip Erase
Bei mir kamen solche Phänomene eigentlich nur, wenn der ISP-Takt bei 'frischen' AVR zu hoch war. Mit '-B20' als avrdude-Parameter konnte ich dann aber trotzdem ohne Probleme flashen. Grüße Oliver
-
Thread
Anfänger: Microcontroller programmieren?
Mikrocontrollern kompatibel. Wenn Du eine richtig universelle Lösung willst, die mit ganz vielen AVR-Mikrocontrollern kompatibel ist, dann musst Du von solchen Development Boards Abstand nehmen, alles auf Steckboard aufbauen, einen sogenannten "AVR ISP Programmer", einen USB-Seriell-Wandler etc. kaufen
my2ct http://www.mcselec.com/index.php?option=com_docman&task=cat_view&gid=99&Itemid=54 BASCOM AVR DEMO dazu noch das Handbuch, und los gehts
-
Thread
DIY Frequency Counter mit 10 bis 12 Digits?
Helmut L. schrieb im Beitrag #5243117: > 64 Bit Integer geht auf einem AVR aber seeehr langsaaamm. Das stimmt nicht. Sofern man die internen Register im Griff hat, dauert es doppelt solange wie bei 32 Bit. Man kann das auch ausrechnen: 2 x 32 = 64 ;-) > 64Bit Float kann
mit Festkomma ? oder zwingt das schon zu Fließkommaoperationen? > > 64 Bit Integer geht auf einem AVR aber seeehr langsaaamm. Jetzt bleib mal auf dem Teppich. Da der AVR eine 8-Bit ALU hat, muß er alle Operationen mit längeren Zahlen stückweise machen. Eine Addition von zwei 32-Bit Zahlen braucht
-
Thread
MIPS Global Pointer Linker error
werden, darf dieser Speicher nicht größer als 64k sein. Bisher hat alles funktioniert, bis ich ein 32kByte großes Array angelegt habe. Dieses landet laut mapfile aber komplett richtig im .bss Aber trotzdem habe ich nun diesen Fehler beim compilen: [code]ld: small-data section exceeds 64KB; lower
Das große Array ist in linpack.o vorhanden. Die Erklärung des Linkerscripts: http://www.fritzler-avr.de/spaceage2/soft_start.php Hat da wer ne Idee was da Amok läuft?
-
Thread
MCP3201 mit Atmega 8 in BASCOM
ADC noch nicht, möchte aber wissen wie das geht. Wären die Anschlüsse so richtig? CLK(ADC)--->SCK(AVR) pin 17 Dout--->MISO pin 16 CS--->SS pin 14 MfG Steven
------------------------------------ ' System Settings '--------------------------------------- avr.device = atmega328p avr.clock = 16000000 avr.stack = 42 '--------------------------------------- ' Macros '--------------------------------------- #define BV(n) as ( 1<<(n) ) #define NBV
-
Thread
Problem: 16 Bit Variable über UART zu empfangen
18432000 #include <stdio.h> #include <string.h> #include <stdlib.h> #include <stdio.h> #include <avr/wdt.h> #include <util/delay.h> #include <avr/io.h> #include <avr/interrupt.h> volatile uint8_t AufstromzeitHB = 0; volatile uint8_t AufstromzeitLB = 0; volatile uint16_t Aufstromzeit = 0; int
Blöcken zusammenfasst und auf die Adressbits verzichtet, also bei einem Nutzdatenblock mit 7 oder 14 Bytes.
-
Thread
Ausgaben von objdump
LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) */ /* Linker script for ATMEL(R) AVR(R) ATmega32P. */ INPUT(libc.a libm.a libgcc.a) OUTPUT_FORMAT("elf32-avr","elf32-avr","elf32-avr") OUTPUT_ARCH(avr:5) /* The beginning and end of the program ROM area. */ /* Leave 4 bytes
Avr und stm32 schon recht groß. Egal wie - jedenfalls wollte ich die Methodik der Funktionsumbenennung auf beiden Systemen nutzen, fand aber die Ausgaben von objdump (womit wir wieder beim Thema wären)
-
Thread
Was ist das für ein Microcontroler?
Ich tippe mal auf einen Atmega32. Mit der Mozzi-Lib kommen die Arduinos auf 14Bit DAC Werte ( durch das Mischen zweier PWM Ausgänge ). http://sensorium.github.io/Mozzi/
Markus schrieb im Beitrag #4794767: > Ich tippe mal auf einen Atmega32. > Mit der Mozzi-Lib kommen die Arduinos auf 14Bit DAC Werte ( durch das > Mischen zweier PWM Ausgänge ). Ich habe auch so ein "Piano" und gerade mal am Ausgangspin gemessen: da kommt wirklich ein
-
Thread
SPI flash GD5F1GQ4UB auslesen
Schade das Du nicht mit STM32 arbeitest. Für den und deinen Chip gibt es hier etwas: https://github.com/rgwan/stm32-gcc/blob/master/workspace/src/msc/bsp_nand.c Vielleicht lässt sich daraus eine abgespeckte Version für AVR
hp-freund schrieb im Beitrag #4793752: > Schade das Du nicht mit STM32 arbeitest. Einen STM32 hab ich rumliegen. > Vielleicht lässt sich daraus eine abgespeckte Version für AVR machen. Da ist ja gleich ein ganzes Dateisystem dabei... Ich befürchte das macht die
-
Thread
Assembler Zeitverzögerung
evtl. Dein Wert atomgenau (falls DCF77 noch verfügbar ist). https://www.mikrocontroller.net/articles/AVR
rcall wait56clk wait56clk: rcall wait28clk wait28clk: rcall wait14clk wait14clk: rcall wait7clk wait7clk: ret [/code] Zyklen gelten für Einsprung mit RCALL bei AVR mit 16-Bit Programmzähler Gruß Jobst
-
Thread
Informationen zu C vs C++ / aka Futter für die Diskussion
Falls wer heut noch was zum Lachen braucht: https://www.youtube.com/watch?v=tsG95Y-C14k&index=32&list=PLHTh1InhhwT7GoW7bjOEe2EjyOTkm6Mgd Zu gut. :)
C++ (Buch von Christopher Kormanyos) ref_app https://github.com/ckormanyos/real-time-cpp stm32f103 template lib: https://github.com/ekoeppen/stm32f103-template-lib Stm32-Template-Gpio-Library: https://github.com/ThatEmbeddedGuy/Stm32-Template-Gpio-Library
-
Thread
Speicherfragmentierung kein Thema mehr?
besser) wissen. Ja. Ich habe schließlich erstens selbst mal ein malloc() geschrieben (in der avr-libc), zweitens mir das angesehen, was andere da so machen. (Die avr-libc-Implementierung macht allerdings kein Pooling, da so ein AVR halt nur wenig RAM hat und man dann zu viel verschwendet.)
der kernel32.dll ist, und hoffentlich so effizient, wie irgend möglich arbeitet.
-
Thread
Für was ist diese Doppeldiode
die Portanschlüsse dargestellt. Anbei ein Anschluss. Ich frage mich für was da die Doppeldiode D14 ist? Da ist ja ein Spannungsteiler dargestellt, nur versteh ich nicht was die D14 da soll? Kann mir da jemand mit der Erklärung helfen?
nicht. Da die STM32 auch oft 5V tolerante Eingänge haben, können sie hier sogar sehr sinnvoll sein. In diesem Fall solltest du dann statt VCC_AVR die 3,3V verwenden, aus denen der STM32 gespeist wird.
-
Thread
Neue 8-Bit Tinys vorgestellt: 417/814/816/817 Gesperrt
denke da vor allem an die AT91RM9200 bzw. AVR32AP. Aber auch die AVRs hatten (haben?) Ihre Tücken (EMV...). Über die AT89er wollen wir garnicht reden.
Strombedarf (zu hoch) war schon manchmal ein Thema, mit den pico-power Typen aber ok. Die grössern Atmels (AVR32 oder XMega) habe ich eh nie angefasst Inzwischen sind sie (gemessen an der Leistungsfähigkeit und in Produktionsstückzahlen) einfach auch zu teuer geworden.
-
Thread
"Universalprogrammer" für Linux
programmierbaren Devices umfasst derzeit etwa 400 Typen, wobei teilweise auch generische dabei sind (z.B. STM32F0xx-32K), die meherere Typen abdecken. Programmiert werden können: - Atmel AVR (SPI) - Atmel ATxmega (PDI) - Cypress PSOC4 (SWD) - Microchip PIC10xx/PIC12xx/PIC16xx - Microchip PIC18xx - Microchip
Forderungen, dass der Quellcode auch mit der Arduino-IDE übersetzbar und flashbar ist... STM32: Bevor ich über 20000 Zeilen Assemblercode von AVR nach Thumb2 übersetze, fallen mir sicher sinnvollere Projekte ein :-) Jörg
-
Thread
LED-Matrix 32x16 mit ATMEGA32_ Lauflicht darstellen
Wie kann ich nun den Pixel erst komplett durch die Reihen schieben?? Also(Die Zahlen 0 bis 7, dann 32 bis 39, dann 64 bis 71, dann 96 bis 103) und dann so weiter??? Iwie mit Schleifen oder evtl Funktionen? #define F_CPU 14745600 //Quarz mit 14.745 MHz #include <avr/io.h> #include <inttypes.h
Dann hilft Dir sicherlich auch diese Zusammenstellung für die avr gcc Programmierung: https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial Natürlich muss man Einzelheiten immer am aktuellen Datenblatt deines Atmel AVR µC fest machen.
-
Thread
Wieso gibt es keine gute Programmiersprache?
dann brauchst du nicht jedes Mal dein BASIC-Programm auszuführen. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81
zwischen beiden nicht unterschieden hat, waren halt alles Daten. So macht's ja am Ende auch der AVR-GCC.
-
Thread
mal wieder: Spass mit Linux Gesperrt
anderen kackte auch immer irgendein Prozess ständig ab). Habe dann mal die Vorgängerversionen (V14) durchprobiert, und damit gab es nie ein Problem. Bin also dann auf sein Lubuntu V14 wieder zurückgegangen, und habe dem gesagt, er solle nur noch updaten, aber nicht upgraden, weil böse für die schon
mit Fernschaltung ist der AVR Pollin NETIO m1284p auch geeignet und genügsam
-
Thread
AVR führt Programm nicht aus, wenn zusätzliche Funktionen definiert sind
was ist es denn für ein AVR?
Das ist exakt das, was ich mit avr-gcc übersetzt habe.
-
Thread
Wie die Baudrate am Pin rausfinden? Gesperrt
glaube wenn ich erst mal die Spannungspegel kenne würde ich ein bis zwei Programme schreiben win LCC32 oder AVR und alle möglichen Baudraten, Startstopbits und parity durchtesten bis was sinnvolles erscheint wenn ich denn erkenne was sinnvoll ist! Kann ASCII sein oder nur Bytes in unbekannter Reihenfolge
Wenn man im Gerätemanager zb 19k Schnittstellengeschwindigkeit einstellt und im TerminalProgramm zb 14k Geschwindigkeit, funktioniert das trotzdem? Oder muß im Gerätemanager erst wieder 14k eingstellt werden? Vielen Dank
-
Thread
Atmega flashen nach Ubuntu Upgrade nicht mehr möglich
Hallo zusammen, ich habe von Ubuntu 14.04 auf 16.04 geupdatet. Seit diesem Zeitpunkt funktioniert der upload von Arduino Sketches mittels einem avrisp mlII auf atmega 168 oder 328 nicht mehr. Ich vor längerer Zeit mal eine Leiterplatte mit
avrdude: Recv: . [01] . [00] . [0a] A [41] V [56] R [52] I [49] S [53] P [50] _ [5f] M [4d] K [4b] 2 [32] avrdude: stk500v2_getsync(): found AVRISP mkII programmer AVR Part : ATmega168 Chip Erase delay : 9000 us PAGEL
-
Thread
wie variablenadresse in einer eff datei ändern?
Hi. Ich habe ein Problem mit einer eff Datei. Avr und avrstudio 4.18. Etliche variabeln werden nicht aufgelöst. Im map file sehe ich das die Adressen auf komischen werten stehen. H Kann man das irgendwie ändern? Klaus
wie Lookuptabellen zur Laufzeit im RAM haben will. Bei AVR hat man das Problem nicht, wird eh ins RAM geladen, das stimmt.
-
Thread
Interessante g++ Erweiterung für user-defined literals
technical report changes. Calling conventions for any target might also change. At present, only the AVR, SPU, M32C, RL78, and x86 targets support address spaces other than the generic address space. Address space identifiers may be used exactly like any other C type qualifier (e.g., const or volatile
Meine aktuellen Randbedingungen: ******************************* Mcucpp, Atmel-Studio6.2 und avr-gcc-8.0_2017-07-19_mingw32
-
Thread
Einbausteckdose mit eingebautem Zeitschalter
Für den Funkschalter oder wlanschalter zeitgesteuert anzusteuern gibt es auch Lösungen, Arduino, AVR, 1,-€ 433 MHz Funken.
wissen, wie sie die Kindersicherung deaktivieren, dann fragen Sie Ihre Kinder." Als Vater einer 14jährigen kann ich dem nur zustimmen. Ich ziehe sie öfter zu Rate wenn irgendetwas "Tamper proof" ist.
-
Thread
Inbetriebnahme ENC28J60 Radig/RoeBue Arduino nano3
Dokumente und Einstellungen\jar>ping 192.168.178.90 Ping wird ausgeführt für 192.168.178.90 mit 32 Bytes Daten: Antwort von 192.168.178.90: Bytes=56 (gesendet 32) Zeit=1ms TTL=128 Antwort von 192.168.178.90: Bytes=56 (gesendet 32) Zeit=1ms TTL=128 Antwort von 192.168.178.90: Bytes=56 (gesendet 32) Zeit=1ms TTL=128 Antwort von 192.168.178.90: Bytes=56 (gesendet 32) Zeit=1ms TTL=128 Ping-Statistik für 192.168.178.90: Pakete: Gesendet = 4, Empfangen = 4, Verloren = 0 (0% Verlust), Ca.
-
Thread
Leiterplatten-Layout so in Ordnung?
MOSFET-Ansteuerung ist komisch. Nimm lieber Logic-Level MOSFETs ala IRLZ34N, die kann man direkt vom AVR mit 5V ansteuern. Aber bitte an jedem Gate 10K gegen Masse, damit sie sicher aus sind, wenn der AVR im Reet ist. >Ziel ist das elektrische Zünden eines Feuerwerks. Dazu werden A-Zünder >eingesetzt
Schaltzeit ausreichend schnell zünden. >Der 2K zum Entladen ist okay? Brauchst du nicht, der AVR hat Push-Pull Ausgänge, der kann aktiv auf LOW schalten.