Probleme mit ATMEGA16

[Lars U. (lars_u)]

Hallo,
ich habe heute meine Schaltung für meinen LED Cube fertig gebaut und 
binn auf ein paar Probleme gestoßen.

1. Ist 2,8 A zu viel für den µC ? (5V)
2. Ich habe ein Programm aus einem Forum drauf gespielt, seite dem kann 
ich ihn leider nicht mehr neu Programmieren da er den gesamten Strom vom 
Progger zieht (SMD LED auf dem Progger erlischt)
3. Mein µC wird heiß , kann das an 1. liegen ?

Leider habe ich die Vermutung das ich den µC gehimmelt habe.
Werde mir wohl mal ein anderes Programm raussuchen , vorallem eins für 
16MHz Crystal.

[Oliver (Gast)]

1. Ja
2. ;)
3. Ja

Oliver

[Martin V. (oldmax)]

Hallo Lars
Schön, das du eine Heizung gebaut hast. Wird ja jetzt bald Winter und da 
ist es ja nicht so verkehrt, etwas gegen die Kälte zu haben. Ein 
Elektroniker würde ja jetzt anfangen, nachzuschauen, wo der Strom 
entsteht und vielleicht mithilfe von Skizzen die Wege ergründen. Daher 
vermute ich mal, das du mal grade weißt, das Ampere das Maß für 
elektrischen Strom ist. Nun ja, das ist ja schon mal etwas. Kommen wir 
zum eigentlichen Kern deines Problems. Um eines mal klarzustellen, nur 
mit einem Programm bekommst du den Rauch aus dem Chip nicht raus. Also 
davon wird ihm nicht warm und schon gar nicht heiß. Also liegt es an 
deiner Hardware. Vielleicht hast du ja die Vorwiderstände vor den LED's 
weggelassen oder Hochstrom-LED's benutzt und keine Treiber dafür 
vorgesehen. 2,8 A ist ja schon ne Menge Strom...
Also, nicht verzagen, fleißig messen und weniger fragen und wenn fragen, 
dann bitte mit entsprechender Info. Also Schaltplan, vielleicht 
Programm, damit ausgeschlossen werden kann, das Ausgänge direkt 
kurzgeschlossen sind. Übrigends, wenn du einen Ausgang schnell von Low 
nach High hin und her schaltest, sollte da kein Kondensator 
angeschlossen sein. Je nach Kapazität wirkt das auch wie ein 
Kurzschluss.
Gruß oldmax

[Lars U. (lars_u)]

Martin Vogel schrieb:
> Hallo Lars
> Schön, das du eine Heizung gebaut hast. Wird ja jetzt bald Winter und da
> ist es ja nicht so verkehrt, etwas gegen die Kälte zu haben. Ein
> Elektroniker würde ja jetzt anfangen, nachzuschauen, wo der Strom
> entsteht und vielleicht mithilfe von Skizzen die Wege ergründen. Daher
> vermute ich mal, das du mal grade weißt, das Ampere das Maß für
> elektrischen Strom ist. Nun ja, das ist ja schon mal etwas. Kommen wir
> zum eigentlichen Kern deines Problems. Um eines mal klarzustellen, nur
> mit einem Programm bekommst du den Rauch aus dem Chip nicht raus. Also
> davon wird ihm nicht warm und schon gar nicht heiß. Also liegt es an
> deiner Hardware. Vielleicht hast du ja die Vorwiderstände vor den LED's
> weggelassen oder Hochstrom-LED's benutzt und keine Treiber dafür
> vorgesehen. 2,8 A ist ja schon ne Menge Strom...
> Also, nicht verzagen, fleißig messen und weniger fragen und wenn fragen,
> dann bitte mit entsprechender Info. Also Schaltplan, vielleicht
> Programm, damit ausgeschlossen werden kann, das Ausgänge direkt
> kurzgeschlossen sind. Übrigends, wenn du einen Ausgang schnell von Low
> nach High hin und her schaltest, sollte da kein Kondensator
> angeschlossen sein. Je nach Kapazität wirkt das auch wie ein
> Kurzschluss.
> Gruß oldmax

Ich lerne vieles in der Schule und beherrsche ein wenig Grundwissen.
Mein problem ist auch dass, das Programm für ein 14,7xxxMHz Quarz ist.
Ich habe allerdings einen 16MHz.

Vorwiderstand ist bei jeder LED dabei, der Strom an PIN 10/11 und 30/31 
kommt auch richtig an, nur eben etwas zu groß (2,8A / 5V).

Ich werde mal einen anderen 7805 einsetzen um ca 1A zu haben.

Leider kann ich meinen ATMEGA16 nicht mehr neu programmieren da er wen 
ich ihn an den Progger anschließe , dieser keinen Strom mehr hat (Die 
LED auf ihm erlischt langsam). Habe eben schon 2 neue gekauft.


Die LED's haben auch alle den richtigen Widerstand un funktionieren 
einwandfrei auf meinem Breadboard.

[Peter D. (peda)]

Lars U. schrieb:
> Leider habe ich die Vermutung das ich den µC gehimmelt habe.

Ja.
Man nimmt ja auch zur Inbetriebnahme kein Netzteil, was 2,8A kann.
Vermutlich hast Du einen Schaltungsfehler, d.h. ein neuer MC wird auch 
sofort durchbrennen.

Der MC braucht max 20mA, d.h. ein Netzteil mit Strombegrenzung 100mA 
wäre richtig.
Erst wenn man die LEDs anklemmt, kann man die Strombegrenzung höher 
drehen.

[Martin V. (oldmax)]

Hi
Schön, das du mich zittierst, aber mir scheint, ich muss da noch ein 
wenig nachhaken:
Mach von deiner Schaltung eine Skizze. Nicht deine Vorlage, sondern 
deinen Aufbau brauchen wir, wenn unsere Aussagen zutreffen sollen. Denn: 
Ein Programm treibt nicht den Strom hoch ! Auch die MHz sind nicht dein 
Problem, der Atmega16 kann durchaus 16 MHz.
So richtig versteh ich deine Beschreibung auch nicht: Der 7805 wird 
jetzt auf 1 A ausgelegt? Welcher hat denn die fast 3 A geleistet, ohne 
Schweißperlen zu bekommen? Bist du dir sicher, das der Controller 
wirklich nur die für ihn gesunden 5 V bekommen hat ? Du weißt, wer 
zuviel isst wird dick und Controller tun das manchmal auch, wenn die 
Versorgung zu üppig ist. Außerdem, wie hoch war der Strom zu den LED's ? 
Hast du da mal gemessen? Soweit ich das von hier aus beurteilen kann, 
ist nur ein Schaltungsfehler möglich, den Controller derart heiß zu 
machen.... ich tippe mal "Spannung zu hoch "
Gruß oldmax

[Lars U. (lars_u)]

http://obrazki.elektroda.pl/5944479000_1337370257.png
Das ist die Schaltung, ich habe mir bei Conrad einen 7805 für 2A und 
einen für 1A gekauft , stimment tuht das aber nicht wirklich. Denn bei 
dem 1A bekomme ich nur 0.18 raus.

Die LED bekommen garkein saft , am µC ist ca 5.08V auf beiden seiten.

[Lars U. (lars_u)]

Ich habe jetzt einen neuen µC mit eigenem Code und richtigem Crystal.
Leider wird er immernoch heiß, ich habe zur sicherheit die Knöpfe am µC 
abgelötet und alles andere überprüft. (Wusste nich wie man sie 
anschließt, konnte es nur aus anderen Schaltung deuten.

Heute werde ich mal versuchen an einen 7805 zu kommen bei dem ich 1A 
raus bekomme.

[Carsten R. (kaffeetante)]

Aua.

Der Regler liefert nicht 1 A. Er liefert bis zu 1 A. Er liefert 5 V 
und der Verbraucher nimmt soviel er braucht. Der Verbraucher bestimmt 
den Strom! Erst wenn die 1 A überschritten werden oder der Regler zu 
heiß wird nimmt dieser Einfluß auf den Stromfluß. Dann geht aber auch 
die Spannung in die Knie. Es gibt Spannugsregler und es gibt 
Stromregler. Es gibt aber keine Regler die beides gleichzeitig Regeln, 
sondern höchstens begrenzen.

[Nicolas S. (Gast)]

Lars U. schrieb:
> einen 7805 für 2A und
> einen für 1A gekauft , stimment tuht das aber nicht wirklich. Denn bei
> dem 1A bekomme ich nur 0.18 raus.

Hmmmm.....ich fürchte, nach der Bemerkung gibt es nichts mehr, was einen 
Shitstorm im Forum noch aufhalten könnte.

Mein Rat: Beschäftige Dich noch einmal mit den Grundlagen der 
Elektrotechnik und Elektronik. Mit Spannungen, Strom und Widerständen. 
Und mit LED-Vorwiderständen.

Und dann zieh den ATmega aus dem Sockel und such nach dem Fehler auf der 
Leiterplatte - ohne Betriebsspannung mit dem Durchgangsprüfer, mit 5V 
Betriebsspannung mit dem Voltmeter. Mach Dir vorher klar, welche 
Spannung an welchem Punkt laut Schaltplan sein sollte und miß nach. Wenn 
Du keinen Schaltplan hast ist es jetzt an der Zeit einen zu zeichnen. 
Das Fehlen eines Schaltplans gehört zu den Sachen, die eigentlich immer 
bereut werden.

Versuch anschließend die LEDs mit Drahtbrücken im Sockel einzeln zum 
leuchten zu bringen. Kurz: such den Fehler erst außerhalb des ATmegas, 
denn da wird mit Sicherheit einer sein. Vielleicht nicht ausschließlich. 
Aber da sein wird er - vermutlich ein Kurzschluß zwischen Leiterbahnen.

Viele Grüße
Nicolas

[Lars U. (lars_u)]

Naja das mit dem Strom lag am Elko ...
Einen Schaltplan kann man in einem Post weiter oben sehen ...
Der Strom am eingang stimmt auch, er wird jetzt auch nicht mehr heiß.
Aber leider gibt er auf keinem Port strom, was er eigentlich tuen 
sollte.

[Freddy (Gast)]

>...habe zur sicherheit die Knöpfe am µC abgelötet

Was für Knöpfe?

[Lars U. (lars_u)]

Ich habe jetzt auch deinen Rat befolgt und es mit Kabelbrücken gemacht, 
funktioniert 1A.

http://obrazki.elektroda.pl/5944479000_1337370257.png
S1-4

[Dave C. (dave_chappelle)]

Ja, das wundert mich kein bisschen.
Wie willst du ohne Treiber so viele LEDs betreiben?

Von Programmierung hast du wohl keine Ahnung (Hilfe Programm ist für 
14.xx Quarz, habe aber nur einen 16Mhz Quarz). Stell dir vor, das kann 
man einstellen.

Und Mein 5V/1A Regler bringt nur 0.18A.. Hm komisch was.
Mach doch mal den Versuch: Hänge einen 1Megaohm Widerstand deinen 5V 
Regler, wenn dann 1A fliesst hast du die Physik ausgehebelt mein Lieber!

Gruss

[Lars U. (lars_u)]

Dave Chappelle schrieb:
> Von Programmierung hast du wohl keine Ahnung (Hilfe Programm ist für
> 14.xx Quarz, habe aber nur einen 16Mhz Quarz). Stell dir vor, das kann
> man einstellen.

Natürlich weiß ich das man das einstellen kann, allerdings hatte ich nur 
die HEX Datei ! Und habe eben alles nach dem Schaltplan oben gebaut.

>
> Und Mein 5V/1A Regler bringt nur 0.18A.. Hm komisch was.
> Mach doch mal den Versuch: Hänge einen 1Megaohm Widerstand deinen 5V
> Regler, wenn dann 1A fliesst hast du die Physik ausgehebelt mein Lieber!
>
> Gruss

Wusste ich nicht...

[Lars U. (lars_u)]

Alles funktioniert soweit, allerdings gibt der µC auf keinem Port Strom.

Hier mal den code den ich benutze, hauptsächlich geht es mir aktuell um 
die bootmsg welche leider nicht funktioniert :

// ############################################
// 
// 4x4x4 LED Cube project
// By Christian Moen 2008
// [e-mail]
// Lisence: GPL
//
// ############################################

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>

// Define USART stuff
// CPU speed and baud rate:
#define FOSC 16000000
#define BAUD 9600
// Are used to calculate the correct USART timings
#define MYUBRR (((((FOSC * 10) / (16L * BAUD)) + 5) / 10) - 1)


// Define masks used for status LEDs and input buttons.
#define LED_GREEN 0x01
#define LED_RED 0x02
#define BUTTON 0x08
// Define port used for status and input.
#define LED_PORT PORTB
#define BUTTON_PORT PORTB


// Define masks for the layer select.
#define LAYER1 0x80
#define LAYER2 0x40
#define LAYER3 0x20
#define LAYER4 0x10
#define LAYERS 0xf0 // All layers
#define LAYERS_R 0x0f // The inverse of the above.
#define LAYER_PORT PORTD

// Define LED grid ports
// Each of the grid ports are connected to two rows of leds.
// The upper 4 bits is one row, the lower 4 bits are one row.
#define GRID1 PORTC
#define GRID2 PORTA


void ioinit (void); // initiate IO on the AVR
void bootmsg (void); // blink some leds to indicate boot or reboot
void delay_ms (uint16_t x); // delay function used throughout the program
void led_red(unsigned char state); // led on or off
void led_green(unsigned char state);
void launch_effect (int effect); // effect program launcher

// *** Cube buffer ***
// The 3D image displayed on the cube is buffered in a 2d array 'cube'.
// The 1st dimension in this array is the Z axis of the cube.
// The 2nd dimension of the array is the Y axis.
// Each byte is a stripe of leds running along the X axis at the given
// Z and Y coordinates.
// Only the 4 lower bits are used, since the cube is only 4x4x4.
// This buffer design was chosen to have code compatability with a 8x8x8 cube.
// "volatile" makes the variables reachable from within the interrupt functions
volatile unsigned char cube[4][4];

// We sometimes want to draw into a temporary buffer so we can modify it
// before writing it to the cube buffer.
// e.g. invert, flip, reverse the cube..
volatile unsigned char tmpcube[4][4];

// What layer the interrupt routine is currently showing.
volatile unsigned char current_layer;

// Low level geometric functions
#include "draw.c"

// Static animation data
#include "frames.c"

// Fancy animations to run on the cube
#include "effect.c"


int main (void)
{
  // Initiate IO ports and peripheral devices.
  ioinit();
  
  // Indicate that the device has just booted.
  bootmsg();

  int x;
  int i;
  int z;

  // Set the layer to start drawing at
  current_layer = 0x00;
  
  // Enable interrupts to start drawing the cube buffer.
  // When interrupts are enabled, ISR(TIMER2_COMP_vect)
  // will run on timed intervalls.
  sei();

  // Main program loop.
  while (1)
  {
    for (i=0;i<13;i++)
    {
      launch_effect(i);
    }
    // Comment the loop above and uncomment the line below
    // if you want the effects in random order (produced some bugs.. )
    //launch_effect(rand()%13);
  }

}

// Launches one of those fancy effects.
void launch_effect (int effect)
{
  switch (effect)
  {
    // Lights all the layers one by one
    case 0:
      loadbar(1000);
      break;
      
    // A pixel bouncing randomly around
    case 1:
      // blink
      boingboing(150,500,0x03,0x01);
      break;
    
    // Randomly fill the cube
    // Randomly empty the cube
    case 2:
      fill(0x00);
      random_filler(100,1,500,1);
      random_filler(100,1,500,0);
      break;
    
    // Send voxels randomly back and forth the Z axis
    case 3:
      sendvoxels_rand_z(150,500,2000);
      break;
      
    // Spinning spiral
    case 4:
      effect_spiral(1,75,1000);
      break;
    
    // A coordinate bounces randomly around the cube
    // For every position the status of that voxel is toggled.
    case 5:
      // toggle
      boingboing(150,500,0x03,0x02);
      break;
    
    // Random raindrops
    case 6:
      effect_rain(20,5000,3000,500);
      break;
    
    // A snake randomly bounce around the cube.
    case 7:
      // snake
      boingboing(150,500,0x03,0x03);
      break;
      
    // Spinning plane
    case 8:
      effect_spinning_plane(1,50,1000);
      break;
    
    // set x number of random voxels, delay, unset them.
    // x increases from 1 to 20 and back to 1.
    case 9:
      random_2();
      break;
    
    // Set all 64 voxels in a random order.
    // Unset all 64 voxels in a random order.
    case 10:
      random_filler2(200,1);
      delay_ms(2000);
      random_filler2(200,0);
      delay_ms(1000);
      break;
      
    // bounce a plane up and down all the directions.
    case 11:
      flyplane("z",1,1000);
      delay_ms(2000);
      flyplane("y",1,1000);
      delay_ms(2000);
      flyplane("x",1,1000);
      delay_ms(2000);
      flyplane("z",0,1000);
      delay_ms(2000);
      flyplane("y",0,1000);
      delay_ms(2000);
      flyplane("x",0,1000);
      delay_ms(2000);
      break;
      
    // Fade in and out at low framerate
    case 12:
      blinky2();
      break;
  }
}

// ** Diagnostic led functions **

// Set or unset the red LED
void led_red(unsigned char state)
{
  if (state == 0x00)
  {
    LED_PORT &= ~LED_RED;
  } else
  {
    LED_PORT |= LED_RED;
  }
}

// Set or unset the green LED
void led_green(unsigned char state)
{
  if (state == 0x00)
  {
    LED_PORT &= ~LED_GREEN;
  } else
  {
    LED_PORT |= LED_GREEN;
  }
}


// Cube buffer draw interrupt routine
ISR(TIMER2_COMP_vect)
{

  // AND the reverse bitmask onto the layer port.
  // This disables all the layers. rendering all the leds off.
  // We don't want to see the cube updating.
  LAYER_PORT &= LAYERS_R;

  // Take the current 2D image at the current layer along the Z axis
  // and place it on the LED grid.
  GRID1 = (0x0f & cube[current_layer][0]) | (0xf0 & (cube[current_layer][1] << 4));
  GRID2 = (0x0f & cube[current_layer][2]) | (0xf0 & (cube[current_layer][3] << 4));

  // Enable the apropriate layer
  LAYER_PORT |= (0x01 << (7 - current_layer));

  // The cube only has 4 layers (0,1,2,3)
  // If we are at layer 3 now, we want to go back to layer 0.
  if (current_layer++ == 3)
    current_layer = 0;
}

void ioinit (void)
{
  // ### Initiate I/O
  
  // Data Direction Registers
  // Bit set to 1 means it works as an output
  // Bit set to 1 means it is an input
  DDRA = 0xff;  // Inner cube byte
  DDRB = 0xf7;  // ISP and 0-1: led. 3: button
  DDRC = 0xff;  // Outer cube byte
  DDRD = 0xff;  // Layer select
  
  // Set all ports OFF, and enable pull up resistors where needed.
  PORTA = 0x00;
  PORTC = 0x00;
  PORTB = 0x08; // Enable pull up button.
  PORTD = 0x00;

  // ### Initiate timers and USART

  // Frame buffer interrupt
  TCNT2 = 0x00;  // initial counter value = 0;
  TIMSK |= (1 << OCIE2); // Enable CTC interrupt
  
  // Every 1024th cpu cycle, a counter is incremented.
  // Every time that counter reaches 15, it is reset to 0,
  // and the interrupt routine is executed.
  // 14745600/1024/15 = 960 times per second
  // There are 4 layers to update..
  // 14745600/1024/15/4 = 240 FPS
  // == flicker free :)
  OCR2 = 15;       // interrupt at counter = 15
  TCCR2 = 0x05;     // prescaler = 1024
  TCCR2 |= (1 << WGM01);  // Clear Timer on Compare Match (CTC) mode


  // Initiate RS232
  // USART Baud rate: 9600
  UBRRH = MYUBRR >> 8;
  UBRRL = MYUBRR;
  // UCSR0C - USART control register
  // bit 7-6      sync/ascyn 00 = async,  01 = sync
  // bit 5-4      parity 00 = disabled
  // bit 3        stop bits 0 = 1 bit  1 = 2 bits
  // bit 2-1      frame length 11 = 8
  // bit 0        clock polarity = 0
  UCSRC  = 0b10000110;
  // Enable RS232, tx and rx
  UCSRB = (1<<RXEN)|(1<<TXEN);
  UDR = 0x00; // send an empty byte to indicate powerup.

}


// Blink the status LEDs a little to indicate that the device has just booted.
// This is usefull to see if an error is making the device reboot when not supposed to.
// And it looks cool.
void bootmsg (void)
{
  int i;
  LED_PORT |= LED_GREEN;
  for (i = 0; i < 2; i++)
  {
    // Blinky
    delay_ms(1000);
    LED_PORT &= ~LED_GREEN;
    LED_PORT |= LED_RED;
    // Blink
    delay_ms(1000);
    LED_PORT &= ~LED_RED;
    LED_PORT |= LED_GREEN;
  }
  delay_ms(1000);
  LED_PORT &= ~LED_GREEN;
}


// Delay function used in graphical effects.
void delay_ms(uint16_t x)
{
  uint8_t y, z;
  for ( ; x > 0 ; x--){
    for ( y = 0 ; y < 90 ; y++){
      for ( z = 0 ; z < 6 ; z++){
        asm volatile ("nop");
      }
    }
  }
}