-
Thread
Ideen für FPGA-Projekte?
zerlegen wollen wirst. Ich würde dafür Wireshark nehmen, das kann das auch und viele Switches können Ports spiegeln.
Also das kommt sehr auf die Datenrate an. Also komplettes Gigabit macht so ein AVR nicht mit. Aber FPGA und AVR geht vermutlich. Der AVR stellt im FPGA den Filter ein welche (wenigen) Packete der durchlassen soll, und diese kann der AVR dann auswerten. Aber auch sonst wäre es eigentlich
-
Thread
DIP Schalter abfrage funktioniert nicht
wenn ich den Code von 80% da reinlege, funktioniert es nicht. Woran liegt es also? [c] #include <avr/io.h> #include <util/delay.h> #include <avr/interrupt.h> #include <avr/sleep.h> volatile int sekunde = 0; //wird vom Timer immer um 1 erhöht. //1 = 0,01sekunden
#define LED_PORT PORTD #define ERROR_LED PD5 #define TURN_ON(b) LED_PORT |= ( 1 << b ) #define TURN_OFF(b) LED_PORT &= ~( 1 << b ) ... TURN_ON( ERROR_LED ); TURN_OFF( BUSY_LED ); [/c] und
-
Thread
LED Tisch mit Berührungs-/Gegenstandserkennung
easiest way to achieve this. Note that the AVR will never drive the SPI lines in a programming situation, since the AVR is held in RESET to enter programming mode – and RESET’ing the AVR tri-states all pins. D.h. wenn die Daisy Chain sicher nicht
cyblord ---- schrieb im Beitrag #3661103: > avr-gcc unterstüzt den 841 in der aktuellen > Version. Wo finde ich Referenzen darauf? Auf der Homepage von avr-libc [1] ist davon noch keine Rede. Mein Eclipse mit aktueller Toolchain avr-gcc 4.9.0
-
Thread
Schieberegister: Abfrage von mehreren Tastern
OK. Erstes Testprogramm [c] #include <avr/io.h> // Schieberegister MC14021 #define SR_DDR DDRB #define SR_PORT PORTB #define SR_PIN PINB #define SR_PS PB0 #define SR_C PB1 #define SR_DATA PB2 #define SET_BIT(p,b) p
// 1 MHz #define BAUD 31250 // MIDI-Baudrate (31,25kBit) #include <avr/io.h> #include <util/setbaud.h> // Schieberegister MC14021 #define SR_DDR DDRB #define SR_PORT PORTB #define SR_PIN PINB #define SR_PS PB0 #define SR_C PB1 #define SR_DATA PB2
-
Thread
Potentiometer erzeugung eines Midisignals
nett wenn jemand drüber schauen könnte, ich seh mitlerweile einfach nichts mehr. :) [c] #include <avr/io.h> #include <avr/io.h> #define F_CPU 1000000 // 1 MHz #define BAUD 31250 // MIDI-Baudrate (31,25kBit) #include <util/setbaud.h> void adc_init (void){ //interne
nochmal den Code überarbeitet und alles sauber eingerückt. Das kam dabei raus: [c] #include <avr/io.h> #include <avr/io.h> #define F_CPU 1000000 // 1 MHz #define BAUD 31250 // MIDI-Baudrate (31,25kBit) #include <util/setbaud.h> void adc_init (void){ //interne
-
Thread
AVR Zeit zwischen 2 Eingangssignalen messen
Beispielcode dort hat mir kaum weiter geholfen. Hier mein Code: [c] #define F_CPU 16000000 #include <avr/io.h> #include <stdlib.h> #include <avr/interrupt.h> #include "lcd.h" int taster; int overflow = 0; int mess1; int mess2; int ergebnis; char Buffer[20]; ISR (TIMER0_OVF_vect)
Zum Beispiel daran [c] DDRA=0xff; ... taster = PINA & 0xf0; [/c] wenn man vom Port A über das Pin Register den Zustand von Tasten einlesen will, dann ist es eher wenig zielführend, den kompletten Port auf Ausgang zu schalten. volatile wurde schon angesprochen. Das Rücksetzen
-
Thread
Problem mit AD- Wandlung
Dir Ports und so weiter sind alle initialisiert. Also das drum rum ist alles richtig. Hab noch mehr in meinem Programm stehen, was auch alles funktioniert nur der AD- Wandler mach Probleme. Deswegen hier nur
Warum benutzt du nicht die Routinen aus dem [[AVR-GCC-Tutorial]] (Nach ADC suchen und dann dem Link folgen) Die würden aus dem Stand heraus funktionieren. In deinem Programm gibt es so viele Probleme, dass ich gar nicht anfangen will, die
-
Thread
Denkfehler? UART + Delay danach
[c] #include <stdlib.h> #include <avr/io.h> #include <util/delay.h> void init_USART(void) { UCSRB |= (1<<TXEN); UCSRC |= (1<<URSEL)|(3<<UCSZ0); UBRRH = 0; //High=0 UBRRL = 15; //Low
Übergabe der der Midi-Bytes } void main() { init_USART(); int bank=0; DDRA = 0xff; //PortA als Ausgang für BCD-Treiber setzen PORTA = 0; //PortA --> 0 als Anfangswert schreiben (Bank anzeige) DDRD = 0b11100011; // Bit 2,3,4 Eingang setzen (Pin 16,17,18 Schalter für den Kanal)
-
Thread
Signal Umwandlung Sinus in Rechteck?
würde aber auch Low/high gehen. mein Gedankengang: Mein Problem ist die Auflösung des Analog-Ports der mit 10Bit das Eingangssignal einliest 5=1024 ich aber doch mit dem AVR Assembler die Standart Register nur mit 8 Bit Information füttern kann ? In C kann ich den Eingangswert ja teilen in dem ich
ausgeben. So etwa: http://www.solorb.com/elect/musiccirc/ArduinoLFO/ Hier wird der komplette Port D als arbitrary-waveform-generator benutzt, die Wavetables mit einem python-prog erzeugt.
-
Thread
Schieberegister Taster abfrage
man ein Schieberegister einliest? Nun gut. Ich hab dir ja schon geschrieben, wie das geht: Bit einlesen, Schieben, Bit einlesen, Schieben... Das wirst du schon selbst schreiben müssen. Controller-Programmierung ist kein Copy & Paste. Beispiele findest du im Artikel über Schieberegister. Ich hatte
Wenn du sowas bauen willst, tastest du dich Schritt für Schritt heran. - Ein Schieberegister einlesen - Zwei Schieberegister kaskadieren und einlesen oder sinnvollerweise eine 4 x 4 Matrix am Controllerport Danach 8 x 8 mit 2 Schieberegistern. Dann freust du dich über 64 Tasten und fragst dich
-
Thread
bitte hilfe bei CNY37
die schaltung hängt am lpt port meines rechners
oder echtem DOS fahren. Alles andere sollte besser ein dedizierter MC machen, wie z.B. der o.a. AVR.
-
Thread
Ideen für Projekte mit dem Infineon XMC 2Go Gesperrt
Meine Idee: Datenlogger für ein Fahrzeug mit folgenden Features: - Einlesen von Messwerten, wie Öltemperatur, Ladedruck, Geschwindikeit, Drehzahl - Streamen der Daten an ein Aufzeichengerät, z.B. an einen Laptop via WLAN-Adapter oder auf einen USB Stick - Anzeige der momentanen
Überwachung der Motortemperatur - Batteriespannungsüberwachung - Ausgabe interner Werte auf (seriellem) Port
-
Thread
Atmega 8a bits an PortD manipulierren für LCD später
Hallo, ich bin blutiger Anfänger und versuch gerade zu verstehen warum ich mit dem nachfolgenden Code nicht die LED's 1 und 2 zu Blinken kriege? Ich suche auch noch eine Möglichkeit mal eine Libraries von extern in das AtmelStudio6.1 zu integrieren was ich aber anscheinend nicht verstehe. Bitte jetzt nicht einfach auf eine englische Seite verweisen denn da bin ich einen echte Niete! Ich versuch C zu lernen damit ich mir meine µControler selbst programmieren kann. Ich hab mal einen Videokurs von Java mitgemacht und der war auf deutsch, das ging super. Aber in C hab ich noch nichts vergleichbares
-
Thread
Int auslösen beim einlesen von Schieberegister z.B. 4021
die Daten einlesen, vergleichen, den Interrupt melden, und aber auch noch die Schieberegister ersetzen.
input of the microcontroller. An interrupt is generated by any rising or falling edge of the port inputs in the input mode. Resetting and reactivating the interrupt circuit is achieved when data on the port is changed to the original setting or data is read from or written to the port which
-
Thread
0-10v in Pwm umsetzen für Konstantstromquelle
Eingangsignal 1-10V müsste doch mit zwei 1k E12 hin hauen oder? Dann mit Bascom ADC die Spannung einlesen und dann per Pwm ausgeben. Habe heut Nacht die bascom avr tutorial auf youtube durchgemacht. Sprich auch die folgen mit der pmw und adc aber wie die Erkenntnisse miteinander verbinden????? Weil das Einlesen ist die eine Sache aber dann die Pmw Ausgabe anhand der ermitteltem Werte die andere :-(
-
Thread
DIP-Schalter an ATmega8515
RTFM http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Eing.C3.A4nge_.28Wie_kommen_Signale_in_den_.C2.B5C.29
Man kann die DMX-Adresse nicht direkt einlesen, da die einzelnen Pins mit einschalten des Schalters, auf Low gezogen werden... Wenn man ihn direkt einliest, kommt nur Schwachsinn raus :)
-
Thread
ADC Text-LCD-Ausgabe
bleiben auch aus. :-( Da ich n bissl Angst hab, mein µC zu zerstören habe ich noch keine Spannung an PortK Pin0 angelegt. Müsste der µC dann nicht einfach Null Volt einlesen? Oder passiert genau aus diesem Grund nichts mit meinem Programm, da es auf die Beendigung der Konvertierung wartet? 2.) Eigentlich
drehen. Strom dabei auf Minimum festgestellt. LEDs sind mit der 5V Boardsp. gespeist und liegen auf PortC. Text-Display ist ein EA W204B-NLW und hängt korrekt am PortA. THX
-
Thread
Motor läuft erkennen
Ich denke du bist schneller, wenn du das Tutorial hier ==> http://www.mikrocontroller.net/articles/AVR-Tutorial und hier ==> http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial durcharbeitest. Das Equipment dafür kostet ein Bruchteil des CAN-Equipments und du hast das ganze in max 2 Wochenenden
denke du bist schneller, wenn du das Tutorial hier ==> > http://www.mikrocontroller.net/articles/AVR-Tutorial > und hier ==> > http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial > durcharbeitest. > Das Equipment dafür kostet ein Bruchteil des CAN-Equipments und du hast > das ganze in max
-
Thread
Über UART Buchstaben einlesen und PORT setzen
Hallo Leute, Ich habe eine Atmega 32 und dort die RS232 Schnittstelle programmiert, hardware-mäßig aufgebaut und über ein kleines Testprogramm Daten eingelesen und wieder ausgegeben. Jetz hab ich allerdings ein Problem und zwar möchte ich untersuchen ob sich ein a im UDR befindet und dann einen Pin am PORTB setzen. Überprüfe ob ein a über Uart eingelesen ja--> LED einschalten Hier mein Code: [c] #include <avr/io.h> #include <util/delay.h> #include <ctype.h> // ---------- Konstantendefinitionen ---------------------------------- const char startText[] = "UART Test\r";
-
Thread
µC von 0 auf lernen. ASM oder C?
schreiben oder daraus lesen. Okay noch LDR r1,=... Ist das auf dem AVR so viel einfacher??
Ja und was? Man muss clock enable für die GPIO setzten. Sonst gibt es keinen Unterschied zu den AVR.
-
Thread
2 LEDs im Gegentakt toggeln lassen? + Zeitproblem
per Fuses richtig ausgewählt bzw. F_CPU define falsch. http://www.mikrocontroller.net/articles/AVR_Fuses#Taktquellen_Fuse_Einstellung
IR-LEDs hängen an PORT C und JTAG Fuse ist deaktiviert. Habe keinen VOLLSTÄNDIGEN Quelltext gepostet, da das Programm ja noch mehr macht und ich nur das wesentliche Problem hervorheben wollte...
-
Thread
Startschwierigkeiten mit Stm32F4 Discovery Board
Auf dem Programmer Port sagt es: [c] ID 0483:3748 STMicroelectronics ST-LINK/V2[/c] Auf dem Applikationsport nichts. Das bestätigt wohl, dass die Firmware NICHT läuft. Leider hab ich vorher nicht nachgesehen wie sich
Das Problem hatte ich auch mal, weil ich sämtliche Pins von Port-A auf Input gesetzt hatte und damit die Debug-Schnittstelle totgelegt habe. Ich habe mich dann erinnert, dass es da noch ein Programmier-Programm "STM32 ST-Link Utility" gibt. http://www.st.com
-
Thread
Abtastrate ADC
Atmega16 einen ADC gebastelt. Ich möchte eifach gearde am Pin ADC0 ein Audio-Signal (0-5Volt) einlesen und am Port B an Hand eines R2R Netzwerks wieder ausgeben. Mein Problem ist jetzt, dass er mir nur die unteren Frequenzen (bis ca 500Herz) nach dem R2R Netzwerk hören kann. Ich schließe jetzt mal
Chris N. schrieb im Beitrag #3509706: > Liegt bei 125,00 kHz Der Takt mit dem der AVR betrieben wird? Sicher? Oder meinst du den ADC-Takt, der sich aus CPU Takt und dem ADC-Prescaler ergibt? Der ADC braucht ein paar CPU-Takte um zu wandeln. Wenn der AVR wirklich mit 125kHz betrieben
-
Thread
Basketball Scoreboard selber bauen (Anfänger)
begreifen ist Leich zu begreifen dürfte Arduino sein. Wenn du aber einen "richtigen" µC willst, kann ich AVR oder PIC empfehlen, die sind für dein Projekt beide geeignet. Zum AVR gibt es hier im Forum ein Tutorial, zum PIC hier: http://pic-projekte.de/wordpress/ Für die Anzeige brauchst du min. 7+8 (Multiplexing
Jan Mustermann schrieb im Beitrag #3501618: > SainSmart MEGA2560 ATmega2560-16AU AVR Board + USB Cable For Arduino UNO > R3 Von den beiden würde ich dieses wählen, weil beim ersten viel dabei ist, das du für dein Projekt nicht brauchen wirst.
-
Thread
RAM gegen µC-Schaltung austauschen?
Speicherzugriffszyklus alle nötigen Unterschritte (angelegte Adresse und Steuersignel auswerten, Daten holen und am Port bereitstellen) zu erledigen... Du könntest bestenfalls das RAM durch ein Dual-Port RAM ersetzen, und könntest dann in aller Gemütsruhe über den 2. Port den RAM-Inhalt manipulieren. http://www.cypress.com
mein nächster Schritt wird sein heute Abend nach der Arbeit mich mal grob in das Thema FPGA, Dual Port SRAM & Logic Analyzer ein zu lesen. Für den Start und einstieg habe ich mir ein paar PIC und AVR Controller gekauft und bastel an einem n64 Controller und einem alten Super Nintendo rum. Wobei der
-
Thread
Gibt es einfach zu handhabende "große" Rams (16/32MB?)
Beim einem AVR kann man externes SRAM direkt anschliessen.
MW wieder am µC. Audiocodec wie gehabt am SPI (PortB) Mirko
-
Thread
Problem Atmega 644P Programmierung
Programmierung eines ATMega644P. Ich verwende als Software avrdude 5.11 mit der Benutzeroberfläche AVR Burn-O-Mat 2.1.1. Als Programmieradapter habe ich den Diamex AVR USB-ISP Programmer, die 5 Volt für den Atmega werden durch den ISP-Programmer bereit gestellt. Im Burn-O-Mat habe ich als AVR Typ
Pins des 644P gelegt. Wenn ich nun mit dem AVR Burn-O-Mat die fuses auslesen will, kommt folgende Meldung: C:\avrdude\avrdude.exe -C C:\avrdude\avrdude.conf -p m644 -P com12 -c stk500v2 -U efuse:r:C:\.... avrdude.exe: AVR device initialized
-
Thread
SD-Karte wird nicht erkannt NetIO
meistens kein Problem. Ich nehme immer 5 Volt Stromversorgung und einen 3volt-StepDown-Regler für den AVR und die 3V-Geräte. Was du noch machen könntest, wäre die sd-Karte an PortB anzuschließen. Der wird wegen dem enc eh mit 3Volt versorgt. Du musst dann nur die CS-Leitung auf 3Volt herunterregeln,
PORTB |= (1 << PORTB1); // Pullup einschalten PortB1 eepvar_init(); // Grundeinstellungen einlesen com74hc595_init(); .... [/c]
-
Thread
Schwerpunkte in den Datenblättern
Und wenn man dann eine LED blinken lassen will, ist es eben hilfreich, sich mal den Abschnitt über Ports durchzulesen. Dann kommt ein Taster dazu... usw. Es gibt ja hier auch den AVR Anfängerkurs, der genauso gebaut ist, das man sich langsam hocharbeitet, und damit auch neue Kapitel im Datenblatt öffnet
Timer+Ports+Interupts (gut - man könnte auch Delayschleifen nehmen, um auf die Zeiten zu kommen - das wäre dann wirklich Anfänger ;-) Willste das Lauflicht auch noch steuern - brauchte Eingaben (Port einlesen
-
Thread
XMEGA128A1 Pin einlesen
sich doch etwas tun? #include <avr/io.h> #include <avr/interrupt.h> void io_init(void); void clock_init(void); int main(void){ clock_init(); io_init(); while(1){ PORTE.IN = PORTE.OUT; } return
[c] PORTE.DIR = 0xff; PORTE.DIR = 0x00; ^------------- ? [/c]
-
Thread
Midi Platine bauen
index-de.html besteht. Dort werkelt ein Mega-8 als USB-Midi Eingabegerät für 12 Tasten, die direkt am Port hängen. Hatte das vor einiger Zeit mal angepasst für ein Kinderkeyboard, in dem die Tasten zu einer 8x8 Matrix (mit Dioden) verschaltet sind. Da es aber nur zweieinhalb Oktaven hatte, habe ich die einige
DDRA=DDRA<<1; }[/c] An PortB brauch es Pullups Ich hoffe ich habe das mit den DDRx nich invertiert gemacht, ist mein erster Code für den AVR
-
Thread
Welche Auflösung / Frequenz für PWM?
mit 8MHz. Macht 78 Takte für die ISR, richtig? Schau mer mal :-) Was bisl doof ist: an dem Port sind bereits 2 Pins als GPIO vorgesehen. D.h. ich kann nicht einfach meinen Wert auf den Port schreiben sondern muss erstmal den Port einlesen, Maske setzen, mit dem neuen Wert verodern und dann kann
meine ISR jetzt soweit fertig. Diese soll mir pro Aufruf einen vorher berechneten Wert auf einen Port ausgeben. Wie in meinem vorherigen Post beschrieben wird aber zuerst dieser Port eingelesen und maskiert, da auch "normale" Ausgänge an diesem Port hängen. Anschließend wird das Timerregister aktualisiert
-
Thread
Wie steige ich am besten von AVR auf PIC um?
Wie ist das beim AVR eigentlich wenn ich einen Pin setzen/löschen will? Muss ich dann den Port in ein Arbeitsregister einlesen, das bit verändern und wider zurückschreiben?
(Gast) schrieb im Beitrag #3490820: > Muss ich dann den Port in ein Arbeitsregister einlesen, das bit > verändern und wider zurückschreiben? Bei den höher nummerierten Ports der "großen" AVRs muss man das so machen, aber bei den "kleinen" Ports (alles
-
Thread
ATmega8 - allgemeine Frage
hätte ich ja zwei ADC6-Eingänge? PC6 hat keinen Analog-Eingang. ADC6 und ADC7 gehören zu keinem Port. Bei abgeschaltetem RESET hast du ganz andere Probleme. MfG Spess
wenn alles was es dazu braucht das Verlegen von 4 Anschlüssen an eine bitmässig andere Position am Port ist
-
Thread
8051 Chip für Einstieg
tmp-Register, welches man bei AVR ständig benötigt. Oder Bitoperationen, Bitadressierbarer Speicher. Bei den bedingten Sprüngen muss ich beim AVR jedes Mal nachsehen ... Oder MOVC A, @A + DPTR (Addiere A zum Pointer und hole den
ich beim AVR jedes Mal nachsehen ... Ich nicht. Das ist reine Übungssache. >Oder MOVC A, @A + DPTR (Addiere A zum Pointer und hole den Inhalt der >ROM-Adresse in A) - beim AVR erst mal eine 16-Bit-Addition
-
Thread
Auswahl des richtigen AVR -Controllers für einen Leistungsdimmer?
AVR keine große Sache, ist eine Abwandlung von [[Soft-PWM]] oder Servoansteuerung. Kriegt man schon hin, wenn man ein wenig nachdenkt. Nebenbei noch DMX einlesen geht auch. Been there, done that.
Das Projekt mit "MC68HC11ECFN2", mögliche Pin-Belegung (Anzahl Einzelpins): PortA: 4 OC-Ausgänge von Timern >> 4 TRIAC's 4 Standard-Ausgänge >> Soft PWM an TRIAC's PortB + C: Anschluss externes EEPROM/EPROM PortD: 2 UART für DMX 4 SPI für Display PortE:
-
Thread
Fröling Heizungssteuerung auslesen.
ich die mitgeschriebenen Daten: Mein Aktuelles Testprogramm sieht so aus. #include <avr/io.h> #include <stdlib.h> #include "lcd.c" #include <stdarg.h> #include <stdlib.h> #include <avr/io.h> #define F_CPU 3686400UL #define UART_BAUD_RATE 9600 void initUART(void) {
Berichte bitte ob es funktioniert. Ich habe auch diesen Thread eröffnet -> Fröling P2 S3100 und AVR-NET-IO Kannst ja mal nach suchen. Grüsse aus Hessen!
-
Thread
was spricht eigentlich gegen die xmega? Gesperrt
dem AVR Dragon? Ist der nicht gescheit?
CortexM wohl zuviel strom verbraucht, deswegen setzen Microsoft in seinen Surface Pro einen 32Bit AVR ein, und in Samsung Tablets steckt ebenfalls ein 32Bit AVR. schon komisch obwohl Atmel auch einen SAMD20 gehabt hätte aber anscheinend ist ein ARM core nicht so effizient wie ein AVR32. Da hilft auch
-
Thread
DS18B20 Datenformat
mir. hier mein Main: [C] #define F_CPU 16000000UL #include <avr/io.h> #include <util/delay.h> #include <string.h> #include "i2cmaster.h" #include "ds18x20lib.h" #include <stdio.h> #include <stdlib.h> //*****************************************
Hi dein Problem ist nicht AVR oder DS18B20-Spezifisch sondern ein generelles C-Problem. Ich würde dir daher empfehlen, das was du tun willst, außerhlb des AVR mit einem normalen C-Compiler zu testen. In C sind Strings Null-Terminiert
-
Thread
erst programmieren, dann schalten
vielen Pins hätte: Soft-PWM um zu dimmen und einfacher zu programmieren (nur ein Array auf die Ports kopieren)
Core407Z-STM32F407ZxT6-STM32F407ZET6-Cortex-M4-Development/dp/B00E0FJFVG). Die Programmierung ist Easy: - Port Clock aktivieren - 100 Port-Pins als Ausgang parametrieren - je nach Schalterstellung die Ports setzen/löschen. fertig. So wie in diesem Demo gezeigt: [[STM32 CooCox Installation]] nur eben
-
Thread
SPI-Empfangen
genommen. Um fehler in der verdrahtung oder am EEPROM auszuschließen, habe ich den Atmega 16 auf das AVR-NET-IO montiert, und versucht auf den ENC28j60 zuzugreifen, weil das der einzige andere spi chip ist, den ich habe von dem ich 100%ig weiß das er funktioniert. Nun gut, jedenfalls funktioniert es
prüfen. Wie gesagt es soll ja eigentlich für den 25lc werden. Die per Spi empfangenen daten werden an port c ausgegeben, an dem leds hängen, da der reine code vom tutorial auch nichts brachte, habe ich die befürchtung das evtl mein eeprom defekt sein kann.. Kann jemand vieleicht einen Blick auf meinen
-
Thread
Taster um Windows zu steuern?!
nun habe ich hier die Verschiedensten Gerätschaften rumliegen, die mit dem PC Kommunizieren können: AVR-NET-IO, Arduino und ein Raspberry.... Die Frage ist nun ob ich über eine der Eingangsgrößen auf irgendeine weise die Effekte abrufen kann?! Ich habe gestern krampfhaft versucht die über das Arduino
mir das ganze ja erstma auf meinem PC so vorgestellt: import processing.serial.*; Serial myPort; // The serial port void setup() { // List all the available serial ports println(Serial.list()); // Open the port you are using at the rate you want: myPort = new Serial(this, Serial.list
-
Thread
PIC - erkennen ob Ausgang belegt
1. Du legst die Led auf einen Eingang den du auch analog abfragen kannst. 2. Ein Pic hat 2 Port abfragen. Die erste hängt direkt am Port, die zweite geht über ein Register. Gab mal zu Urzeiten ein read modify write Problem das so gelöst wurde, das kannst dir zu nutze machen. Wenn du den Port
Hallo, wenn man Analogeingänge übrig hat (bin allerdings kein AVR-Spezialist): die Spannung an der LED-Beschaltung analog einlesen, dann den Pin umprogrammieren auf digital out. Gruss Reinhard
-
Thread
µC ATmega 8515 LEDs leuchten nach Tastendruck nicht
Hallo und guten morgen liebe Gemeinde. Ich habe mich gerade eben über das zweite Progrämmchen im AVR-Tutorial gemacht. Hier der ASM Code: [avrasm].include "m8515def.inc" ldi r16, 0xFF out DDRB, r16 ;Alle Pins an Port B durch Ausgabe von 0xFF ins ;Richtungsregister DDRB als Ausgang konfigurieren ldi r16, 0x00 out DDRB, r16 ;Alle Pins an Port D durch Ausgabe von 0x00 ins ;Richtungsregister DDRD als Eingang konfigurieren loop: in r16, PIND ;an Port D anliegende Werte (Taster nach r16 einlesen out PORTB, r16 ;Inhalt
-
Thread
Diode mittels Mikrochip ansteuern
eine Frequenz angeben, die diese Diode ausstrahlen soll? Meines (geringen) Wissens nach kann man Ports bzw. Steckplätze zwar ansteuern, ein- und ausschalten oder überspringen, aber ist es möglich eine auf dem Port befindliche Diode eine Frequenz ausstrahlen zu lassen? Wenn ja - funktioniert das auch
Vielleicht magst du dir auch tinyUSBboard ansehen: http://matrixstorm.com/avr/tinyusbboard/ Fuer deine Zwecke sollte es locker reichen und es kann ausserdem als Programmer fuer andere AVR Mikrocontroller eingesetzt werden. MfG
-
Thread
Erstes Programm vom AVR-Tutorial mit dem ATmega8515
Folgendes Programm habe ich im AVR - Tutorial gefunden: [avrasm] .include "m8def.inc" ldi r16, 0xFF out DDRB, r16 ; Alle Pins am Port B durch Ausgabe von 0xFF ins ; Richtungsregister
DDRB als Ausgang konfigurieren ldi r16, 0x00 out DDRD, r16 ; Alle Pins am Port D durch Ausgabe von 0x00 ins ; Richtungsregister DDRD als Eingang konfigurieren loop: in r16, PIND ; an Port D anliegende Werte (Taster) nach r16 einlesen
-
Thread
AVR eigene Pins verbinden?
#3455579: > Kann ich einen eigenen Pin, welcher getoggelt wird am gleichen Prozessor > am ICP einlesen? Du musst nur an eins denken: die Erfassung der Flanke am Eingang erfolgt beim AVR /vor/ dem Umschalten des Ausgangs. Folgendes funktioniert daher nicht: [c] PORTB |= (1 << 3); // aktivieren
------------------------------ #include <stdint.h> // Standard Int-Datentypen #include <avr/io.h> // avr Header File für IO Ports #include <avr/interrupt.h> // Interrupt Vektoren #include <inttypes.h> // Makros für int Datentypen // -----------------------------------
-
Thread
Mit was in die Mikrokontrollerwelt einsteigen?
Allerdings ist der Mikrocontroller "untrennbar" mit dem Arduino-Board verbunden. Ein Evalboard mit AVR funktioniert auch recht sicher, allerdings gibt es schon mehr Freiheitsgerade und damit mehr Fehlerquellen (richtiger Sockel, richtiger Port, Jumperkabel, IDE richtig einstellen etc.) und die Programmierung
kleinen" MSP430, wie er für das Launchpad verwendet wird, für wesentlich besser als den "klassischen" AVR. Der MSP430 hat eine klarere Register-Terminologie und keine seltsamen Seiteneffekte. Beispielsweise ist MSP430 das Output-Register auch immer dafür verantwortlich, den Output des Ports zu steuern und