Arduino serial monitor, From this forum because, I need an intelligent answer

[carl0s]

Ahhh.. I get what you're doing now, sorry :-) That's an interesting idea, using the gpio as a parallel data bus. I still think you should have a look at the stm32 stuff though too 😁

[westfw]

Yeah: the first things to learn about the Arduino core functions:

• IO is referred to by "pin number"
• "pin numbers" are defined by the board, not by the chip.  They're not necessarily grouped by the "ports" of the underlying chip (for example, the Arduino MEGA groups all the UART pins together, and "a bunch" of the PWM pins.)
• Except for higher IO functions, like UART, SPI, or I2C, which become C++ objects.  Sometimes configured with a bunch of pin numbers, sometimes HW-fixed.  (Why isn't a Pin an object too?  We may never know!)
• And except for some things they overlooked (attachInterrupt() should surely use a pin number, rather than the AVR "interrupt number.")

So the preferred "generic" Arduino implementation of a PORT in an Arduino environment involves an array of pin numbers, set one-at-a-time with digitalWrite()   This is slow, but works on any board, allows the port to span multiple chip-level "ports", and allows an arbitrary number of bits in the PORT.  If you're good, and write a PORT library, you can go ahead and optimize as much as you want to (it's pretty common to cache the pin to port/bit translation data and skip some of the digitalWrite() work like "turn off PWM if it was turned on."  Or to detect whether the pins specified implement the hardware version of the function being provided...)

[Quarlo Klobrigney]

Yep it's all a bit counter intuitive. Give me my STK500 (2 of them free from Atmel seminars) AS4, (not AS7 bloat) and I can have my way with any chip, sans SMD.
 
Funny you should mention the MEGA (2560), I was just looking at it before seeing your reply. I bought it PT (pre-tarrif or pre-Trump, choose 1, 2 or none) so it was fairly cheap.

I don't like Arduino. I hated it when a less savvy colleague (IT) said "look what I can do!" He never programmed an Atmel chip in his life.
My reply was "it'll never last. It's just a fad" That was 4 years and 1 job ago.
 
It's an abomination in my eyes, but like I said, it needs to be learned. Painfully or not.

Thanks again for you kind input.

[westfw]

It's an abomination in my eyes

Whatever.  It's a recent player in a long string of "abominations" like BASIC52, BASIC Stamp, PLCs, and so on.Overall, I find it ... less depressing than the long string of "Vendor Libraries" of questionable merit.
It is annoying to get old and curmudgeonly when the job and "stylish" markets want you to be wildly enthusiastic about something new and not-nearly-as-different as they want to believe.

[AG7CK]

I am an Atmel fanboy, and have been programming them since the AT90S1200 in both asm & C.
My point being, I just don't get the Arduino syntax gobbly-gook.
I can't understand what's going on in the background.
What say, for example what pin 13 is tied to in a sketch <- "I hate that word" 
Is it PD7 or really pin 13 on the IC?

Another thing is getting for example to display whats in the serial monitor on a port.
Any help to answer my inquiries or point me to any other site besides Arduino. I'm old and don't have a lot of patience to wade through all the stuff scattered on hundreds of large font pages.

Signed: Dazed in the hot southern sun ..... Thanks

I cannot understand the helplessness of certain "experts" asking for "intelligent" answers.

Search string: 'arduino pin map to ports'

One of the first returned results in all major engines: https://www.arduino.cc/en/Hacking/PinMapping168

Contains cute little figure that - if one uses one's wit - answers a lot about Arduino pins, ic pins, ports and Arduino serial :





Digging a bit more will yield a figure where one will see that the ASCII-based serial can be parallel dumped on a port using a "bigger" board where there are ports without dedicated pins.




Imo almost all the OP's further questions can be answered in a similarly simple way. Not being able to find the (both) web- and IDE-accessed 'DigitalReadSerial' example is beyond my understanding.

Arduino is no worse or better than anything else. Just different. The information on how to use or discard it on any level is easy searchable.

[Quarlo Klobrigney]

Well I suppose because you are infinitely more intelligent than everyone else. You presuppose that I have not looked. Wrong. Perhaps i lack the search results for the questions that I submitted. I got my answer previous to you, so move along now.

[rrinker]

 I have a different one, with an ATmega328 and the pin labels are all color-coded. One color is the Atmel port, one is the Arduino "Pin", one s the function, etc. I printed this out and put it in a protective sleeve because I refer to it often as I do a lot of my prototyping work on Uno or Nano but my final projects just use bare ATMega328's.

 As for 'abomination' - why? Unlike many other "designed for beginner' environments, with Arduino you can freely bypass the 'simplifications' that cost performance and do the register writes yourself, as others have pointed out. You aren't stuck with the limitations of JUST the Arduino functions. The sheer mass of the Arduino movement has resulted in Arduino plug-ins for MANY different editors and development environments, if your ire is strictly directed at the official Arduino IDE. Don't like it? Don't use it, but still write the same code.

 One of my designs will make use of the normally 'reserved' pins 0 and 1, because the bare chip will have no serial IO connected, so those pins are free to use for whatever I want, just like programming the bare micro with any Atmel compatible devlopment environment. Best thing is, I am writing the code to those bare chips using - an Arduino!

 It should be obvious by now that the Uno/Nano and similar are just not suitable for what you are attempting to do, because there are no full 8 bit ports available. But the Mega DOES have full 8 bit ports available and you should be able to easily accomplish this. For a 'pure' Arduino solution you will have to decode the value into binary and set the pins accordingly, or just skip the whole thing and set the port register - which I do not think of as not using 'Arduino' because in all but the most beginner of Arduino references I have read, the technique of bypassing the pinMode and digitalWrite and so forth is well documented as a way to massively increase performance. 

[Quarlo Klobrigney]

It's not that it's not suitable, I'm just trying to understand why crippling certain functions are good thing.

Remember as you say, the bare 328 and others, are fully functional, and I have used them so for years.

I'm approaching this backwards. From full ops to reduced ops. So a head scratcher for me.

Not to mention learning that int8_t is now int, _delay_ms() is now delay(), PORTD 0 & 1 are unusable in the boards, and so on and so on. In the native Arduino language.

I spent a few hours trying to figure out why D0 & D1 would not go low or go into output mode (including reflashing the bootloader on the STK500. Thanks to westfw above I found out that I can't use it on an Arduino board!

Thanks, I do appreciate all of your input(s). You just didn't understand my direction of flow.

Looking at someone else's sketch, I'm trying to learn the syntax. Not necessarily how to program an AVR, as well as finding out the limitations of the boards.

[carl0s]

I'm sure I used uint8_t in Arduino as well.

To be fair, I was pulling my hair out when that didn't work at repl.it the other day. Apparently I just needed to include stdint.h or something.

Anyway, use platformio. Or stm32 and truestudio.

[Quarlo Klobrigney]

And yet I can do FPGA's Altera... And STM32's in Eclipse.
For some reason the Arduino is counter-intuitive to my brain.
Maybe I suffer from CRS.
 
Quote from: carl0s on Today at 16:08:07

Anyway, use platformio. Or stm32 and truestudio.

[rstofer]

And yet I can do FPGA's Altera... And STM32's in Eclipse.
For some reason the Arduino is counter-intuitive to my brain.
Maybe I suffer from CRS.

The device was never intended for engineers or programmers.  It was designed specifically for artists as it allows them to add some amount of animation to their creations.

Once you start to apply the device beyond simple artistic animations, it falls flat.  In its domain, it is highly capable.

Because the boards are cheap, they are being used in all kinds of projects for which they really weren't designed.  The users have to adapt their thinking to the platform or just keep the bootloader and write everything else from scratch.  There's no compelling reason to use the Arduino libraries as long as the user is capable of writing every single line of code (or possibly use avr-lib).  But sometimes the Arduino libraries are truly worthwhile.

When I want something in a big hurry, I reach for the Arduino.  I use the VisuaMicro Arduino plug-in for Microsoft Visual Studio.

https://www.visualmicro.com/

[westfw]

I'm just trying to understand why crippling certain functions are good thing.

Have you ever tried to explain "PORTD &= (1<<PD4);" to someone with minimal embedded programming experience?  Even somewhat experienced application programmers don't get it, what with bitwise operations and shifting being pretty uncommon in the numeric and text processing worlds.
I pretty much believe that the "pin number" abstraction is one of the best design decisions in the Arduino core.

Not to mention learning that int8_t is now int,

No.  int is still int (16 bits), and uint8_t is still available.  "byte" is also uint8_t, which is a common alias (also "BYTE", and "BYTE8") in various environments.  Because it took the C folk so freaking long to admit that maybe having exact sized variables was a good idea.

_delay_ms() is now delay(),

delay() is somewhat different than _delay_ms()  Well, substantially different, actually, given that the argument doesn't have to a floating point compile-time constant.

PORTD 0 & 1 are unusable in the boardsI spent a few hours trying to figure out why D0 & D1 would not go low or go into output mode

Um.  They shouldn't be "unusable": D1 should act pretty normal, and D0 should act like it has a relatively strong (~1k) pull-up attached.  Unless you're trying to use Serial communications at the same time, which wouldn't work on a bare ATmega328p, either.  (I guess it's less than obvious that D0/D1 are shared with the UART pins than if you were dealing with bare ports.  Not all Arduinos have this limitation, BTW - chips with more than 20 usable IO pins, or with native USB, shift things around (easy to do, give the "board pin number based" scheme) and have different things to worry about.

[sleemanj]

Some people seem to rail against the Arduino abstractions... I don't get it, abstractions are good, "digitalWrite(1, HIGH)" does exactly what it says on the tin, on any "arduino" core/derivation/board, same with the higher level stuff like Serial, SPI or Wire (I2C).

Yes the way that some of the abstractions are implemented in the standard core are a bit... suboptimal (for various reasons historical political and implementational), and there could be some more (for port-wide writing for example) but the idea of the abstractions themselves is GOOD, for readability, for simplicity, and for portability. 

Above all, if you don't like the abstractions, then don't use them, nobody is twisting anybody's arm when it comes to Arduino, if you want to write to ports directly do it, if you want to mix in assembly, do it, if you want to handle all your own Serial comms do it. 

Very little is actually setup for you in the core's main(), basically just the timer for millis and ADC stuff form memory, all easily disabled or changed in your "setup()" if you don't want that.

It's like a naive web developer saying "I don't use a database abstraction layer, it's faster to do mysql_query()", yeah sure it's faster but it's a terrible idea for all sorts of reasons.

[Nusa]

I think your primary problem is that you are far less of an expert than you think you are and are frustrated because you don't know some core details about the C or C++ language.

You can't read and understand a book or proper tutorial about C without learning that "int" is a language defined hardware-dependent type with a MINIMUM size of 16 bits. You'd also know about "char" and "long" and "unsigned", etc.

The int8_t and similar types you're used to are useful extensions to the language defined by typedefs in a header file. #include <stdint.h> and you should be able to use them again. Go look at that file if you want to see what they're defined as for the arduino hardware.

[rrinker]

It's not that it's not suitable, I'm just trying to understand why crippling certain functions are good thing.

Remember as you say, the bare 328 and others, are fully functional, and I have used them so for years.

I'm approaching this backwards. From full ops to reduced ops. So a head scratcher for me.

Not to mention learning that int8_t is now int, _delay_ms() is now delay(), PORTD 0 & 1 are unusable in the boards, and so on and so on. In the native Arduino language.

I spent a few hours trying to figure out why D0 & D1 would not go low or go into output mode (including reflashing the bootloader on the STK500. Thanks to westfw above I found out that I can't use it on an Arduino board!

Thanks, I do appreciate all of your input(s). You just didn't understand my direction of flow.

Looking at someone else's sketch, I'm trying to learn the syntax. Not necessarily how to program an AVR, as well as finding out the limitations of the boards.

 Simple - keeping it simple. The 'crippling' is just using the PD0 and PD1 as the serial port that is part of the Atmel architecture to provide a simple serial (USB) connection for the user. Surely easier than some non-micro expert trying to figure out how to connect one of a multitude of ICSP programmers. It's all part of the overall picture - just plug your board into your computer, write some code, click the button, and it gets compiled and uploaded. Penalty: loss of two potential data pins.
 Same thing with the timers and stuff. The whole idea is to isolate the user from the intricacies of all the register programming, so the Arduino 'shell' assigns things in a consistent manner to provide functions that the beginner can use without figuring out how to configure the timer registers or even worse, read them.

 Is it the ideal way to utilize this (or any other supported by Arduino) micro? Certainly not, removed from the ecosystem you can do anything the micro is capable of, not just a limited subset. The cost is more complexity. The goal of Arduino was not to exploit the capabilities of the micro, it was to provide an easy to learn consistent basis for non-programmers.

 I think I DO know where you are coming from. You are already well beyond the knowledge level of the typical Arduino target audience. You just KNOW that "this" is the way to accomplish a particular task, but in the simplified Arduino world, it just isn't possible. It's hard to go backwards. I felt much the same way back in the day going from an 1802 CPU in my first computer to trying some assembly on a 6502. On the 1802, I had 16 registers, each 16 bits wide to play with. Then I got to the 6502 and it was horrible to me. So much more complicated despite being, in essence, a simpler design. I had to make and manage a stack for even relatively trivial programs, whereas on the 1802 I could simply store some data in one of the registers I wasn't using.
 It's hard going back. It's like driving around in a Ferrari for a year, then having to give it up and drive a Yugo.

[cstratton]

I know it's a limited architecture, but the blasted thing needs learning. I know all the regular GCC command stoof PORTx = 0xnn and the (1<<zzzz) etc. etc. Don't get me started on millis(). And no _BV.
As you say it was restricted function wise for the "artists" & "hackers" who learned how to make a LED flash after 3 weeks.

No, it wasn't restricted at all.  All of those capabilities of the AVR hardware are still there.  Beginners are lead to using some questionable abstractions, but you aren't required to follow suit.  There are plenty of raw AVR-isms appearing in "sketches" that accomplish real, useful tasks.   Sometimes that is warranted, sometimes it is stylistic, but apart from a very few things to keep in mind (such as not colliding with default background functionality) you're free to do things either the Arduino way, or the AVR way, in the same program..

Of course if your target platform is not an AVR Arduino but an official or unofficial Arduino port to some other platform, then primitives exposed (at least with the right include files) are those of that chip, rather than an AVR.

[brucehoult]

And if it's NOT an AVR, you may have to hunt up info in strange places (the ESP chips in particular are an obscure architecture with awful documentation (by Western Chip Vendor standards.  It's really amazingly better than the documentation we usually get for Chinese chips.)

I'm not sure you could call xtensa (which is what at least the ESP8266 uses) an obscure architecture! It's owned these days by Cadence, one of the biggest vendors of EDA software. It's certainly not in the league of x86 or arm but it's one of only about 20 ISAs supported by the linux kernel, and you can get gcc and llvm for it.

[mtdoc]

It was designed specifically for artists as it allows them to add some amount of animation to their creations.

No, not really. It was developed for design students and other non-engineers - which does not mean “artists”.  Sure, some artists have made use of Arduino, but they’ve always been a very tiny minority of Arduino users. Most artists are too non-tecnical to even consider encorporating even simple electronics into their work. It is fallacious thinking to suppose that non-engineer == artist.

This thread has some some great responses and really does a great job at flushing out some of the misunderstandings and misconceptions about the reality of what the Arduino platform is about and what it is and is not capable of.  Some really great nuggets of info here!   If it was really as limiting as some seem to assume, it would never have grown as vast a community (even including many engineers) as it has.

[westfw]

I'm not sure you could call xtensa (which is what at least the ESP8266 uses) an obscure architecture!

How many xtensa-based chips can I go out and buy, other than the two (?) from Espressif?
Is there a cheap version of the core that I can add to hobbyist-sized FPGA boards?

[sokoloff]

Have a look:
https://ip.cadence.com/ipportfolio/tensilica-ip

Tensilica shipped billions of cores, not all xtensa (Cadence later bought Tensilica), so I have to agree that it’s not “obscure”.

[brucehoult]

I'm not sure you could call xtensa (which is what at least the ESP8266 uses) an obscure architecture!

How many xtensa-based chips can I go out and buy, other than the two (?) from Espressif?
Is there a cheap version of the core that I can add to hobbyist-sized FPGA boards?

There are billions of them. Most are embedded so deeply that users never know they are there, let alone what ISA they are.

I regret now that when I did some work on the Samsung Bio Processor (https://en.wikipedia.org/wiki/Samsung_Bio_Processor) systolic array chip, and its earlier cousins that listen for "OK Google" in phones, I didn't check the instruction set precisely against xtensa. I definitely had the very strong impression that it looked a lot like xtensa with some extra (doh) stuff added.

[hans]

It's not that it's not suitable, I'm just trying to understand why crippling certain functions are good thing.

Remember as you say, the bare 328 and others, are fully functional, and I have used them so for years.

I'm approaching this backwards. From full ops to reduced ops. So a head scratcher for me.

Not to mention learning that int8_t is now int, _delay_ms() is now delay(), PORTD 0 & 1 are unusable in the boards, and so on and so on. In the native Arduino language.

I spent a few hours trying to figure out why D0 & D1 would not go low or go into output mode (including reflashing the bootloader on the STK500. Thanks to westfw above I found out that I can't use it on an Arduino board!

Thanks, I do appreciate all of your input(s). You just didn't understand my direction of flow.

Looking at someone else's sketch, I'm trying to learn the syntax. Not necessarily how to program an AVR, as well as finding out the limitations of the boards.

It's not crippling.. just another set of tools. Let's define what the Arduino is:

- A range of boards to choose from. Some may use the ATMEGA328, some don't. But above all, they are standardized on pin maps.
- The micros have a bootloader integrated, most of them are serial.
- You can upload programs via the Arduino IDE, or commandline tools.
- Sketches are preprocessed C++  programs. They include a few libraries:
   - Millisecond time base
   - Basic serial library, with asynchronous data receive (interrupts)
   - Functions for GPIOs, PWM and ADCs
   - A gazillion number of user libraries, of varying quality
   - A setup() and loop() convention, which is basically:

Code: [Select]

void main() {
   backgroundSetup();
   setup();
   while(1){
       loop();
   }
}
Coincidentally, people rant on just about everything I just mentioned. The classic boards standardization have weird mechanical dimensions (off-grid). The IDE has no debugger, is limited to use (it provides no details such that beginners are not intimidated). The provided software libraries are  confusing or inefficient.

You got to take it for what it is, or find alternatives. You can  skip almost all of the software libraries if you want to. You can program (almost) bare programs compiled with  GCC into an  Arduino. Most arduinos also feature an ISP header, so you could even bypass the bootloader if you want. Or you could program the bootloader onto any ATMEGA328  and use Arduino software on your own boards.

It's up to you. I rarely use Arduino, but for what it is (rapid prototyping), it does the job quite well.

[Quarlo Klobrigney]

Again for clarity, I'm not trying to program with the Arduino IDE in GCC, I'm trying to learn a muddle through a whole other way of doing it "their" way.
I use the AVR GCC commands that I always use in Studio, with debugging.
I just didn't realize that such a thing was possible with the Arduino IDE (sans debugging) until 6 months ago. Just a dumbed down, obfuscated bloat IMHO.
Again, to restate the goal here is the "learning" of native Arduino syntax.
No rod of correction or chastising is necessary.

I saw this a few days ago from a YouTube comment, not my words, and I quote:

Name Withheld I feel we walk in each other's shoes.

This is the terrible result of the dark age of the Arduino.
The generation behind has no idea how to program in assembly much less how to do
timing calculations on an RC circuit.

The Arduino is a dumb bomb aimed directly at America.
Europe has been in the back seat of science and engineering since WWII.
Now from the most unproductive parts of a dead European empire (the Mediterranean)
comes the perfect weapon to destroy America's technological leadership - the Arduino.

Things will be much worse before turning about. There must be a generation of failed
embedded systems before academia wakes up and again challenges youth to learn Boolean algebra.

It came to mind that the Soviet Union went through a phase like this. In their case,
Stalin's purges were the dumb bomb that wrecked their generation of scientists.

Long rant. I know. But I am depressed at the state of blissful ignorance in the minds
that should be learning Maxwell's equations but is instead captivated by idiot Name Withheld and his blinkies.

Sad days in America.

End quote.

[mtdoc]

So IOW, just another disgruntled engineer whining about Arduino. 

There are literally millions of people around the globe whose introduction to electronics and embedded systems is only due to Arduino.  Many thousands of those, whose interest was sparked by their Arduino experience, will go on to learn to use C or even Assembly as their project or educational requirements dictate.

That would never have happened if the only option for learning embedded programming was the “professional” approach using non-intuitive toolchains and/or expensive professional IDEs.   

It’s as if some just can’t tolerate the fact that there are millions of “non-engineers” out there building embedded projects that previously only those in the elite club of embedded engineers and sophisticated hobbyists could do.

So what if there are better ways to program and produce more efficient code? Without the “inefficient”  Arduino abstractions there are millions who would never be coding at all.

The value of the Arduino approach has even been validated by professional engineers who have admitted they often trun to it for quick prototyping.

If you don’t like Arduino - fine just don’t use it.  But this type of circuitous criticism is pretty transparently just sour grapes IMO.

[sokoloff]

So IOW, just another disgruntled engineer whining about Arduino. 

There are literally millions of people around the globe whose introduction to electronics and embedded systems is only due to Arduino.  Many thousands of those, whose interest was sparked by their Arduino experience, will go on to learn to use C or even Assembly as their project or educational requirements dictate.

That would never have happened if the only option for learning embedded programming was the “professional” approach using non-intuitive toolchains and/or expensive professional IDEs.   

It’s as if some just can’t tolerate the fact that there are millions of “non-engineers” out there building embedded projects that previously only those in the elite club of embedded engineers and sophisticated hobbyists could do.

I expect the same kind of arguments from those opposed to electric starters, then automatic transmissions, then anti-lock brakes, then traction control, then stability control, then collision avoidance on automobiles.

If it was hard for me, it damn well ought to be hard for others as well.

I made a living as a programmer; I did my time, wrote assembly, C, C++, others, did digital logic labs in college, wrote my undergrad thesis on finite state machine design tools, etc. With all that as background, I find Arduino to be a marketing and community building stroke of genius.

It's not an elite priesthood anymore; I think that's a great thing for hobbyists and consumers.