-
Thread
Seltsames Verhalten bei verschiedenen Timer Prescalern-Atmega 328P
ich zu übersehen bzw nicht zu wissen. Hat dazu jemand eine Erklärung? MfG Andre [c] #include <avr/io.h> #include <avr/interrupt.h> /* jflags*/ #define taster_einlesen 0 #define Rampe 1 /* tflags */ #define pwm_start 0 /* Globale Variablen*/ volatile uint8_t jflags = 0; volatile
//PORTB als Ausgänge PORTB = 0xFF; DDRC = 0xFF; //PortC als Ausgänge PORTC = 0xFF; DDRD = 0x00; //PORTD als Eingänge } int main(void) { _setup(); while (1) { if(jflags &= (1<<taster_einlesen))
-
Thread
Bit Matrix in VHDL
insgesamt 32 Bytes an Daten gesendet die dieser intern in einer Matrix a 8*32 Bit speichern soll. Das Einlesen dieser Matrix muß also über die Addresse (Range 0 to 31) als Index immer 8 Bits in dieser Speichermatrix abspeichern. Bei auslesen aber müssen nun die Zeilen a 32 Bits an einem 32Bit breiten Port
. Im Worstcase kann sich dies auf 2/3 reduzieren. Im Grunde wird daraus dann ein "Dual Port SRAM" bei dem der AVR und der CPLD gemultiplext in 50% der AVR Zugriffszeit auf den SRAM zugreifen. Der CPLD packt also in 1 AVR-MCU Takt = 1 Takt WR\, RD\ == Low Pegel insgesammt 2 Speicherzugriffe
-
Thread
74HC597
dieser HC597 sein muss, könnte ich Dir noch den 4021 oder den HC165 empfehlen für das serielle Einlesen von digitalen Signalen. Jörg
pic-tutorial/shift-registers nicht stimmt. Wayne interessierts. Ich verstehe beides nicht und mein AVR auch nicht. Daher schreibe ich sowas in C. Das kann ich lesen, der AVR C-Compiler und sogar ein PIC C-Compiler sollte es auch können. [c] uint8_t shift_io( uint8_t b ) // send / receive byte
-
Thread
AtMega8 und g++ Optimierung: PIN einlesen wird wegoptimiert
Hallo, ich steuere ein Display mit dem Atmega8 an, der Code ist in C++ geschrieben. Unter anderem gibt es folgende Methode mit der "PROBLEMZEILE". [code] unsigned char readByte() { unsigned char byte; DDRD=0x00; //PortD as input PORTD=0xFF; //PortD with internal Pull-Up PORTB |= (1 << WRB); // Read //Dummy read after setting address PORTB |= (1 << RDB); PORTB &= ~(1 << RDB); PORTB |= (1 << RDB); // really read PORTB |= (1 << RDB); PORTB &= ~(1 << RDB); byte = PIND; //PROBLEMZEILE PORTB |= (1 << RDB); return byte; } [
-
Thread
mit µC in Excel schreiben
Mittels VBA in Excel kannst die port.dll Datei ansprechen und über diese seriell kommunizieren. Edit: wenn ich mich recht erinnere wird es auch so im Kainka Buch umgesetzt
weiterarbeiten. Excel mag nur 65000 Zeilen haben, aber um wie viel Daten handelt es sich hier überhaupt? Ein AVR-µC hat selten mehr als 128k RAM an Bord. Gruß, DetlevT
-
Thread
Simple Frage zu Relaissteuerung
An den AVR-NET-IO kannst kein Relais direkt anschliessen, denn an den Anschlüssen sind nur die Ports des Mikroprozessors angeschlossen. Bevor Du dich mit solchen Dingen beschäftigst, solltest Du zuerst einmal
"""An den AVR-NET-IO kannst kein Relais direkt anschliessen, denn an den Anschlüssen sind nur die Ports des Mikroprozessors angeschlossen.""" an diese port´s kommt nun ein treiber dran der die relais schalten
-
Thread
Mal wieder: _delay_ms() Zeit stimmt nicht
Welcher AVR ist es denn eigentlich? Es gibt auch welche, deren int. Osc.auf 9.6 MHz laufen kann, z.b Tiny13 als kleinstes Beispiel.
mindestens einen Port"? Ein Port hat in der Regel 8 Pins. Wozu brauchst du dann die übrigen 7 bzw. 6 Pins?
-
Thread
Dimensionierung Pull-Up
und runter programmieren, aber > habe noch nie einen Arduino da kannst du genau wie bei nackten AVR die Ports setzen wie immmer, du musst nicht mal die Arduino Schreibweise bemühen. entweder PORTB |= (1<<4); oder digitalWrite(12, HIGH); // 12 für D12 auf dem ATmega328p PB4 für den internen
runter programmieren, aber >> habe noch nie einen Arduino > > da kannst du genau wie bei nackten AVR die Ports setzen wie immmer, du > musst nicht mal die Arduino Schreibweise bemühen. Richtig, aber Darius wollte ja gern, dass ich ihm mit einem Sketch demonstriere, wie das aussehen soll. Das
-
Thread
NMEA - Protokoll / UBLOX SAM - LS / ATMEGA 16
TAKT-Flanke /* **************** Bit - Funktionen ****************** */ #define SET_BIT(PORT, BITNUM) ((PORT) |= (1<<(BITNUM))) //Zum setzen von einzelnen Bits #define CLEAR_BIT(PORT, BITNUM) ((PORT) &= ~(1<<(BITNUM))) //Zum loeschen von einzelnen Bits #define TOGGLE_BIT(PORT,
Hallo Martin, schau mal bei http://www.holger-klabunde.de/avr/avrboard.htm#GPSdisplay Gruß Wolfgang
-
Thread
Microcontroller über Windows Applikation anpassen. Aber wie?
LED gesetzt. Der Mega braucht dann diese Bits nur noch > auf den LED-Port zu kopieren. Ich würde mal sagen 30 Befehle in ASM :-) Danke für die Rückmeldung. Ich sehe UART klingt nach dem richtigen Stichwort. Da werde ich mich ein wenig einlesen. Die Hauptfunktion die
Wenn alle LEDs am gleichen Port hängen lässt sich das Programm übrigens noch deutlich verkürzen: [c]#define F_CPU 14745600 #include <stdint.h> #include <avr/io.h> #include <util/delay.h> #define LED_KEINE 0x00 #define
-
Thread
Zwei Prozesse nutzen einen Vektor. Geht das so?
Reinhard J. schrieb im Beitrag #3866150: > Ist das dann ein 16 Bit Integer vom Typ int16_t für den AVR? Soviel ich weiss, arbeitet der AVR little endian. Also passt es.
gewünschte Adresse anlegen und darin steht dann direkt der Wert. Du musst also nicht erst "manuell" Ports einlesen, sondern die Werte stehen dann quasi direkt in der Variable. Aber so wie du das vor hast, geht das natürlich auch. Ist nur ein bisschen umständlicher. Falls es dich interessiert, deine
-
Thread
Frage zu IR-Remote+LED-Strips an AVR
[bit]" "\n\t" // 1 bit-- (T = 5) "st %a[port], %[next]" "\n\t" // 2 PORT = next (T = 7) "mov %[next] , %[lo]" "\n\t" // 1 next = lo (T = 8) "breq nextbyte20" "\n\t" // 1-2 if(bit == 0) (from dec above
einfache, aber relativ RAM-intensive Lösung. Und der serialisiert und transferiert die Daten über den Port zu den LEDs?
-
Thread
Auslesen des Beschl.-Sensors ADXL202
Werten berechnen und somit, das ziemlich flatterige Signal des Sensors glätten. Hier zum Einlesen des AD-Wertes: ////////////////////////////////////////////////////////////////////////////////////////// // sample ADC PortC... /////////////////////////////////////////////////
Programm (mit Interrupts), welches dir dann nie Pulslänge an den PC schicken sollte : #include <avr/io.h> #include <avr/signal.h> #include <avr/interrupt.h> #include <inttypes.h> // um Register auch bitweise in Binärformat ansprechen zu können #define BIN8(b7,b6,b5,b4,b3,b2,b1,b0) (
-
Thread
Modellhaus Beleuchtung
> hab aber keine ahnung wie ich das in den mikrocontroller > reinprügeln soll. AVR-Studio und ein paar Zeilen Assembler: 1 Zähler hochzählen (z. B. im Sekundentakt) 2 Tabelle mit Schaltzuständen aus Flash einlesen 3 Wert aus Tabelle holen 4 auf Port ausgeben 5 weiter mit 1
Schieberegister IC's hintereinander schalten, so dass du 3*8=24 Ausgänge hast. Deshalb nennen manche sie auch *Port-multiplikator* :) Ich würde an den Ausgängen des IC's immer einen Transistor verwenden, also je LED einen BC547C oder BC846 ...
-
Thread
Arduino oder Mikrocontroller - Was ist besser?
nur im Grenzbereich. Ein "digital write" Befehl dauert deutlich länger als ein direktes setzen der Port-Register in c und ist nicht wesentlich einfacher. Jedoch gibts für AVR-GCC (das "normale" c für die Atmels) ebenso viele Bibliotheken. Diese sind nur viel weiter verstreut und man sucht länger.
hat. Programmieren und vor allem SIMULIEREN dann mit dem guten AVR-Studio4 (gibt Menschen, die auch das 6er mögen - AVR-Studio6 kommt mit einem c++-Compiler daher, der Compiler der 4er ist glaub rein c). Einen Programmer braucht es dann noch (zB. http://www.ebay.de
-
Thread
Assembler, Counter, 7Segment
bisheriges Programm würde in C so aussehen (ohne dein Tastenproblem damit gelöst zu haben) [C] #include <avr/io.h> uint8_t team1Points; uint8_t team2Points; // die Tastenpins am Port B #define T1_UP 0 #define T1_DOWN 1 #define T2_UP 2 #define T2_DOWN 3 #define T_RESET 4 uint8_t
zum thema AVR-Assembler Programmierung sagen ?
-
Thread
Stoppuhr mit Bascom AVR
Moin Leute, Hab jetzt schon des Öfteren mit Bascom AVR rumgespielt und nun wollte ich mal eine Stoppuhr programmieren und auf einen ATmega16 ziehen. Mir persönlich würde jetzt nur einfallen dass ich im Programm jeweils "wait" eingebe und er dann weiter
Ubersetzt zum Testen habe ich das Prg. mit Basom Version 2.0.81. Text, Zeitanzeigeformat und Taster-Ports sind deinem Prog. entnommen. Gruß Alex
-
Thread
WinAVR "unerklärliche Fehler beim compilieren"
bool Taste_x; bool Taste_4; unsigned int Lux_Ausgabe(void) // Makros #define SET_BIT(PORT, BIT) ((PORT) |= (1<<BIT)) // Einzelbit auf Port SET #define CLR_BIT(PORT, BIT) ((PORT) &= ~(1<<BIT)) // Einzelbit auf Port RESET // Funktionsprototypen void initDisplay(void); //
====== // TASTENABFRAGE void SwitchQuery() ***{ // Umschaltung Port C, Bit 0..3 auf Eingang CLR_BIT(PORTD, ENABLE); // Enable-Signal auf 0 DDRC = DDRC & 0xF0; // Port C auf Eingabe schalten PORTC = 0x0F; // Pullup-Rs eingeschaltet
-
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
STM32: Wie funktioniert diese Entprellung?
Wie kann ich diese Funktion für alle Pins verallgemeinern? Ich würde an die Funktion den Pin und Port übergeben (z.B. PD2) und dort eine switch-case Abfrage mit allen möglichen Pins. In dieser Abfrage dann den jeweiligen Pin einlesen. Peter D. schrieb im Beitrag #4608892: > Z.B. reicht ein 2Bit-Zähler
Wie kann ich diese Funktion für alle Pins verallgemeinern? > Ich würde an die Funktion den Pin und Port übergeben (z.B. PD2) und dort > eine switch-case Abfrage mit allen möglichen Pins. In dieser Abfrage > dann den jeweiligen Pin einlesen. Mir fällt gerade auf, dass dies keinen Sinn macht, weil
-
Thread
DRAM am AVR: Wie sieht Euer Wunsch-Interface aus?
interessiert, für welche Anwendungen kann man überhaupt DRAM sinnvoll benutzen ??? Nur deshalb DRAM an den AVR dranpappen, damit man ihn mal drangepappt hat, finde ich persönlich völlig witzlos. Der AVR ist auch ne äußerst ungünstige Wahl, da er nur max 64kB RAM adressieren kann. Ich würde mindestens
nicht? zu 4) wo ich ja eigentlich drauf hinaus will ... zu 5) Wenn man schon viele Pins am AVR benutzen will/muss, kann man das Timing auch gleich im AVR machen. So viel kostet das Refresh ja wirklich nicht. Das einzig schoene waere das XMEM Interface, da es sehr transparant zu programmieren
-
Thread
DOGM128 und Atmega16 via STK500
eigentlich später, aber evtl frage ich jetzt. Das Testprogram ist eigentlich schon da, mit LunaAVR kommt eines genau für den LCD, allerdings gefällt mir eine Stelle da nicht so. Da werden die Pins des µC so verwendet bzw. ich verstehe das Kommentar so, dass die Pins des Port C auf die angegebene Pins des LCD gehen (Angabe ist jeweils Text hinter dem Hochkomma): [code] #define dogmMosiPin as PortC.0 ' in dogm datasheet named 'SI' #define dogmSckPin as PortC.1 ' in dogm datasheet named 'SCL' #define dogmA0Pin as PortC.2 ' in dogm datasheet named 'A0' #define dogmSsPin as PortC.3 ' in
-
Thread
PWM mit AD-Wandler steuern
mit mir gemeckert wird wegen formatierung. Ich wollte jetzt mit demn Wert den ich über den ADC einlese an die PWM ausgeben. Das gelingt auch, nur kann ich das Tastverhältniss nur bis etwa 50% einstellen. Wo ist hier der Knacks ? [c] #define F_CPU 1000000UL #include <avr\io.h> #include <util
pin liegt über 100nF an Masse. VACC liegt an 5 Volt. [c] #define F_CPU 1000000UL #include <avr\io.h> #include <util/delay.h> int main (void) { DDRB = 255; // PORT auf Ausgang // AD INIT ADMUX |= (0<<REFS1) |(1<<REFS0); // externe Referenz ADMUX |= (0<<MUX3) |(0<<MUX2) | (0<
-
Thread
Ablauf eines Programms?
Hallsensor im Poll-Betrieb (Timer-Interrupt bzw. Takte während einer Torzeit zählen) abfragen. Mit einem AVR sollte man das auf jeden Fall hinbekommen.
Ja das hat er. Interrupt auf port RB.
-
Thread
Problem bei ADC Messung
auf 0 gesetzt wird also die Wandlung nicht beendet wird. Hier mal mein Code: [c] #include <avr/io.h> #include <avr/interrupt.h> #include <stdio.h> // Hier die verwendete Taktfrequenz in Hz eintragen, wichtig! #define MCU at90can128 #define F_CPU 14000000//7372800UL #define ADC_PORT 0
delay_ms (500); // Messwerte jede 1/2 Sekunde erfassen Wert = adc_read_avg( ADC_PORT, 7 ); errechne aus Wert die Temperatur gib die Temperatur auf dem LCD aus } } [/c] wird ja genau die Sequenz ADC_einlesen -> Temperatur_errechnen -> Temperatur_ausgeben immer
-
Thread
Basom:wo fehler bei portabfrage
Die Sache mit Pin statt Port ist AVR Standard, gibts schon seit dem 90S1200 und steht in jd. Datenblatt unter 'IO Ports'.
Die unterscheidung zwischen PIN und PORT hat ganz einfach damit zu tun, dass man beim AVR jedes Register wieder einlesen kann. Auserdem wird das PORT-Register auch verwendet zum die Pullups einschalten. Gruß, Florian
-
Thread
fehlerfreie UART-Übertragung?
um nicht noch mehr Verwirrung durch die verscheidenen Signalpolaritäten auf dem Weg bis zu deinem AVR zu stiften Mess einfach nach: Vor dem Start des Terminal Programms sollte RTS "nicht Empfangsbereit" anzeigen, nach dem Start/Öffnen des COM Ports sollte dann die Leitung umschalten. Daran erkennst
***mist, hab gerade nochmal nachgeprüft: selbst bei deaktivierten RTS/CTS Handshake wird beim COM Port öffnen RTS aktiviert, dann aber in der Pufferüberlaufsituation nicht mehr zurückgenommen. Ob der COM port von deinem Terminalprogramm richtig konfiguriert ist kriegt man also so nicht direkt heraus.
-
Thread
2 Externe Interrup auf gleichen Vektor
Nö, ich würde erstmal den Port (PINx) einlesen, damit Änderungen während der Auswertung unwirksam bleiben. Dann würde ich die interessierenden Bits der Portkopie prüfen und danach die Entscheidungen treffen. In der ISR an PCMSKx
Hannes Lux schrieb: > Nö, ich würde erstmal den Port (PINx) einlesen, damit Änderungen während > > der Auswertung unwirksam bleiben. Dann würde ich die interessierenden > > Bits der Portkopie prüfen und danach die Entscheidungen treffen. > >
-
Thread
Dumme Frage
Schau Dir die Hilfe zu "config port" an. Markus
(Zitat aus der Hilfe): 'Again, note that the AVR port pins have a data direction register 'when you want to use a pin as an input it must be set low first 'you can do this by writing zeros to the DDRx: 'DDRB =&B11110000 'this will set portb1.0,
-
Thread
externes Interrupt wird beliebig ausgelöst (Motorrad)
Das Entprellen funktioniert ja und macht auch keine Probleme. [c] #include <stdint.h> #include <avr/io.h> #include <avr/interrupt.h> #include <inttypes.h> #ifndef F_CPU #define F_CPU 8000000UL // processor clock frequency 8Mhz #endif #define LED PA6 //
Versorgungsspannung so dicht wie möglich am µC. Ich wollte erstmal die Signalerkennung ordentlich einlesen, erst dann mit der Auswertung und dem Display weitermachen. Jedoch ohne diese Grundlage, ist der Rest hinfällig, daher ist der Schaltplan im Moment nur minimal.
-
Thread
AVR Mikrocontroller Lohnenswert?
Controllern den Vorteil, dass Du Dich nicht noch zusätzlich mit Dingen wie unterschiedlichen Clock domains, Port-Matrix, IRQ-Prioritäten oder komplexerer Hardware herumschlagen musst. (Obwohl es das auch da gibt - aber nicht beim einfachen AVR.) Wenn Du noch eine Stufe weiter herauszoomen möchtest, wäre der
;P1.0 (LED1) Toggle > BR $ ; Waitt of Watchdog Reset Beim AVR geht das nicht, da setzt das Watchdog-Reset alle Port-Register zurück, da toggled also nichts. Welcher seltsame MC ist das denn, wo der Watchdog kein richtiges Reset ausführt? Man könnte den AVR
-
Thread
Tastertest AVR Evaluationsboard Pollin
Hallo, ich habe das Pollin Atmel Evaluationboard 2.01 und pobiere gerade einige Dinge aus. Ich möchte einfach, das die LEDs die Tasterstati anzeigen. Auf dem Board sind die verwendeten Taster 2/3 mit PD3/4 und die LEDs 1/2 mit PD5/5 verbunden. Es ist ein Tiny2313 gesteckt. Dazu habe ich folgendes Assembler-Programm geschrieben. ;------------------------------------------------------------------------ .include "2313def.inc" ;Definitionsdatei laden .cseg ;Beginn eines Code-Segmentes .org 0 ;Startadresse = 0 ; start: ldi r16, low(ramend)
-
Thread
LM75 mit Mega88PA auslesen
; DDRB = 0xFF; // use all pins on port B for output DDRC = 0xFF; // use all pins on port B for output PORTB = 0x00; PORTC = 0x00; i2c_init(); // init
Karl Heinz Buchegger schrieb im Beitrag #2481322: > Beim Ablesen der LED die Ports falsch zugeordnet (kann auch ein > optischer Irrtum sein!)? Ja, Ports vertauscht! -> jetzt funzt alles! Das ganze werde ich im nächsten Schritt auf eine 7-Segment-Anzeige bringen. Positive
-
Thread
externer Interrupt 0 --> Entprellung funktioniert nicht !
---------------------------------------------------------------- #define F_CPU 3686400 #include <avr\io.h> #include <inttypes.h> #include <avr\interrupt.h> #include <util/delay.h> //---------------------------------------------------------------------- volatile unsigned char buffer; // globale
der Prozessor aus der ISR wieder herauskommt. Warum verwendest du nicht einfach diese Tasten-Einlese-und-Entprell- ISR zusammen mit einerm Systemtimer? http://www.mikrocontroller.net/articles/Entprellung#Komfortroutine_.28C_f.C3.BCr_AVR.29 Die ist 100% zuverlässig.
-
Thread
ATtiny26 Balkenanzeige ( Hysterese ) mit acht Schaltschwellen (ASM)
Oldtimer wie den ATTiny26. Der hat noch nicht einmal den vollständigen Befehlssatz eines aktuellen AVR. MfG Spess
Bargraf [/avrasm] ... [avrasm] end_loop: com r18 ; negieren (wegen STK500) out PortA,r18 rjmp mainloop [/avrasm] Bernd_Stein
-
Thread
µC + LCD + Tastatur - newbie
?? Programmspeicher? Du musst dir definitv erstmal ein paar Grundlagen erarbeiten..z.b. mit dem AVR-Tutorial hier..erst langsam anfangen, was heisst eine LED zum leuchten bringen mit dem controller, taster einlesen, dann evtl textdisplay ansteuern, UART, SPI...und das dauert, va. wenn du alles selber
klar, AVR <> ARM
-
Thread
Hackbarer(?) 21 EUR Quadcopter
... und ein Blinky-Projekt war auch dabei. Es muss nur noch der Port angepasst werden. (Auf welchem Port ist die LED angeschlossen?)
LDROM) memory; 256 bytes direct and indirect RAM, 256 bytes XRAM; 25 I/O with bit-addressable I/O ports; two 16-bit timers/counters; 8-channel multiplexed 10-bit A/D converter; 4-channel 10-bit PWM; three serial ports including a SPI, I2C and an enhanced full duplex serial port; 2-level BOD voltage detection
-
Thread
[C] While Schleife mit drücken eines Buttons abbrechen
Mario I. schrieb im Beitrag #5336671: > PinD ist die Pingruppe D Pingruppe? == PortD ?-\ Mario I. schrieb im Beitrag #5336671: > Und was meinst du damit ? KA, ich hab einfach NULL Plan von AVR. Dachte das bringt dich auf einen neuen Ansatz zur Fehlersuche...... Ich sollts lieber
stoppen. Oder statt eines Pin-Interrupt regelmäßig (zB.300ms wie du gerade wartest) /pollen/, einlesen -> Nennt sich Polling. :) https://de.wikipedia.org/wiki/Polling_(Informatik)
-
Thread
High-speed AVR
Taktgeschwindigkeit wieder ausgeglichen... @Michael Schade, dann hätte man ja wirklich einen "normalen" AVR mit höherer Geschwindigkeit... Falls jemand mir helfen kann: Beim Bootvorgang werden die Programmdaten in den Programm-SRAM gelesen. Doch warum braucht man 3 verschiedene Modi zum einlesen? Und wozu der USB-Mode? Wird dann das Programm durch den USB-Port gelesen? Wozu?
-
Thread
Programm bleibt stehen
"Überprüfungsled" getoggelt, also das Programm läuft weiter. [c] #include <stdlib.h> #include <avr/io.h> #include <avr/interrupt.h> #include <avr/pgmspace.h> #include <util/crc16.h> #include <avr/eeprom.h> #include "uart.h" #include "lib_crc.h" #include <util/delay.h> /* define CPU frequency
10; uint8_t t_overflow = 0; uint16_t ptherme EEMEM = 0000; void entprellung( volatile uint8_t *port, uint8_t maske ) { uint8_t port_puffer; uint8_t entprellungs_puffer; for( entprellungs_puffer=0 ; entprellungs_puffer!=0xff ; ) { entprellungs_puffer<<=1; port_puffer = *port
-
Thread
goto verpönt - was dann nehmen?
>static u16_t tcp_new_port(void) { > static u16_t port = TCP_LOCAL_PORT_RANGE_START; > do { > if (port++ >= TCP_LOCAL_PORT_RANGE_END) > port = TCP_LOCAL_PORT_RANGE_START; > } while(port_is_in_use(port));
port = TCP_LOCAL_PORT_RANGE_START; } if (!port_is_in_use(port)) break; } if (i==0) { return 0; // error, no more free ports } else { return port; } } [/c]
-
Thread
PIC12F675 & Poti.Wer kann mir helfen???
mittlerer entfernung,rot bei mittlerer bis naher entfernung. im moment bin ich mich bei sprut.de am einlesen.schau später mal bei fernando heitor vorbei. poste dann nomma wenns was neues gibt! mfg
fertig ADC-Wert einlesen; if (ADC_wert < 512 && a) { a=0; Timer so einstellen das es langsam piepst; LED_grün=1; LED_rot=0; b=255; }
-
Thread
Raspberry Pi Taster stören sich gegenseitig
keine!) Ahnung von elektrischen > Schaltungen. mal ehrlich, +3,3V ohne Strombegrenzung auf einen Port zu schalten ist keine besonders gute Idee, 1. wenn der Port mal auf out und low gestellt wird (reicht ja ein falsches Programm ein falsches Kernelupdate oder ein Absturz) dann hat der Port an +3,3V
Raspberry PI Erfolg garantiert, das Datenblatt vom SoC BCM2835sagt was von ca. 50mA zusätzlich an allen Ports als Quelle oder Senke, das ist nicht üppig, Strombegrenzung wie beim AVR findet auch nicht statt, man kann locker pro Port mehrere mA verballern bis der SoC aufgibt.
-
Thread
geschachtelte if Abfrage auf AVR Pins
Hi, vielleicht zum debuggen die Ports separieren und einzeln die PINx werte zur Fehlersuche binaer/hex ausgeben. Dann bieten sich zur beseren Lesbarkeit auch noch Masken an. //hufnala
Ansonsten gebe ich dir zu 100% Recht, es ist übersichtlicher und man läuft nicht in die Gefahr, dass der Port zwischen den einzenlen Vergleichen den Zustand wechselt. Je nach Anwendung ist das aber auch egal.
-
Thread
Wecker mit Solar und Ladeüberwachung bauen
und dass mit der ladungsanzeige is dass für einen anfänger ratsam? ich habe ein avr buch hier nur finde ich die beschreibungen da drinn ziemlich kacke.
liegt? ich schalte bei meiner schaltung das die spannungsversorgung des dcf77 moduls durch den avr ein und dann kommt das signal auf einen pin am avr.
-
Thread
Optrex DMF5008
SEL1 auf GND D0-D7 auf PA0-PA7 /RD auf PB1 /WR auf PB2 A0 auf PB3 Hier die DEFINES: // Data port #define LCDDATAPIN PINA #define LCDDATADDR DDRA #define LCDDATAPORT PORTA // Control port #define LCDCTLPIN PINB #define LCDCTLDDR DDRB #define LCDCTLPORT PORTB
fast zwei Jahre alt ist, so habe ich doch trotzdem heute eine Frage dazu: Ihr gebt hier Codes für AVR und PIC an, aber wie ist das Display denn überhaupt angeschlossen? Kann mal jemand einen kleinen Verdrahtungsplan aufzeigen? Ich will mich eigentlich in die AVR-Arbeit einlesen und habe noch so ein
-
Thread
Inkrementalgeber
euch dankbar wenn ihr mir weiterhelfen könnt, da ich noch Anfänger bin! benutzt wird Atmega8 PortD - PIN5 --> Phase_A PortD - PIN6 --> Phase B gruß
kürzlich Teile des GCC-Tutorial in separate Artikel ausgelagert. http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Die_Timer_und_Z%C3%A4hler_des_AVR
-
Thread
Bitte einmal den Schaltplan kontrollieren
basteln möchtest oder den UART nutzt. Ich habe hier immer 2 Sorten (ein großer und ein kleinerer AVR) Standard-Platinen die ich für alles möglich nutzen kann, auf denen ist der jeweilige AVR, Pads für einen Quarz, Widerstände für die Ausgänge, die Filterung für den ADC, eine Spannungsregelung und eine
Platine mit paar Taster verbinden oder man nimmt einen USB-nach-UART/TTL Konverter und redet mit dem AVR über den Seriellen Port. (diese MAX232 nutze ich nicht, das ist heutzutage eh sinnlos da nirgends mehr ein Com-port verbaut wird)