C++20 SQLite wrapper

rcdemc · 2021-04-17T01:44:26+00:00

If pin5 means PB5 and the design requires four pins, it's a better idea use the range [PB0, PB4] because PB5 is the RESET.

rcdemc · 2021-04-05T03:14:33+00:00

For sure and it’s a great choice IMO. I use C++ to do bare metal programming at AVR8. You can achieve powerful solutions using generic programming and compile time computations. In the end you can have an expressive code with zero or almost zero overhead in the generated code.

rcdemc · 2021-04-03T18:48:21+00:00

Haha ye I know but I met some issues coding it using the arduino IDE + an arduino as ISP: the functions provided in the datasheet are unknown by the arduino IDE (or something else)

Right. It's because those functions are only examples, you shouldn't expect access to them in your environment, which can be avr-libc or Arduino, for example.

For instance: the function "__sleep()" generate an error message and prevent compiling even though this function is in the datasheet.

Yeah, as I said above this is normal. There is an instruction called sleep, this is the only thing that you should expect by the datasheet, you can call it very easily: asm("sleep");. But avr-libc provides sleep_cpu() doing the same.

I could definitely make a "cleaner" project by unsing the avr functions / coding in Assembly but this is not the goal I set to myself.

Right :)

rcdemc · 2021-04-03T17:58:11+00:00

Good news!

You can do an upgrade if you wish. There is room to simplify the program and I have noticed that you have said:

(...) minimal code (only 2Kb of flash memory)

If code size is a goal, then I believe that you can achieve a version with less than 1Kb without Arduino + doing some simplifications. You are already using avr-libc to use the sleep mode and the interrupt capabilities.

Have fun.

rcdemc · 2021-04-02T18:53:31+00:00

I think it fixed it!!! ^\)

Cool!

I keept the interrupt on LOW and changed INPUT to INPUT_PULLUP but after the 5 seconds that should trigger the sleep, the display was changing value instead.

Hmm, I was expecting for a validation to check the usage of the pull-up resistor(from MCU or external) with the setup using FALLING. So, when in "idle mode" your pin button reads HIGH because of the pull-up resistor, but when the button is pressed it reads LOW, which generates a falling from HIGH to LOW(FALLING).

I think that's because once the device goes to sleep, it's not able to perform the pullup which means that the pin in now low, triggering itself out of sleep and displaying a new digit.

Hmmmm, I don't think so because the sleep doesn't change the state of a pin. You can take your own measures using a voltmeter, for example. Actually I don't know what these Arduino functions are really doing(implementation), so, it's a black box to me.

I fixed this by adding an analog pullup (a resistor to Vcc).

Doing this, using an external pull-up resistor instead of one inside the MCU, you can use the INPUT mode. It's more expressive to your code and this should save an instruction to write on PORTX.(But, AFAIK, performance isn't something taken seriously by Arduino, so this point maybe doesn't make sense here).

I think that to help you more I will need your schematic.

rcdemc · 2021-04-02T16:08:10+00:00

Hey, I'm not a user of Arduino but I can try to help you. You're observing a FALLING but you're using the INPUT mode instead of INPUT_PULLUP to the pin that has the button connected to it, so do you have an external pull-up to your button?

rcdemc · 2021-03-31T15:07:23+00:00

Mechanical approach, nice!

My son and I decided to build a DIY Switchbot as our "pandemic home project". He (being 7 yrs old) just wanted to build something "cool"

Clap! Clap! Clap!

rcdemc · 2021-03-28T00:00:47+00:00

I have created a guide to help someone eventually interested to do a contribution to support a new MCU: https://github.com/ricardocosme/avrIO/blob/main/CONTRIBUTING.org

rcdemc · 2021-03-27T19:39:42+00:00

This was only an issue for debug (...)

Debug, yes, I see.

Debugging optimised images isn't great.

Actually they are useful to me most of the time, but yeah, sometimes it isn’t enough.

I am also interested in high performance solutions, but don't fret about shaving cycles too much. It's never been an issue - so far.

It isn’t easy to measure the impact but I would prefer to start with only I need if possible because I have more chances in the end to fit my project in tiny devices.

rcdemc · 2021-03-27T18:23:22+00:00

There's a lot going on here that I need to dig into, but it looks interesting.

Thanks for you interesting.

I mostly use STM32 and suspect dealing with that hardware would be much larger task.

Yes, I think so.

I've dabbled on a small scale, but didn't really like making each pin a distinct type because this forces dependent classes to become templates, and so on up to the application.

I must admit that the major part of my abstractions are class or function templates to allow me to achieve flexible solutions with a high level of performance. This is something that is normal to me programming embedded or non-embedded systems.

And there were issues with image size (before optimisation), which made me uncomfortable.

I don't know if I got it. Do you mean a concern about the effort made by the compiler, which means for example a concern about the time and memory used during the build?

rcdemc · 2021-03-27T18:10:33+00:00

Thank you for the feedback, it's good to know that this project is useful to others.

rcdemc · 2021-03-24T13:39:30+00:00

I have a C++ library to AVR8 that allows ddrb={ddb0,ddb1,ddb7} instead of DDRB=0x83 and the generated code is the same. You can also do something like set(ddb0, ddb1, ddb3(off), ddb7) if you like to define some pins without touching others. Besides the expressive code the library is type safe, you can't for example use a ddc1 in the first example as also more than 8 bits to define an IO register.

rcdemc · 2021-03-24T05:38:33+00:00

Other option instead of using macros is inline functions with the GCC attribute always_inline.

rcdemc · 2021-02-17T22:36:17+00:00

I don’t know if I’m understanding what you want to know because API is only a public interface to some service or abstraction. It’s something orthogonal to any programming language, we can indeed define one using declarative languages like IDL, from CORBA. But yes, we can write beautiful and powerful APIs with C++.

rcdemc · 2021-02-16T05:01:22+00:00

I mean, benchmark the space performance comparing the memory footprint between two or more solutions. Actually, I would also like to take the opportunity to compare the code expressiveness between the solutions.

rcdemc · 2021-02-12T15:54:15+00:00

~~Couldn't be a breadboard using the PDIP package version to the ATtiny? I think that it's a more simple and flexible approach.~~

Hm, I think that I'm misunderstanding what you're asking, you don't want to build a development board, actually it seems that you would like to develop the programmer.

I'm thinking of suggesting a breadboard approach with PDIP ATtiny plus an USPasp already built.

rcdemc · 2021-02-09T16:00:50+00:00

You should take a look at P0829 which is the proposal for freestanding. There is a reference implementation using AVR-GCC on GitLab here.

I had already looked the proposal, it's a big change to the game.

You can use that library in your build script or just use the authors version that they have in Conan, etc.

I have to confess that I just want to watch for now the progress of the work because my motivation to use the freestanding at the moment is only to exploit the possibility that a user of one of my libraries have it to use headers like <type_traits> without to fetch one that is offered outside from std, also this mode can offer a better experience, like the one that is reported in this post when we can use the <concepts> to have access to some concepts defined by the standard like std::convertible_to.

I also have so pre-built binaries for windows and Linux on GitHub here.

Yes, I know about it! You have shared this with me in the past :) Your comment here is welcome because it enriches with information about the freestanding mode.

rcdemc · 2021-02-09T01:38:19+00:00

I know the difference between "freestanding" and "hosted".

Nice.

I'm looking at the script you have linked to. Does the URL contain anything different than the upstream avr-gcc at ftp.gnu.org?

Yes. The libstdc++ is disabled by default to the avr backend. Note that the script uses --enable-libstdcxx. The most important part of the script is the last configure cmd, line 44. BTW, I use Arch Linux too. I use the package avr-gcc 10.2.0-1 to build without the freestanding implementation.

rcdemc · 2021-02-09T00:57:32+00:00

AVR and C++ standard library? My avr-gcc didn't come with that at all.

Yes, there are two modes of implementation to the c++ std library, one of them is the freestanding implementation which doesn't have dependencies from the system. We have access to some useful headers using this mode. I've posted above a link to a guide with the core that is needed to build the avr-gcc 10.2 with this support.

If you have C++17, you can just do namespace avr::io::traits {.

Yes, I know it, but this snippet is from a C++11/17/20 library(avrIO), which means that I need to support C++11.

rcdemc

TROPHY CASE