Mikrocontroller.net - Benutzerbeiträge [de]

Entwicklungsboard mit PIC

2013-07-09T09:00:10Z

Horha: Unsinn entfernt

[[Kategorie:Wettbewerb]]

''von Denys Maiier''

{{Wettbewerb Header}}

[[Datei:brd mini.jpg]] [[Datei:Entwicklungsboard_gefräst.JPG]]

== Vorwort ==

Dieses Kit dient als Lehrmittel für Studenten, Schüler und diejenigen, die Grundlagen und Funktionalität der Mikroprozessortechnik, am Beispiel des Microcontrollers der PIC18 Familie von der Firma Microchip, beherrschen möchten. Mit Hilfe der im Kit erhaltenen Modulen können folgende Programmieraufgaben gelöst werden:

• Ein- und Ausgabe über I/O Ports und Kontrolle der Ausgabe über 16 LED’s

• Externe Programmunterbrechung über 3 Interruptquellen(3 Buttons)

• Verbindung mit dem PC über UART

• Datenübertragung über IR

• Tonausgabe (Buzzer)

• Datenübertragung über SPI und I²C im Halb-Duplex-Mode

• Schrittmotorensteuerung

• Dynamische Tastatureingabe

• AD- Umwandlung

• Datenausgabe auf dem HD44780 Display

== Projektinhalt ==

a. Mainboard
b. SPI-Board
c. I²C-Board
d. Com-Board
e. Hitachi LCD Board

== Hardware ==

Projekt der Entwicklungsplatine basiert sich auf dem PIC 18F4520 Microcontroller und besteht aus dem Main-board und Peripherie-Modulen , die mit Hilfe der Kabelverbindungen mit Main-board verbunden werden.

== Mainboard ==

Mainboard verfügt über 33 I/O Ports, die allerdings spezifisch benutzt werden können. Die PORTB I/O Pins können softwaremäßig an die innere Pull-Up Widerstände angeschlossen werden. Das MCU wird über Quarz/Keramik Oszillator taktversorgt.Die Kapazität der Kondensatoren liegt im Bereich 15-25pF und von den Quartzeigenschaften abhängig.Die empfohlene Größe steht üblicherweise im Datenblatt. Buzzer SG1 kann anhand dem Jumper JP2 an Port RE2 angeschlossen werden. Drei Tasten (INT1-INT3) zusammen mit Widerständen R69 bis R71 und R20 bis R23 ermöglichen die externe Programmunterbrechung. Mikrocontroller PIC18 verfügt über ICSP Modul und kann über ICSP Input direkt im Board programmiert werden. 16 separat gesteuerte LED sind über JP5 und JP10 an die Output-Pins von PIC18 anzuschließen.

''Mainboard Modul''
[[Datei:Mainboard V1.0.jpg]]

PIC 18 verfügt über Master Synchronous Serial Port und kann im SPI oder I²C Modus arbeiten. Dieses Entwicklungsboard hat zwei Module womit die Grundlagen der seriellen Übertragung geübt werden können.

== SPI-Interface Board ==

''SPI Modul''
[[Datei:SPI Modul.png]]

Wenn MSSP als SPI eingestellt ist, sollen die Pins RC3-RC5 des PIC18 entsprechend softwaremäßig eingestellt und mit ISP – Modul verbunden werden. Benötigt wird auch noch ein Port-Pin des MCU um den Chip Select Eingänge der MCP23S17 zu steuern.
SPI Interface Modul – Platine ermöglicht separate Steuerung von zwei MCP23S17 Bausteinen, die allerdings mit dem gemeinsamen Chip Select Signal und unterschiedlichen HW-Adressen (000 und 111) als I/ O Serial – zu –Parallel Treiber funktionieren.
IC2 ist mit 4 Binär zu Dezimal Wandler ausgestattet und wird zur Ausgabe der 16 Bit Daten benutzt.
Die ersten 8 Bit vom IC3 können über JP15 mit zwei L293D Schritt-Motoren –Treiber beschaltet werden.
Die Bits 9 bis 16 dienen als Inputs und können mit externer Tastatur 4x4 angeschlossen werden.

== I²C Interface Board ==

''I²C Modul'' [[Datei:I2C Interface.jpg]]

Wenn MSSP im I²C Modus ist, wird die I²C Interface Platine benötigt. Entsprechende MCU Pins RC3 und RC4 sollen dann mit I2C-Input beschaltet werden.
Über I²C Protokoll können folgende Peripherie-Bauteile angesteuert werden: Real Clock Modul, EEProm, ADU Umwander mit 4 über Potis beschalteten Analog- Eingängen, Serial-to-Parallel Wandler mit 8 LED , Serial-to-Parallel Wandler mit 4x4 Tastatur und ein Temperatursensor.
Zugang zu den einzelnen Bauelementen erfolgt über verschiedene Adressen der Peripherie. Damit werden die Kollisionen vermieden.

''HW-Adressen der I²C Peripherie''
[[Datei:HW-Adresse.bmp]]

== Comm-Modul ==
RS-232& USB Modul [[Datei:USB&RS-232&Keyboard.jpg]]

Peripherie- Com-Modul ermöglicht die Datenübertragung zwischen dem PC und MCU über eine UART Schnittstelle. Dafür müssen gewisse Änderungen im Software vorgenommen werden. Außerdem sollen die Port-Pins RC6 und RC7 mit den entsprechenden Kontakten der JP18 JP17 verbunden sein(Siehe Videobeispiel "Anschluß mit PC über USB").

== LCD-Modul ==

''PVC200403P''[[Datei:PVC200403P.JPG]]

Über die Pin-Heads JP8(JP6 oder JP7) und JP19 kann die parallele Steuerung des LCD-Moduls organisiert werden. In meinem Fall habe ich ein Display PVC200403P von PICVUE genommen. Das ist ein Hitachi HD44780 Standard- Display, und verfügt über 8–bit Daten-Bus + 3 Steuerung-Wires. Erlaubt ist auch die Datenübertragung über 4-bit Daten-Bus+3 Steuerung-Wires. D.h. benötigt werden mindestens 7 Adern des MCU + Stromversorgung. Im Beispiel 3 und 4 (Siehe Anhang "Videobeispiele"), habe ich mein Display mit insgesamt 8 Adern gesteuert(-,+ -Stromversorgung, E-Enable, RS-Register Select, 4-bit Datenbus). Alle anderen Eingänge wurden mit "-" verbunden. Diese Lösung spart Euch I/O, benötigt allerdings bisschen komplexere LCD-Initialisierung. Die im Datenblatt"PVC200403P" angegebene Zeitverzögerungen zwischen den Initialisierungsbefehlen habe ich mit Timer1 realisiert und damit die Abfrage des Busy-Flags gespart.

== ICSP Programmierung ==

''ICSP I/O Beschaltung'' [[Datei:ICSP.png]]

Ein ICSP I/O ermöglicht die interne Programmierung des Microcontrollers,
Z.b. via PicKit2 oder PicKit3. In meinem Fall habe ich ein EEPRom Programmiergerät mit ZIF-Socket zu ICSP Adapter genommen(Siehe Anhang).

[http://www.mikrocontroller.net/wikifiles/2/2f/ICSP_Programmierung.JPG EEPROM_Programmer + ICSP Adapter]

== Leiterplatte ==

''A4 Größe Design'' [[Datei:Brd Entwicklungsboard.png]]

Schaltplandesign und Leiterplattenentwurf wurde im Eagle realisiert. Der Prototyp wurde auf der doppelseitigen Leiterplatte gefräst und bestückt. Das MCU wurde im Sockel befestigt. Hiermit können die weitere Erweiterungen und MCU-Wechsel ohne Löten durchgeführt werden.
Der Spannungsregler wurde auf die Leiterplatte gelegt und übers Wärmeleitpad mit dem Lötzinn befestigt. Somit spielt die Plattenfläche auch die Rolle des Kühlkörpers.

[[Datei:7805T.JPG]]

== Praktische Anwendung ==

''Real Time Clock '' [[Datei:Realtime_Clock.BMP]]

Eine der möglichen Anwendungen der Entwicklungsplatine ist ein Real-Clock mit der Ausgabe auf dem LCD-Display (siehe Bild). Hiermit werden die Prinzipien der I2C-, Parallel Datenübertragung und der dynamischen Tastenabfrage geübt. In dem Fall benötigen wir ein HD44780 Modul, Mainboard- Modul und ein I2C Modul.
Die 4x4 Tastatur wird direkt an PortB des MCU angeschlossen. Die ersten 4 Bits sind als Ausgange konfiguriert und die letzten 4 Bits dienen als Eingange mit den inneren Pull-Up Widerständen. Die parallele Datenübertragung zwischen dem MCU und LCD-Modul erfolgt über Port D und Port E des Microcontrollers. Die beiden Peripherie – Bausteine PCF8574 und PCF8583 benötigen serielle Datenübertragung im I²C Mode mit Taktfrequenz <100kHz. Damit es nicht zu Kollisionen führt, haben die beiden Bausteine verschiedene Adressen. Achten Sie auch darauf, dass alle Bausteine der I²C Peripherie eigene Protokollspezifik haben. Z.B.:

''PCF8574_Read_Mode'' [[Datei:8574_Read_Mode.png]]

''PCF8574_Write_Mode'' [[Datei:8574 Write Mode.png]]

''PCF8583_Read_Mode'' [[Datei:Clock_Read_Mode.png]]

''PCF8583_Write_Mode'' [[Datei:Clock_Write_Mode.png]]

== Fazit ==
Der Einstieg in die moderne Mikroprozessor- und Mikrocontroller-welt ist praktisch ohne Evaluations-Kits nicht möglich. An manchen Stellen ist die Simulationsprogramm ungenau, insbesondere ist sehr von der Prozessorbelastung abhängig,und lässt die äußere Einflüsse nicht simulieren.In dem Fall ist der Einsatz der Entwicklungsplatine unvermeidlich. Mehrere auf dem Markt vorgestellte Platten sind wegen ihren hohen Preisen nicht an einen durchschnittlichen Käufer(Studenten oder Schüler) gedacht und beziehen sich auf den konkreten Mikroprozessor, der nicht auszutauschen ist. In diesem Zusammenhang , bietet die angebotene Entwicklungsplatine die Universalität, kann leicht nachgebaut und erweitert werden. Der IC-Sockel ermöglicht den unkomplizierten MCU-Tausch, Upgrade oder Übergang zu dem MCU anderer Hersteller.

== Kontakt ==
Nach Anfrage kann ich auch die Quellcode, sowie PCB-Design und Programmierbeispiele zur Verfügung stellen.
Ihre Fragen bitte an : maiierok@t-online.de

== Videobeispiele ==
''Video "Anwendung Real-Time Clock"''
[http://www.youtube.com/watch?v=9R3alJx_ldA Simulation im Proteus]

''Video "Versuch #1 LED& Buzzer- Steuerung"''
[http://youtu.be/Yn8-Ny-1He0 LED&Buzzer TEST#1 ]

''Beispiel 3 "Liebeserklärung''
[http://youtu.be/26qt7u2WQ8s Mainboard + HD44780]

''Beispiel 4 "Anschluß mit PC über USB''
[http://www.youtube.com/watch?v=nqvd8O5QHOQ Mainboard+ Comm-Board+ HD44780]

== Link ==

''PIC18 Datasheet'' [[Datei:Pic18f2420-2520-4420-4520.pdf]]

''A200_ua7805'' [[Datei:A200_ua7805.pdf]]

''PCF8583'' [[Datei:Clock and Calendar.pdf]]

''PCF8574'' [[Datei:PCF8574.pdf]]

''I²C_ Temperature Sensor'' [[Datei:Thermo_I²C.pdf]]

''Mcp23s17 SPI Expander'' [[Datei:Mcp23s17.pdf]]

''HD44780 Display'' [http://www.adafruit.com/datasheets/HD44780.pdf Datasheet]

AVR Arithmetik/Sinus und Cosinus (Lineare Interpolation)

2012-04-22T16:52:41Z

Horha: http://www.pmelms.de/bit/ws/berech_zweikompl.htmlng 65865 von 95.208.157.192 (Diskussion) wurde rückgängig gemacht.

''von [[Benutzer:gjlayde|gjlayde]]''

<div style="float:right; margin:1em;">
{| {{Tabelle}}
|+ '''Lineare Interpolation: Ressourcenverbrauch'''
|- bgcolor="#ffddbb"
! Größe || maximaler Verbrauch
|-
| Laufzeit Sinus || 60 Ticks (incl. CALL+RET)
|-
| Laufzeit Cosinus || 74 Ticks (incl. CALL+RET)
|-
| RAM (statisch) || 0 Bytes
|-
| RAM (Stack) || 2–3 Bytes<ref name="pc">Abhängig von der Größe des PC</ref>
|-
| Flash || 300 Bytes<ref name="3.4.6">Übersetzt mit avr-gcc 3.4.6 für einen ATmega88</ref>
|-
| || 318 Bytes (avr-gcc 4.3.3 für ATmega88)
|}
</div>
Die AVR-Implementierung der linearen Interpolation von Sinus und Cosinus braucht mit 300 Bytes etwas mehr Platz als [[AVR Arithmetik/Sinus und Cosinus (CORDIC)|CORDIC]], arbeitet dafür aber deutlich schneller. Das Eingabeformat ist allerdings ein anderes als bei der obigen CORDIC-Implementierung. Die Werte streuen weniger als beim CORDIC, und sowohl Maximalfehler als auch Standardabweichungen sind kleiner.

Der Algorithmus ist in GNU-C implementiert, greift jedoch auf Inline-Assembler zurück. Dennoch dürfte er leichter zu portieren und zu verstehen sein als eine reine Assembler-Implementierung. Er verwendet Befehle wie MUL, setzt also einen AVR aus der ATmega-Familie voraus.

Der Algorithmus braucht für keine Berechnung (inclusive CALL und RET) länger als 60 Ticks<ref name="3.4.6"/> für den Sinus bzw. 74 Ticks<ref name="3.4.6"/> für den Cosinus. Für avr-gcc 4.x kommen u.U einige Ticks hinzu.

{{Clear}}

== Ein- und Ausgabe ==

Die Eingabe ist so skaliert, daß ein Grad aus 256 Inkrementen besteht. Gültige Eingaben liegen also in einem Bereich von 0° bis 255.99° bzw. 0·256...255·256+255. Für die Berechnung von sin(45°) ist der Aufruf beispielsweise
<c>
// si = sin (45°)
// co = cos (45°)
int16_t si = linsin (45*256);
int16_t co = lincos (45*256);
</c>

Für die Ausgabe gilt das gleiche wie für [[AVR Arithmetik/Sinus und Cosinus (CORDIC)#Ein- und Ausgabe|CORDIC]]: Es sind vorzeichenbehaftete Werte im 1.15 Q-Format, wobei der kritische Wert 0x8000 bzw. −32768 nicht produziert wird.

== Quellcode ==

=== linsin.h ===

<c>
#ifndef LINSIN_H
#define LINSIN_H

#include <stdint.h>

int16_t linsin (uint16_t);
int16_t lincos (uint16_t);
#endif // LINSIN_H
</c>

=== linsin.c ===

{{Scrollbox|40ex;|
<c>
#include <avr/pgmspace.h>

#include "linsin.h"

// Nachguck-Tabelle für eine Sinus-Interpolante.
// Die Stützstellen sind volle °-Werte von 0°...90°.
// Die Werte sind so gewählt, daß die Polygonzug-Interpolante
// den Maximalfehler minimiert; daher sind die Werte in der
// Tabelle nicht die Funktionswerte des Sinus an den
// entsprechenden Stellen.
static const int16_t linsin_tab[91] PROGMEM =
{
0x0000, 0x023c, 0x0478, 0x06b3, 0x08ee, 0x0b28, 0x0d61, 0x0f9a, 0x11d1, 0x1406,
0x163a, 0x186d, 0x1a9d, 0x1ccb, 0x1ef8, 0x2121, 0x2348, 0x256d, 0x278e, 0x29ad,
0x2bc8, 0x2ddf, 0x2ff4, 0x3204, 0x3410, 0x3619, 0x381d, 0x3a1d, 0x3c18, 0x3e0f,
0x4001, 0x41ed, 0x43d5, 0x45b7, 0x4794, 0x496c, 0x4b3d, 0x4d09, 0x4ecf, 0x508e,
0x5248, 0x53fb, 0x55a7, 0x574d, 0x58eb, 0x5a83, 0x5c14, 0x5d9e, 0x5f20, 0x609b,
0x620f, 0x637a, 0x64df, 0x663b, 0x678f, 0x68db, 0x6a1f, 0x6b5b, 0x6c8e, 0x6db9,
0x6edb, 0x6ff5, 0x7106, 0x720e, 0x730d, 0x7403, 0x74f0, 0x75d4, 0x76af, 0x7781,
0x7849, 0x7908, 0x79bd, 0x7a69, 0x7b0c, 0x7ba5, 0x7c34, 0x7cb9, 0x7d35, 0x7da7,
0x7e0f, 0x7e6e, 0x7ec2, 0x7f0d, 0x7f4e, 0x7f85, 0x7fb1, 0x7fd4, 0x7fed, 0x7ffc,
0x7fff
};

// Ein Word per post-Increment aus dem Flash lesen.
// Dies ist besser als pgm_read_word (p++)
#define pgm_read_word_inc(addr) \
(__extension__({ \
uint16_t __result; \
__asm__ \
( \
"lpm %A0, Z+" "\n\t" \
"lpm %B0, Z+" \
: "=r" (__result), "+z" (addr) \
); \
__result; \
}))

// Multiply-Accumulate
// return c + a*b
// c = 1.15 signed Q-Format
// a = 1.15 signed Q-Format
// b = 0.8 unsigned Q-Format
static inline int16_t fmac16_8 (int16_t c, int16_t a, uint8_t b)
{
asm ("; fmac16_8: %B[c]:%A[c] += %B[a]:%A[a] * %[b]" "\n\t"
"mulsu %B[a], %[b]" "\n\t" // ( (signed)ah * (unsigned)b ) << 1
"add %A[c], R0" "\n\t"
"adc %B[c], R1" "\n\t"
"mul %[b], %A[a]" "\n\t" // ( (unsigned) b * al ) << 1
"add %A[c], R1" "\n\t"
"clr __zero_reg__" "\n\t"
"adc %B[c], __zero_reg__"
: [c] "+r" (c)
: [a] "a" (a), [b] "a" (b)
);

return c;
}

// Sinus
// phi in [0°,256°) wobei 1° = 256
int16_t linsin (uint16_t phi)
{
uint8_t neg = 0;
uint16_t _180_grad = (uint16_t) 180*256;
// Wir wollen diese Konstante in einem Register
asm ("" : "+r" (_180_grad));

if (phi >= _180_grad)
{
// sin(x) = -sin(x+pi)
// phi in [0°,180°)
phi -= _180_grad;
neg = 1;
}

if (phi > 90*256)
// sin(x) = sin(pi-x)
// phi in [0°,90°]
phi = _180_grad - phi;

// Stützpunkte aus Tabelle lesen.
// Für phi = 90° ist das formal nicht 100% korrekt,
// da über das Tabellenende hinausgelesen wird.
// In diesem Falle ist aber phi.lo=0, so daß unten
// dann data1-data0 mit 0 multipliziert wird.
// Ausserdem gibt's auf AVR keine Segmentation Faults ;-)
const int16_t * p = & linsin_tab[phi >> 8];
uint16_t data0 = pgm_read_word_inc (p);
uint16_t data1 = pgm_read_word (p);

// sin = data0 + (data1-data0) * phi_lo
int16_t si = fmac16_8 (data0, data1-data0, phi);

return neg ? -si : si;
}

// Cosinus
// phi in [0°,256°) wobei 1° = 256
int16_t lincos (uint16_t phi)
{
uint16_t _90_grad = (uint16_t) 90*256;
// Wir wollen diese Konstante in einem Register
asm ("" : "+r" (_90_grad));

if (phi <= _90_grad)
// cos(x) = sin(pi/2 - x)
return linsin (_90_grad - phi);
else
// cos(x) = -sin (x - pi/2)
return -linsin (phi - _90_grad);
}
</c>
}}

=== Aufbau der Tabelle ===

Zur Erstellung der Tabelle gehen wir von äquidistanten Stützstellen im Abstand δ aus. Entwickeln wir die zu interpolierende Funktion in eine [http://de.wikipedia.org/wiki/Taylorreihe Taylor-Reihe] um den Mittelpunkt eines Teilintervalles der Breite δ, so erhalten wir für den absoluten Fehler
:<math>
\Delta = \frac{f''(\xi)}2 \cdot \left(\frac\delta 2\right)^2 + \mathcal O(f'''\cdot\delta^3)
</math>
Indem wir durch eine Sekante annähern anstatt durch – wie durch die Taylor-Reihe gegeben – eine Tangente, können wir die Größenordnung des Fehlers halbieren und erhalten:
:<math>
|\Delta| \approx \tfrac1{16}\cdot |f''|\cdot \delta^2
\;\leqslant\; \tfrac1{16} \cdot \delta^2
\;\stackrel!\leqslant\; 2^{-15}
</math>
Weil mit der Tabelle das Intervall [0..π/2] interpoliert werden soll, brauchen wir mindestens
:<math>
16\pi\sqrt{2} \approx 71
</math>
Teilintervalle. Wir machen also die naheliegende Wahl von 90 Teilintervallen bzw. 91 Stützstellen von 0°...90° und damit
:<math>
\delta = \tfrac1{90} \cdot \tfrac\pi2 \approx 0.01745 = 571.9\cdot 2^{-15}
</math>
Damit wäre ein Eingabeformat von 512=29 Inkrementen pro Grad zwar naheliegend (die Ableitung des Sinus/Cosinus ist höchstens 1), aus rechentechnischen Erwägungen unterteilen wir ein Grad jedoch nur in 256=28 Inkremente und kommen damit zum vorliegenden Eingabeformat.

== Genauigkeit ==

<div style="float:right; margin:1em;">
{| {{Tabelle|text-align:center;}}
|+ '''Lineare Interpolation: Genauigkeit'''
|- bgcolor="#ffddbb"
! Größe || Standardabweichung || Maximaler Fehler
|-
! sin
| 2.2·10-5 || 6.1·10-5
|-
! cos
| 2.3·10-5 || 6.1·10-5
|-
! Radius
| 2.9·10-5 || 6.1·10-5
|-
! φ
| 1.5·10-5 || 3.1·10-5
|}
</div>
Die Güte der Ergebnisse kann aus der nebenstehenden Tabelle entnommen werden.

Die Ergebnisse sind recht gut normalverteilt um das korrekte Ergebnis. Der maximale absolute Fehler liegt bei 2 Inkrementen bzw. 0.00006, was einer effektiven Auflösung von 14  Nachkomma-Bits bzw. insgesamt 15 Bits entspricht.

Im Gegensatz zum CORDIC sind die Ergebnisse der linearen Interpolation per Konstruktion ''monoton'': Im Intervall 0...π/2 ist die Sinus-Funktion z. B. monoton wachsend, und das gilt auch für die hier berechneten Werte. Bei CORDIC sind die Ergebnisse "verrauscht", so daß es auch bei etwas größerer Eingabe zu einem kleineren Wert kommen kann.

Die untenstehenden Diagramme zeigen die Verteilungen der absoluten Fehler. In x-Richtung ist der Fehler aufgetragen, wieder in Einheiten von 1/32767. In y-Richtung ist die Anzahl der Werte aufgetragen, die mit dem entsprechenden absoluten Fehler behaftet sind.

<gallery perrow="2" caption="Standard- und Maximalabweichungen in Einheiten von  1/32767" widths="260" heights="130">
Bild:Linsin-dsin.png|Sinus
Bild:Linsin-dcos.png|Cosinus
Bild:Linsin-dr.png|Radius
Bild:Linsin-dphi.png|Winkel
</gallery>

== Siehe auch ==
* [[AVR-CORDIC]]
* [[AVR Arithmetik/Sinus und Cosinus (CORDIC)|Sinus und Cosinus mit CORDIC]]

== Anmerkungen ==
<references/>

[[Kategorie:AVR-Arithmetik|S]]

Kategorie Diskussion:AVR-Boards

2011-09-20T06:03:37Z

Horha: Die Seite wurde neu angelegt: „Hallo, ::::::::::::::: Aktuelle Version vom 23:00, 19. Sep. 2011 (Bearbeiten) (rückgängig) 173.180.202.160 (Diskussion) (Ich schätze alle harte Arbeit der We…“

Hallo,

:::::::::::::::
Aktuelle Version vom 23:00, 19. Sep. 2011 (Bearbeiten) (rückgängig)
173.180.202.160 (Diskussion)
(Ich schätze alle harte Arbeit der Webmaster dieser Blog)

Zeile 1: Zeile 1:
- In dieser Kategorie findest Du selbst entwickelte AVR-Entwicklungsboards und Beschreibungen zu käuflichen AVR-Entwicklungs-Kits. + Ich kann wirklich sagen , dass ich nie so viel gelesen nützliche Informationen über Bearbeiten von Kategorie:AVR-Boards - Mikrocontroller.net. Ich möchte meine Dankbarkeit an den Webmaster von diesem Blog zu äußern.
:::::::::::::::

Es ist schön das Leute, wie auch ich, sehr dankbar für das Forum sind,
aber dabei dann die Links auf AVR Bootloader rauszuschmeissen, ist nicht die feine englische Art.
Ich hoffe 173.180.202.160 liest es.
Vielleicht fehlt eine Dankesrubrik im Forum ;-) Oder ein Knopf "Danke" und ein Zähler für erhaltene Danke.

Kategorie:AVR-Boards

2011-09-20T05:51:43Z

Horha: Änderung 60553 von 173.180.202.160 (Diskussion) wurde rückgängig gemacht.

In dieser Kategorie findest Du selbst entwickelte AVR-Entwicklungsboards und Beschreibungen zu käuflichen AVR-Entwicklungs-Kits.

Siehe dazu auch [[:Kategorie:AVR-Programmer und -Bootloader]]

[[Category:AVR]]
[[Category:Boards]]

Kategorie:AVR-Boards

2011-09-13T08:25:17Z

Horha: Änderung 60384 von 173.183.73.202 (Diskussion) wurde rückgängig gemacht.

Liste der Wecker- und Uhrenprojekte

2010-11-29T08:32:45Z

Horha: /* www */

Scheinbar dominiert unter Hobbyelektroniker neben dem Verstärkerbau noch ganz groß der selbst gebaute Wecker. Bevor nun jeder von vorne sein eigens Projekt startet, hier zur Anregung eine Sammlung ähnlich gelagerter Projekte.

(Bitte nach Bedarf ergänzen)

== www.mikrocontroller.net ==

* [[Wake-Up Light]]
* [[DCF77-Funkwecker mit AVR]]
* [[Word Clock]]
* siehe auch Artikel in Kategorie [[:Kategorie:Timer und Uhren|"Timer und Uhren"]]

== www ==

* [http://www.wiesolator.de/index.php?area=Projekte&topic=MP3-Wecker MP3-Wecker]
* [http://s-huehn.de/elektronik/tischuhr/tischuhr.htm Projekt: Tischuhr]
* [http://s-huehn.de/elektronik/multiuhr/multiuhr.htm Projekt: Multifunktionsuhr]
* [http://s-huehn.de/elektronik/wecker/wecker.htm Projekt: Wecker]
* [http://mosfetkiller.de/?s=funkwecker Funkwecker mosfetkiller.de]
* [http://www.mcamafia.de/nixie/ncp_dt/ncp.htm Mein Nixie Uhren Projekt]
* [http://www.kielnet.net/home/julien.thomas/tech/NETZUHR.htm Energieeffizienter Uhrenwecker mit Leuchtanzeige 0,25 W ohne Trafo/mit Kondensatornetzteil]
* [http://pic-projekte.de/dcf.html Mit LC-Touchdisplay]
* [http://www.elektronikbasteln.pl7.de/dcf77-uhr-mit-pic.html DCF77-Uhr mit PIC 16F84]
* [http://www.marwedels.de/malte/uhr/ DCF77-Uhr mit Atmega16 und RS232 Interface]

== Zeitschriften ==

* [http://www.elektor.de/jahrgang/2004/marz/wecker-mit-pic.62739.lynkx Wecker mit PIC]

[[Kategorie:Timer und Uhren| ]]

Liste der Wecker- und Uhrenprojekte

2010-08-28T06:00:28Z

Horha: /* www */

Scheinbar dominiert unter Hobbyelektroniker neben dem Verstärkerbau noch ganz groß der selbst gebaute Wecker. Bevor nun jeder von vorne sein eigens Projekt startet, hier zur Anregung eine Sammlung ähnlich gelagerter Projekte.

(Bitte nach Bedarf ergänzen)

== www.mikrocontroller.net ==

* [[Wake-Up Light]]
* [[DCF77-Funkwecker mit AVR]]
* [[Word Clock]]

== www ==

* [http://www.wiesolator.de/index.php?area=Projekte&topic=MP3-Wecker MP3-Wecker]
* [http://s-huehn.de/elektronik/tischuhr/tischuhr.htm Projekt: Tischuhr]
* [http://s-huehn.de/elektronik/multiuhr/multiuhr.htm Projekt: Multifunktionsuhr]
* [http://s-huehn.de/elektronik/wecker/wecker.htm Projekt: Wecker]
* [http://mosfetkiller.de/?s=funkwecker Funkwerker mosfetkiller.de]
* [http://www.mcamafia.de/nixie/ncp_dt/ncp.htm Mein Nixie Uhren Projekt]
* [http://www.kielnet.net/home/julien.thomas/tech/NETZUHR.htm Energieeffizienter Uhrenwecker mit Leuchtanzeige 0,25 W ohne Trafo]

== Zeitschriften ==

* [http://www.elektor.de/jahrgang/2004/marz/wecker-mit-pic.62739.lynkx Wecker mit PIC]

Temperatursensor

2010-08-18T07:49:48Z

Horha: /* NTC/PTC */

Will man mit einem [[Mikrocontroller]] Temperaturen messen, dann braucht man
* einen [[Sensor]], der die Temperatur z. B. in eine Spannung oder einen Strom umwandelt
* einen [[ADC | AD-Wandler]], der das Signal digitalisiert. Der kann auf dem Sensor oder dem Mikrocontroller integriert sein.

Temperatursensoren gibt es nun in allen möglichen Varianten. Vom temperaturabhängigen [[Widerstand]] bis zum fertig abgeglichenen All-in-one-Bauteil mit digitalem Ausgang. Wie bei allen Sensoren sollte man auch hier genau hinschauen und [[Auflösung und Genauigkeit]] unterscheiden.

== Analoge Temperatursensoren ==

=== PT100 ===

Unter einem PT100 versteht man einen Platinwiderstand, der bei 0°C einen Widerstand von 100 Ohm hat.
Platinwiderstände sind temperaturabhängige Widerstände mit hoher Wiederholgenauigkeit und Konstanz[http://de.wikipedia.org/wiki/Konstante]. Wegen der relativ geringen Widerstandsänderung von nur ca. 0,4 Ohm pro Grad ist etwas mehr Schaltungsaufwand erforderlich als bei anderen Sensoren. Genauere Formeln zur Temperaturbestimmung gibt es u.a. bei der [http://de.wikipedia.org/wiki/Pt100 Wikipedia]. Ein Schaltplan findet sich bei der [http://www.heise.de/ct/04/22/236/ c't].

Die Sensoren gibt es auch mit anderen Widerstandswerten, z. B. mit 1000Ω und heißen dann entsprechend PT1000.

Vorteil:
* genormt
* hohe Linearität
* hohe Wiederholgenauigkeit
* einfach austauschbar

Nachteil:
* relativ teuer (bei segor.de ab 3,80€)
* brauchen aufwendigere Auswerteschaltung

Links:
* [http://www.heise.de/ct/04/22/236/ c't-Artikel: Mikrocontroller-Programmierung: Timer, Sensoren und Drehgeber (mit PT100 Schaltung)]

=== NTC/PTC ===

NTC und PTC sind temperaturabhängige Widerstände.

* NTC (engl. '''N'''egative '''T'''emperature '''C'''oefficient, Heißleiter), hat bei hohen Temperaturen seinen niedrigsten Widerstand, z. B. Silizium
* PTC (engl. '''P'''ositive '''T'''emperature '''C'''oefficient, Kaltleiter), hat bei niedrigen Temperaturen seinen geringsten Widerstand, z. B. Glühlampe

Um den Widerstandswert zu messen schaltet man sie mit einem normalen Widerstand oder einer [[Konstantstromquelle]] in Reihe zu einem [[Spannungsteiler]] und misst den Spannungsabfall. Eine Beispielschaltung findet sich [http://www.mathar.com/msp_thermo1.html hier].

Vorteil:
* billig (Reichelt ~0,40€)

Nachteil:
* müssen abgeglichen werden
* brauchen A/D-Wandler
* sind nichtlinear

Links:
* [http://www.sprut.de/electronic/temeratur/temp.htm Temperaturabhängige Stromquelle und NTC/PTC inclusive Linearisierung]
*[http://www.umnicom.de/Elektronik/Mikrokontroller/Atmel/AtFan/AtFan.html#2.2.2 Berechnung des Linearisierungswiderstandes für gewünschten Temperaturbereich] der fällt sonst immer vom Himmel

=== LMx35 ===

Eine IC-Familie, die pro Kelvin Temperaturänderung ihre Ausgangsspannung um 10 mV ändert. Die ICs gibt es in verschiedenen Genauigkeiten und Temperaturbereichen mit den Bezeichnungen LM135(A), LM235(A) und LM335(A). Der günstigste ist der LM335 mit einem Temperaturbereich von −40 … +100°C.
In verschiedenen Bauformen erhältlich. Beispielschaltungen finden sich im [http://www.national.com/ds.cgi/LM/LM135.pdf Datenblatt] und [http://www.suessbrich.info/elek/elektherm1.html hier]

Vorteile:
* hat auch ohne Kalibrierung eine Genauigkeit von einem Grad (bei 25°C)
* relativ billig (LM335 bei Reichelt ab 0,50 €)

Nachteile:
* benötigt A/D-Wandler
* bei längerer Anschlussleitung störanfällig

=== LM334 ===

Ein IC ähnlich dem LM335 mit dem Unterschied, dass der durch das IC fließende Strom proportional von der Temperatur abhängt. Mit einer einfachen Schaltung aus nur zwei Widerständen kann man dann den Strom in einer Weise wandeln, dass pro Kelvin eine Spannungsänderung von 10mV ausgegeben wird. Da die Strom-Spannungswandlung auf der Platine (und damit nahe am AD-Wandler) stattfindet und die Übertragung des Messwerts durch einen Strom stattfindet, sind Störungen durch Netzbrumm etc. viel geringer als beim LM335

Vorteile:

* relativ billig ([http://www.reichelt.de/?ARTICLE=10468 Reichelt 0,54 €])

Nachteile:
* benötigt A/D-Wandler
* Bereich 0°C-70°C

Ähnliche ICs:
* AD592 (Ausgangsstrom 1µA pro Kelvin, absolute Temperatur) [http://www.reichelt.de/?ARTICLE=3825 Reichelt: 3,75 €], Conrad 174912 8,50 €

=== SMT160-30 ===

Ist ein Zwischending zwischen Digital und Analog. Sein Ausgangssignal ist ein digitales PWM-Signal, zu dessen Messung man am besten den Input-Capture-Eingang eines Mikrocontrollers verwendet. Man kann ihn also wie einen analogen Sensor nur indirekt auslesen, anstatt über einen AD-Wandler hier über einen Timer.

Vorteile:
* Digitales PWM-Signal ist unempfindlich gegen Störeinflüsse
* gibt es in SO8, TO18, TO92 und TO220, gut befestigbar, z.B am Kühlkörper
* linear
* kein Abgleich nötig

Nachteile (viele):
* benötigt Timer
* jittert extrem, genaue Messungen nur über Mittelung / Filterung möglich
* nicht nur das PWM-Verhältnis, sondern auf die Frequenz ist temp-abhängig (1-4kHz)
* teuer (Farnell 10,90€ +16%, Conrad 9,xx€ , www.hy-line.de ??).
* TO92 Gehäuse ist günstiger, dafür weniger genau

Links:
* http://www.hy-line.de/co/sensor-tec/hersteller/smartec/smt-160-30/index.html

=== Thermoelement ===

Ein Thermoelement besteht im einfachsten Fall aus zwei ungleichen Metallendrähten, die an einem Punkt miteinander verbunden sind und bei dem die Verbindungsstelle einer anderen Temperatur ausgesetzt ist als die offenen Enden der Drähte. An den offenen Enden der Drähten entsteht eine Spannung (Thermospannung). Dieser Effekt wurde 1821 von Thomas Seebeck entdeckt ([http://de.wikipedia.org/wiki/Seebeck-Effekt Seebeck-Effekt] bei Wikipedia). Eine weitere Anwendung ist der thermoelektrische Generator ("Thermogenerator").

Vorteil:
* über einen sehr weiten Temperaturbereich einsetzbar

Nachteil:
* die sehr geringen Temperaturspannungen im Mikrovoltbereich benötigen eine sehr gute Auswertelektronik (guter Analogteil + AD-Wandler).

Links:
* [http://digital.ni.com/worldwide/germany.nsf/web/all/7A4F02BAEFEC22AC802567F6003E0D6E Temperaturmessung mit Thermoelementen] - Eine Einführung von David Potter (deutsche Überarbeitung: G.Sinkovic) (inkl. Erläuterung der Kaltstellenkompensation)
* [http://www.ipetronik.com/pdf/Newsletter/Ipetronik_NL2_2004_d.pdf Warum Thermoelemente Relativtemperaturen messen! oder Was ist eine Kaltstelle?] - Technische Information von www.ipetronik.com (PDF, 272 KB)

== Digitale Temperatursensoren ==

=== DS1621 ===

Der DS1621 ist Temperatursensor und A/D-Wandler in einem. Er gibt seine Daten per [[I²C]]-[[Bus]] aus. Ein Schaltplan für einen elektronischen Thermometer mit diesem IC findet sich [http://www.myplace.nu/avr/thermo/ hier].

Vorteile:
* bereits kalibriert
* kein A/D-Wandler nötig
* da I²C ein Bus ist, kann man mehrere DS1621 und andere I²C-Bausteine zusammen anschließen und braucht dafür trotzdem nur zwei I/O-Ports.
* Messbereich -55°C to +125°C
* Genauigkeit +-0,5°
* Auflösung besser 0,01°, wenn man die beiden Zählerregister (Count-Remain und Count-per-C) auswertet

Nachteile:
* teuer (Segor 5,80€; RS 3,95€; Conrad 5,22€)
* obwohl die meisten Register [[Speicher#NVRAM | nichtflüchtig]] sind, kann man ihn nicht als Stand-Alone-Thermostat einsetzen, da er erst nach einem Start-Conversion-Befehl zu messen beginnt.

Nachfolger:
* DS1631, DS1631A (Auto-Start-> Stand-Alone-Thermostat), DS1731
* weitere Stand-Alone-Thermostaten: DS1821, DS1629

=== LM75 ===

Der LM75 ist so ähnlich wie der DS1621, allerdings nur in SMD erhältlich und nicht so genau. Er ist aber öfters mal auf PC-Mainboards zu finden, so dass man beim Schlachten eines solchen günstig an einen Temperatursensor kommen kann. Einen Schaltplan findet man [http://www.mcselec.com/index.php?option=com_docman&task=cat_view&gid=83&limit=1&limitstart=35 hier].

Vorteile:
* bereits kalibriert
* kein A/D-Wandler nötig
* I²C-Bus Ausgang
* billiger als DS1621 (Reichelt 1,45 €; RS 3V: 3,75€; 5V: 2,72€)
* Auflösung 0,5°

Nachteile:
* nur im SMD-Gehäuse erhältlich
* relativ ungenau (+-2°), kann man jedoch kalibrieren / kompensieren

Kompatible Typen:
* AD7415ART

=== TMP175 / TMP75 ===

Ähnelt dem LM75 stark! Temperatursensor von Texas Instruments.

=== DS18S20 / DS18B20 ===

Der DS18S20 (Nachfolger des DS1820) und DS18B20 sind scheinbar Temperatursensoren und A/D-Wandler in einem. Wenn man genauer hinschaut, stellt man fest, dass es sich um direktwandelnde Sensoren handelt. Die Temperatur wird ohne Umweg über eine analoge Zwischengröße (Spannung oder Strom) in ein digitales Signal überführt. Die Datenkommunikation erfolgt über ein 1-Wire-Interface, wodurch man am [[Mikrocontroller]] mit nur einen einzigen I/O-Pin auskommen kann. Außerdem beherrschen sie die parasitäre Stromversorgung, d.h. man braucht für Daten und Stromversorgung zusammen nur zwei Leitungen. Der DS18B20 hat 12 Bit Auflösung gegenüber 9 Bit Auflösung beim DS18S20.

Vorteile:
* bereits kalibriert
* Genauigkeit +-0,5°
* 1-Wire-Ausgang

Nachteil:
* relativ teuer: Reichelt: 2,50€ / CSD: 1,85€ / Conrad 5,08€

Links:
* [http://chaokhun.kmitl.ac.th/~kswichit/avrthermo/avrthermo.html Ein Schaltplan]
* [http://www.mikrocontroller.net/topic/6505 Code zur Ansteuerung ASM ATTiny12]
* [http://www.mikrocontroller.net/topic/14792 Code zur Ansteuerung AVR-GCC]
* [http://pdfserv.maxim-ic.com/en/ds/DS18S20.pdf Datenblatt DS18S20]
* [http://pdfserv.maxim-ic.com/en/ds/DS18B20.pdf Datenblatt DS18B20]
* [http://www.mikrocontroller.net/forum/read-4-248219.html Webserver zur Ansteuerung von bis zu 63 Bausteinen]
* [http://www.teslabs.com/openplayer/docs/docs/other/ds18b20_pre1.pdf PDF Anleitung zur Beschaltung und Programmierung (C)]

=== DS1822 ===

Ähnlich wie DS18S20, aber weniger genau (+-2°) und in großen Stückzahlen billiger. Wegen der geringeren Verbreitung kommt der Preisvorteil aber bei Einzelstücken nicht beim Kunden an. So kostet er bei Reichelt mit 3,50€ mehr als der DS18S20.

=== DS1921 / DS1922 ===

Sind wie die DS1821 1-wire-Sensoren mit zusätzlicher Logging-Funktion.
Im iButton-Gehäuse befindet sich eine Lithium-Zelle, eine RTC, CMOS-RAM und der Temp-Sensor. Nach umfangreicher Progammierung startet der Button seine Mission (Aufzeichnung des Temperaturverlaufs).
Gibt es auch mit zusätzlicher Feuchtemessung (DS1923).

=== TSic ===

Die TSic Sensoren werden baugleich von 3 Herstellern angeboten:
* ZMD ([http://www.zmd.biz/temp.php?group=temp&content=products Homepage]) ([http://tarr.uspto.gov/servlet/tarr?regser=serial&entry=78673282 Trademark])
* IST AG ([http://www.ist-ag.com/eh/ist-ag/de/home.nsf/contentview/8F5D32432CAC53C2C1257405003C2433 Homepage])
* Hygrosens ([http://www.hygrosens.de/english/shop/list.html?tx_ttproducts_pi1%5Bcat%5D=11&cHash=dcd89b823b Homepage])

Die TSic Sensoren ([http://www.zmd.biz/pdf/ZMD%20TSic%20Data%20Sheet%20V3%207.pdf Datenblatt]) geben ihre Temperaturmessdaten automatisch in einem festen Intervall aus. Daher muss der Host nur warten bis die nächsten Messdaten rausgeschickt werden. Die TSic Sensoren die es im freien Handel gibt, geben ihre Messdaten alle 100ms (10Hz) aus.
Zur Übertragung wird das [http://www.zmd.biz/pdf/IST_TSic_ZACwire_V2.3%20Digital%20Output_17-Oct-06.pdf ZACwire] Protokoll benutzt. Es handelt sich um eine einfach zwei Byte Übertragung per Manchester-Code. Diese zwei Byte repräsentieren den digital gewandelten Temperaturwert. Im Gegensatz zu Sensoren wie den DS18xxx von Dallas muss dieser Wert aber erst auf einen dezimalen Wert umgerechnet werden.
Die Sensoren kommen mit 3 Pins aus (VCC, GND, Dout).

Vorteile:
* Bereits kalibriert
* Verschiedene Genauigkeiten lieferbar
* Sehr einfaches Kommunikationsprotokoll
* Geringer Stromverbrauch
* Hochgenau: bis zu +/- 0.1°C (TSic 50x)

Nachteil:
* Recht teuer (Reichelt: 4,70€ für den TSic206)
* Nur ein Sensor an einem I/O nutzbar (Kein Bussystem)

Achtung!
Die TSic Sensoren gibt es auch als Version mit analog Ausgang. Bei der Typenbezeichnung gibt die 3. Stelle an ob es sich um die analog- oder Digitalversion handelt (1 = analog, 6 = digital).
Der TSic201 ist also analog, wärend der TSic206 ein digitaler ist.

Links:
* [http://www.mikrocontroller.net/topic/45573#347765 Ansatz zum Empfang der Daten]
* [http://ethersex.de/index.php/Zacwire Fertige Ansteuerung durch AVR in Ethersex]
* [http://www.zmd.biz/temp.php?group=temp&content=products Herstellerseite mit Datenblättern und FAQ]
* [http://www.mikrocontroller.net/topic/82087 Diskussion mit Beispielcode (MSP430, AVR, PIC)]
* [http://www.mikrocontroller.net/search?query=tsic* Suche in den Foren]

=== SHT1x/SHT7x ===

Der SHT1x/SHT7x (SHT10, SHT11, SHT15, STH71, SHT75) sind kombinierte Temperatur- und Feuchtesensoren von [http://www.sensirion.com Sensirion]. Sie unterscheiden sich in Bauform und Genauigkeit.

Vorteile:
* digitale Schnittstelle mit einfacher [[I²C]]-''ähnlicher'' Ansteuerung
* keine Kalibrierung notwendig
* Beispielcode (C, MC51) auf der Sensirion-Seite verfügbar (relativ leicht portierbar)
* interne Heizelemente (Funktionsprüfung, "rauhe" Umgebung)
* Spannungsmonitor ("Battery fail")

Nachteile:
* kann nicht am [[I²C]] Bus betrieben werden, theoretisch gleiche Clockleitung möglich, fixe Adresse
* relativ teuer (Farnell 18,60€)

Es gibt jetzt einen Nachfolger SHT2x, der I²C-kompatibel ist.

=== ADT7310 ===

Der ADT7310 von [http://www.analog.com/en/sensors/digital-temperature-sensors/adt7310/products/product.html Analog Devices] besitzt eine Auflösung von 16 Bit und eine Genauigkeit von ±0.5°C im Bereich von −40°C bis +105°C.

Vorteile:
* Ansteuerung per [[SPI]]
* keine Kalibrierung notwendig
* hohe [[Auflösung und Genauigkeit]]
* programmierbarer [[Interrupt]]ausgang für Unter- und Übertemperatur

Nachteile:
* zur Zeit noch schlecht erhältlich (z.B. bei Digikey für 4,39$)

[[Category:Sensorik]]

Diskussion:Royer Converter

2009-11-01T11:28:48Z

Horha:

"gt ??mA. ABER! Der Leerlaufstrom im Schwingkreis beträgt ???A! "
usw Ist das nur bei mir so oder sind einfach kaum Werte im Artikel?

----
Der Artikel ist noch leicht im Betastadium. Die Exakten Zahlen + Bild folgen, wenn ich Zeit hab das mal aufzubauen und zu testen. ;-)

MfG
Falk

----
Okay, danke :)
----
Hallo,

ich habe eine Verständnisfrage:
Wieso soll die Spannung in diesem Parallel-Resonanzkreis Up= pi *V_in erreichen können?
Ich dachte, es gäbe nur eine Stromüberhöhung im Parallel-Resonanzkreis, die Spannung bliebe V_in.
http://de.wikipedia.org/wiki/Stromüberhöhung
Oder wirkt (Lprim/2+L1)-(1/(1/C1+1/C2)) als Serien Resonanzkreis?

Bei dem Link zu Epcos ( noch eine MOSFET-Variante, auch mit kleineren Fehlern im Text ) steht:
Speisespannung um ein Vielfaches übersteigen kann. Bei einer Eingangsspannung von 12 V können dabei Werte von bis zu 80 V auftreten..

Gruß Horst

----

"Wieso soll die Spannung in diesem Parallel-Resonanzkreis Up= pi *V_in erreichen können? "

- Die Gleichspannung vor der Spule muss gleich sein dem Mittelwert der Spannung hinter der Spule (sonst würde an der Spule ein Gleichspannung anliegen, was ja nicht sein kann).
Das heißt also, der Mittelwert der Spannung Sinushalbkurve ist gleich der Betriebsspannung. Der Gleichrichtwert einer Sinusspannung ist 2/PI. Da es hier rückwärts geht, müsste die
Spitzenspannung nach der Spule Uspitze=Uein*PI/2 betragen.
- Durch die Mittelanzapfung verdoppelt sich die Spitzenspannung nochmals. Somit fällt der Faktor 1/2 raus: Uspitze=Uein*PI

"Speisespannung um ein Vielfaches übersteigen kann. Bei einer Eingangsspannung von 12 V können dabei Werte von bis zu 80 V auftreten.."

Das ist einer der Fehler. 80V erreicht man nur als Spitze-Spitze-Spannung. Das muss nur der Kondensator C2 aushalten.

MfG

Falk
----
Hallo,

aha, also der Gleichrichtwert = Uein *2/pi bringt pi ins Spiel.
Danke für die Aufklärung des Sachverhaltes.

Gruß Horst

Diskussion:Royer Converter

2009-10-31T13:15:41Z

Horha:

Diskussion:Uhr

2009-09-22T09:59:29Z

Horha:

--[[Benutzer:Sternst|Sternst]] 19:33, 11. Sep. 2009 (CEST) 
Ich möchte ja nicht unbedingt den Miesmacher spielen, aber der Code ist nicht gerade ein Musterbeispiel. Vielleicht hättest du ihn vor Veröffentlichung als Artikel mal im Forum zur Diskussion stellen sollen. 
'''1)'''
<c>
switch (Hunderter)
//Hier wird der jeweilige Zahlenwert in PORTB geschrieben
{
case 0: PORTB=Zahl[0];break;
case 1: PORTB=Zahl[1];break;
case 2: PORTB=Zahl[2];break;
case 3: PORTB=Zahl[3];break;
case 4: PORTB=Zahl[4];break;
case 5: PORTB=Zahl[5];break;
case 6: PORTB=Zahl[6];break;
case 7: PORTB=Zahl[7];break;
case 8: PORTB=Zahl[8];break;
case 9: PORTB=Zahl[9];break;
}
</c>
Soll das etwa irgendeinen Vorteil gegenüber einem simplen<c>PORTB = Zahl[Hunderter];</c>haben? 
'''2)'''
<c>OCR1A = 31250; //genau eine Sekunde (8000000Hz / 256 / 31250 = 1); </c>
Für genau eine Sekunde im CTC-Modus müsste man 31250 - 1 (also 31249) ins Register laden. 
'''3)'''
<c>TCCR1B = 0b00001100;</c>
Warum benutzt du nicht wie üblich die symbolischen Namen? Diese Zahlenkonstanten erschweren nur unnötig das Portieren auf einen anderen Controller.
 
'''4)''' 
Etwas mehr Sorgfalt beim Formatieren (Einrückungen) wäre auch nicht schlecht.
----
1 und 2: das ist gut, korrigier ich sofort.
3: Ich finde die 0bxxxxxxxx Schreibweise übersichtlicher, ich denke das ist Geschmackssache.
4: Die Einrückungen hab ich im Code ja auch richtig, aber hier im Wiki ist das etwas komisch 
Danke nochmal für die Anregungen. Sind jetztf umgesetzt. Die Version mit den Defines hab ich rausgenommen, macht ja nun wirklich keinen Sinn.

== Sekunden ist nicht ISR-sicher ==

So wie das Programm momentan aufgebaut ist müsste auf "Sekunden" atomar zugegriffen werden. Ansonsten hat x bei
x = Sekunden;
u.U keinen sinnvollen Wert! Dito für die Ausdrücke im Programm. (zumindest wenn long int nicht in einer Maschineninstruktion gelesen oder geschrieben werden kann.)

Zudem ist es wesentlich einfacher (und in dieser ISR absolut unkritisch) die Sekunden bei 60 überlaufen zu lassen und dabei die Minuten um 1 zu erhöhen; die Minuten bei 60 überlaufen zu lassen und dabei die Stunden um 1 zu erhöhen; etc. --[[Benutzer:Gjlayde|Gjlayde]] 19:54, 20. Sep. 2009 (CEST)

=== Etwa so ===
<c>
//32Bit Variable; 24Bit würdens auch tun
volatile long int Sekunden=86399;
unsigned char Tausender;
unsigned char Hunderter;
unsigned char Zehner;
unsigned char Einer;
unsigned char sek;

//Bei Compare-Match mit OCR1A (31249) wird Sekunden um eins erhöht.
ISR(TIMER1_COMPA_vect)
{
Sekunden++;

if (++sek >= 60)
{
sek = 0;
if (++Einer >= 10)
{
Einer = 0;
if (++Zehner >= 6 )
{
Zehner = 0;
Hunderter++;
if ((Tausender >= 2) && (Hunderter == 4))
{
Sekunden = 0;
Tausender = 0;
Hunderter = 0;
}
else
if (Hunderter >= 10)
{
Hunderter = 0;
Tausender++;
}
}
}
}
}
</c>

Damit dauert ein ISR Aufruf zwischen 50 und maximal 100 Takten (23:59:59)
Aber das Problem der ISR-Sicherheit bleibt.
Auch hier kann sich alles durch einen Interrupt während der Abfrage ändern.
Wie löst man das clever? ISR vor Abfrage mit CLI abschhalten, alle Daten kopieren und wieder einschalten mitttels SEI. Wird der mögliche Compare-Match mit OCR1A-Interrupt dann nachgeholt? Steht sicher in den PDF's

: Ja, die ISR wird dann nachgeholt. --[[Benutzer:Gjlayde|Gjlayde]] 18:35, 21. Sep. 2009 (CEST)

: Wenn ich am Wochenende Zeit hab, werde ich das mal ausprobieren zu integrieren. [[Benutzer:Inox5|Inox5]] 19:17, 21. Sep. 2009 (CEST)

:: Es genügt, in der ISR ein Flag zu setzen, daß eine neue Sekunde angefangen hat. Alles andere kann in der (möglichst blockierfreien) Hauptschleife abgehandelt werden. Aber auch dort ist dieses hochzählen einfacher als Division+Modulo. --[[Benutzer:Gjlayde|Gjlayde]] 20:42, 21. Sep. 2009 (CEST)
:::Statt eines Flags vielleicht zur Sicherheit einen Zähler?
<c>unsigned char Tausender;
unsigned char Hunderter;
unsigned char Zehner;
unsigned char Einer;
unsigned char sek;
volatile unsigned char DeltaSek;

ISR(TIMER1_COMPA_vect) //Bei Compare-Match mit OCR1A (31249) wird Sekunden um eins erhöht.
{DeltaSek++;}

void Berechnung (void)
{unsigned char temp;
cli();
temp = DeltaSek; // deltaSek retten
DeltaSek = 0; // und direkt löschen
sei();

while (temp > 0 )
{sek++;
if (sek >= 60 )
{sek = 0;
Einer++;
if ( Einer >= 10 )
{Einer = 0;
Zehner++;
if ( Zehner >= 6 )
{Zehner = 0;
Hunderter++;
if ((Hunderter == 4)&&(Tausender >= 2))
{Tausender = 0;
Hunderter = 0;}
else
if ( Hunderter >= 10 )
{Hunderter = 0;
Tausender++;}
}// Zehner
}//if Einer
}// if sek
temp--;
}//while
}</c>
--[[Benutzer:Horha|Horha]] 11:59, 22. Sep. 2009 (CEST)

Diskussion:Uhr

2009-09-21T14:34:00Z

Horha:

--[[Benutzer:Sternst|Sternst]] 19:33, 11. Sep. 2009 (CEST) 
Ich möchte ja nicht unbedingt den Miesmacher spielen, aber der Code ist nicht gerade ein Musterbeispiel. Vielleicht hättest du ihn vor Veröffentlichung als Artikel mal im Forum zur Diskussion stellen sollen. 
'''1)'''
<c> switch (Hunderter) //Hier wird der jeweilige Zahlenwert in PORTB geschrieben
{
case 0: PORTB=Zahl[0];break;
case 1: PORTB=Zahl[1];break;
case 2: PORTB=Zahl[2];break;
case 3: PORTB=Zahl[3];break;
case 4: PORTB=Zahl[4];break;
case 5: PORTB=Zahl[5];break;
case 6: PORTB=Zahl[6];break;
case 7: PORTB=Zahl[7];break;
case 8: PORTB=Zahl[8];break;
case 9: PORTB=Zahl[9];break;
}
</c>
Soll das etwa irgendeinen Vorteil gegenüber einem simplen<c>PORTB = Zahl[Hunderter];</c>haben? 
'''2)'''
<c>OCR1A = 31250; //genau eine Sekunde (8000000Hz / 256 / 31250 = 1); </c>
Für genau eine Sekunde im CTC-Modus müsste man 31250 - 1 (also 31249) ins Register laden. 
'''3)'''
<c>TCCR1B = 0b00001100;</c>
Warum benutzt du nicht wie üblich die symbolischen Namen? Diese Zahlenkonstanten erschweren nur unnötig das Portieren auf einen anderen Controller.
 
'''4)''' 
Etwas mehr Sorgfalt beim Formatieren (Einrückungen) wäre auch nicht schlecht.
----
1 und 2: das ist gut, korrigier ich sofort.
3: Ich finde die 0bxxxxxxxx Schreibweise übersichtlicher, ich denke das ist Geschmackssache.
4: Die Einrückungen hab ich im Code ja auch richtig, aber hier im Wiki ist das etwas komisch 
Danke nochmal für die Anregungen. Sind jetztf umgesetzt. Die Version mit den Defines hab ich rausgenommen, macht ja nun wirklich keinen Sinn.

== Sekunden ist nicht ISR-sicher ==

So wie das Programm momentan aufgebaut ist müsste auf "Sekunden" atomar zugegriffen werden. Ansonsten hat x bei
x = Sekunden;
u.U keinen sinnvollen Wert! Dito für die Ausdrücke im Programm. (zumindest wenn long int nicht in einer Maschineninstruktion gelesen oder geschrieben werden kann.)

Zudem ist es wesentlich einfacher (und in dieser ISR absolut unkritisch) die Sekunden bei 60 überlaufen zu lassen und dabei die Minuten um 1 zu erhöhen; die Minuten bei 60 überlaufen zu lassen und dabei die Stunden um 1 zu erhöhen; etc. --[[Benutzer:Gjlayde|Gjlayde]] 19:54, 20. Sep. 2009 (CEST)

== Etwa so ==
<c>
volatile long int Sekunden=86399; //32Bit Variable; 24Bit würdens auch tun
unsigned char Tausender;
unsigned char Hunderter;
unsigned char Zehner;
unsigned char Einer;
unsigned char sek;

ISR(TIMER1_COMPA_vect) //Bei Compare-Match mit OCR1A (31249) wird Sekunden um eins erhöht.
{
Sekunden++;
sek++;
if (sek >= 60 )
{sek = 0;
Einer++;
if ( Einer >= 10 )
{Einer = 0;
Zehner++;
if ( Zehner >= 6 )
{Zehner = 0;
Hunderter++;
if ((Tausender >= 2)&&(Hunderter == 4))
{Sekunden = 0;
Tausender = 0;
Hunderter = 0;}
else
if ( Hunderter >= 10 )
{Hunderter = 0;
Tausender++;}
}
}
}
}</c>

Damit dauert ein ISR Aufruf zwischen 50 und maximal 100 Takten (23:59:59)
Aber das Problem der ISR-Sicherheit bleibt.
Auch hier kann sich alles durch einen Interrupt während der Abfrage ändern.
Wie löst man das clever? ISR vor Abfrage mit CLI abschhalten, alle Daten kopieren und wieder einschalten mitttels SEI. Wird der mögliche Compare-Match mit OCR1A-Interrupt dann nachgeholt? Steht sicher in den PDF's

CAN

2009-09-12T12:57:42Z

Horha:

Eine ausführliche Liste: http://www.mjschofield.com/devices.htm

==Mikrocontroller mit CAN==

=== Atmel AT90CAN128===
* Atmel AVR Controller mit CAN-Schnittstelle (ein Kanal)
* 15 CAN "Message Objects", jedes individuell konfigurierbar.
* 128kByte Flash, 4kByte RAM
* Bis auf die CAN-Funktionen weitestgehend identisch mit dem ATmega128 (vgl. Migration-Guide ATmega128->AT90CAN128 bei atmel.com)
* Beispielcode inkl. CAN für den IAR-C-Compiler findet sich bei atmel.com. Autobaud-Routinen in Assembler (etwas Aufwand bei der Portierung nach avr-gcc/avr-as).
* Für die ISP-Programmierung schliesst man Ihn wie den ATmega128 an. MOSI-2 ; MISO-3 ; SCK-11 ; /Reset-20 ; GND-22,53,63 ; Vcc-21,52,(62),(64). Auf die übliche "ATmega64/128-Problematik" achten: MISO/MOSI der Programmierschnittstelle sind nicht identisch mit der SPI-Schnittstelle.
* Im Auslieferungszustand ist nur der interne RC-Oszillator aktiv (wie üblich bei allen modernen AVRs mit internem R/C-Oszillator vgl. [[AVR Checkliste]]). Umschalten auf externe Taktquelle über die AVR-Fusebits.
* Dieser MC ist für nicht-gewerbliche Endanwender einzeln z.B. bei Reichelt, CSD und Segor erhältlich (ca. 9EUR). Beim Bestellen des MC sollte man einen CAN-BUS-Treiber gleich mitbestellen: z.B. Philips PCA82C250. Jedoch auf vorhandene Versorgungsspannungen achten (AT90CAN128 "kann mit" VCC=2,7...5,5V, PCA82C250 lt. Datenblatt für VCC=4,5...5V).
* die aktuelle Hardware-Version (Stand 4/2005) hat einen "silicon bug" (Hardwarefehler, vgl. avrfreaks-Forum): Liegt der Stack im ''externen'' RAM, führt dies zu Fehlern in der Stackverwaltung (push/pop/rcall etc.). Details in aktuellen Fassungen des Datenblatts. Abhilfe/Workaround: Stack im internen RAM (<0x1001) verwalten. Dies ist ohnehin sinnvoll, da der Stackzugriff dann schneller ist.
* CANopen software protocol stacks at http://www.port.de/Atmel.html
* Freier CANopen stack: http://www.canfestival.org/



=== Atmel AT91SAM7X, AT91SAM7A ===
* ARM7TDMI-Kern

=== Luminary Micro Stellaris LM3S8xxx ===
* ARM Cortex-M3
* bis 64kByte RAM und 256kByte Flash
* CAN und Ethernet

=== Microchip PIC18Fxx8 PIC18Fxx8x ===
* Mikrocontroller mit CAN Schnittstelle
* [http://www.microchip.com/ParamChartSearch/chart.aspx?branchID=50&mid=10&lang=en&pageId=74 Herstellerseite]

=== Mitsubishi / Renesas R8C / M16C / M32C ===

R8C/23, M16C/6Nx

=== Motorola / Freescale DSP56F8xx ===
* Clock des CAN-Moduls von PLL speisen, nicht von XTAL, sonst gibt es sporadische Aussetzer
* Bei hohen Datenraten ist es notwendig die CAN-TX-Leitung vom Controller mit einem PullUp-Widerstand zu beschalten. Sonst stimmt das Bit-Timing nicht, weil die Anstiegszeit des TX-Signals zu schlecht ist.

=== Freescale MC9S08 ===
* D Serie

=== Freescale MC9S12 ===
* B, C, D und H Serie

=== NXP (ex. Philips) LPC2129 LPC2194 LPC2290 LPC2292 LPC2294 ===
* Mikrocontroller mit ARM7TDMI-S-Kern (vgl. [[LPC2000 Philips ARM7TDMI-Familie]])
* 2 - 4 CAN Schnittstellen
* CAN-Modul angelehnt an Philips SJA1000 (aber mit recht langer und deftig gewürzter Bug-Liste)
* Herstellerseite: [http://www.nxp.com Philips Semiconductors]
* LPC2194 erhältlich bei http://www.microcontroller-starterkits.de und http://de.digikey.com/
* CANopen software protocol stacks at [http://www.port.de/Philips.html]

=== NXP LPC23xx ===
* Mikrocontroller mit ARM7TDMI-S-Kern (vgl. [[LPC2000 Philips ARM7TDMI-Familie]])
* 2 CAN Schnittstellen

=== NXP P80C591 P80C592 P80C598 ===
* 8-Bit Mikrocontroller mit 8051-Kern
* P80C591 ist neuer und beherrscht CAN2.0B
* P80C592: CAN2.0A, P80C598 ist die Automotive-Version vom '592

=== STMicroelectronics STM8S20 ===
* STM8 Kern [http://www.st.com/stonline/products/literature/ds/14733/stm8s208c6.pdf] DIV/MUL -Befehle
* SPI mit automatischer CRC Berechnung
* 1 beCAN Schnittstelle CAN2.0B
* sehr preiswert (128 kFlash/6K RAM ) 3,30 bis 4,80 € ([http://search.digikey.com/scripts/DkSearch/dksus.dll?vendor=0&keywords=CAN+STM8] aber SMD LQFP

=== STMicroelectronics STR730 STR750 ===
* ARM7TDMI-Kern
* 1-3 CAN Schnittstellen

=== STMicroelectronics STR910FM32, STR910FW32, STR911FM42, STR911FM44, STR912FW42, STR912FW44 ===
* 96MHz ARM966E-S CPU Kern

=== TI TMS470 ===
* ARM7TDMI-Kern

==CAN Controller==

===MCP2515 ===
"Stand-alone" CAN-Controller von Microchip.
* SPI Schnittstelle
* 2 Empfangs- und 3 Sendepuffer jeweils individuell konfigurierbar (ID, Masken/Filter etc.)
* ein gemeinsamer Interruptpin (RX)
* ein Interruptpin pro Empfangspuffer, umkonfigurierbar als GPO
* ein Triggerpin pro Sendepuffer, umkonfigurierbar als GPI
* Stromsparmodus
* auch für 3,3V-Betrieb geeignet.
* Diverse C- und Assembler Beispielcodes verfügbar (z.B. bei microchip.com und kvaser, Assembler meist für PICs). Auch Software für Direktanschluss an die parallele Schnittstelle eines PC verfügbar ("bit-bang Interface").
* erhältlich z.B. bei Reichelt (ca. 2€)

====Links====
*[http://www.kreatives-chaos.com/index.php?seite=mcp2515 Ansteuerung eines MCP2515] gcc
*[http://www.intrepidcs.com/BitCindex.htm Bit Timing Calculator]
*[http://mcp2510btc.berlios.de/ Bit Timing Calculator für Linux]

===SJA1000===
"Stand-alone" CAN-Controller von Philips
* Parallele Schnittstelle ca. 12 Leitungen
* erhältlich z.B. bei Reichelt (ca. 4 Euro)

===AN82526===
"Stand-alone" CAN-Controller von Intel (entwickelt von Bosch)
* Vorgänger des AN82527

===AN82527===
"Stand-alone" CAN-Controller von Intel (entwickelt von Bosch)
* Nachfolger des AN82526
* parallele UND SPI-Schnittstelle
* 8- oder 16-Bit Multiplex Bus, oder 8-Bit Non-Multiplexed Bus
* 14 Tx/Rx Puffer
* bis zu 16 IO-Pins (je nach Controlleranbindung)
* erhältlich z.B. bei Reichelt (ca. 5€)

===Bosch CC170 / CC750 / CC770===
* kompatibel zum AN82527
* mehr Debug-Register
* CC750 im SOIC16-W Gehäuse ohne Parallel-Interface, nur SPI
* erhältlich bei Rutronik (ca. 8 Euro)

===SAE81C9x===
* SPI und Busanschluss möglich.
* PLCC44 und PLCC28, letzteres allerdings in ungebräuchlicher Bauform
* Nur CAN 2.0A, beherrscht also keine Extended IDs.

==Bustreiber (CAN-Transceiver)==

=== High-Speed ===

====MCP2551====
* von Microchip
* PDIP8 und SOIC
* VCC = 4,5...5,5V
* kostet rund 1€

====PCA 82C250====
* von NXP (ex. Philips)
* PDIP8 und SO8
* VCC = 4,5...5,5V
* V-CAN: -8V..+18V -> "TTL-kompatible" Bus-Spannung
* erhältlich z.B. bei Reichelt (ca. 1,50€)

====PCA 82C251====
* von NXP (ex. Philips)
* PDIP8 und SO8
* VCC = 4,5...5,5V
* V-CAN: -40V..+40V -> +24V Bus-Spannung
* erhältlich z.B. bei Reichelt (ca. 1,50€)

====TJA 1050====
* von NXP (ex. Philips)
* SO8, pinkompatibel
* VCC = 4,75...5,25V
* 3. Generation, Nachfolger der PCA82C25x
* http://www.semiconductors.philips.com/pip/TJA1050

====ATA6660====
* von Atmel
* SO8
* VCC = 4,75...5,25V

====SN65HVD23x====
* von Texas Instruments
* SO8
* VCC = 3,0V...3,6V
* erhältlich z.B. bei Reichelt (SN65HVD230, SN65HVD231)

=== Fault-Tolerant / Low-Speed ===

==== TJA1054 ====
* von NXP (ex. Philips)
* bis 125 "kBaud"
* SO14
* ähnliche Funktionen, gleicher Hersteller: TJA1053, TJA1055

== CAN Repeater ==

==== AMIS-42700 ====
* Dual High-Speed CAN Transceiver
* High speed (up to 1Mbit/s)
* SOIC-20
* vgl. http://www.mikrocontroller.net/topic/53799

==== Alternative ====
* zwei Transceiver
* [http://www.mikrocontroller.net/attachment/9353/CANREPEATER.JPG Schaltung]
* Anmerkung: Diese Schaltung ist Quatsch und funktioniert nicht.
* -Zum Senden eines Zeichen, muss beim CAN paralell auf dem Bus gelesen werden.
-Die TRansceiver tun dies nicht, mach nur der Controller.
-Die gelesene Nachricht muss also durch einen Controller erneut gesendet werden, wenn der Bus frei ist...

==== CAN Hub ====
CAN Hub mit standard Knoten
* http://www.oschmid.ch/mt/can-hub/can-hub.php
CAN Hub mit getrennten Rx und Tx Leitungen
* http://www.oschmid.ch/mt/can-hub4/can-hub4.php

==SLIO-CAN==

Preisgünstigste Bausteine sind die Serial Linked I/O Bausteine (SLIO). Diese Bausteine ermöglichen den Aufbau von Ein- und Ausgabeknoten ohne lokalen Prozessor. Auf der Basis dieser Bausteine lässt sich eine dezentrale Signal-Ein-Ausgabe mit minimalem Kostenaufwand realisieren.

=== Philips P82C150===
* Single-Chip-I/O-Einheit mit integriertem CAN-Controller
* mögliche Busdatenrate 20kBd bis 125kBd
* interner RC-Oszillator wird durch den Bitstrom auf den Bus synchronisiert
* Kalibrierungsnachricht alle 8000 Bitzeiten erforderlich
** 4-Bit des Identifiers über Port-Pins einstellbar
* maximal 16 P82C150 in einem CAN-Segment
** 16 Port-Pins mit unterschiedlichen Konfigurationsmöglichkeiten
*** 16 mal als digitale Eingänge
*** 16 mal als digitale Ausgänge
*** 2 mal als analoger Ausgang ( 10-Bit, DPM )
*** 6 mal als analoger Eingang ( 10-Bit, multiplex )
*** 2 mal als Komparator

* [http://www.htw-dresden.de/fe/labor/mikror/projects/slio_can/ slio-CAN]

Anmerkung: Philips stellt die SLIO nicht mehr her! Es ist auch "nichts" mehr am Markt beschaffbar, wenn, dann zu horrenden Preisen (um die 60,-EUR/Stück zur Zeit). --[[Benutzer:OldBug|Patrick]] 09:08, 25. Jan 2005 (CET)

'''obsolete'''

===DS 36001M===
'''Obsolete'''

===MCP2502X/5X===
[http://ww1.microchip.com/downloads/en/devicedoc/21664c.pdf Datenblatt]

== Verkabelung ==
* auf beidseitige Busterminierung achten (typisch 2x 124 Ohm bei "high-speed")
* Standardbelegung für diverse Steckverbindungen vgl. CANOpen-Dokumentation http://www.can-cia.de/index.php?id=440 (CiA 303-1); erfordert Anmeldung
* Schaltplan für galvanische Trennung z.B. nach Datenblatt des PCA82C250
* für einfache Testaufbauten über sehr kurze Strecken oder "on-board-CAN" kann auf die Bustreiber verzichtet werden (vgl. Siemens Application-Note [http://www.mikrocontroller.net/attachment/28831/siemens_AP2921.pdf AP2921])

Es gibt auch CAN mit
* einpoliger unsymmetrischer Verbindung (SAE J2411 single wire)
* optischer Verbindung (Faser, Glasfaser)

Für einfache Tests genügt auch eine direkte wired-and-Verbindung ohne Treiber:
http://www.mikrocontroller.net/forum/read-1-325202.html?reload=yes#325962

== Debugging ==
Hersteller von Debug-Geräten
* Vector-Informatik CANscope (Pegeltester) http://www.vector-informatik.de/deutsch/ - ca. 3300EUR
* Gemac CBT (CanBusTester) testet auch Pegel, Reflexionen ... (Treiber etc. etwas ältlich, von 2002, was ist mit Weiterentwicklung?), auch leihweise http://www.gemac-chemnitz.de/pages/d_html/produkte/bus-tester/new-de-can-bust.html http://www.brandt-data.de/canbus/can_intro.html - ca. 2400EUR
* ixxat bietet ebenfalls den Gemac-cbt an, auch leihweise

Oszilloskope mit CAN-Analyse (manche auch SPI, LIN, RS232, SATA ...):
* LeCroy WaveRunner 6040 wird mit Vector-CANcaseXL (externer CAN-Trigger) geliefert (sehr gut, ab ca.9000 EUR)
* LeCroy WaveSurfer 424 wird mit Vector-CANcaseXL (externer CAN-Trigger) geliefert (sehr gut, ab ca.8000 EUR)
* Yokogawa DL1640 und DL9040 (CAN-Trigger ist intern) ähnliche Preise wie LeCroy, Bedienung gewöhnungsbedürftig, geht mit etwas Übung besser
* Tektronix
* HP / Agilent
* LogicPort http://www.pctestinstruments.com/

Triggermöglichkeiten: SOF, CAN-ID, CAN-Data, ErrorFrame, RTR, Ack, NoAck - alle verknüpfbar (gleich ungleich kleiner größer inRange outofRange)

=Links=

==Intern==
[[CAN als Hausbus]]

==Allgemein==
* [http://can-wiki.info CAN-WIKI] - spezielle Wiki Site für CAN bus (Englisch)
* [http://de.wikipedia.org/wiki/Controller_Area_Network Wikipedia - CAN]
* [http://www.thomas-wedemeyer.de/elektronik/CAN-Bus/can-bus.html Grundlagen zum CAN-Bus] - Kurze Zusammenfassung der Funktionsweise und Einsatzmöglichkeiten vom CAN-Bus
* [http://www.canbus.cz CAN] - Controller_Area_Network (Czech)

==Hardware==
*[http://www.mjschofield.com/devices.htm ausführliche Liste mit CAN-Chips und -Controllern]

===Testboards===
*[http://www.kreatives-chaos.com/artikel/can-testboard ATmega8 CAN Testboard und MCP2515 Tutorial]

===Dongles===
*[http://private.addcom.de/horo/can200/ Can200 Selbstbauprojekt]
*[http://www.mhs-elektronik.de/tiny_can.html MHS-Elektronik Low-Cost USB-CAN-Adapter (60,- EUR) + Open Source CAN-Monitor für Windows und Linux]
*[http://www.cantronik.com/ cantronik]
*[http://www.kopfweb.de/automotive_3.htm usb-can]
*[http://www.mictronics.de Open Source USB<>CAN Bus Interface mit AVR ATmega162]
*[http://www.ixxat.de IXXAT u.a. USB<>CAN Bus Interface ca. 200 Eur]
*[http://www.peak-system.com Peak-System u.a. USB<>CAN Bus Interface ca. 200 EUR]
*[http://www.ems-wuensche.com EMS Dr. Thomas Wünsche u.a.] [http://www.ems-wuensche.com/product/datasheet/html/can-usb-adapter-converter-interface-cpcusb.html USB to CAN Bus Interface ca. 180 EUR]
*[http://www.systec-electronic.com/html/index.pl/en_product_can_interfaces SYS TEC electronic - USB-CANmodul Serie mit Unterstützung von 1, 2, 8, oder 16 CAN Kanälen (ab 129,- Eur)]

*[http://www.edevices.lt USB2CAN USB to CAN bus converter 65 EUR]

*[http://www.lawicel.com Lawicel RS232/V24<>CAN Bus Interface]
*[http://www.canusb.com/ canusb USB<>CAN über V24-Treiber von Lawicel]
*[http://www.canusb.com/projects.htm freie Software für canusb]

*[http://www.port.de/engl/canprod/hw_ethercan.html PORT CAN-LAN-Bridge mit ARM und Linux]

*[http://www.anagate.de/products/can-ethernet-gateways.htm AnaGate CAN-Ethernet Gateways (LowCost Lösung und Professionelle Varianten mit Linux System für eigene Anwendungen) (Shop)]

*[http://www.pp2can.wz.cz PP2CAN:LPT-CAN bus interface]
*[http://www.pp2can.wz.cz/CAN2MMC.htm CAN2MMC: datalogger(CAN,RS232-GPS)]
*[http://www.usb2can.wz.cz USB2CAN: USB-CAN bus interface (80 Eur)]

*[http://www.canhack.de/viewtopic.php?t=137 CANHACK CANUSB Interface, High Speed CAN + OBD2 (79,- Euro; inkl. CAN Monitor)]

*[http://www.pp2can.wz.cz PP2CAN:LPT-CAN bus interface]

*[http://oschmid.home.solnet.ch/mt/can-hub/can-hub.php CAN Bus HUB]

*[http://martinsuniverse.de/projekte/caninterceptor/caninterceptor.html CAN-Interceptor]

*[http://www.microcontroller-starterkits.de USB-zu-CAN-Interface mit verschiedenen Transceivern (LOW-Speed / HIGH-Speed) Beschreibung/Schaltplan im Online-Magazin. Leerplatinen dazu preiswert im Online-Shop erhältlich]

==Software==

*[http://canhack.de/viewtopic.php?f=25&t=135 CAN Monitor und Tracer für Peak USB, Lawicel CANUSB+CAN232 und kompatible]
*[http://www.mhs-elektronik.de/tiny_can.html GNU – Open Source CAN Monitor, Makro und Filter Funktion, Plugin fähig, unter GTK+ entwickelt]

===Protokolle===
====CANOpen====

*[http://canopen.sourceforge.net/index.html CANopen free software resource center]

[[Category:CAN]]
[[Kategorie:Bauteile]]

Diskussion:Sinus berechnung

2009-07-31T15:00:12Z

Horha: Die Seite wurde neu angelegt: Hallo, wieviele Multiplikationen brauchst Du, um einen beliegen Wert zu bestimmen?# Wenn Dein Eingabe FOrmat wie bei linearer Näherung: http://www.mikrocontroller.net...

Hallo,

wieviele Multiplikationen brauchst Du, um einen beliegen Wert zu bestimmen?#
Wenn Dein Eingabe FOrmat wie bei linearer Näherung:
http://www.mikrocontroller.net/articles/AVR_Arithmetik/Sinus_und_Cosinus_(Lineare_Interpolation)
High Byte = ganzzahliger Winkel in Grad
Low Byte = Vielfach von 1/256 Grad also Dein DX ist
<pre>
dx=DX*math.pi/2.0/n | * Konstante 1
dx2=dx**2 | 1
si=sin[k]*(1.0-0.5*dx2) | 2
co=sin[n-k]*dx*(1.0-1.0/6.0*dx2)| 3
return (si+co)/float(div) | *Konstante 1</pre>
Sind 8 Multiplikationen und 5 Konstante
Aber wie http://www.mikrocontroller.net/articles/Benutzer:Gjlayde schon schrieb.
Wofür braucht man das noch.
Lineare Näherung ist wesentlich schneller und Cordic wäre auch für Attiny's ohne Mul Befehle geeignet und überhaupt, wer braucht diese Genauigkeit.

Ein ATxmega könnte ja 12-Bit Sinus-Schwingungen auf seinem DAC ausgeben mit fast 500.000 Werten in der Sekunde bei 32 Mhz
20 Khz also mit 25 Stützstellen.

Diskussion:AVR Arithmetik/Sinus und Cosinus (Lineare Interpolation)

2009-07-27T16:00:37Z

Horha:

Hallo,

ich dachte mir schon, dass jetzt das Übergabeformat für lineare Interpolation sich gegenüber Cordic ändert, um leichter rechnen zu können ;-)
Mein Vorschlag von 0.16 als Zahlenformat bei der Cordic-Diskussion [[Diskussion:AVR Arithmetik/Sinus und Cosinus (CORDIC)]],
bezog sich nur auf die Tabelle selbst linsin_tab:

..const int16_t linsin_tab[91] PROGMEM = ...
Damit wäre ein Bit Genauigkeit gewonnen, ohne am Platzbedarf etwas zu ändern.

Eine quadratische Interpolation mit den Werten:
<pre>
a := sintable[i];
b := sintable[i+1] /2;
c := sintable[i-1] /2;
// Parabel durch sintable[i-1],sintable[i],sintable[i+1]
sinquadratNaeh := ((b+c-a)*frak + b-c)*frak+a; //oder
sinquadratNaeh := (Diff2*frak + Diff1)*frak+a;
Ließe sich auch in einer Tabelle speichern, in der a,diff1,diff2 in einer Reihe stehen, speichern
type
tfloat = 1.15;
tquaTab = record
Diff2,Diff1,a: Tfloat;
end;
const
quaTable = array [-1,16] of tquaTab;
</pre>

Das schöne daran ist, man kann mit frak im Bereich -1..1 rechnen.
<pre>
sinquadratNaeh(i,Frak=-1) = sintable[i-1];
sinquadratNaeh(i,Frak=0) = sintable[i];
sinquadratNaeh(i,Frak=1) = sintable[i+1];
</pre>
Man kommt also mit einer halben Tabelle aus.
Wenn man Tabelle [1,frak=0] rechnen will, kann man man Tabelle[0,frak=1] oder Tabelle[2,frak=-1] rechnen, oder Tabelle[1,frak=0.7]=Tabelle[2,frak=0.7-1]
Damit kann Tabelle[1] wegfallen. Weil aber die Genauigkeit etwas darunter leidet, braucht man vielleicht einen Tabellenplatz mehr. Ausserdem müssen die Konstanten anders skaliert sein, da Diff2>0 und Werte im Bereich von -0.004815..0 hat müßte um -256 erweitert werden, damit daraus noch etwas vernünftiges wird.

Nun fehlt noch die klassische Taylor-Reihe, mit weniger Konstanten:

Taylor Reihe für x im Bogennmass:
<pre>
sin(x) = x-x^3/3!+x^5/5!-x^7/7!+..-..+
mittels Horner Schema, wenn man weiß wann man aufhören will.
sin(x) = x*(1/1 - x^2/(2*3)*(1-x^2/(4*5)*(1-x^2/(6*7)*(1-x^2...-x^2/((2*n-2))*(2*n-1)){n-fach}))

function SinTaylor(x:float):float;
var
x2 : float;
i,n,n2_1:integer;
begin
n := 7; // anpassen an geforderte Genauigkeit
x2 := x*x;
n2_1 := n+n-1;
result := 1.0;
For i := n downto 2 do
begin
result := 1-x2/((n2_1-1)*n2_1)*result;
n2_1 := n2_1-2;
end;
//den Rest mal x
result := x*result;
end;
</pre>
oder schneller mit Tabelle der Kehrwerte:
<pre>
function SinTaylor(x:float):float;
const
rezSinFakt : array[0..4] of float(oder 1.15/0.16 ... ) =
(1/(2*3), 1/(4*5) ,1/(6*7) ,1/(8*9) ,1/(10*11));
rezCosFakt : array[0..4] of float = (1/(1*2), 1/(3*4) ,1/(5*6) ,1/(7*8) ,1/(9*10));

var
x2 : float;
i:integer;
begin
Umwandeln von x in Bogenmass
x Auf den Bereich 0..pi/2 bringen, passendes Vorzeichen merken
falls x >= 1 dann
x = pi/2-x -> cos_rechnen = true damit bleibt x< 1 und x^2<1
da man bei sin_rechnen ab x=0.69 sowieso schon dreimal durch die Schleife muss
und für x = 1 die Genauigkeit dann bei 17.5 Bit liegt (Taschenrechner)

x2 := x*x;
result := 1.0;
if not(cos_rechnen) then
begin
For i := 4 downto 0 do
begin
result := 1-x2*result*rezSinFakt[i]
end;
result := x*result;
end
else
//cos_rechnen
begin
For i := 4 downto 0 do
begin
result := 1-x2*result*rezCosFakt[i]
end;
end;
Vorzeichen anpassen
end;
</pre>

Da es eine alternierende Reihe ist, wird der Abbruchfehler kleiner als das erste weggelassene Glied. Hier also delta < x^13/13! (x= 1 → delta < 1.6 e-10 (auf meinem Aldi-Taschenrechner 2.17e-10) )

<pre>
Für eine Genauigkeit von 2^-15 reicht für sin Rechnung:
bis x[rad] = 0.23 For i := 0 downto 0
bis x[rad] = 0.69 For i := 1 downto 0
bis x[rad] = 1.19 For i := 2 downto 0
Multiplikationen ( 1.15 x 1.15-> 1.15) : 1 (x^2)+1 (x*result) + 2*Anzahl Schleifendurchläufe
Multiplikationen : (1+Anzahl Schleifendurchläufe)*2
</pre>
Also statt 16 Multiplkationen wie bei Cordic (aber nur, weil es keinen schnellen Shifter gibt) maximal 8 für sin+cos Berechnung also etwa gleich schnell oder schneller.

Ich schon sagen, dass Du Dir ausgesprochen viel Mühe gibst.

Heisst das heute chapeau oder Hut ab ?

:Wie an der Abschätzung für die linsin_tab zu erkennen, wird der Fehler dominiert durch den Eingabefehler im Bereich von 2 Inkrementen, nicht durch den Interpolationsfehler. Dementsprechend wird eine Umstellung auf eine 0.16-Tabelle keine wesentliche Verkleinerung des Fehlers bringen. Eine Probeimplementierung bestätigt dies: die Standardabweichungen werden zwar was kleiner, aber die Maximalfehler bleiben unverändert.

:Die Implementierungen habe ich aus Interesse gemacht – es ging mit nicht darum, den ganzen Zoo von denkbaren sin-Implementierungen für AVR durchzunudeln. Meine mathematische Intuition sagt mir immer noch, daß Taylor nicht sinnvoll ist (u.a. gerade ''weil'' die Reihe alternierend ist) und quadratische Interpolation mit unangenehmen Fußangeln aufwartet.

:Im übrigen rechnet man nicht im Intervell [-1,1] sondern in [-1,1) bzw. hier – da zunächst keine negativen Werte auftauchen – in [0,1).

:Da mit der linearen Interpolation eine Implementierung mit halbwegs akzeptabler Laufzeit zur Verfügung steht, wäre eher zu überlegen, CORDIC auf Codegröße zu optimieren anstatt auf Geschwindigkeit. Ohne Fallunterscheidungen und mit Schiebeschleifen anstatt Multiplikation solle deutlich an Flash gespart werden können – natürlich auf Kosten der Laufzeit. --[[Benutzer:Gjlayde|Gjlayde]] 10:08, 26. Jul. 2009 (CEST)

Hallo,

ich habe es mal mit Taylor simuliert( mit smallint ) und vorerst nur Winkel von 0..32787 /32767 also von 0..1 im Bogenmass betrachtet.
<pre>
abs. Abweichung: Anzahl
-2: 0
-1: 2791
0:27291
1: 2686
2: 0</pre>
bis 590 keine Iteration, bis 8100 ( 14.16° ) eine, bis 18000 (31.47°) zwei und dann drei bis 57.29°.
Also kommt nie eine Abweichung von +-2 zustande.

Lange Rede keinen Sinn. Warum sollte man Cordic nutzen, wenn es Abweichungen bis +-7 hat und nicht schneller rechnet?
<pre>
program TayLorTest;

type
tfloat = smallint;
var
i : smallint;
count: longint;
Fehler :array[-10..10] of longint;

function SinTaylor(x:tfloat):tfloat;
const
// (1/(2*3), 1/(4*5) ,1/(6*7) ,1/(8*9) ,1/(10*11) *65536);
rezSinFakt : array[0..2] of smallint = (10923,3277,1560);
var
x2 : longint;
i : shortint;
cos_rechnen:boolean;
begin
If x > 590 then
begin
result := $7FFF;//= 1
IF (x >= 0) AND (x <= 32767) then
begin
x2 := (x*x ) shr 15;
i := 2;
if x < 18000 then
i := 1;
if x < 8100 then
i := 0;
while i>= 0 do
begin
result := $7FFF - result*((x2*rezSinFakt[i]) shr 16 ) shr 15;
dec(i);
end;
result := x*result shr 15;
end;
// else cos (90-alpha) = 51472-x rechnen
end;
else
// x < 590
result := x-1;
inc(count);
inc(Fehler[round(result-int(32768*sin(x/32768)))]);
end;

begin
for i := -10 to 10 do
Fehler[i]:= 0;
count:= 0 ;
for i := 0 to 32767 do
sinTaylor(i);
for i := -10 to 10 do
write(i:4,Fehler[i]:12);
writeln(count)
end.</pre>

Diskussion:AVR Arithmetik/Sinus und Cosinus (Lineare Interpolation)

2009-07-25T09:42:13Z

Horha: Quadratische INterpolation / Taylorreihe

Hallo,

ich dachte mir schon, dass jetzt das Übergabeformat für lineare Interpolation sich gegenüber Cordic ändert, um leichter rechnen zu können ;-)

Mein Vorschlag von 0.16 als Zahlenformat bei der Cordic-Diskussion http://www.mikrocontroller.net/articles/Diskussion:AVR_Arithmetik/Sinus_und_Cosinus_(CORDIC) ,
bezog sich nur auf die Tabelle selbst linsin_tab:

..const int16_t linsin_tab[91] PROGMEM = ...
Damit wäre ein Bit Genauigkeit gewonnen, ohne am Platzbedarf etwas zu ändern.

Eine quadratische Interpolation mit den Werten:
<pre>
a := sintable[i];
b := sintable[i+1] /2;
c := sintable[i-1] /2;
// Parabel durch sintable[i-1],sintable[i],sintable[i+1]
sinquadratNaeh := ((b+c-a)*frak + b-c)*frak+a; //oder
sinquadratNaeh := (Diff2*frak + Diff1)*frak+a;
Ließe sich auch in einer Tabelle speichern, in der a,diff1,diff2 in einer Reihe stehen, speichern
type
tfloat = 1.15;
tquaTab = record
Diff2,Diff1,a: Tfloat;
end;
const
quaTable = array [-1,16] of tquaTab;

Das schöne daran ist, man kann mit frak im Bereich -1..1 rechnen.

sinquadratNaeh(i,Frak=-1) = sintable[i-1];
sinquadratNaeh(i,Frak=0) = sintable[i];
sinquadratNaeh(i,Frak=1) = sintable[i+1];

Man kommt also mit einer halben Tabelle aus.
Wenn man Tabelle[1,frak=0] rechnen will, kann man man Tabelle[0,frak=1] oder Tabelle[2,frak=-1] rechnen,
oder Tabelle[1,frak=0.7]= Tabelle[2,frak=0.7-1]
Damit kann Tabelle[1] wegfallen.
Weil aber die Genauigkeit etwas darunter leidet, braucht man vielleicht einen Tabellenplatz mehr.
Ausserdem müssen die Konstanten anders skaliert sein, da Diff2>0 und Werte im Bereich von -0.004815..0 hat
müßte um -256 erweitert werden, damit daraus noch etwas vernünftiges wird.

</pre>

Nun fehlt noch die klassische Taylor-Reihe, mit weniger Konstanten:
<pre>
Taylor Reihe für x im Bogennmass:
sin(x) = x-x^3/3!+x^5/5!-x^7/7!+..-..+
mittels Horner Schema, wenn man weiß wann man aufhören will.
sin(x) = x*(1/1 - x^2/(2*3)*(1-x^2/(4*5)*(1-x^2/(6*7)*(1-x^2...-x^2/((2*n-2))*(2*n-1)){n-fach}))

function SinTaylor(x:float):float;
var
x2 : float;
i,n,n2_1:integer;
begin
n := 7; // anpassen an geforderte Genauigkeit
x2 := x*x;
n2_1 := n+n-1;
result := 1.0;
For i := n downto 2 do
begin
result := 1-x2/((n2_1-1)*n2_1)*result;
n2_1 := n2_1-2;
end;
//den Rest mal x
result := x*result;
end;

oder schneller mit Tabelle der Kehrwerte:
function SinTaylor(x:float):float;
const
rezSinFakt : array[0..4] of float(oder 1.15/0.16 ... ) =
(1/(2*3), 1/(4*5) ,1/(6*7) ,1/(8*9) ,1/(10*11));
rezCosFakt : array[0..4] of float = (1/(1*2), 1/(3*4) ,1/(5*6) ,1/(7*8) ,1/(9*10));

var
x2 : float;
i:integer;
begin
Umwandeln von x in Bogenmass
x Auf den Bereich 0..pi/2 bringen, passendes Vorzeichen merken
falls x >= 1 dann
x = pi/2-x ->cos_rechnen = true damit bleibt x< 1 und x^2<1
da man bei sin_rechnen ab x=0.69 sowieso schon dreimal durch die Schleife muss
und für x = 1 die Genauigkeit dann bei 17.5 Bit liegt (Taschenrechner)

x2 := x*x;
result := 1.0;
if not(cos_rechnen) then
begin
For i := 4 downto 0 do
begin
result := 1-x2*result*rezSinFakt[i]
end;
result := x*result;
end
else
//cos_rechnen
begin
For i := 4 downto 0 do
begin
result := 1-x2*result*rezCosFakt[i]
end;
end;
Vorzeichen anpassen
end;

</pre>
Da es eine alternierende Reihe ist, wird der Abbruchfehler kleiner als das erste weggelassene Glied.Hier also delta < x^13/13! (x= 1 -> delta < 1.6 e-10 (auf meinem Aldi-Taschenrechner 2.17e-10) )
<pre>
Für eine Genauigkeit von 2^-15 reicht für sin Rechnung:
bis x[rad] = 0.23 For i := 0 downto 0
bis x[rad] = 0.69 For i := 1 downto 0
bis x[rad] = 1.19 For i := 2 downto 0
Multiplikationen ( 1.15 x 1.15-> 1.15) : 1 (x^2)+1 (x*result) + 2*Anzahl Schleifendurchläufe
Multiplikationen : (1+Anzahl Schleifendurchläufe)*2
Also statt 16 Multiplkationen wie bei Cordic (aber nur, weil es keinen schnellen Shifter gibt) maximal 8 für sin+cos Berechnung also etwa gleich schnell oder schneller.
</pre>

Ich schon sagen, dass Du Dir ausgesprochen viel Mühe gibst.

Heisst das heute chapeau oder Hut ab ?