-
Thread
40x SPI-Chipselect?
jeweils ein PT100 hängt an einem dieser ICs? Und Du willst alle 40 ICs dannn durch einen Master-IC (AVR?) steuern und jeweils die CS Leitungen vom Master-IC durchsteuern und die Messwerte dann per SPI auslesen? Mit einem Port-Extender (MCP23017 et al.) oder einem TQFP64 AVR (z.B. ATMega644 oder ATMega128
Vcc+ gezogen ist das der Baustein 1 A0 und A1 auf Vcc+ Baustein 2 usw Wenn du einen GPIO einlesen willst, und du weisst, welchen du einlesen willst, z.B den des Baustein 3 Port A Bit3 dann schreibst einfach Value = SPI_READ(Device, GPIO); Wenn du dir schöne Defines anlegst, .. #define
-
Thread
"keine Änderung" des ADC soll zu Ereignis führen
ich hab sowas ähnliches mal mit Hilfe der einfachen linearen Regression gelöst: - Werte in array einlesen - Regressionsgerade berechnen - die Steigung dieser Geraden mit Schwelle vergleichen Gruß Willi
Hier Fehlermeldung + hier der Code: [c] #define F_CPU 1000000UL /* 1MHz */ #include <avr/io.h> #include <util/delay.h> #include <avr/io.h> #include <avr/interrupt.h> #include <stdlib.h> //Variablen für die Zeit volatile unsigned int millisekunden; volatile unsigned int sekunde
-
Thread
AVR: Port wiederholt schnellstmöglich auslesen?
Moin! Folgendes Problem: Mit einem AVR moechte ich ein Port-Register PinX ueber einen Zeitraum von wenigen Millisekunden so oft wie moeglich auslesen und die Bytes sequentiell im RAM ablegen, um diese dann anschliessend in Ruhe auszuwerten
anschliessend in Ruhe auszuwerten. Danach kann man die Daten aus den RAMs in aller Ruhe über einen Port in den Controller einlesen, verarbeiten, zum PC schicken oder sonstwas damit veranstalten. mfg.
-
Thread
Verständnissprobleme mit der SD Karten- Speicherverwaltung
braucht es nicht den TOP Algorthimus. >Für die Verschlüsselung brauchst Du Rechenleistung. Ein AVR reicht >nicht. Es gibt Controller mit Hardware-Crypto. Die ATXmegas haben AES in Hardware drin.
sein, keine Ahnung wie das in der Praxis aussieht. Ich würde beim AVR nach Möglichkeit bei symmetrischen Algorithmen bleiben. Zur Manipulationserkennung muß man die Daten sozusagen "unterschreiben". Dafür gibt es auch wieder asymmetrische und symmetrische Verfahren
-
Thread
Bascom Variablen
findest du im Roboternetz bzw. In der Hilfe von Bascom. Fang doch aber erst einmal mit dem eeprom vom avr an zu spielen.
' 7 Zeichen einlesen Eeprom_adr = &H0000 ' Ab Adresse 0 Gosub Read_eeprom ' Nur "ist ein" einlesen Print Eeprom_data Gosub Write_eeprom
-
Thread
Bascom I2C Eeprom
============ ' =========== Für 24C256 EEprom ===================== ' 8MHz Quarz ' LCD auf Port B , ' $regfile = "m32def.dat" $crystal = 8000000 Das war's dann: Verarsche Dich selbst!
Write_eeprom Wait 1 Eeprom_anz = 7 ' 7 Zeichen einlesen Eeprom_adr=&H0005 ' Ab Adresse 5 Gosub Read_eeprom ' Nur "ist ein" einlesen Print Eeprom_data End '####
-
Thread
Temperaturmessung mit TSIC 206
Funktion (und der dazugehörigen Funktionen): [c] #include "tsic.h" void TSIC_INIT(void) { TSIC_PORT_DDR_Power |= TSCI_POWER_PIN; // Ausgang TSIC_PORT_DDR &= ~TSIC_SIGNAL_PIN; // Eingang } uint8_t readSens(uint16_t *temp_value){ uint16_t strobelength = 0; uint16_t strobetemp =
eher so: readSens(&temp_value1); // 1. Byte einlesen readSens(&temp_value2); // 2. Byte einlesen if (!checkParity(&temp_value1)) return 0; if (!checkParity(&temp_value2)) return 0; Du solltest versuchen, das Programm zu verstehen. Btw:
-
Thread
Starterkit Mikrocontroller
so zu helfen, erst recht auf so nem einfach zu durchschauenden und zu beherrschenden Ding wie nem AVR.
SPI-Bus, der bei AVR am ICSP Port rausgeführt wird. SPI heißt also 4 Drähte (+VCC, +GROUND). Es gibt aber auch die Möglichkeit dass ein gerade laufendes Programm selber Befehle in den Flash schreiben darf. (Instruction
-
Thread
Port mit 200 kHz einlesen
Hallo zusammen! Ich möchte die Zustände zweier Ports (Port B, Port C) mit einer Frequenz von 200 kHz einlesen. Dazu verwende ich den Timer1 mit entsprechender Vorladung im CTC-Modus: Vergleichswert 80, Prescaler 1, f=16MHz. Laut Simulator benötigt die
: > Aber wozu überhaupt Interups? > Was soll der MC noch in der Loop erledigen? 20 Werte pro Port mit einer (einstellbaren) Frequenz von bis zu 200 kHz einlesen. Da die Frequenz einstellbar ist, verwende ich den Timer. Bis 100 kHz geht es auch. M.O. schrieb im Beitrag #3984373: > Das wird an
-
Thread
ESP8266 hängt bei gleichzeitigem senden/empfangen
irre ich mich? In anderen programmiersprachen ist es ja mittels png + 'x' zb. aufrufbar, aber mit AVR GCC dürfte das nicht gehen. Danke Lg
esp8266@esp8266-VirtualBox:~/Share/sdk/app$ make FW firmware/0x00000.bin usage: esptool [-h] [--port PORT] [--baud BAUD] {load_ram,dump_mem,read_mem,write_mem,write_flash,run,image_info,make_image,elf2image,read_mac,flash_id,read_flash,erase_flash} ... esptool: error
-
Thread
Raspberry Pi: Messwerte im Webbrowser anzeigen
Vielen Dank für die Antworten. Sascha Weber schrieb im Beitrag #3970821: > werden die Daten die vom AVR kommen auf dem PI schon irgendwie > weiterverarbeitet? Die Daten die vom AVR kommen sind schon fertig, also Temperatur, Luftfeuchte, etc. Ich habe es mir so vorgestellt, ich schreibe auf dem
Bedarf zu aktualisieren. Für das Auslesen der Sensoren brauche ich allerdings Zugriff auf die GPIO-Ports, der meines Wissens nach nur dem root-User gestattet ist.
-
Thread
Spannungskomperator mit ADC
* * Created: 06.01.2015 19:52:30 * Author: ***** */ #define F_CPU 800000UL #include <avr/io.h> #include <avr/interrupt.h> #include <util/delay.h> #include "ADC.h" #define HEATER PB1 #define LED PB3 #define DEBUG_LED PB0 void init_ports(void); void checkTemperature(void); void
checkTemperature(); _delay_ms(500); } return 0; } // Initialize the port-pins void init_ports(void) { // LED-Port (output), Relay-Port (for heater) (output) DDRB |= (1<<LED) | (1<<HEATER) | (1<<DEBUG_LED); PORTB &= ~(1<<LED); PORTB &= ~(1<<HEATER); PORTB
-
Thread
LED Blinker Multitasking Attiny 85
dem Analog-Digital-Umsetzer auf > einer SD Karte zu loggen mit einer txt Datei die man in Exel einlesen > kann. Sehr spannendes Vorhaben, es gibt ja nur (gefühlt) 20.000 Lösungen für AVR-Datenlogger bisher... Ich würde dir eher empfehlen, dir eine der bestehenden Lösungen zu greifen und zu versuchen
LED1 as PortB.0 LED1.mode = output Avr.Interrupts.Enable // Globale Interrupts einschalten Timer0.Cmp.Isr = meineServiceRoutine // Serviceroutine zuweisen timer0.pwm.mode = 2 avr.ocr0 = 199 Timer0.Cmp.Enable
-
Thread
CooCox V2 Beta crashed auf Windows XP
es kommen so seltsame Sachen wie auf dem Bild wenn man ein Projekt estellen will. Alte projekte einlesen geht auch nicht mit dem STM32F429, a behauptet wird den Chip gäbe es nicht und danach ist die IDE wieder eingefroren. Mal friert sie schon beim Starten ein, mal nach ein paar Klicks. Ich fahre Windows
RAM, nebenbei ~20 offenen Tabs in Chrome und Safari, Mail, ... hervorragend. Plug-ins für ARM und AVR sind installiert. Das Starten dauert paar Sekunden, aber danach geht es problemlos weiter.
-
Thread
Motor selbständig alle XSekunden langsam hin und her fahren lassen!
Nickenden Vögel, die mit Wasser gefüllt sind, die könnten immer nen Taster betätigen, was dann von dem AVR ausgewertet wird.... Lange Rede, überhaupt keinen Sinn, du kannst ALLES nehmen, was entweder irgendwie programmierbar ist, oder eben das Gatter Zeug. Empfehle -> setz dich mal an Arduino, wenig
Dim Geschwindigkeit As Byte Dim Adcwert As Byte Dim Zeitzaehler As Word Dim Merker As Byte 'PortB0 Taster Rosum +LED 1 'PortB1 Taster Sorum +LED 2 'PortB2 Poti 'PortB3 Oberer OPV 'PortB4 Unterer OPV Const Fahrzeit = 1000 'Entspricht
-
Thread
Aus Temp-Sensor Tabellen-Werten Formel erstellen
bedeuten? Hm.... Zur Rechenzeit des µCs. Der soll genau drei Dinge tun: Den Messwert des Sensors einlesen, das Umrechnen und drittens alles auf eine dreistellige LED-Anzeige ausgeben (wobei nicht multiplext werden soll, der Platinenplatz ist reichlich, und der angestrebte PIC hat 5 ganze Ports). Die
bedeuten? Hm.... > Zur Rechenzeit des µCs. Der soll genau drei Dinge tun: Den Messwert des > Sensors einlesen, das Umrechnen und drittens alles auf eine dreistellige > LED-Anzeige ausgeben (wobei nicht multiplext werden soll, der > Platinenplatz ist reichlich, und der angestrebte PIC hat 5 ganze Ports).
-
Thread
Interupt vom RFM12
folgenden Code womit es auch tadellos funktioniert: [c] int main(void) //Hauptprogramm { initPorts(); //AVR-Ports initialisieren initUART(); //zu Testzwecken initInterrupt(); //Interrups initialisieren Power_On(); //Powern On Prozedur RFM_ON(); //RFM
auf Dauer+ _delay_ms(200); //Etwas Zeit verbummeln bis das Modul bereit ist initRFM_Ports(); //MOSI / MISO Ports initialisieren initRFM(); //RFM Grundkonfiguration RFM_EMPF_EIN(); //Empfang einschalten while(true) //Hauptschleife { RFM_EMPF_EIN(); //
-
Thread
Bin neu hier! Wie kann man beim atmega8 speichern?
-------------------------------------------------- #define F_CPU 3686400 // Taktfrequenz des myAVR-Boards #include <avr\io.h> // AVR Register und Konstantendefinitionen //---------------------------------------------------------------------- void initPorts(void) // Unterprogramm füpr
www.atmel.com/devices/atmega8.aspx?tab=parameters und geht so: http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#EEPROM http://www.mikrocontroller.net/articles/AVR-Tutorial:_Speicher
-
Thread
C Programmierung STM32
doch deutlich besser. (Bevorzuge Visual Studio vor Eclipse). Die ganzen Initilaisierungen der Ports sind in meinen Augen grundlegend verschieden. Gibt es irgendwo ein gutes Tutorial, was man ab arbeiten kann, bei dem man mal Grundlegend die neue Technik bzgl. Taster einlesen oder Led setzen lernt
Hi, also im Unterschied zum AVR solltest Du dringlichst die vorgegebenen Initialisierungsroutinen benutzen um die Clocks etc. einzustellen. Im Gegensatz zum AVR wird das NICHT per Fuses geregelt, sondern durch die Software zur
-
Thread
LON Bus Windhager mitlesen/steuern
platformio.ini and change > build_flags = !bash -c "echo -Isrc -DDEBUG_ESP_HTTP_UPDATE > -DDEBUG_ESP_PORT=Serial -DPIO_SRC_REVNUM=$(git rev-list --count HEAD) > -DPIO_SRC_REV=$(git rev-parse --short HEAD)" to > build_flags = -Isrc -DDEBUG_ESP_HTTP_UPDATE -DDEBUG_ESP_PORT=Serial > -DPIO_SRC_REVNUM
Hallo, Ich hab noch einen Kommunikationsmodul, XLON und AVR Schnittstellen mit Kabeln zum auslesen von Windhager Regelung zum abgeben. Bei Interesse einfach melden. Gruß Heizi
-
Thread
Probleme mit AVR Frequenzmessung
Anfang stehe, danke. Hier der Code: [c] // Einbinden der erforderlichen Bibliotheken #include <avr/io.h> #include <avr/interrupt.h> #include <stdio.h> #include <util/delay.h> #include "lcd.h" // benutzt zum Berechnen der Ergebnisse volatile uint32_t frequenz; // aktuelle
frequenz); counter = 0; TCNT0 = 0; sei(); } // Hauptprogramm int main(void) { // IO-Ports initialisieren und vorbelegen DDRC |= (1 << DDC5) | (1 << DDC4) | (1 << DDC3) | (1 << DDC2); DDRC &= ~ ((1 << DDC6) | (1 << DDC1) | (1 << DDC0)); // PC6=in, RESET // PC5=out, PC4=out, PC3
-
Thread
Universelle Tastenabfrage nach PeDa in AVR Assembler
zusammen, leider programmiert PeDa ( Peter Dannegger ) ja nur noch in C. Ich würde gerne als " AVR-ASM-Übender " die erweiterte Version von dieser hier verstehen und suche somit Leute die Lust und Können besitzen, dies einem AVR-Assembler-Übenden zu erklären : http://www.mikrocontroller.net/topic
. Nehmen wir einmal an, das LCD ist an einem anderen Port besser im Layout zu verdrahten, dann ordnet man dem LCD einfach einmalig den anderen Port in der Definition zu und muss sich im Programm um nichts weiter kümmern. Ich habe Dir jetzt mal als _nicht
-
Thread
I2C programmierung lernen
Was du suchst, sind I2C Port Expander. zb sowas hier http://www.mikrocontroller.net/articles/Port-Expander_PCF8574
bin auch für die Lösung der Zentralen Steuerung und gegen "parallele" Schaltwege. Schnapp dir einen AVR der als Gehirn den Zustand deiner Aktoren überwacht und bei Bedarf jedem der will Auskunft gibt. Bus ------> |AVR| ---> Relais Schalter -> |___| Gruß deathfun
-
Thread
RFM01 Empfänger mit Interrupt
! Erste Zeile nach main. > * (an den RFM sende ich dazu : 0xc0a2, 0xce88, 0xce8b) [c] RF_PORT=(1<<CS); RF_DDR=(1<<SDI)|(1<<SCK)|(1<<CS); for (i=0; i<16; i++) _delay_ms(10); // wait until POR done rf01_trans(0xC2E0); // AVR CLK: 10MHz rf01_trans(0xC42B);
("Interrupt"); unsigned char c; cbi(RF_PORT, SDI); sbi(RF_PORT, CS); //low avctiv cbi(RF_PORT, SCK); sbi(RF_PORT, SDO); //low activ _delay_ms(2); cbi(RF_PORT,CS); //RFM ausgewählt for (j=
-
Thread
Anfänger in C und welcher PIC (evtl. uno32) ist geeignet ?
kennt, kann man später auch komplexe Projekte damit realisieren ohne gleich wechseln zu müssen. Ports setzen und PWM augeben / einlesen sin nicht schwieriger als beim PIC18.
kleinste 8-Bitter wird zu 95% der Zeit Däumchen drehen. Auch die Unterschiede zwischen PIC und AVR werden von C zu einem gewissen Grad nivelliert. Klar, die magischen Variablennamen für Ports, Timer & Co unterscheiden sich. Genauso wie die Includefiles in denen sie definiert sind. Aber das sind Kleinigkeiten
-
Thread
AVR ATtiny26 - 3Channel PWM
isr_ptr_time[pwm_cnt]; tmp = isr_ptr_mask[pwm_cnt]; if (pwm_cnt == 0) { PWM_PORT = tmp; // Ports setzen zu Begin der PWM // zusätzliche PWM-Ports hier setzen pwm_cnt++; } else { PWM_PORT &= tmp; // Ports löschen // zusätzliche PWM-Ports hier setzen if (pwm_cnt == pwm_cnt_max) { pwm_sync = 1
-
Thread
ADC, Attiny84 interne Referenzspannung
Hallo, möchte am PA3 des Attiny84 einen analogen Wert einlesen. Die anderen Pins des Ports A werden als Ausgänge verwendet. Nun kann man im ADMUX die Bits REFS1 und REFS0 einstellen. Habe es schon im Öfteren versucht, und es hat leider nicht geklappt.
iGast schrieb im Beitrag #3917241: > möchte am PA3 des Attiny84 einen analogen Wert einlesen. Die anderen > Pins des Ports A werden als Ausgänge verwendet. Karl Heinz schrieb im Beitrag #3917312: > Was in diesem Fall aber keine Rolle spielt, da sein Messwertaufnehmer > von der selben
-
Thread
Mal wieder ein Selbstbau-Logicanalyzer mit ATmega.
Eingängen. Das glaube ich nicht. Die kürzestmögliche Read/Store-Sequenz für ein Sample ist: in reg,port ;1 st idxreg+,reg ;2 ;- ;3 D.h.: selbst mit vollständigem loop unrolling müßtest du den armen AVR mit 30MHz betreiben, um die 10MHz Samplefrequenz zu schaffen
Avr 30 mhz Mit einem Xmega? Oder Taktest du die 30 Mhz extern in ein Ram?
-
Thread
GPSDO mit ATMega - Suche 32 Bit Zähler IC
Beispiel auf die Schnelle: http://www.mikrocontroller.net/topic/241150#new Und wenn Du Dich vom AVR verabschieden möchtest, etwas Feines: http://www.mino-elektronik.de/FM_407/fmeter_407.htm
mit single bei so einem > Projekt, wo es um richtig große Auflösungen geht. 'double' geht mit AVR und ist nicht einmal langsam.
-
Thread
AVR-Mikrocontrollertechnik-Kursus in Assembler besprechung Gesperrt
rjmp _loop ;Weitere Programmteile bearbeiten _pla_service: in A,LED_PORT ;LED Port-Zustand einlesen eor A,B ;PLA-Bit toggeln out LED_PORT,A ;PLA-LED toggeln cbr Flag_Byte,1<<LED_PLA ;Flag fuer Programmlaufanzeige
rjmp _loop ;Weitere Programmteile bearbeiten _pla_service: in a,Led_Port ;LED Port-Zustand einlesen eor a,b ;PLA-Bit toggeln out Led_Port,a ;PLA-LED toggeln cbr flag_byte,1<<LED_PLA ;Flag fuer Programmlaufanzeige
-
Thread
Auswahl Mikrocontroller (von Anfänger)
> jedenfalls schonmal deutlich weitergeholfen. > > Vielen Dank > > Grüße > Ruben Beim AVR komme ich auf ca. 6€ "Einstiegskosten". 2,50€ AVR ISP bei Ebay 1,50€ Mini Steckbrett bei eBay 1,00€ AVR ATTiny 1,00€ Kleinkrams
El Jefe schrieb im Beitrag #3898660: > Beim AVR komme ich auf ca. 6€ "Einstiegskosten". > 2,50€ AVR ISP bei Ebay > 1,50€ Mini Steckbrett bei eBay > 1,00€ AVR ATTiny > 1,00€ Kleinkrams Hirn einschalten, Lernen, ausprobieren: Unbezahlbar.
-
Thread
Projekt: MC (ATtiny26) als Messinstrument zur Steuerung
weniger wie 5V, sagen wir mal 0-3V nur von der PV-Zelle erzeugt werden soll Port Pin 17 geschaltet werden und eine LED (gelb) zum leuchten bringen. Sollte mehr wie 5V erzeigt werden, soll Port Pin 18 geschaltet werden und eine LED (rot) zum leuchten bringen. Wie gesagt das
Kondensatoren und Widerstände sind da nicht per Lust und Laune verteilt worden, sondern haben einen Sinn. [[AVR-Tutorial]]
-
Thread
LCD Keypad Shield zeigt nichts an
und getestet, dabei auf alle Arduino-spezifischen Befehle verzichtet, so dass es ganz normal unter AVR-GCC laufen sollte. Funktioniert's?
verwenden möchtest, mußt Du den ADC an A0 direkt abfragen, dazu gibt es hier auch ein Tutorial, wie auf AVR-Controllern der ADC abgefragt wird: http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Analoge_Ein-_und_Ausgabe#Der_interne_ADC_im_AVR
-
Thread
C++ auf einem MC, wie geht das?
definiere dann meine Ports als Konstante . #ifdef __AVR_ATmega16__ constexpr AvrPortRegsTyp1 PORTA = {0x19,0x1A,0x1B}; constexpr AvrPortRegsTyp1 PORTB = {0x16,0x17,0x18}; constexpr AvrPortRegsTyp1 PORTC = {0x13,0x14,0x15}; constexpr AvrPortRegsTyp1 PORTD = {0x10,0x11,0x12}; #endif // __AVR_ATmega16__ #ifdef __AVR_ATtiny1634__ constexpr AvrPortRegsTyp2 PORTA = {0x0F,0x10,0x11,0x12}; constexpr AvrPortRegsTyp2 PORTB = {0x0B,0x0C
-
Artikel
STM32F10x Standard Peripherals Library
dafür eine eigene Funktion geschrieben. Diese lautet GPIO_PinLockConfig(). Erster Parameter ist der Port, der zweite sind die Pins, welche man sperren möchte. Diese kann man wieder mit der ODER Verknüpfung kombinieren. Eingänge einlesen. Um Daten in den STM32 einzulesen, gibt es wieder ein paar ST Funktionen
verwendbaren Funktionen sind: GPIO_ReadInputDataBit() sowie GPIO_ReadInputData(). Erster Parameter ist der Port, der zweite sind die Pins, die man einlesen möchte. Bei GPIO_ReadInputData() wird jedoch nur der Port übergeben, da diese Funktion den gesamten Port zurück liefert! Hier wird der tatsächliche logische
-
Thread
C code automatisch in hexfile compilieren
# Programming support using avrdude. Settings and variables. # Programming hardware: alf avr910 avrisp bascom bsd # dt006 pavr picoweb pony-stk200 sp12 stk200 stk500 # # Type: avrdude -c ? # to get a full listing. # AVRDUDE_PROGRAMMER = stk500 # com1 = serial port. Use lpt1 to connect
# Programming support using avrdude. Settings and variables. # Programming hardware: alf avr910 avrisp bascom bsd # dt006 pavr picoweb pony-stk200 sp12 stk200 stk500 # # Type: avrdude -c ? # to get a full listing. # AVRDUDE_PROGRAMMER = stk500 # com1 = serial port. Use lpt1 to connect
-
Thread
Richtiges C++ hardwarenah
: > Sag mal an, wie Du ein Portbit setzt! > Wehe, das geht über 'sbi PortA,0' hinaus. Würde ich übrigens in C++ genau so schreiben wie in C und wie es üblich ist. Und Oh, sieh mal, wass der Assembler output draus macht, [c] #include <avr/io.h> int main(void) {
über-Alles-Optimierung bekommt. Wieviele Versionen von Library gibt es denn für die verschiedenen AVR's. Für jeden eine, oder eine, die zur Laufzeit entscheidet ob der Port im IO- oder MEM-Bereich liegt. ASM hab ich benutzt, als es keine bezahlbaren Compiler gab. Anfangs gab's noch nicht mal Assembler
-
Thread
Problem bei Einlesen der Analogwerte
Schönen Guten Abend, mein Problem ist folgendes. Ich habe eine Schaltung mit zwei Analogen Eingängen wo jeweils ein CNY70 dranhängt. An den beiden Ausgängen jeweils eine LED. Das Programm läuft soweit, mit einem Eingang. Nehme ich allerdings den zweiten Eingang dazu, reagieren beide Ausgänge identisch, obwohl ich nur einen Eingang manipuliere. Wäre nett wenn ihr mir eine Tipp bzw. weiterhelfen könntet. Seh den Wald vor lauter Bäumen nicht mehr! Programmiert wird ein ATmega32 über das Pollin Evaluationsboard. [c] #include <avr/io.h> void ADC_Init(void); uint16_t ADC_Read(uint8_t channel
-
Thread
Bitte um Prüfung meines Layout
Jede Menge Masseschnippsel, z.B. an den Ports. Aber keine Massefläche unter dem µC ;)
was aus dem NE kommt hat 15 Volt. Wenn ich das Signal als eine Art "Enable"-Signal an meinen uC einlesen will darf es maximal 3,6Volt haben. Das war wohl etwas komplizierter gedacht als nötig. Hab es inzwischen durch einen einfachen Spannungsteiler ersetzt ^^ > Woher kommen die +15V? Die 15V
-
Thread
ca. 100 PT1000 Messwiderstände messen
sein muss als die 5VRef, die also höchstens auf > 4.65V verstärkt werden darf aus den 2.5V die der AVR ausgibt. > > Die 2.5C ARef des AVR darf sogar zwischen 2.3V und 2.7V liegen, sie ist > also nicht genau, aber 1000 mal stabiler als die 5V Versorgungsspannung, > damit 2.7V auf 4.85V verstärkt
100 °C sind in der Regel 1 K aber auch mal 2 K. An anderer Stelle hatte ich geschrieben, daß aus der AVR-Reihe ein ATXmega mit 12 Bit ADC 'optimal' wäre. Oder man ergänzt einen AVR um einen MCP3208 ADC. Alex Student schrieb im Beitrag #3916837: > Also der C8051F350, welchen ich für die Auswertung
-
Thread
Funktion zum vergleich von Variablen
möchte. Dafür habe einen einen uC über SPI mit einem 74HC595 (Ausgang) und einen 74HC165 (zum einlesen) verwendet. Die Kommunikation funktioniert auch sehr gut. Zum testen habe ich einfach die Eingänge vom 165 1 zu 1 an die Ausgänge vom 595 geschlossen und kann so immer sehen was ich gesendet hab
ein echter Prozessorport sein. Oder man realisiert die Datadirectionfunktion mit einem zweiten SPI-Port, das ist recht aufwendig.
-
Thread
Leds mit gleichen Taster durchschalten
vervollständigen könnte oder neuer Code mit Timer oder anderem Lösung schreibt. Alex [c] #include <avr/io.h> int main(void) { DDRB|=(1<<PD3)|(1<<PD4)|(1<<PD5);// Pin 3,4,5 im Port B auf Ausgang DDRB&=~(1<<PD0); // Pin 0 im Port B auf Eingang (Taster) PORTB|=(1<<PD0); // Pull-Up aktivieren
Ansonsten es ist egal was für ein Board ich habe, Quellcode kann ich zu meinem Atmega8 auf dem myAVR mk2 Board anpassen.
-
Thread
PWM über 2 Potis
. ==> vergiss den AVR , das kann der nicht. Bei den Rahmenbedingungen bleiben dir jetzt 3 Möglichkeiten. 1. eine Softwarelösung mit Interuptgetriebenen Umkonfigurierungen des Timers. Hier musst du sehr darauf achten
für beide Potis. Erhöht die Schrittweite auf 4 µs, dann brauchst du einen 18 Bit Timer. reicht im AVR immer noch nicht. Eine Beschaltung der ADC die eine Nutzung der 10 Bit erlaubt, ist mit praktikablen Aufwand im Hobbybereich nicht umsetzbar.
-
Thread
AVR: unsigned 24 bit auf 3 Ports verteilen
inline-Assembler oder einer eigenen Assembler-Routine kannst du die Werte direkt aus den Registern in die Ports schreiben. Schneller gehst es nicht. Oliver
auf dem stack liegen. Bei irgendwelchen Compilern für irgendwelche Zielplattformen ja. Beim avr-gcc mit einem uint32-Funktionsparameter wie im oben gezeigten Code liegt der immer in den Registern. Oliver