Hi,

Cosa is not a library but an entire core replacement for all boards.

The main issue is that your custom core does not contain a HardwareSerial or ano class which would normally be available for the selected processor.

The Visual Micro debugger needs to know the type of the serial object (HardwareSerial or USB etc).

If you try to use Serial in your code does it work without debug?

Thanks

Hi,

Thanks for the info. Actually visual micro does switch to use alternative classes for some processors such as UART. However this functionality is currently hard coded.

It wouldn't be difficult to change to make this more flexible.

Can you confirm if the UART class for your board provides both Serial.write() and Serial.print() functions. .print() should send ascii .write() should send the binary.

If the UART class supports the correct version of .print() I can tell you how to hack some Visual Micro files to test it and try to make it work.

Thanks

I know the author calls the board core a library but that is actually quite confusing because arduino libraries are something different. The author has actually re-written the arduino core so it is no longer arduino. He appears to have done a good and big job but it would help if we could call his variations "replacement cores".

Okay interesting. 

It will need to have the ascii print() and println() overloads for the various data types

print(int)
print(char)
print(long)

etc.

Hi Cosa,

Thanks for the info. Your core is certainly very impressive!

Correct me if I am wrong but you seem to provide the equivalent of the Arduino serial.write() methods?

Can you provide the same print() and println() functions as used in the Arduino core?

Thanks

Oh okay thanks. I will give it a try I think it will work easily enough. 

I'll try to add this over the next 24/48 and make a service pack release.

One last question. Is there a single value against all boards.txt defs that can be used to determine that cosa is being used. I have not yet looked at boards.txt but assume there might be something? Otherwise I will use the first few chars of the board names which all seems to contain "Cosa" but that seems a bit limiting for you in the future.


As a reminder for me....

By the looks of it Visual Micro just needs to substitute HardwareSerial references with IOStream then in the debugBegin() use the following code to init the Serial port:-

// Create an instance of the iostream and bind to the uart
IOStream Serial(&uart);
// Start the uart
uart.begin(debug_speed);
 

Thanks again

It is easy to detect the core in the boards.txt file. Each board has the following property.

BOARD.build.core=cosa
 

There is also preprocessor symbol for the board. You might also want to integrate with the Cosa command line build. Please see the folder build and the shell script cosa and default makefile Cosa.mk. The script allows users to compile, link, upload and monitor without writing a makefile. 

Cheers!

Quick answer to some of the questions:

Cosa has two implementations of millis() depending on resolution and if the user wants to take full advantage of Cosa's support for extreme low power mode. The first implementation is Watchdog::millis(). This implementation gives a resolution of max 16 ms. The advantage is that the Watchdog timer will continue to run when the MCU is put into power down sleep (uA level). The second and more accurate version is RTC::millis() which is closest to the Arduino millis() function. Both timers requires a call to begin() in setup. 

#include "Cosa/RTC.hh"
inline uint32_t millis()
{
  return (RTC::millis());
}

void setup() {
  ...
  RTC::begin();
  ...
}
 

Cosa is fully object-oriented and pins are different classes; Pin, InputPin, OutputPin, IOPin, AnalogPin, etc. There is a very rich set of member functions to write and read the pin values. Also Cosa uses strong data typing so that pins are actually symbols. The mapping to Arduino is:

#include "Cosa/InputPin.hh"
#include "Cosa/OutputPin.hh"
#include "Cosa/AnalogPin.hh"

inline int digitalRead(Board::DigitalPin pin)
{
  return (InputPin::read(pin));
}

inline void digitalWrite(Board::DigitalPin pin, uint8_t value)
{
  OutputPin::write(pin, value);
}

inline int analogRead(Board::AnalogPin pin)
{
  return (AnalogPin::sample(pin));
}
 

The normal way to use Cosa Pins is:

InputPin button(Board::D4);
OutputPin LED(Board::D5, 1);
 

The pin constructor does all the initialization of pin mode, pull-up, and start value if needed.

Both the object-orientation (classes) and the strong typing contribute to the X2-X10 higher performance than Arduino/Wiring. Please see the Benchmarks; https://github.com/mikaelpatel/Cosa/tree/master/examples/Benchmarks. The compiler can do a much better job and it is actually possible to write a pin-toggle function that is done in a single instruction (clock cycle, 62.5 ns) and still have a very high level of abstraction. 

BW: There is a high level IOStream class for trace which allow syslog style prorities and that adds a lot of information to trace points. Below is a snippet from a trace.

45:void setup():trace:free_memory() = 387

53:void loop():measure:one character (new-line):28 us
1
54:void loop():measure:one character:36 us
1
55:void loop():measure:one character string:44 us
 

https://github.com/mikaelpatel/Cosa/blob/master/examples/Benchmarks/CosaBenchmar...
The source code that generated this looks like this:

void setup()
{
  ...
  TRACE(free_memory());
  ...
}

void loop()
{
  // Measure time to print character, string and number
  MEASURE("one character (new-line):", 1) trace << endl;
  MEASURE("one character:", 1) trace << '1' << endl;
  MEASURE("one character string:", 1) trace << PSTR("1") << endl;
  ...
}
 

https://github.com/mikaelpatel/Cosa/blob/master/examples/Benchmarks/CosaBenchmar...
Cheers!

I fully agree with Tim.
excellent core “Cosa”
Especially if used with Visual micro.
But requires programming experience.
I am new to programming a hobby for me, but I can appreciate it.
The digital output is faster, checked.

Nice screenshots. You can go even faster with:

OutputPin::toggle(Board::D10);
OutputPin::toggle(Board::D10);
 

Please see the Cosa Pin Benchmark: 
https://github.com/mikaelpatel/Cosa/blob/master/examples/Benchmarks/CosaBenchmar...
This allows the compiler to reduce the code even further but is not so flexible as the pin value must be a constant. 

Cheers!
gelius59 wrote on Jan 24^th, 2015 at 6:18am:

Cosa wrote on Jan 24^th, 2015 at 11:38am:


Thanks.
It's fast, practice test.
I'm still learning core “Cosa”

Best regards.
Yrij.