Elektronik

Einen TV wie im Werbebild an die Wand bringen

TJ — Sun, 31 Jan 2010 21:07:39 +0000

Wenn man sich einen ordenltichen TV kauft, soll der auch stilvoll an die Wand, aber wohin mit den Kabeln? Genau, unter den Putz! Hier eine kleine Dokumentation wie das sehr gut und schnell funktioniert.

Zeit: ca. 10 Stunden absolute Arbeitszeit (gemÃ¼tlich und als Laie)
BenÃ¶tigte Materialien: FÃ¼llspachtel fÃ¼r den Heimgebrauch, Wandhalterung, Abdeckfolie
BenÃ¶tigte Werkzeuge: Bohrmaschine, Wasserwage, kleine Flex mit Diamantscheibe, MeiÃŸel, Spachtel, GipsanrÃ¼hrgummitopf, Schleifpapier, Wandfarbe, Farbrolle, Pinsel

ZunÃ¤chst montiert man die Wandhalterung, das ist klar denke ich. Dann wird der Putz da wo die Kabel nach unten sollen mit der Flex aufgeschnitten, damit es eine saubere Kante gibt. AnschlieÃŸend meiÃŸelt man den Putz von der Wand so tief, dass Ã¼ber die Kabel noch 2 bis 3mm Gips passt.

Dann werden die Kabel nach MaÃŸ wo sie an den TV angeschlossen werden mit wenig Gips in dem “Schacht” fixiert und anschlieÃŸend vollstÃ¤ndig verputzt. Nach einigen Stunden (je nach Gips/Putz) kann man alles glattschleifen, so dass es nicht mehr zu sehen ist. Danach einfach mit der Wandfarbe drÃ¼berstreichen.

Am Ende sieht das Ganze dann so aus:

KRC-778R/KDC-V7521/KDC-7090R Folienleiter wechseln

TJ — Wed, 12 Aug 2009 16:30:09 +0000

Wer ein oben genanntes Autoradio der Firma Kenwood besitzt wird spÃ¤testens nach 4 Jahren feststellen, dass das Frontpanel langsam immer weniger funktioniert und dann gar nichts mehr tut. GroÃŸe Wirkung â€“ kleine Ursacheâ€¦

Schuld daran ist der Verbinder zwischen Haupteinheit und Frontpanel. Dieser Folienleiter wird durch das Umklappen des Bedienteils bei jedem Vorgang an einer bestimmten Stelle geknickt und reiÃŸt nach maximal 4 Jahren ein. Dann ist die Stromversorgung unterbrochen und es wird nichts mehr angezeigt.

Zum GlÃ¼ck kann man statt einem neuen Radio diesen Folienleiter (J84-0121-12) bestellen: TV-Ersatzteile

Unterschiede der CAN Transceiver im Highspeed-Betrieb

TJ — Tue, 28 Apr 2009 12:15:51 +0000

Vor einiger Zeit habe ich in einem Beitrag die Unterschiede zwischen dem MCP2551 und dem PCA82C250 aufgelistet. Ich hatte ebenfalls geschrieben, dass sie bis auf Kleinigkeiten keine nennenswerte Unterschiede haben. Das muss ich an der Stelle revidieren.

Beim CAN-Bus im Highspeed-Betrieb mÃ¼ssen die Leitungen CAN-H und CAN-L auf die Referenzspannung von 2,5V gezogen werden (5V CAN). Der groÃŸe Unterschied ist, dass der MCP2551 das intern macht, der 82C250 jedoch nicht. Dort muss man das selbst bei den Knoten implementieren. Erkennen kann man das in den Block-Diagrammen der Chips im Datenblatt und beim Oszilloskopieren des Signals. Meiner Meinung nach ist das nicht nur gut zu wissen, sondern auch ein gravierender Entscheidungspunkt bei der Entwicklung eines eigenen Systems.

Galerie und Lightbox

TJ — Mon, 20 Apr 2009 08:32:02 +0000

Nichts ist so bestÃ¤ndig wie die VerÃ¤nderung! Jeder kennt den Satz â€“ so ist es auch bei mir. Ab sofort sind alle Bilder, die in BeitrÃ¤gen verwendet wurden und werden, in einer Flickr Galerie zu sehen. Neben dem Home-Button ist nun ein neuer Button â€œGalerieâ€ entstanden. Dort kann man sich alle Bilder nach Alben sortiert ansehen.

Des Weiteren werden die Bilder nun etwas schÃ¶ner geÃ¶ffnet, wenn man diese anklickt. DafÃ¼r ist das Tool Lightbox im Einsatz. Die BeitrÃ¤ge enthalten selbstverstÃ¤ndlich weiterhin Bilder, wie ich sie einfÃ¼ge werde ich noch sehen. Evtl. werden sie direkt aus Flickr mit dem Tool Flickr4Writer eingefÃ¼gt und so direkt mit der Galerie verlinkt. Die bestehenden BeitrÃ¤ge werde ich nicht verÃ¤ndern.

Flickr4Writer

TJ — Sun, 19 Apr 2009 12:53:46 +0000

Schon lÃ¤nger benutze ich den recht komfortablen Windows Live Writer um meine BeitrÃ¤ge fÃ¼r das Blog zu erstellen, da mich ein Freund darauf gebracht hatte. Seit kurzer Zeit probiere ich Flickr und Lightbox aus um ein paar VerÃ¤nderungen durchzufÃ¼hren, es hieÃŸ jedoch immer, dass man im Windows Live Writer keine Flickr Bilder einfÃ¼gen kann.

Tim Heuer hat dafÃ¼r genau das richtige Plug-In entwickelt. Sein Flickr4Writer integriert sich perfekt bei den Writer Plug-Ins und arbeitet tadellos! Man gibt einfach sein Flickr Benutzername ein und autorisiert das Plug-In â€“ fertig. Eine Upload Funktion hat es nicht.

Externe Interrupts mit dem AVR leicht gemacht

TJ — Thu, 16 Apr 2009 08:40:54 +0000

Die Unterschiede zwischen Polling und Interrupt sind in einem Ã¤lteren Beitrag schon aufgelistet. Theorie findet man jedoch sehr oft. Hier findet ihr ein einfaches Beispiel wie man einen Taster per Interrupt eine Aktion ausÃ¼ben lÃ¤sst. Das Beispiel ist fÃ¼r einen AT90CAN128 mit folgender Hardwarekonfiguration:

- Taster an PORT E, PIN 7
- LED an PORT E, PIN 6

Beim Initialisieren aktiviert man die Interrupts und konfiguriert wann dieser ausgelÃ¶st werden soll:

// Init Taster DDRE &= ~_BV(7); // PORT E, PIN 7 als Eingang definieren


EIMSK |= _BV(INT7);  // Interrupt fuer Pin 7 aktivieren        
EICRB |= _BV(ISC50); // steigende Flanke erzeugt einen INT         
EICRB |= _BV(ISC51); 
//  Init LED        
DDRE  |= _BV(6);     // PORT E, PIN 6 als Ausgang definieren 
sei();    //activate global interrups

In der ISR fÃ¼r Signal 7 kann dann eine Aktion erfolgen oder ein selbst erstelltes Flag (in einer Variablen) gesetzt werden.

// ISR Taster SIGNAL(SIG_INTERRUPT7) { // LED an PORTE |= _BV(6);


  // entprellen        
  delay_ms(100);         
}

Die beiden Dateien stehen hier zur VerfÃ¼gung.

Beispiel CAN Bus Testapplikation fÃ¼r AT90CAN128

TJ — Tue, 07 Apr 2009 12:27:12 +0000

Ich habe es in letzter Zeit oft erlebt, dass sich angehende Mikrocontrollerprogrammierer mit dem AT90CAN beschÃ¤ftigen wollen oder mÃ¼ssen um eine CAN Anwendung zu entwickeln. Dabei stÃ¶ÃŸt man immer auf folgendes Problem: Man wird in den Wald geworfen und weiÃŸ nicht welchen Baum man zuerst studieren soll. Wenn man nach einfachen Testanwendungen sucht, dann findet man meist ausgeklÃ¼gelte Bibliotheken oder Anwendungen wo man zunÃ¤chst nicht durchsieht. AuÃŸerdem sind die meist viel zu umfangreich und kÃ¶nnen auch beide CAN 2.0 Standards. Diesem Problem mache ich heute ein Ende, hier folgt eine einfache Anwendung fÃ¼r den AT90CAN und eine kleine EinfÃ¼hrung in die Software. Es sind alle Derivate des AT90CAN verwendbar (32, 64, 128), man muss selbstverstÃ¤ndlich beim Kompilieren darauf achten den Richtigen einzustellen.

Beginnen wir mit der Struktur der Software:

- main.c	Hauptdatei, Aufruf der Funktionen
- at90can.c	Sourcedatei fÃ¼r CAN-Funktionen, inkl. ISR
- at90can.h	Headerdatei fÃ¼r CAN, Definition der Struktur, Geschwindigkeiten
- utils.h	Korrekte Definitionen fÃ¼r True/False und nÃ¼tzliche Dinge

FÃ¼r die Variablen in denen CAN-Nachrichten gespeichert werden sollen wurde eine Struktur CAN_messageType erstellt. Die im Datenblatt empfohlenen Einstellungen fÃ¼r die Geschwindigkeiten sind in einem Feld (array) in der at90can.h hinterlegt. Die Applikation besteht nun darin, dass in der main-Funktion zunÃ¤chst die Initialisierung aufgerufen wird und anschlieÃŸend eine CAN-Botschaft testweise gesendet wird. Die Empfangenen Nachrichten werden nur in der globalen Variable recMsg abgespeichert, jedoch nicht weiter verarbeitet. Bei jeder Operation mit MObs muss die CANPAGE auf das entsprechende gesetzt werden.

Wichtig ist zunÃ¤chst die korrekte Initialisierung. Der CAN-Controller muss zum konfigurieren in den config-mode versetzt werden um Geschwindigkeit und Interrupteinstellungen zu Ã¤ndern. Die globalen Interrupts sollte man erst nach der Konfiguration aktivieren, denn sonst kÃ¶nnte mitten in der Konfiguration beim aktivieren der einzelnen Interrupts ein kommender die Konfiguration verfÃ¤lschen. Zur Initialisierung des CAN-Controllers gehÃ¶rt das aktivieren des config-mode, die Einstellungen der Interrupts und das Setzen der Busgeschwindigkeit. Die Konfiguration der einzelnen MObs kann auch in gesonderten Funktionen erledigt werden.

Bei einem Empfang einer Nachricht wird in der entsprechenden Interrupt-Service-Routine (ISR) die CAN-Botschaft aus den Registern ausgelesen und in eine globale Variable gespeichert. Variablen die in einer ISR beschrieben werden sollen, mÃ¼ssen als volatile deklariert werden. Nach dem speichern der Daten muss der Interrupt durch readmodwrite resetet werden. Ebenso muss das Bit CONMOBn gesetzt werden, um erneut Empfangsbereitschaft zu signalisieren.

Zum Senden einer Nachricht werden die gewÃ¼nschten Daten und ID in einer Variable gespeichert und die Funktion can_tx aufgerufen werden. Diese kopiert die Daten in die Register des Controllers und setzt das Bit CONMOBn des als Sender konfigurierten MOb.

Fragen, Anregungen oder VerbesserungsvorschlÃ¤ge kÃ¶nnen gerne als Kommentare erfolgen!

Einstellungen im EEPROM eines AVR speichern

TJ — Fri, 20 Mar 2009 18:59:17 +0000

Es gibt kaum eine Anwendung in der man keine Einstellungen speichern mÃ¶chte. Doch wenn man sich schon den Aufwand macht Einstellungen zu speichern, sollten diese nach dem Reset auch wieder abrufbar sein. Daher wird so etwas im EEPROM gespeichert und ausgelesen. Wie man das ganz sinnvoll programmieren kann folgt hier:

Am sinnvollsten Ã¼berlegt man sich vorher was zu speichern ist, dann erstellt man gesondert dafÃ¼r eine Sourcedatei mit deren Header. Im Header erfolgt die Definition der BenÃ¶tigten Bytes:

#define EEPROM_SECTION __attribute__ ((section (".eeprom")))


/*        
** this global variables are stored in EEPROM         
*/         
uint16_t  dummy          EEPROM_SECTION  = 0;  // avoid using lowest addresses 
//——————————————————————————        
// section 1: default settings         
uint8_t   eeprom_def_brightness EEPROM_SECTION  = 1;  // EEPROM address 0002         
uint16_t  eeprom_def_TempID     EEPROM_SECTION  = 2;  // EEPROM address 0003         
uint8_t   eeprom_def_TempUnit   EEPROM_SECTION  = 3;  // EEPROM address 0005         
uint16_t  eeprom_def_Filter     EEPROM_SECTION  = 4;  // EEPROM address 0006         
uint8_t   eeprom_def_CANspeed   EEPROM_SECTION  = 5;  // EEPROM address 0008 
// placeholder        
uint16_t  eeprom_def_dummy1     EEPROM_SECTION  = 6;  // EEPROM address 0009         
uint16_t  eeprom_def_dummy2     EEPROM_SECTION  = 7;  // EEPROM address 000B         
uint8_t   eeprom_def_dummy3     EEPROM_SECTION  = 8;  // EEPROM address 000D         
uint8_t   eeprom_def_dummy4     EEPROM_SECTION  = 9;  // EEPROM address 000E         
uint8_t   eeprom_def_dummy5     EEPROM_SECTION  = 10; // EEPROM address 000F 
//——————————————————————————        
// section 2: user settings         
uint8_t   eeprom_usr_brightness EEPROM_SECTION  = 11;  // EEPROM address 0010         
uint16_t  eeprom_usr_TempID     EEPROM_SECTION  = 12;  // EEPROM address 0011         
uint8_t   eeprom_usr_TempUnit   EEPROM_SECTION  = 13;  // EEPROM address 0013         
uint16_t  eeprom_usr_Filter     EEPROM_SECTION  = 14;  // EEPROM address 0014         
uint8_t   eeprom_usr_CANspeed   EEPROM_SECTION  = 15;  // EEPROM address 0016 
// placeholder        
uint16_t  eeprom_usr_dummy11    EEPROM_SECTION  = 16;  // EEPROM address 0017         
uint16_t  eeprom_usr_dummy12    EEPROM_SECTION  = 17;  // EEPROM address 0019         
uint8_t   eeprom_usr_dummy13    EEPROM_SECTION  = 18;  // EEPROM address 001B         
uint8_t   eeprom_usr_dummy14    EEPROM_SECTION  = 19;  // EEPROM address 001C         
uint8_t   eeprom_usr_dummy15    EEPROM_SECTION  = 20;  // EEPROM address 001D

AnschlieÃŸend werden in der Sourcedatei die entsprechend der Reservierung benÃ¶tigten Funktionen erstellt um die Werte zu lesen/schreiben.

#include #include #include #include #include "eeprom_access.h"


// returns the dataset from eeprom        
uint16_t get_eeprom_word(uint8_t setting)         
{         
  uint16_t   eeprom_word; 
  switch (setting)        
  {         
    case 12:         
      eeprom_word = eeprom_read_word( &eeprom_usr_TempID );         
      break;         
    case 14:         
      eeprom_word = eeprom_read_word( &eeprom_usr_Filter );         
      break;         
    default:         
      break;         
  }         
  return eeprom_word;         
} 
// save data to eeprom        
void set_eeprom_word( uint16_t eeprom_word, uint8_t setting )         
{         
  switch (setting)         
  {         
    case 12:         
      eeprom_write_word( &eeprom_usr_TempID, eeprom_word );         
        break;         
    case 14:         
      eeprom_write_word( &eeprom_usr_Filter, eeprom_word );         
        break;         
    default:         
      break;         
  }         
} 
// returns the dataset from eeprom        
uint8_t get_eeprom_byte(uint8_t setting)         
{         
  uint8_t   eeprom_byte; 
  switch (setting)        
  {         
    case 15:         
      eeprom_byte = eeprom_read_byte( &eeprom_usr_CANspeed );         
        break;         
    default:         
      break;         
  } 
  return eeprom_byte;        
} 
// save data to eeprom        
void set_eeprom_byte( uint8_t eeprom_byte, uint8_t setting )         
{         
  switch (setting)         
  {         
    case 15:         
      eeprom_write_byte( &eeprom_usr_CANspeed, eeprom_byte );         
        break;         
    default:         
      break;         
  }         
}

In der main-Datei (oder wo man die Funktion aufrufen mÃ¶chte) muss anschlieÃŸend definiert werden wie die Einstellungen heiÃŸen und die externen Funktionen deklariert werden.

//——– // EEPROM //——– // settings #define CAN_Speed 15 #define CAN_Filter 14 #define Temp_ID 12


extern void set_eeprom_byte( uint8_t eeprom_byte, uint8_t setting );        
extern uint8_t get_eeprom_byte(uint8_t setting);         
extern void set_eeprom_word( uint16_t eeprom_word, uint8_t setting );         
extern uint16_t get_eeprom_word(uint8_t setting);

Der Aufruf aus der main-Datei kÃ¶nnte dann wie folgt aussehen:

CANspeed = get_eeprom_byte(CAN_Speed);


set_eeprom_byte(CANspeed, CAN_Speed);

Alientech Powergate im Check

TJ — Thu, 05 Mar 2009 14:28:42 +0000

Ich hatte neulich mal die Gelegenheit ein ECU-flasher (ProgrammiergerÃ¤t fÃ¼r MotorsteuergerÃ¤t) zu testen. Das GerÃ¤t kam aus dem Hause Alientech und nennt sich Powergate Pro. Interessant zu sehen fand ich, dass auch hier ein AT90CAN128 als Controller verwendet wurde, ein recht bekannter Chip mit integriertem CAN Controller und einigen mÃ¤chtigen Features. Daneben platzierte man die Ã¼blichen VerdÃ¤chtigen wie FT245BL, M6636B, 7805C, PCA82C250 und vier Flashbausteine a 16MB AT45DB161.

Zu sagen ist, dass die Komponenten recht gut verlÃ¶tet sind und sehr sauber platziert. Die Leiterbahnverlegung und Anordnung der Controller halte ich allerdings fÃ¼r fragwÃ¼rdig. Negativ anzumerken ist, dass ein Fahrzeug nur einmal geflasht werden kann.

CANlogger mit Temperaturmessung

TJ — Sat, 21 Feb 2009 16:07:56 +0000

Vor einiger Zeit hatte ich das Konzept der Projektarbeit schon einmal vorgestellt. Nun wurde Version 1.0 fertig gestellt.

Features:

- Temperaturmessung mit Thermoelement und MAX6675
- ISP Stecker nach ATMEL Standard
- Schutz zum CAN durch DC-DC und Optokoppler
- CAN Stecker ist CAN-CiA konform
- Stromversorgung wÃ¤hlbar zwischen CAN und extern
- zusÃ¤tzlich IÂ²C EEPROM auflÃ¶tbar fÃ¼r groÃŸe Bilder
- EinstellmÃ¶glichkeit mit Drehgeber fÃ¼r CAN-Speed, ID und Filter
- Anzeige von empfangenen CAN-Nachrichten auf dem TFT
- 65k Farb-TFT mit 176×132 Pixel von display3000

Hier eine kleine Demo des Moduls: