64 LEDs ansteuern

Es gibt 9 Antworten in diesem Thema. Der letzte Beitrag () ist von gfcwfzkm.

    64 LEDs ansteuern

    Ich habe 4 LED-Panele. Jedes dieser Panele besteht aus 4 Zeilen. Jede Zeile besteht aus 4 Segmenten, deren Anoden zusammenhängen (also gibt es eine gemeinsame Andoe und 4 Separate Kathoden). Und jedes der 64 Segment besteht aus 9 in Serie geschalteten LEDs, was aber für die Funktion irrelevant ist.
    Ich habe leider keine Datenblätter für die LEDs, weil es sich um Hintergrundbeleuchtungen von Fernsehern handelt, aber folgendes kann ich durch experimentieren sagen:
    Die Nennspannung der Segmente liegt bei ca. 24 Volt, kann aber auch um ein paar Volt höher sein. Bei 20 Milliampere (ca. 22 bis 24 Volt) leuchten die LEDs mäßig. Bei einer etwas höheren Spannung (24 bis 26 Volt) fließen ca. 30 Milliampere und die LEDs leuchten ziemlich hell.

    Mein Ziel ist es, diese LEDs mit einem Microcontroller anzusteuern. Nur leider bin ich in dem Halbleiter-Jungel total verloren.
    Ich hätte da an mehrere D-FlipFlops gedacht, die alle an einem Ausgang des Microcontrollers hängen, deren Zustände aber separat gesetzt werden können.
    Oder mehrere Schieberegister mit parallelen Ausgängen wären auch möglich.
    Dann brauche ich aber noch passende Treiber für die LEDs. Ich könnte 64 diskrete NPN-Transistoren (z.B. BC337) verwenden, aber das wird dann doch etwas viel, also wenn es fertige Bausteine gibt, wäre mir das lieber.

    Also könnt ihr mir da vielleicht ein paar Tipps geben? Konkrete Typennamen wären mir am liebsten.
    "Luckily luh... luckily it wasn't poi-"
    -- Brady in Wonderland, 23. Februar 2015, 1:56
    Desktop Pinner | ApplicationSettings | OnUtils
    maximintegrated.com/en/product…ower-control/MAX7219.html

    Ist für 7-Segment anzeigen gedacht, aber da sind es auch nur LEDs. Den Controller kannst du also dazu gut zwecksentfremden.
    Mehrere Hintereinanderschalten und mit dem uC deiner Wahl ansteuern, fertig.

    mfg

    gfc
    Hallo,

    den MAX7219 hab ich mal zusammen mit einem 8x8 LED-Array und dem Arduino verwendet, schau mal vielleicht hilf Dir das.
    ebay.de/itm/like/301128289035?lpid=106&chn=ps (Zum Vergleich)
    playground.arduino.cc/Main/MAX72XXHardware
    gammon.com.au/forum/?id=11516

    Und ich habe zum Lernen eigene Bibliotheken geschrieben (Vielleicht hilft Dir der Code beim Protokoll)
    MAX7219.h

    C-Quellcode

    1. #ifndef _MAX7219_H_
    2. #define _MAX7219_H_
    3. //Holds a 8x8 LED matrix state buffer and provides managing methods
    4. class MAX7219_state
    5. {
    6. public:
    7. MAX7219_state();
    8. void clear();
    9. void fill();
    10. bool get_pixel(unsigned int row, unsigned int column);
    11. void set_pixel(unsigned int row, unsigned int column, bool value);
    12. void push(unsigned int direction, unsigned char data);
    13. unsigned char inner_state[8];
    14. };
    15. //Provides access to the MAX7219 chip
    16. class MAX7219
    17. {
    18. public:
    19. MAX7219(const int pinCLK, const int pinCS, const int pinDIN);
    20. void initialize();
    21. void present();
    22. void set_brightness(unsigned char value);
    23. MAX7219_state state;
    24. private:
    25. unsigned int _pinCLK;
    26. unsigned int _pinCS;
    27. unsigned int _pinDIN;
    28. void write_byte(unsigned char data);
    29. void write_row(unsigned char row, unsigned char data);
    30. };
    31. #endif


    MAX7219.cpp

    C-Quellcode

    1. #include <wiring_private.h> //Needed for Arduino constants and makros
    2. #include "MAX7219.h"
    3. //Implementation of MAX7219
    4. //Constructor, takes the pin numbers
    5. MAX7219::MAX7219(const int pinCLK, const int pinCS, const int pinDIN)
    6. {
    7. //set pin numbers
    8. _pinCLK = pinCLK;
    9. _pinCS = pinCS;
    10. _pinDIN = pinDIN;
    11. //initialize pins
    12. pinMode(_pinCLK, OUTPUT);
    13. pinMode(_pinCS, OUTPUT);
    14. pinMode(_pinDIN, OUTPUT);
    15. }
    16. //Initializes the shield chip
    17. void MAX7219::initialize()
    18. {
    19. //default settings
    20. write_row(0x09, 0x00); //Decoding mode: BCD
    21. write_row(0x0a, 0x08); //Brightness: 50% (Range 0x00 - 0x0F)
    22. write_row(0x0b, 0x07); //Scanlimit: 8 LEDs
    23. write_row(0x0c, 0x01); //Power-down mode: off
    24. write_row(0x0f, 0x00); //Test mode: off
    25. state.clear();
    26. present();
    27. }
    28. //Writes the buffer to the display
    29. void MAX7219::present()
    30. {
    31. unsigned int i=0;
    32. for(i=1; i<=8; i++)
    33. {
    34. write_row(i, state.inner_state[i-1]);
    35. }
    36. }
    37. //Sets the LEDs' brightness
    38. void MAX7219::set_brightness(unsigned char value)
    39. {
    40. write_row(0x0a, value);
    41. }
    42. //Writes a byte to the shield chip
    43. void MAX7219::write_byte(unsigned char data)
    44. {
    45. digitalWrite(_pinCS, LOW); //write start command
    46. unsigned char i;
    47. //write the byte bitwise
    48. for(i=0; i<=7; i++)
    49. {
    50. digitalWrite(_pinCLK, LOW); //start writing bit
    51. digitalWrite(_pinDIN, data&0x80); //read a bit data
    52. data = data<<1; //place next bit data to read
    53. digitalWrite(_pinCLK, HIGH); //end writing bit
    54. }
    55. }
    56. //Writes a byte at an address to the shield chip
    57. void MAX7219::write_row(unsigned char row, unsigned char data)
    58. {
    59. digitalWrite(_pinCS, LOW); //start writing byte
    60. write_byte(row); //write row number
    61. write_byte(data); //write row configuration
    62. digitalWrite(_pinCS, HIGH); //end writing byte
    63. }
    64. //Implementation of MAX7219_state
    65. //Constructor, initializes buffer (all LEDs off)
    66. MAX7219_state::MAX7219_state()
    67. {
    68. unsigned int i=0;
    69. for(i=0; i<=7; i++) inner_state[i] = 0x00;
    70. }
    71. //Clears the buffer (all LEDs off)
    72. void MAX7219_state::clear()
    73. {
    74. unsigned int i=0;
    75. for(i=0; i<=7; i++) inner_state[i] = 0x00;
    76. }
    77. //Fills the buffer (all LEDs on)
    78. void MAX7219_state::fill()
    79. {
    80. unsigned int i=0;
    81. for(i=0; i<=7; i++) inner_state[i] = 0xFF;
    82. }
    83. //Returns the state of a pixel at a specific position
    84. bool MAX7219_state::get_pixel(unsigned int row, unsigned int column)
    85. {
    86. if((row >= 0) && (row <=7) && (column >= 0) && (column <= 7)) { return inner_state[row] & (1 << (7-column)); }
    87. else { return false; }
    88. }
    89. //Sets the state of a pixel at a specific position
    90. void MAX7219_state::set_pixel(unsigned int row, unsigned int column, bool value)
    91. {
    92. if((row >= 0) && (row <=7) && (column >= 0) && (column <= 7))
    93. {
    94. if(value) { inner_state[row] |= 1 << (7-column); }
    95. else { inner_state[row] &= ~(1 << (7-column)); }
    96. }
    97. }
    98. //Shifts the buffer content, data loss possible
    99. void MAX7219_state::push(unsigned int direction, unsigned char data)
    100. {
    101. unsigned int i=0;
    102. switch(direction)
    103. {
    104. //Up
    105. case 0:
    106. for(i=0; i<=6; i++) inner_state[i] = inner_state[i+1];
    107. inner_state[7] = data;
    108. break;
    109. //Left
    110. case 1:
    111. for(i=0; i<=7; i++)
    112. {
    113. inner_state[i] = inner_state[i] >> 1;
    114. set_pixel(i, 0, ((1 << i) & data));
    115. }
    116. break;
    117. //Down
    118. case 2:
    119. for(i=7; i>=1; i--) inner_state[i] = inner_state[i-1];
    120. inner_state[0] = data;
    121. break;
    122. //Right
    123. case 3:
    124. for(i=0; i<=7; i++)
    125. {
    126. inner_state[i] = inner_state[i] << 1;
    127. set_pixel(i, 7, ((1 << i) & data));
    128. }
    129. break;
    130. default:
    131. break;
    132. }
    133. }


    und Buchstaben dafür:

    MAX7219FONT.h

    C-Quellcode

    1. #ifndef _MAX7219FONT_H_
    2. #define _MAX7219FONT_H_
    3. //Provides a special font for the 8x8 matrix, defines ASCII chars 32-126 (space and printable chars)
    4. //Created by Nick Gammon; see http://www.gammon.com.au/forum/?id=11516
    5. const unsigned char MAX7219FONT[95][8] = {
    6. { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // ' '
    7. { 0x00, 0x06, 0x5F, 0x5F, 0x06, 0x00, 0x00, 0x00 }, // '!'
    8. { 0x00, 0x07, 0x07, 0x00, 0x07, 0x07, 0x00, 0x00 }, // '"'
    9. { 0x14, 0x7F, 0x7F, 0x14, 0x7F, 0x7F, 0x14, 0x00 }, // '#'
    10. { 0x24, 0x2E, 0x6B, 0x6B, 0x3A, 0x12, 0x00, 0x00 }, // '$'
    11. { 0x46, 0x66, 0x30, 0x18, 0x0C, 0x66, 0x62, 0x00 }, // '%'
    12. { 0x30, 0x7A, 0x4F, 0x5D, 0x37, 0x7A, 0x48, 0x00 }, // '&'
    13. { 0x04, 0x07, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00 }, // '''
    14. { 0x00, 0x1C, 0x3E, 0x63, 0x41, 0x00, 0x00, 0x00 }, // '('
    15. { 0x00, 0x41, 0x63, 0x3E, 0x1C, 0x00, 0x00, 0x00 }, // ')'
    16. { 0x08, 0x2A, 0x3E, 0x1C, 0x1C, 0x3E, 0x2A, 0x08 }, // '*'
    17. { 0x08, 0x08, 0x3E, 0x3E, 0x08, 0x08, 0x00, 0x00 }, // '+'
    18. { 0x00, 0x80, 0xE0, 0x60, 0x00, 0x00, 0x00, 0x00 }, // ','
    19. { 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00 }, // '-'
    20. { 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x00, 0x00 }, // '.'
    21. { 0x60, 0x30, 0x18, 0x0C, 0x06, 0x03, 0x01, 0x00 }, // '/'
    22. { 0x3E, 0x7F, 0x71, 0x59, 0x4D, 0x7F, 0x3E, 0x00 }, // '0'
    23. { 0x40, 0x42, 0x7F, 0x7F, 0x40, 0x40, 0x00, 0x00 }, // '1'
    24. { 0x62, 0x73, 0x59, 0x49, 0x6F, 0x66, 0x00, 0x00 }, // '2'
    25. { 0x22, 0x63, 0x49, 0x49, 0x7F, 0x36, 0x00, 0x00 }, // '3'
    26. { 0x18, 0x1C, 0x16, 0x53, 0x7F, 0x7F, 0x50, 0x00 }, // '4'
    27. { 0x27, 0x67, 0x45, 0x45, 0x7D, 0x39, 0x00, 0x00 }, // '5'
    28. { 0x3C, 0x7E, 0x4B, 0x49, 0x79, 0x30, 0x00, 0x00 }, // '6'
    29. { 0x03, 0x03, 0x71, 0x79, 0x0F, 0x07, 0x00, 0x00 }, // '7'
    30. { 0x36, 0x7F, 0x49, 0x49, 0x7F, 0x36, 0x00, 0x00 }, // '8'
    31. { 0x06, 0x4F, 0x49, 0x69, 0x3F, 0x1E, 0x00, 0x00 }, // '9'
    32. { 0x00, 0x00, 0x66, 0x66, 0x00, 0x00, 0x00, 0x00 }, // ':'
    33. { 0x00, 0x80, 0xE6, 0x66, 0x00, 0x00, 0x00, 0x00 }, // ';'
    34. { 0x08, 0x1C, 0x36, 0x63, 0x41, 0x00, 0x00, 0x00 }, // '<'
    35. { 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x00, 0x00 }, // '='
    36. { 0x00, 0x41, 0x63, 0x36, 0x1C, 0x08, 0x00, 0x00 }, // '>'
    37. { 0x02, 0x03, 0x51, 0x59, 0x0F, 0x06, 0x00, 0x00 }, // '?'
    38. { 0x3E, 0x7F, 0x41, 0x5D, 0x5D, 0x1F, 0x1E, 0x00 }, // '@'
    39. { 0x7C, 0x7E, 0x13, 0x13, 0x7E, 0x7C, 0x00, 0x00 }, // 'A'
    40. { 0x41, 0x7F, 0x7F, 0x49, 0x49, 0x7F, 0x36, 0x00 }, // 'B'
    41. { 0x1C, 0x3E, 0x63, 0x41, 0x41, 0x63, 0x22, 0x00 }, // 'C'
    42. { 0x41, 0x7F, 0x7F, 0x41, 0x63, 0x3E, 0x1C, 0x00 }, // 'D'
    43. { 0x41, 0x7F, 0x7F, 0x49, 0x5D, 0x41, 0x63, 0x00 }, // 'E'
    44. { 0x41, 0x7F, 0x7F, 0x49, 0x1D, 0x01, 0x03, 0x00 }, // 'F'
    45. { 0x1C, 0x3E, 0x63, 0x41, 0x51, 0x73, 0x72, 0x00 }, // 'G'
    46. { 0x7F, 0x7F, 0x08, 0x08, 0x7F, 0x7F, 0x00, 0x00 }, // 'H'
    47. { 0x00, 0x41, 0x7F, 0x7F, 0x41, 0x00, 0x00, 0x00 }, // 'I'
    48. { 0x30, 0x70, 0x40, 0x41, 0x7F, 0x3F, 0x01, 0x00 }, // 'J'
    49. { 0x41, 0x7F, 0x7F, 0x08, 0x1C, 0x77, 0x63, 0x00 }, // 'K'
    50. { 0x41, 0x7F, 0x7F, 0x41, 0x40, 0x60, 0x70, 0x00 }, // 'L'
    51. { 0x7F, 0x7F, 0x0E, 0x1C, 0x0E, 0x7F, 0x7F, 0x00 }, // 'M'
    52. { 0x7F, 0x7F, 0x06, 0x0C, 0x18, 0x7F, 0x7F, 0x00 }, // 'N'
    53. { 0x1C, 0x3E, 0x63, 0x41, 0x63, 0x3E, 0x1C, 0x00 }, // 'O'
    54. { 0x41, 0x7F, 0x7F, 0x49, 0x09, 0x0F, 0x06, 0x00 }, // 'P'
    55. { 0x1E, 0x3F, 0x21, 0x71, 0x7F, 0x5E, 0x00, 0x00 }, // 'Q'
    56. { 0x41, 0x7F, 0x7F, 0x09, 0x19, 0x7F, 0x66, 0x00 }, // 'R'
    57. { 0x26, 0x6F, 0x4D, 0x59, 0x73, 0x32, 0x00, 0x00 }, // 'S'
    58. { 0x03, 0x41, 0x7F, 0x7F, 0x41, 0x03, 0x00, 0x00 }, // 'T'
    59. { 0x7F, 0x7F, 0x40, 0x40, 0x7F, 0x7F, 0x00, 0x00 }, // 'U'
    60. { 0x1F, 0x3F, 0x60, 0x60, 0x3F, 0x1F, 0x00, 0x00 }, // 'V'
    61. { 0x7F, 0x7F, 0x30, 0x18, 0x30, 0x7F, 0x7F, 0x00 }, // 'W'
    62. { 0x43, 0x67, 0x3C, 0x18, 0x3C, 0x67, 0x43, 0x00 }, // 'X'
    63. { 0x07, 0x4F, 0x78, 0x78, 0x4F, 0x07, 0x00, 0x00 }, // 'Y'
    64. { 0x47, 0x63, 0x71, 0x59, 0x4D, 0x67, 0x73, 0x00 }, // 'Z'
    65. { 0x00, 0x7F, 0x7F, 0x41, 0x41, 0x00, 0x00, 0x00 }, // '['
    66. { 0x01, 0x03, 0x06, 0x0C, 0x18, 0x30, 0x60, 0x00 }, // backslash
    67. { 0x00, 0x41, 0x41, 0x7F, 0x7F, 0x00, 0x00, 0x00 }, // ']'
    68. { 0x08, 0x0C, 0x06, 0x03, 0x06, 0x0C, 0x08, 0x00 }, // '^'
    69. { 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80 }, // '_'
    70. { 0x00, 0x00, 0x03, 0x07, 0x04, 0x00, 0x00, 0x00 }, // '`'
    71. { 0x20, 0x74, 0x54, 0x54, 0x3C, 0x78, 0x40, 0x00 }, // 'a'
    72. { 0x41, 0x7F, 0x3F, 0x48, 0x48, 0x78, 0x30, 0x00 }, // 'b'
    73. { 0x38, 0x7C, 0x44, 0x44, 0x6C, 0x28, 0x00, 0x00 }, // 'c'
    74. { 0x30, 0x78, 0x48, 0x49, 0x3F, 0x7F, 0x40, 0x00 }, // 'd'
    75. { 0x38, 0x7C, 0x54, 0x54, 0x5C, 0x18, 0x00, 0x00 }, // 'e'
    76. { 0x48, 0x7E, 0x7F, 0x49, 0x03, 0x02, 0x00, 0x00 }, // 'f'
    77. { 0x98, 0xBC, 0xA4, 0xA4, 0xF8, 0x7C, 0x04, 0x00 }, // 'g'
    78. { 0x41, 0x7F, 0x7F, 0x08, 0x04, 0x7C, 0x78, 0x00 }, // 'h'
    79. { 0x00, 0x44, 0x7D, 0x7D, 0x40, 0x00, 0x00, 0x00 }, // 'i'
    80. { 0x60, 0xE0, 0x80, 0x80, 0xFD, 0x7D, 0x00, 0x00 }, // 'j'
    81. { 0x41, 0x7F, 0x7F, 0x10, 0x38, 0x6C, 0x44, 0x00 }, // 'k'
    82. { 0x00, 0x41, 0x7F, 0x7F, 0x40, 0x00, 0x00, 0x00 }, // 'l'
    83. { 0x7C, 0x7C, 0x18, 0x38, 0x1C, 0x7C, 0x78, 0x00 }, // 'm'
    84. { 0x7C, 0x7C, 0x04, 0x04, 0x7C, 0x78, 0x00, 0x00 }, // 'n'
    85. { 0x38, 0x7C, 0x44, 0x44, 0x7C, 0x38, 0x00, 0x00 }, // 'o'
    86. { 0x84, 0xFC, 0xF8, 0xA4, 0x24, 0x3C, 0x18, 0x00 }, // 'p'
    87. { 0x18, 0x3C, 0x24, 0xA4, 0xF8, 0xFC, 0x84, 0x00 }, // 'q'
    88. { 0x44, 0x7C, 0x78, 0x4C, 0x04, 0x1C, 0x18, 0x00 }, // 'r'
    89. { 0x48, 0x5C, 0x54, 0x54, 0x74, 0x24, 0x00, 0x00 }, // 's'
    90. { 0x00, 0x04, 0x3E, 0x7F, 0x44, 0x24, 0x00, 0x00 }, // 't'
    91. { 0x3C, 0x7C, 0x40, 0x40, 0x3C, 0x7C, 0x40, 0x00 }, // 'u'
    92. { 0x1C, 0x3C, 0x60, 0x60, 0x3C, 0x1C, 0x00, 0x00 }, // 'v'
    93. { 0x3C, 0x7C, 0x70, 0x38, 0x70, 0x7C, 0x3C, 0x00 }, // 'w'
    94. { 0x44, 0x6C, 0x38, 0x10, 0x38, 0x6C, 0x44, 0x00 }, // 'x'
    95. { 0x9C, 0xBC, 0xA0, 0xA0, 0xFC, 0x7C, 0x00, 0x00 }, // 'y'
    96. { 0x4C, 0x64, 0x74, 0x5C, 0x4C, 0x64, 0x00, 0x00 }, // 'z'
    97. { 0x08, 0x08, 0x3E, 0x77, 0x41, 0x41, 0x00, 0x00 }, // '{'
    98. { 0x00, 0x00, 0x00, 0x77, 0x77, 0x00, 0x00, 0x00 }, // '|'
    99. { 0x41, 0x41, 0x77, 0x3E, 0x08, 0x08, 0x00, 0x00 }, // '}'
    100. { 0x02, 0x03, 0x01, 0x03, 0x02, 0x03, 0x01, 0x00 }, // '~'
    101. };
    102. #endif


    Beispiel:

    running_text.ino

    C-Quellcode

    1. #include <MAX7219.h> //The MAX7219 8x8 LED matrix shield access provider
    2. #include <MAX7219FONT.h> //The font for the 8x8 LED matrix
    3. //Port Definitions
    4. const unsigned int MAX7219_pinCLK = 8;
    5. const unsigned int MAX7219_pinCS = 7;
    6. const unsigned int MAX7219_pinDIN = 6;
    7. //LED shield interface object and state
    8. MAX7219 ledshield(MAX7219_pinCLK, MAX7219_pinCS, MAX7219_pinDIN);
    9. void setup()
    10. {
    11. ledshield.initialize();
    12. }
    13. const char text[] = "Hallo Welt! ";
    14. unsigned int i=0;
    15. unsigned int j=0;
    16. void loop()
    17. {
    18. for(i=0; i<strlen(text); i++) //Enumerate letters
    19. {
    20. for(j=0; j<=7; j++) //Enumerate rows of current letter
    21. {
    22. ledshield.state.push(3, MAX7219FONT[text[i]-32][j]); //push row in buffer and correct letter orientation
    23. ledshield.present();
    24. delay(80);
    25. }
    26. }
    27. }


    Und ein kleines .NET-Programm um eigene Buchstaben oder Symbole/Muster zu definieren: MAX7219_8X8LED_HELPER.zip


    Viel Spaß und Erfolg!
    SᴛᴀʀGᴀᴛᴇ01
    @gfcwfzkm
    @StarGate01
    Der MAX7219/MAX7221 sieht zwar super aus, aber leider ist der nur für 5 Volt geeignet. Die LEDs benötigen aber ~24 Volt.
    Ich habe hier noch was gefunden. Aber weil ich, was Halbleiter betrifft, nicht so auf Zack bin, weiß ich nicht genau, welche konkreten Bauteile ich hier verwenden sollte.
    "Luckily luh... luckily it wasn't poi-"
    -- Brady in Wonderland, 23. Februar 2015, 1:56
    Desktop Pinner | ApplicationSettings | OnUtils
    Die Anoden zu schalten ist technisch eine relativ große Herausforderung.
    Du könntest P-Channel FETs nehmen (oder PNP-BJTs), aber diese sind vergleichsweise teuer und immer noch unhandlich (vorallem zu programmieren).

    Ansich wäre für solch eine LED Matrix ein riesiger Verhau aus MOSFET-Treiber ICs die richtige Lösung, aber auch eher unschön.

    Die Lösung für dich wäre wahrs. P-Channel MOSFETs und die MAX7219 (nicht die 7221!) zu kaufen, die Gates der MOSFETs auf VCC der LEDs mit nem Pull-Up hochzuziehen und dann vom MAX7219 auf GND "runterziehen" zu lassen, sodass der PNP einschaltet wenn gefordert.
    So müsstest du eig. die Anodentreiber halbwegs ordentlich hinbekommen.
    Die Kathoden solltest du eig. direkt an die 7219's anschließen können.

    Viele Grüße,
    Manawyrm

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Manawyrm“ ()

    Will man die LED einzeln ansteuern, wird es ein heftiger Verhau aus Treiber-Transistoren. Daran führt nun mal kein Weg vorbei. Aber: Da die LED meist so um die 20mA ziehen, können diese recht klein ausfallen. Es gibt auch passende Treiber-ICs, die 8 solcher Transistoren beinhalten, sowohl in Bipolar (NPN, PNP) als auch als FET-Ausführung.

    Vielleicht kannst du die LED auch gruppieren (7-Segment-Anzeige) - dann genügt je Segment ein Treiber-Transistor, der dann aber natürlich fetter ausfallen muß (8 LED á 20mA = 160mA).
    @OlafSt
    Jo. Bin draufgekommen, dass ich die Anoden von je zwei Zeilen (also 8 Segmenten) zusammenschalten und dann "quer" die Kathoden zusammenhängen kann:

    Sieht dann genau wie eine 8x8 LED Matrix aus.

    @Manawyrm
    Wenn ich das richtig verstehe, ist das Problem mit PNP-Transistoren an den Anoden, dass die LEDs bei logisch 1 aus sind, weil die Basis auf dem gleichen Potenzial ist, wie... ääh... der Pin mit dem Pfeil, der zur Basis zeigt :D ... Emitter! Der Emitter war's.
    Das wäre für mich beim Programmieren weniger das Problem. Viel eher frag ich mich, wie der MAX7219 die Ausgänge schaltet. Wenn nämlich zwischen zwei Zeilen eine kleine Pause ist, bei der alle Segmente auf logisch 0 geschaltet sind, dann werden in dieser kurzen Zeit alle LEDs eingeschaltet.
    Ein weiteres Problem, das ich da sehe: Wenn der Segment-Ausgang des MAX7219 logisch 1 ist, dann liegt da eine Spannung von ca. 5 Volt an. Ich bezweifle aber, dass das (trotz Pull-Up-Widerstand auf 24 Volt) genug ist, um den P-Kanal MOSFET zum Sperren zu bringen:

    Hier bei Figure 2. Current boosting the digit drive using an LED supply 10V or higher. wird eine Schaltung gezeigt, laut der das funktionieren sollte.

    Und dann hab ich da noch eine Frage. Wie sieht das korrekte Symbol für P-Kanal MOSFETs aus? Anscheinend gibt es da jede Menge. Ich hab jetzt temporär BJT-Symbole verwendet.
    Bilder
    • Unbenannt2.png

      35,91 kB, 815×770, 220 mal angesehen
    "Luckily luh... luckily it wasn't poi-"
    -- Brady in Wonderland, 23. Februar 2015, 1:56
    Desktop Pinner | ApplicationSettings | OnUtils
    Das korrekte Symbol für P-Channel MOSFETs ist das zweite. Gebräuchlich sind im Normalfall nur Anreicherungstypen.

    ​Wenn der Segment-Ausgang des MAX7219 logisch 1 ist, dann liegt da eine Spannung von ca. 5 Volt an. Ich bezweifle aber, dass das (trotz Pull-Up-Widerstand auf 24 Volt) genug ist, um den P-Kanal MOSFET zum Sperren zu bringen:

    Ja, bei genauerem Nachdenken ist das nicht ganz so toll, weil da ja dann 24 Volt auf dem Pin anliegen. Urg.

    Meine nächst komplexere Lösung wäre dann auch schon sehr ähnlich der Figure 2. Solltest du wohl so übernehmen...
    Das ganze wird so, wie gezeichnet, eh nicht funktionieren. Du hast die +24V über einen Widerstand an die +5V geklemmt, was automatisch zu einem dauerhaften Strom vom +24V zum +5V-Anschluß sorgt. Die Basis des PNP ist damit stets auf +24V gelegt und das ganze funktioniert nicht. Davon abgesehen knüppelst du die 24V in den MAX-Ausgang, was der auf sicher nicht lustig finden wird ;)

    Ich persönlich bevorzuge NPN-Transistoren, mit denen schaltet man die Masse (anders als bei PNP, wo VCC geschaltet wird). Ergo: Ausgang des MAX-ICs an die Basis des NPN (Vorwiderstand nicht vergessen !). +24V über LED-Vorwiderstand an die LED, Masseanschluß der LED an Kollektor des Transistors. Emitter direkt an Masse. Liefert der MAX eine logische 1 (=+5V) schaltet der NPN durch und es fließt ein Strom von +24V über LED-R und LED durch den NPN zur Masse: die LED leuchtet. Liefert der MAX eine 0 (ergo Masse), ist der NPN gesperrt -> LED duster.
    Ersetzt die Transistoren durch N-Kanal MOSFETs und der Widerstand dort änderst du zu einem Pull-Down Widerstand. Unten kannst du dann nochmals N-Kanal MOSFETS mit Pulldown widerstände nehmen. Es gibt solche die man mit 5V ansteuern kann.

    mfg

    gfc