AVR Freaks

You guys with your statics are crazy.  I think some of you confuse new with malloc().  Don't do that.  new is an operator that can be associated with anything in the operator function. 

Keep in mind if you learned to program in school, your teacher was probably a grade school dropout that couldn't get a real job.

An AVR starts with everything accessible.

Some Cortex-M0 chips start with nothing running.   e.g. no clock to GPIO

So constructor()s need to be very careful on those particular ARM chips.   e.g. Freescale

I have no idea how Atmel Cortex chips work,   or even the UC32 range.

So there is definitely a requirement for different types of initialisation.

David.

Also, I'd rate the ability to create complex data objects as easily as C can create variables (including initialized globals) to be a really important aspect of an object-oriented language.

I think some of you confuse new with malloc().  Don't do that.  new is an operator that can be associated with anything in the operator function. 

That's sort of a scary thought.  Do you have an example of when that it is a good thing?  (and I thought that was the essence of the original complaint - by having a constructor do MORE than memory allocation and initialization, you run the risk of doing things that aren't actually available at that time.)

New calls whatever you want it to call.  It's only requirement is that it return the address of the object you new.   New is good.  Much better than static classes.   malloc() has little or no use in embedded code.

If you want to allocate from the heap and later return it to the heap, you need malloc() and free().  You also need your head examined if you are writing embedded code.

Here is an example of a class that contains it's own new operator function.  This is my Reset_regs class for the Xmega.  Notice the new operator function at the end of the class.  It simply returns the address of the Xmega's reset registers.   I can new this thing a million times.  It doesn't use up any heap memory.   It just returns the address.

Note, I'm not suggesting you do this for I/O registers unless you want to.  The code for flipping bits in the registers is likely to be less efficient than using the more orthodox methods like ASF for instance.

A new operator function in a class might also be useful for other reasons.  Maybe you want to allocate memory for it, but from somewhere other than the heap.  Maybe shared memory, etc.

As far as using new to get the address of a static class, I don't know.  The static class would need to return it's own address.  I suppose that would be the address of it's first data member.  Experimentation would be required as far as I'm concerned.  If you are smart enough to know it's a silly idea, so be it.

#ifndef RESET_REGS_H
#define RESET_REGS_H
#include <stdlib.h>     // for size_t in new and delete operators
#include <avr/io.h>
#include "myTypes.h"
#include "cpu_regs.h"


class Reset_regs   {
friend class Reset_simulator;
friend class Reset_mon;
friend class Jump_to_bootloader_mon;

private:
   union Status   {
      struct  {
         Register power_on                 : 1;  // PORF
         Register external                 : 1;  // EXTRF
         Register brownout                 : 1;  // BORF
         Register watchdog                 : 1;  // WDRF
         Register PDI                      : 1;  // PDIRF
         Register software                 : 1;  // SRF
         Register reserved                 : 2;  // Reserved
         } bits;
      u_int8 byte;
   };

   volatile Status status;                             // STATUS  0x00


   struct Control   {
      Register software                    : 1;  // SWRST
      Register reserved                    : 7;  // Reserved
      };

   volatile Control control;                           // CTRL    0x01


public:


   void Do_software_reset()   {
      Cpu_regs* cpu_regs_p = new Cpu_regs;
      cpu_regs_p->Disable_configuration_change_protection();
      control.software = true;
      }


   bool Is_software_reset()   {
      return status.bits.software;
      }


   void Clear_software_reset()   {
      Status my_status;
      my_status.byte = 0;
      my_status.bits.software = true;
      status.byte = my_status.byte;
      }


   void Clear_resets(u_int8 which)   {
      which ^= status.byte;
      status.byte = which;
      }


   void* operator new(size_t objsize)   {
      return (void*)_SFR_ADDR(RST);        // assign actual memory location of the registers
      }

   };
#endif

Yes lots of news and no deletes.  Do you delete your statics?

The difference is the constructors run in the proper order when I start up the program.  So you say, yes but my constructors don't do much, except initialize data members (I hope).  Okay, whatever floats your boat.

Also it eliminates all those globals.  It seems more modular the way I do it.

I like to be able to control what my program contains just by commenting out a new statement.  I can also pass the address of one class to another class easily at startup.

For instance I have this line in the startup class for my A3BU Xplained board.

      new Parse_in_message(new Usart_e0);

Nobody knows or cares where the Usart_e0 class is except my Parse_in_message class.

If I run on another board where the USART is on d0, I just change Usart_e0 to Usart_d0.

Maybe some of it depends on how our brains are wired.  Mine used to be wired for C but after a lot of neurological stress, it's now wired for C++. 

That is the way it is done, or should be, when writing an embedded system running on a PC also.  In the case of the PC,  malloc() is used at startup.  After that, no mallocs, no deletes, no heap churning allowed.

When does the program construct the 50-odd message handlers?

I'm looking at doing something similar, and was just wondering if you had a clean way of doing all of those initializations, or if there's just 50 "new" calls in a row.

Thanks

Paul

Ok, thanks much.

I didn't remember how I did it, so I looked.  The switcher uses a fixed size table.  If the table is full, it doesn't add any more entries.   When a message with unknown type (not in the table) is received, the switcher sends an error message back to the sender.

There are several ways you could do it.

You could do message types this way:

enum   {

   A_msg_type,

   Another_msg_type,

   Yet_another_msg_type,

   .

   .

   .

   One_more_msg_type,

   LAST_MSG_TYPE,

   };

This would number the types from zero.   If you always had LAST_MSG_TYPE at the end, the message switcher could use this to size the table.  With this method, the message type could be used as an index to fetch the InBox pointer.

You could use a linked list and new a list member for each msg type.  This would use more memory than other methods.

Question: if I redefine "new()" like this, or otherwise use malloc to allocate memory for a new class, how does the "this" pointer get set?

What I would like is to have an array of data structs, with one of the elements being a (void *) labeled "additionalProcessing". When the array is initialized, additionalProcessing is set to an object that handles particular elements in the data struct. Normally I'd create the additionalProcessing object with new, but the AVR GCC new function is not implemented. Any suggestions gratefully welcomed.