-
Thread
Denke ich zu kompliziert?
im Beitrag #2868458: > ... gemixt mit Hardwarezugriffen. Der einzige Hardwarezugriff ist das Port Einlesen und das kann man nicht weglassen. Das kann natürlich auch eine Funktion sein, wie z.B. bei der Tastaturmatrix mit ADC. jay schrieb im Beitrag #2868458: > Zwar perfekt optimiert, > aber
Unter Schmerzen sollst du deine Programme > entwickeln". Das heisst nicht "Biebel", das heisst "Bi-AVR-bel!" :-) Meint Harald
-
Thread
Drehencoder auswerten
Wenn ich Dich richtig verstehe, willst Du den Drehgeber über die Ports des PCA8574 einlesen, oder? Hast Du bedacht, daß die Abtastrate dieser Ports durch die I2C-Verbindung begrenzt ist? Angenommen, Du taktest den Bus mit 400kHz (Maximum für den PCA8574). Du brauchst
Flanken zu erkennen, steigt die Interrupt-Last mit der Drehzahl. Die Frage ist: Kannst Du in Deinem AVR soviel Interrupt-Last vertragen oder nicht? Wenn ja: Häng den Encoder direkt an Port-Pins. Wenn nein: Könntest Du z.B. einen zweiten, kleinen AVR spendieren, der nichts anderes tut, als den Drehgeber
-
Thread
Datenlogger mit SD Karte, hoher Samplerate und 12-Bit ADC
hängt von deinen zu messenden Spannungen ab und der Stromversorgung. Die Grundbeschaltung eines AVR gibs zur Genüge im Netz sowe den Anschluss der SD Karte am AVR.
Steht hier alles auf der Webseite. Den proggste in C mit WinAVR oder AVR Studio. Das Programmiergerät heißt AVR ISP (gibt verschiedene). USBasp gibs fürn 10er beim ebaychinesen.
-
Thread
Falsche Anzeige nach Spannungsverlust
void LCD_Init() { RS_LOW; delay_ms(110); PORTC = 0b00110000; // Setze D4, D5 Port zu 1 _E(); // High->Low zu E Port (Puls) delay_ms(80); PORTC = 0b00110000; // Setze D4, D5 Port zu 1 _E(); // High->Low zu E Port (Puls) delay_ms(80); PORTC = 0b00110000; // Setze D4, D5 Port zu 1 _E(); // High->Low zu E Port (Puls) delay_ms(80); PORTC = 0b00100000; // Setze D4 zu 0, D5 Port zu 1. Wechsel in den 4 Bit Modus. _E(); // High
-
Thread
Was ist Arduino?
pinMode(LED_PIN, OUTPUT); digitalWrite(LED_PIN, HIGH); oder DDRB |= _BV(LED_PIN_PORT_B); PORTB |= _BV(LED_PIN_PORT_B); ist jetzt nicht so die Welt. Schön ist natürlich bei der Arduino Variante, dass Du nicht wissen musst an welchem Port der Pin hängt. Das Programm läuft also
, in Assembler programmiere und die Hexdatei (ggf. auch EEP-Datei, Fuses, Lockbits) per ISP in den AVR schaufle? ...
-
Thread
A2DP Bluetooth Modul China eBay
einfach: man braucht einen EEPROM-Leser/-Programmierer (gibt's als "Minimalvariante" über den LPT-Port) und entsprechende Software wie z.B. PonyProg. Dann EEPROM vom Modul weglöten, an den Leser/Programmierer, Inhalt einlesen, abändern, wieder zurückschreiben, fertig. MfG
Gehäuse. Ich habe auch schon daran gedacht, nach dem einschalten alle commands mit einem kleinem AVR an das Modul zuschicken. Ich finde es aber ziemlich um die Ecke gedacht. Zumal ich schon einen AVR drin habe, allerdings einen Tiny10. :-( Das Modul braucht ja nur das Eprom zu beschreiben. Wenn
-
Thread
GCC: Aufruf mehrerer Inline-Funktionen schießt den AVR ins Nirvana
_always_inline__)) #endif static inline int gpio_local_get_pin_value(uint32_t pin) { return (AVR32_GPIO_LOCAL.port[pin >> 5].pvr >> (pin & 0x1F)) & 1; }[/c] Wie vorgeschrieben ist mein clock für den Port genauso groß wie der CPU-Takt. Rufe ich nun ein paar mal diese Funktionen zum Setzen,
statt dessen den Befehl selber auf, läuft wieder alles. Ein Aufruf würde dann also so aussehen: [c]AVR32_GPIO_LOCAL.port[CLK_PIN >> 5].ovrc = 1 << (CLK_PIN & 0x1F);[/c]
-
Thread
µC hängt sich nach einer weile auf
aus. Wenn deine Ports nicht mehr verändert werden, dann liegt das daran, das er nicht mehr zu der Stelle im Programm kommt, wo die Ports verändert werden. An andere Teile kommt er, vieleicht weil das über Interrupts geschieht
*********************** if (z.imp_s_E){ //Temmperatur einlesen jede sek if(PORT_VER_T &(1<<PIN_VER_T)){ //Wenn Versorgung des Temp.F. aktiv dann Temp. lesen ansonsten nach Fehler(deaktiviert) wieder aktivieren
-
Thread
Schalter einlesen Entprellen notwendig (kein Taster)
Guten Abend zusammen, ich möchte 4 Schalterzustände einlesen. Die Schalter hängen an meinem Mega8 an Port D und zwar PD0...PD3 und schalten Masse an den Port. Schalter offen liegen am Port 5V an (interner Pullup). Mich interessiert nicht der akute Zeitpunkt
vorstellen? > Dann wäre das konrekt im meinem Vorhaben so zu erledigen: > > [c] > uint8_t WertPORT =0; > if get_key_state( ( ( 1<<PD0 ) |( 1<<PD1 ) |( 1<<PD2 ) |( 1<<PD3 ) )){ > // hat sich irgendein Status der 4 Tasten geändert > WertPORT = PIND; // Port einlesen > [/C] [C] WertPORT=
-
Thread
Portpins geschickt einlesen
Prozessor: AVR Atmega8 Hallo, ich möchte eine Kombination aus 3 Portpins geschickt einlesen und je nachdem, welche Kombination ausgewählt ist, etwas Bestimmtes tun. Und zwar so wollte ich beispielsweise Port
Frage, wie man das am besten im Programm einliest, um etwas zu machen. Angenommen man würde nur Port C verwenden und sonst dort nichts anschließen, so könnte man ja den ganzen Port in eine Variable einlesen und bekommt eine Zahl als Ergebnis. Diese könnte man dann auswerten. Am einfachsten wäre es
-
Thread
ARM: kompliziert?
und Umständlichkeit gleichzusetzen. Das ist nicht der Fall. Vereinachtes Beispiel: Wenn ich nen AVR mit einem Port und 8 IO Pins habe (angenommen in der Ausführung gibt es den) und wechsle auf einen Arm der nun zwei Ports mit je 8 Pins hat. Dann läuft das Orginalprogramm genauso auf dem Neuen. Mein Programm ist also genauso einfach gehalten wie vorher. Der AVR lässt sich genauso einfach/ nicht komplizierter wie vorher ansteuern. Dennoch ist der AVR komplexer (um genau einen Port) Wenn du also von Komplexität sprichst, dann trägt das nur dann zur Umständlichkeit
-
Thread
BASCOM LCD 20*4
' Relais 12 Volt für alles Pwr_tft Alias Portg.1 Pwr_video Alias Portb.7 Pwr_xbee Alias Porte.2 Pwr_gps Alias Portc.6 Pwr_lcd Alias Portg.3 ' LCD GND Tft1 Alias Portb.5 Tft2 Alias Portb.3 Tft3 Alias Portb.1 Tft4 Alias Porte.7 Tft5 Alias Porte
'---- LCD ---- Config Lcd = 20 * 4 Config Lcdpin = Pin , Db4 = Portb.2 , Db5 = Portb.0 , Db6 = Porte.6 , Db7 = Porte.4 , E = Portb.4 , Rs = Portb.6 Cursor Off Deflcdchar 0 , 32 , 32 , 21 , 14 , 4 , 4 , 4 , 4 ' Link-Zeichen Deflcdchar 1 , 32 , 14 , 31 , 31 , 31 , 31 , 31 , 31
-
Thread
Welches Mikrocontrollerbard empfehlt ihr?
Shields verfügbar. Zum anfangen genügt das Board, ein USB Port und ein Netzteil. Hardware in verschiedenen Ausführungen verfügbar, Arduino Mega hat mehr als genug Ports. http://arduino.cc
als Shields verfügbar. Zum anfangen genügt das Board, ein USB Port, ein Netzteil und eine LED. Hardware in verschiedenen Ausführungen verfügbar, Arduino Mega hat sehr wenig Ports. http://anti-arduino.cc
-
Thread
7 segment über aus 150m steuern
Optokoppler setzen. PC817 zum Beispiel. Als Pullup reichen 10k > oder der interne Widerstand des AVR. Genau.
Parallelport 8 mal schneller ist. Wenn du ein höherpaariges Kabel verwendest, dann könntest du zum Einlesen der Taster aber z.B. 8-bit-Schieberegister ggfs. auch kaskadiert verwenden, die parallel einlesen, und seriell ausgeben. Da ist auch kein µC erforderlich. Aber keine separate Leitung für jeden Taster
-
Thread
Reflow-Ofen selbstbauen
Bandabstand bzw. dessen Energieäquivaltent von der Dotierung abhängt. Muss mich morgen mal wieder einlesen. Vielleicht mach ich morgen mal den Hardcoreversuch, nimm mir eine 1N4148, miss die bei Raumtemperatur ein und leg sie dann 24h auf einen Halogenstab, lass sie abkühlen und miss sie dann wieder
die Kosten dieser äußerst simplen Schaltung auf einer Lochrasterplatine belaufen sich auf 10€. Ein AVR, ein MAX232, ein SSR und ein ThermocoupleIC. Spart man sich den ganzen Dreck. @ coldtobi Exzellenter Schaltplan. Funktioniert nur so leider nicht. Schau ihn dir nochmal an und denk darüber nach
-
Thread
AT 9058525 Serin Problem
End Habe alle PortBs getestet.Läauft garnix. Wäre dankbar für Hilfe Danke im vorraus
Also ich habe einen Multiprog 2003XXL, und eine Funcard 4(siehe Anhang) Ich arbeite mit Bascom AVR. Mein Problem: Ich möchte über Serin,Daten in den internen Eeprom einlesen (später natürlich auch in den 24LC256),und dann über Serout wieder ausgeben. Ich habe das Codebeispiel aus der Hilfe
-
Thread
TTL Signal Verarbeitung
Fehlerquellen. [C] #define F_CPU 4000000UL #define BAUD_RATE 9600 #include <stdlib.h> #include <avr/io.h> #include <avr/interrupt.h> #include "uart.h" volatile uint8_t getBit; ISR(INT0_vect) { getBit = 1; } int main(void) { DDRD = 0x00; // Port D als Eingang setzen PORTD
auf gleichheit prüfen usw. und wenn das bitpuffer == Flag ist dann die nächsten Bytes einfach einlesen.
-
Thread
Port einlesen und IF abfrage
Atmega32, AVR studio. Würde gerne PortA Port 4-7 als Eingang / 0-3 als Ausgang verwenden. Mein kleines Testprogramm läuft noch nicht, habe noch Probleme mit der Synthax. Der Befehle "PORTA = 1<<PA0;" bzw "PORTA = 0<<PA0;" alleine läuft. Nur das "IF" macht wohl Probleme. Möchte wenn PA7 "Low" ist, soll PA0 auch low sein bzw umgekehrt. #include <avr/io.h> int main (void) { DDRA = 0x0F; // 0-3 Ausgang & 4-7 Eingang PORTA = 0xF0; // 4-7 high (soll dann runtergezogen werden) while(1) { if (PORTA & (1<<PA7)) // geht nicht // if (PA7 == 1) geht auch nicht {PORTA
-
Thread
Werte aus zwei Ports "vereinen"
Die Pullups für Port R sind aktiviert? Gruß Jobst
. Es ist mir nur aufgefallen. Es zu überprüfen, überlasse ich Dir. :-) Was passiert, wenn Du PortR mal komplett und direkt auf PortE ausgibst? Verhält es sich wie gewünscht? Gruß Jobst
-
Thread
FT232RL zu RS232 Converter aus eBay (China) ok?
Hallo, ich wollte etwas mit dem UART lernen, habe aber keinen COM-Port. Nach dem Einlesen habe ich also festgestellt, dass man einen FT232TL oder ähnliche braucht (USB zu seriell Konverter). Nun habe ich auf eBay für ~7€ fertige Adapter gefunden. Beim Preis des FT232RL
3D1831033658291508842%26pid%3D100015%26prg%3D1006%26rk%3D1%26 Sinn und Zweck ist es einfach mit einem AVR (Atmega8) ein bisschen mit dem UART zu spielen… Danke.
-
Thread
Seriell übers Internet?
Alternative wär ein AVR-Net-IO für 20€ mit Ethersex-Firmware und Y-Port ( http://old.ethersex.de/index.php/YPort )
Mega48 und einen Ethernet-Übertrager benötigt: http://www.cesko.host.sk/IgorPlugUDP/IgorPlug-UDP%20(AVR)_eng.htm
-
Thread
Taster enprellen aus Codesammlung
Schon mal mit echten AVR's gearbeitet, oder nur Papiertiger?
Seiteneffekte, wie sie leider viele andere Lösungen haben. Der einzige Hardwarezugriff ist das Einlesen des Ports, da kommt man nicht drumrum. Und einen Timerinterrupt hat eh jede Anwendung, wo man sie mit einfügen kann. Peter
-
Thread
Lange Bitcodes speichern und ausgeben
da ein kleines Problem. Ich würde gern in meinem mega32 einen ca. 2000 bit langen Array per uart einlesen und dann ausgeben. Es handelt sich nur um Bits. Welchen Datentyp nimmt man da? Ein Bitfeld? Kann das so groß sein? Jetzt kommt aber die eigentliche Frage: der Array soll an einem Pin dann ausgegeben
definiert den Pin und bleibt konstant! [/avrasm] c) für die Ausgabe muss das Register /iobits/ in das PortB-Register geschrieben werden: [avrasm] out PORTB,iobits [/avrasm]
-
Thread
8 Tasten einlesen (Möglichkeiten)
zu identifizieren. (Bei positiver Logik isses die Taste '7'). In der u.a. Schaltung verwende ich PortPin 3 zur Erkennung, ob überhaupt eine Taste gedrückt ist, an Port Pin 0-2 steht der BCD Code. Hier mal die Matrix für Taste '5': Controller Port 3 2 1 0 | | --
-- | | | --- GND Ich verwende also positive Logik und habe die Pullups des Portes aktiviert. Wenn PortPin 3 low ist, ist eine Taste gedrückt und an Port 2-0 steht 0b101 = 5 Andere Tasten gehen entsprechend parallel mit ihren Dioden an die PortPins. Taste 7 also hätte nur die Diode
-
Thread
Dual Port Ram durch Single Port Ram ersetzen
erforderlich) und den Rest für den Zeichengenerator nimmst. Die RAM-Blöcke können wahlweise auch als Dual-Port RAM ausgeführt sein, das kannst Du im VHDL-Code konfigurieren. Vorteil des ganzen: es braucht 0 Rechenleistung. Dein AVR schreibt einfach seine Zeichen rein, und das FPGA macht den Rest. Alternative
sich jetzt ja auch herausgestellt hat dass es auch anders geht. Wie >beschalte ich zwei single Port SRAMs so, sodass ich auf ein Dual Port >SRAM verzichten könnte. Für x-fache Ports, je Port RD-WR-Zwischenregister, die nach aussen asynchr die CPUs versorgen, nach innen gemuxt auf ein SRAM gehen
-
Thread
Folientastatur auswerten
key_mask ) { return get_key_press( get_key_rpt( key_mask )); } int main( void ) { LED_PORT = 0xFF; LED_DDR = 0xFF; // Configure debouncing routines KEY_DDR &= ~ALL_KEYS; // configure key port for input KEY_PORT |= ALL_KEYS;
enable timer interrupt sei(); while(1){ if( get_key_short( 1<<KEY1 )) LED_PORT ^= 1<<LED1; if( get_key_long( 1<<KEY1 )) LED_PORT ^= 1<<LED2; // single press and repeat if( get_key_press( 1<<KEY2 ) || get_key_rpt( 1<<KEY2 )){ uint8_t i = LED_PORT
-
Thread
ADC Interne REF zu gering
eine start spannung von 2.5v bei 0A diese spannung sinkt 40mv/A. diese spannung will ich einlesen um somit im programm die ampere die der sensor misst zu verarbeiten. alle meine ADC pins sind voll sonst hätte ich eine externe ref in betracht gezogen. leider habe ich nurnoch die interne 1.6
auf avrfreaks und hier uploaden mfg kris •[c] // The board.h header file defines which IO ports pheripherals like // Switches and LEDs are connected to. #include "../board.h" // Setup for different compilers #include "../avr_compiler.h" // ADC Drivers #include "../adc_driver.h" /
-
Thread
Programmcode aus RAM ausführen
Rolle. Wenn ehe schon Atmel-Tools vorhanden sind, wäre hier ein AVR32 keine schlechte Wahl.
ich vote auch für AVR32
-
Thread
Controllerwahl Energy Harvesting-Anwendungen
Codeteile aufzuspüren... --> AEM Je nach Aufgabe tut es aber auch ein Sleep-Mode mit ISR bei einem PIC/AVR/MSP um das ganze "LOW-Energy" zu nennen. Gruß BT
von Energy Micro top. Für eine Batterie betriebene Uhr sind sie aber oversized, da tut es auch jeder AVR oder PIC.
-
Thread
Einfachen Wert von I/O-Port einlesen klappt nicht
an dieser Stelle: [avrasm] in r16, PIND ;PIND einlesen (hier klemmt der Taster dran) cpi r16, 0b10000000 ;Diesen Wert mit dem vergleichern, der ohne Drücken vorliegt[/avrasm] gehst du davon aus, das alle anderen Pins des Ports low sind. Hast du dafür
Beschaltung gesorgt? Deine Pullups sind high, also wenn du die anderen Pins nicht beschaltet hast, ließt der AVR immer 0bX1111111 wo X für deinen Button steht. Entweder du machst noch ein AND rein, zB: [avrasm] in r16, PIND ;PIND einlesen (hier klemmt der Taster dran) andi r16, 0b10000000 ;andere Bits
-
Thread
AVR für Servo Input und Output
warten und Servodaten ausgeben. Der AVR soll mit UART an den ARM angeschlossen werden. Einlesen sollte mit Port Change Interrupt gehen. Ausgabe mit Hardware-PWM, um nicht das Timing durch Kommunikation oder anderes zu verfälschen. Der
zwischen 20-30 Pins, mehr wird fast zu groß. - Hardware-PWM für 8 Pins, Auflösung ca. 7 Bit. Welcher AVR kommt hier in Frage?
-
Thread
attiny13 anfang kann nicht mal mit schalter led einschalten avrasm
Prinzipiell musst du den Port in einer Schleife einlesen, dann vergleichen, ob der Taster gedrückt ist, dann den Port fit der LED dran entsprechend setzen. Dann warten (Schleife), bis der Taster wieder (oder nicht mehr) gedrückt
etc ... // Input/Output initialisieren ... // Hauptschleife mit Abfrage main: in temp, PORT andi, temp, 0b00001100 // unter der Annahme, dass die Taster am Port an Pin 3/4 hängen cpi temp, 0b00000100 brne Taster2 rcall Aktion_Taster1 rjmp Taster1 Taster2: cpi
-
Thread
Verständnis&genaue Funktion CD4014&21.
8 Takte dafür und woher weiß das CMOS-Register, das es erst beim neunten Takt wieder parallel einlesen soll. Der AVR soll ja schließlich auch keinen Datensalat bekommen also muß ich das irgenwie syncronisieren. (8 Pin-Abfragen vom CMOS-Register-Ausgang syncron zum CI-Takt sollten ein AVR-Register
langsam sein. Mit einem 8515 mit seinen 4 Ports wäre der CMOS-IC natürlich entbehrlich. Aber weil es auch räumlich möglichst klein werden soll und ich genug 2313 da habe, habe ich mich für diese Version entschieden. Weil es den V(U)40511D
-
Thread
C Kontrollstruktur will nicht AVR
Hallo Freunde der Sonne, ich habe ein Problem bei einem einfachen C-Programm. Es soll auf meinem MyAVR USB MK2 Board laufen. Das tut eigentlich nichts zur Sache, es ist ein Logikfehler, den es zu finden gilt. [c] #include <avr/io.h> #include <avr/delay.h> uint8_t Modus; int main(void) {
#2789617: > Was heißt nicht atomar? das die anweisung von compiler ein 3 schritte zerlegt wird. Port einlesen verordern Port ausgeben Atomar ist alles was in einem Schritt erledigt werden kann. Wo also ein Interupt nichts durcheinander bringen kann.
-
Thread
RC Empfänger PWM Signal Mosfet Motorregler
ich bin froh das ich es überhaupt geschafft habe den Motor zum laufen zu bringen. [c] #include <avr/io.h> #include <avr/interrupt.h> #include <util/delay.h> #define F_CPU 4000000UL volatile int flanke=0; volatile int aktuell_pwm_l=0; volatile int aktuell_pwm_h=0; ISR(TIMER1_CAPT_vect
http://www.mikrocontroller.net/topic/74861 http://www.ulrichradig.de/home/index.php/avr/avr_-_rc http://www.ulrichradig.de/home/uploads/File/RC/RC_Sum_Encode.zip
-
Thread
STM32F4Discovery und TLC5940
13 #define SPI2_CS_PORT GPIOB // Alternate(5) #define SPI2_CS_PIN 12 // Not Connected . . . static const SPIConfig spi2cfg = { NULL, SPI2_CS_PORT, SPI2_CS_PIN, 0 // Full 21 MHz-Speed }; . . . palSetPadMode(SPI2_SCLK_PORT, SPI2_SCLK_PIN, PAL_MODE_ALTERNATE(5) | PAL_STM32_OSPEED_MID2); palSetPadMode(SPI2_MOSI_PORT, SPI2_MOSI_PIN, PAL_MODE_ALTERNATE(5) | PAL_STM32_OSPEED_MID2); palSetPadMode(SPI2_CS_PORT, SPI2_CS_PIN
-
Thread
SNES Controller auslesen mit AVR Atmega88
Hallo, Leute! Ich bin immernoch am Einsteigen mit Assemblerprogrammierung und wollte ein bisschen üben, indem ich den SNES-Controller auslese. Das Schema, wie die Daten abgegriffen werden ist folgendes (siehe: Anhang 1): SNES schickt 12μs das Latch Signal auf 1. Der Controller weiß: Abfrage beginnt. Während des Latch Signals wird erster Button geprüft und in ein Schieberegister geschoben. Wenn er gedrückt ist, geht die Verbindung auf Ground. Nach dem Latchsignal kommen 6μs Pause. Danach geht für 6μs das Clocksignal auf 1 und dann wieder für 6μs auf 0, während der nächste Button geprüft
-
Thread
erster Mikrocontroller programmieren -> fragen
Port. Kann ich mit solch einem Adapter (http://www.mikrocontroller.net/attachment/19111/AVR_ISP_Ser.jpg) den ATmega flashen?(Per USB-to-serial Adapter) 3. Ich habe gelesen, das für das programmieren über
mit BASCOM und anderen Entwicklungsumgebungen genutzt werden[...]" Heißt das ich kann aus BASCOM-AVR heraus den Atmega flashen? Edit: > Vorsicht - ich glaube nicht, dass der TE den seriellen Port des uC > meint. Der oben angegebene Programmer (serieller Port am PC, ISP Port am > uC) funktioniert
-
Thread
testprogramm 7 segment
nächste: ich hab ja 4 solche segmente. zusätzlich habe ich ja noch zusätzlich 7 taster die ich einlesen muss (heim +, heim -, gast +, gast-, uhr start, uhr stopp, uhr auf 45min stellen). das geht sich allerdings nicht mit den pins aus. was soll ich eurer meinung nach machen? multiplexen? wäre es
leider hab ich keine ahnung wie ich das angehen soll. http://www.mikrocontroller.net/articles/AVR-Tutorial:_7-Segment-Anzeige das tut hilft mir auch nicht viel weiter, da ich assembler nur ganz wenig beherrsche. ich hoffe ihr könnt mir zum erfolg verhelfen.
-
Thread
Abschätzung Codegröße Mikrocontroller
über die 7-Segment-Anzeigen (multiplex über Schieberegister, welche am SPI-Port des uCs hängen) kleines Menü, in welchem Einstellungen über die Tasten gemacht werden können -------------------------------------------------------------------------- Ich habe soweit schon
über die 7-Segment-Anzeigen (multiplex > über Schieberegister, welche am SPI-Port des uCs hängen) Hast du auf Datentypen geachtet? Immer den kleinsten Datentyp nehmen, der gerade noch ausreicht. Nicht dem µC unnötig 16 Bit Arithmetik aufzwingen, wenn es 8 Bit auch tun? > Habe
-
Thread
Mehr Interrupte - Porterweiterung mit 2. µC?
gefordert ist? Dann hast du knapp 10 Millisekunden. Du kannst z.B. 8 Schieberegister an einen ganzen Port hängen, so kannst du in 8 Lesezyklen (also maximal einigen dutzend Maschinenzyklen) 256 Kontakte einlesen. Oder du hängst die Schieberegister seriell an den Controller und liest sie per SPI ein. Beides
Ja, hier ist es beschrieben: http://www.mikrocontroller.net/articles/Port-Expander_PCF8574 Auch ODER-Gatter würden helfen.
-
Thread
V-USB und der ATtiny84
? Links: [1] http://www.elektronik-labor.de/AVR/WildeMaus.html [2] http://www.elektronik-labor.de/AVR/Rebooter.html Danke burgerohnealles
fast alles mit dem v-usb anfangen, der Treiber ist sehr flexibel. Du müsstest Dich aber weiter einlesen. PCINT ist eine Sammelschiene für max. 8 Interrupt eines Ports: *PCINT0* Pin Change Interrupt Request 0 *Eingänge* PCINT7 bis PCINT0 jeder Zustandswechsel führt zu einem PCINT0 ISR Aufruf.