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

start: 9:15

ComMgr:

• added set methods for all the properties involving the com port.  The constructor sets the defaults and each change will close and reopen the port to save the change.
• port numbers can now be passed in
• Set up toString to reflect what it should look like once everything is working.
• Setup a basic sketch for the arduino so when i figure out how to send data structures I can test it.

End: 6:03

Start: 9:30

Com Console:

• Removed parts from the monitor class and put them into the ComMgr and ArduinoController classes.
• Useful Windows console functions: http://msdn.microsoft.com/en-us/library/ms682073%28v=VS.85%29.aspx
• Added sizing to the constructor so that the buffer and windows size will be appropriate for the application.  It seems that the buffer size width and height must be in a certain ratio in order to work properly.
• Got multiple lines to be overwritten using SetConsoleCursorPosition to set it to (0,0).  At first I used std::system (“CLS”) to clear the screen, but this was flashy so the other way is better.

• Added an output array to receive data to be printed from other classes
• added Printable class so there is a common type for the print method to use
• removed test data and methods
• sprintf is used to format char* to a char* without printing it

Notes:

• malloc is prefered over calloc not exactly sure why besides it having less parameters and something about calloc zeroing everything.  Will need this when sending large objects over the usb wire.

End: 6:00

Start:  8:30

Com Monitor Console:

• r is for carriage return which makes the next line overwrite the previous.  If the string is shorter in length it will not clear all the extra characters.  Padding the data with zeros helps make sure the string stays the same length.  It is important to resize your console to fit the whole line or it will scroll the first line and go back to the beginning of the second line.
• Need to make another class to handle actual communications instead of having it in the monitor class as it is now.
• getch() halts the loop so its not good for user input in this case.  I forget which one to use instead.

Notes for ComManager class:

• Init should be moved into this class
• sendData and recieveData should also be moved and changed to accept null pointers and a size.  This should be easy on the sending side but I am not sure about the receiving side unless the size is always the same.  I will have to see if there is a way to get the size of a incoming package so that the method knows how much its receiving.  One possible solution, if nothing else, might be to put the size in the first byte and have two ReadFile calls one to grab the size and the other to grab the remaining data using that size.
• Need to read this tomorrow to get an idea of how calloc is used to make a generic array:  http://www.cplusplus.com/reference/clibrary/cstdlib/calloc/
• Need to look up more information on void pointers.  They seem to be typeless pure memory and can be cast into anything.

End: 5:00