Copying structs by bytes:

• At first I had it so that I was setting pointers for each struct and then casting the pointers into a char*.   Putting a & in front of the struct name returns the address of the struct eliminating the need for the extra pointers.  ex: char* test = (char*) originalData
• Another thing that was wrong was that I was getting the size by measuring the length of the character array.  This worked fine when I was using unsigned chars as data members but when I changed it to int things broke.  The proper way to do it seems to be sizeof(structName).  This has worked consistently no matter what the data types were including non-primitive string type.  (NOTE:  to use string with printf, the c_str() method needs to be called to format it properly.)
• sizeof(somePtr) seems to always return 4 bytes which I assume is the size of the memory address.  This may be why we were having trouble with sizeof because we were taking the size of a char*, if we were looking for a sizeof(char[]) it would have probably worked.  I tried to find the sizeof the contents of the pointer and it also said 4 bytes.  This might have been because the address it was pointing to was type int.  Either way it wasn’t giving the full size of the allocation which was 12 as found by sizeof(struct) which makes sense considering it had 3 ints in it.

ComMgr:

• It seems I can put the memory address into a void pointer so that send data won’t have to worry about what type it is.  The size will also have to be passed in because its hard to get the size from the pointer.
• The type needs to be identified so the arduino will know what to do with the data.
• Just noticed WriteFile is taking the address of the object and the next parameter is the size.  So I guess you can pass anything you want into it as long as you know the size.
• Have it working with the objectPtr and the size but its still only working with one byte.

Arduino

• Phil recommended that there be 4 states for the arduino:  Ready, Reading, Converting, and Writing.  We may need a 5th for executing once it has to actually do stuff but for communications this should do.  He also suggested putting 4 leds and indicators of each state so we don’t have to depend on the console to tell us during the debugging phase.
• Had to change the write method on the arduino side to print for whatever reason.  Have to look into why this suddenly stopped working tomorrow.

Start: 10:00

Com Console:

• Added StringEnum class because it is useful for keeping track of valid commands, responses, states, and serials.  Made it inherits from Printable so it will be able to print to console.
• Fixed the compiling errors in Command, Response, and State
• The methods for serial tracking as well as some other methods make these classes superior to the structs.

ComMgr:

• Realized I was still using the hard coded com port.  Making it so it can use a number that was passed in was a bit tricky.  CreateFile uses wchar_t which are not easy to manipulate with sprintf.  CreateFileA use LPCSTR which works with standard character arrays.  sprintf_s allows you to manipulate a standard character array as opposed to a char pointer array
• Added a resetPort method.  I think its better that you do it manually after making all the setting changes.  Also added changePort method.

char portNum[32];
sprintf_s(portNum, sizeof(portNum),”COM%d:”, _port);
hCom = CreateFileA(portNum, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);

• Added run function so the send and receive methods didn’t need to be called individually.
• Still trying to find a tutorial for transmitting large objects.  Want to get this working before I start working on the ArduinoController and tweaking the command, response, and  state classes.

Notes On Using pointers:

• Phil showed me how to use pointers to copy a string byte by byte to a memory location allocated to integers.
• Create a pointer of type x(in this case a char*)
• Create another pointer and set it equal to this pointer.  This sets it to the beginning of the memory allocation.
• Create another allocation of memory to be copied to(In this case it was an array of 256 integers)
• Create another pointer and set it to the memory address of the new allocation.  Cast this to the type of the original data(in this case char)
• Start a loop which runs til it reaches the size of the original allocation
• Within the loop, set the contents of the new allocation equal to the contents of the old then increment both pointers.
• After the loop, set reset the new allocations pointer back to the beginning of the memory address.

Going to  try doing this with different data types, arrays, and structs tomorrow.

End: 6:30

Start: 10:45

Amplifier:

• Assembled the amplifier from sparkfun
• Edited a arduino sketch that might be useful for testing to see if A. how well the small amplifer controls the larger one and B. test both types of exciters
• Have not tested yet

ComMgr:

• Did a simple one byte pass-response to make sure everything was working thus far
• Added some test structures which will later be part of ArduinoController once I know its working
• Add command response and state classes but are not using them yet.  It might be better to use structs on the arduino side, so I am not sure if these will be used once everything is working.

End: 6:45